test(core): use collected arrays directly

packages/core/test/bus-session-routing.test.ts

@@ -85,8 +85,8 @@ describe("Bus Session routing", () => {
         projectID: Project.ID.global,
       })
       const done = yield* bus.publish(Done, {})
-      expect(Array.from(yield* Fiber.join(first))).toEqual([moved, done])
-      expect(Array.from(yield* Fiber.join(second))).toEqual([moved, after, same, done])
+      expect(yield* Fiber.join(first)).toEqual([moved, done])
+      expect(yield* Fiber.join(second)).toEqual([moved, after, same, done])
       expect(moved.location).toEqual(a)
     }),
   )
@@ -130,8 +130,8 @@ describe("Bus Session routing", () => {
             )
           const after = yield* bus.publish(SessionEvent.Execution.Succeeded, { sessionID: child })
           const done = yield* bus.publish(Done, {})
-          expect(Array.from(yield* Fiber.join(first)).map((event) => event.id)).toEqual([eventID, after.id, done.id])
-          expect(Array.from(yield* Fiber.join(second))).toEqual([done])
+          expect((yield* Fiber.join(first)).map((event) => event.id)).toEqual([eventID, after.id, done.id])
+          expect(yield* Fiber.join(second)).toEqual([done])
         }),
       )
     }),
@@ -158,19 +158,17 @@ describe("Bus Session routing", () => {
       const explicit = yield* bus.publish(SessionEvent.Execution.Succeeded, { sessionID: id }, { location: b })
       const done = yield* bus.publish(Done, {})
 
-      expect(Array.from(yield* Fiber.join(first))).toEqual([renamed, text, broadcast, done])
-      expect(Array.from(yield* Fiber.join(second))).toEqual([broadcast, explicit, done])
-      expect(Array.from(yield* Fiber.join(workspace))).toEqual([broadcast, done])
-      expect(Array.from(yield* Fiber.join(global))).toEqual([renamed, text, broadcast, explicit, done])
+      expect(yield* Fiber.join(first)).toEqual([renamed, text, broadcast, done])
+      expect(yield* Fiber.join(second)).toEqual([broadcast, explicit, done])
+      expect(yield* Fiber.join(workspace)).toEqual([broadcast, done])
+      expect(yield* Fiber.join(global)).toEqual([renamed, text, broadcast, explicit, done])
       expect(listened).toEqual([renamed, text, broadcast, explicit, done])
       expect(renamed).not.toHaveProperty("location")
       expect(text).not.toHaveProperty("location")
       expect(JSON.parse(JSON.stringify(renamed))).not.toHaveProperty("location")
       const history = yield* bus.log({ aggregateID: id }).pipe(Stream.runCollect)
       expect(
-        Array.from(history)
-          .filter((event): event is Event.Payload => !Bus.isSynced(event))
-          .every((event) => !event.location),
+        history.filter((event): event is Event.Payload => !Bus.isSynced(event)).every((event) => !event.location),
       ).toBe(true)
     }),
   )
@@ -197,8 +195,8 @@ describe("Bus Session routing", () => {
       yield* bus.publish(SessionEvent.Moved, { sessionID: id, location: b, projectID: Project.ID.global })
       const expected = yield* bus.publish(SessionEvent.Renamed, { sessionID: id, title: "destination" })
       const done = yield* bus.publish(Done, {})
-      expect(Array.from(yield* Fiber.join(typed))).toEqual([expected])
-      expect(Array.from(yield* Fiber.join(multiple))).toEqual([expected, done])
+      expect(yield* Fiber.join(typed)).toEqual([expected])
+      expect(yield* Fiber.join(multiple)).toEqual([expected, done])
     }),
   )
 
@@ -226,8 +224,8 @@ describe("Bus Session routing", () => {
       const done = yield* bus.publish(Done, {})
       yield* Deferred.succeed(gate, undefined)
 
-      expect(Array.from(yield* Fiber.join(first))).toEqual([created, before, moved, done])
-      expect(Array.from(yield* Fiber.join(second))).toEqual([moved, after, done])
+      expect(yield* Fiber.join(first)).toEqual([created, before, moved, done])
+      expect(yield* Fiber.join(second)).toEqual([moved, after, done])
       expect(moved).not.toHaveProperty("location")
     }),
   )
@@ -245,9 +243,9 @@ describe("Bus Session routing", () => {
 
       const database = yield* Database.Service
       expect(yield* database.db.select().from(SessionTable).where(eq(SessionTable.id, id)).get()).toBeUndefined()
-      expect(Array.from(yield* Fiber.join(first))).toEqual([deleted, done])
-      expect(Array.from(yield* Fiber.join(second))).toEqual([done])
-      expect(Array.from(yield* Fiber.join(global))).toEqual([deleted, missing, done])
+      expect(yield* Fiber.join(first)).toEqual([deleted, done])
+      expect(yield* Fiber.join(second)).toEqual([done])
+      expect(yield* Fiber.join(global)).toEqual([deleted, missing, done])
     }),
   )
 
@@ -266,8 +264,8 @@ describe("Bus Session routing", () => {
       ])
       const done = yield* bus.publish(Done, {})
       yield* Deferred.succeed(gate, undefined)
-      expect(Array.from(yield* Fiber.join(first))).toEqual([events[0], events[1], done])
-      expect(Array.from(yield* Fiber.join(second))).toEqual([events[1], events[2], events[3], done])
+      expect(yield* Fiber.join(first)).toEqual([events[0], events[1], done])
+      expect(yield* Fiber.join(second)).toEqual([events[1], events[2], events[3], done])
     }),
   )
 
@@ -295,8 +293,8 @@ describe("Bus Session routing", () => {
       const done = yield* bus.publish(Done, {})
       expect(Exit.isFailure(single)).toBe(true)
       expect(Exit.isFailure(batch)).toBe(true)
-      expect(Array.from(yield* Fiber.join(first))).toEqual([before, after, done])
-      expect(Array.from(yield* Fiber.join(second))).toEqual([done])
+      expect(yield* Fiber.join(first)).toEqual([before, after, done])
+      expect(yield* Fiber.join(second)).toEqual([done])
     }),
   )
 
@@ -327,8 +325,8 @@ describe("Bus Session routing", () => {
         { publish: true },
       )
       const done = yield* bus.publish(Done, {})
-      expect(Array.from(yield* Fiber.join(first))).toEqual([done])
-      const received = Array.from(yield* Fiber.join(second))
+      expect(yield* Fiber.join(first)).toEqual([done])
+      const received = yield* Fiber.join(second)
       expect(received.map((event) => event.id)).toEqual([after.id, replayID, done.id])
       expect(received[1]).not.toHaveProperty("location")
     }),

packages/core/test/bus.test.ts

@@ -123,7 +123,7 @@ describe("Bus", () => {
       yield* bus.publish(Message, { text: "hello" })
       yield* bus.publish(CountMessage, { count: 2 })
 
-      const received = Array.from(yield* Fiber.join(fiber)).map((event) =>
+      const received = (yield* Fiber.join(fiber)).map((event) =>
         event.type === "test.message" ? event.data.text : event.data.count,
       )
       expect(received).toEqual(["hello", 2])
@@ -136,7 +136,7 @@ describe("Bus", () => {
       const fiber = yield* bus.subscribe(Message).pipe(Stream.take(1), Stream.runCollect, Effect.forkScoped)
       yield* Effect.yieldNow
       const event = yield* bus.publish(Message, { text: "hello" })
-      const received = Array.from(yield* Fiber.join(fiber))
+      const received = yield* Fiber.join(fiber)
 
       expect(received).toEqual([event])
       expect(event.type).toBe("test.message")
@@ -212,8 +212,8 @@ describe("Bus", () => {
       yield* Effect.yieldNow
       const event = yield* bus.publish(Message, { text: "hello" })
 
-      expect(Array.from(yield* Fiber.join(typed))).toEqual([event])
-      expect(Array.from(yield* Fiber.join(wildcard))).toEqual([event])
+      expect(yield* Fiber.join(typed)).toEqual([event])
+      expect(yield* Fiber.join(wildcard)).toEqual([event])
     }),
   )
 
@@ -602,7 +602,7 @@ describe("Bus", () => {
 
       yield* bus.publish(DurableMessage, durableData(aggregateID, "two"))
 
-      expect(Array.from(yield* Fiber.join(fiber)).map((event) => [event.durable?.seq, event.data])).toEqual([
+      expect((yield* Fiber.join(fiber)).map((event) => [event.durable?.seq, event.data])).toEqual([
         [1, durableData(aggregateID, "one")],
         [2, durableData(aggregateID, "two")],
       ])
@@ -618,7 +618,7 @@ describe("Bus", () => {
 
       yield* bus.publish(DurableMessage, durableData(aggregateID, "one"))
 
-      expect(Array.from(yield* Fiber.join(fiber)).map((event) => [event.durable?.seq, event.data])).toEqual([
+      expect((yield* Fiber.join(fiber)).map((event) => [event.durable?.seq, event.data])).toEqual([
         [0, durableData(aggregateID, "zero")],
         [1, durableData(aggregateID, "one")],
       ])
@@ -653,7 +653,7 @@ describe("Bus", () => {
         yield* bus.publish(DurableMessage, durableData(aggregateID, "during handoff"))
         yield* Deferred.succeed(continueRead, undefined)
 
-        expect(Array.from(yield* Fiber.join(fiber)).map((event) => [event.durable?.seq, event.data])).toEqual([
+        expect((yield* Fiber.join(fiber)).map((event) => [event.durable?.seq, event.data])).toEqual([
           [0, durableData(aggregateID, "during handoff")],
         ])
       }).pipe(Effect.provide(eventLayer))
@@ -672,7 +672,7 @@ describe("Bus", () => {
         yield* bus.publish(DurableMessage, durableData(aggregateID, String(index)))
       }
 
-      expect(Array.from(yield* Fiber.join(fiber)).map((event) => [event.durable?.seq, event.data])).toEqual(
+      expect((yield* Fiber.join(fiber)).map((event) => [event.durable?.seq, event.data])).toEqual(
         Array.from({ length: count }, (_, index) => [index, durableData(aggregateID, String(index))]),
       )
     }),
@@ -688,7 +688,7 @@ describe("Bus", () => {
       yield* bus.publish(Message, { text: "live only" })
       yield* bus.publish(DurableMessage, durableData(aggregateID, "durable"))
 
-      expect(Array.from(yield* Fiber.join(fiber)).map((event) => event.type)).toEqual([DurableMessage.type])
+      expect((yield* Fiber.join(fiber)).map((event) => event.type)).toEqual([DurableMessage.type])
     }),
   )
 
@@ -1268,7 +1268,7 @@ describe("Bus", () => {
       yield* bus.publish(DurableMessage, durableData(aggregateID, "zero"))
       yield* bus.publish(DurableMessage, durableData(aggregateID, "one"))
 
-      const items = Array.from(yield* Stream.runCollect(bus.log({ aggregateID })))
+      const items = yield* Stream.runCollect(bus.log({ aggregateID }))
 
       expect(items.map((item) => (Bus.isSynced(item) ? item.type : item.durable?.seq))).toEqual([
         Event.Seq.make(0),
@@ -1284,9 +1284,9 @@ describe("Bus", () => {
       const bus = yield* Bus.Service
       const aggregateID = Session.ID.create()
 
-      const empty = Array.from(yield* Stream.runCollect(bus.log({ aggregateID })))
+      const empty = yield* Stream.runCollect(bus.log({ aggregateID }))
       yield* bus.publish(DurableMessage, durableData(aggregateID, "zero"))
-      const drained = Array.from(yield* Stream.runCollect(bus.log({ aggregateID, after: 0 })))
+      const drained = yield* Stream.runCollect(bus.log({ aggregateID, after: 0 }))
 
       expect(empty).toEqual([{ type: "log.synced", aggregateID }])
       expect(empty[0]).not.toHaveProperty("seq")
@@ -1306,7 +1306,7 @@ describe("Bus", () => {
 
       yield* bus.publish(DurableMessage, durableData(aggregateID, "one"))
 
-      const items = Array.from(yield* Fiber.join(fiber))
+      const items = yield* Fiber.join(fiber)
       expect(items.map((item) => (Bus.isSynced(item) ? item : item.durable?.seq))).toEqual([
         Event.Seq.make(0),
         { type: "log.synced", aggregateID, seq: Event.Seq.make(0) },
@@ -1330,7 +1330,7 @@ describe("Bus", () => {
         yield* bus.publish(DurableMessage, durableData(aggregateID, "three"))
         yield* bus.publish(DurableMessage, durableData(aggregateID, "four"))
 
-        const items = Array.from(yield* Stream.runCollect(bus.log({ aggregateID })))
+        const items = yield* Stream.runCollect(bus.log({ aggregateID }))
 
         expect(items.map((item) => (Bus.isSynced(item) ? item.type : item.durable?.seq))).toEqual([
           Event.Seq.make(0),
@@ -1378,7 +1378,7 @@ describe("Bus", () => {
         yield* bus.publish(DurableMessage, durableData(aggregateID, "one"))
         yield* Deferred.succeed(releaseRead, undefined)
 
-        const items = Array.from(yield* Fiber.join(fiber))
+        const items = yield* Fiber.join(fiber)
         expect(items.map((item) => (Bus.isSynced(item) ? item : item.durable?.seq))).toEqual([
           Event.Seq.make(0),
           { type: "log.synced", aggregateID, seq: Event.Seq.make(0) },

packages/core/test/effect/cross-spawn-spawner.test.ts

@@ -17,18 +17,7 @@ function js(code: string, opts?: ChildProcess.CommandOptions) {
 }
 
 function decodeByteStream(stream: Stream.Stream<Uint8Array, PlatformError.PlatformError>) {
-  return Stream.runCollect(stream).pipe(
-    Effect.map((chunks) => {
-      const total = chunks.reduce((acc, x) => acc + x.length, 0)
-      const out = new Uint8Array(total)
-      let off = 0
-      for (const chunk of chunks) {
-        out.set(chunk, off)
-        off += chunk.length
-      }
-      return new TextDecoder("utf-8").decode(out).trim()
-    }),
-  )
+  return Stream.mkUint8Array(stream).pipe(Effect.map((bytes) => new TextDecoder("utf-8").decode(bytes).trim()))
 }
 
 function alive(pid: number) {

packages/core/test/integration.test.ts

@@ -186,7 +186,7 @@ describe("Integration", () => {
           value: Credential.Key.make({ type: "key", key: "secret", configuration: { accountId: "account" } }),
         }),
       ])
-      expect(Array.from(yield* Fiber.join(created), (event) => ({ type: event.type, data: event.data }))).toEqual([
+      expect((yield* Fiber.join(created)).map((event) => ({ type: event.type, data: event.data }))).toEqual([
         { type: Credential.Event.Updated.type, data: {} },
         { type: Credential.Event.Switched.type, data: { credentialID: stored[0]?.id, integrationID } },
       ])

packages/core/test/worktree.test.ts

@@ -183,7 +183,7 @@ describe("Worktree", () => {
           { directory: created.directory, strategy: "git" },
         ].toSorted((a, b) => a.directory.localeCompare(b.directory)),
       )
-      expect(Array.from(yield* Fiber.join(fiber))[0]?.data).toEqual({ projectID: input.projectID })
+      expect((yield* Fiber.join(fiber))[0]?.data).toEqual({ projectID: input.projectID })
 
       yield* worktree.remove({ projectID: input.projectID, directory: created.directory, force: false })
 
@@ -514,7 +514,7 @@ describe("Worktree", () => {
           { directory: discovered, strategy: "git" },
         ].toSorted((a, b) => a.directory.localeCompare(b.directory)),
       )
-      expect(Array.from(yield* Fiber.join(fiber))[0]?.data).toEqual({ projectID: input.projectID })
+      expect((yield* Fiber.join(fiber))[0]?.data).toEqual({ projectID: input.projectID })
 
       yield* Effect.promise(() => $`git worktree remove --force ${target}`.cwd(input.root.path).quiet())
       expect(yield* worktree.refresh({ projectID: input.projectID })).toEqual({ updated: [], removed: [discovered] })