@livestore/utils 0.3.0-dev.3 → 0.3.0-dev.30

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "@livestore/utils",
-  "version": "0.3.0-dev.3",
+  "version": "0.3.0-dev.30",
+  "type": "module",
   "sideEffects": [
-    "./dist/global.js"
+    "./dist/global.js",
+    "./dist/node-vitest/polyfill.js"
   ],
-  "type": "module",
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
@@ -13,12 +14,11 @@
     "./cuid": {
       "types": "./dist/cuid/cuid.node.d.ts",
       "node": "./dist/cuid/cuid.node.js",
-      "react-native": "./dist/cuid/cuid.browser.js",
-      "browser": "./dist/cuid/cuid.browser.js"
+      "browser": "./dist/cuid/cuid.browser.js",
+      "react-native": "./dist/cuid/cuid.browser.js"
     },
     "./nanoid": {
       "types": "./dist/nanoid/index.d.ts",
-      "react-native": "./dist/nanoid/index.browser.js",
       "default": "./dist/nanoid/index.js"
     },
     "./effect": {
@@ -29,6 +29,10 @@
       "types": "./dist/node/mod.d.ts",
       "default": "./dist/node/mod.js"
     },
+    "./bun": {
+      "types": "./dist/bun/mod.d.ts",
+      "default": "./dist/bun/mod.js"
+    },
     "./node-vitest": {
       "types": "./dist/node-vitest/mod.d.ts",
       "default": "./dist/node-vitest/mod.js"
@@ -38,7 +42,6 @@
       "default": "./dist/node-vitest/polyfill.js"
     }
   },
-  "react-native": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "typesVersions": {
     "*": {
@@ -54,6 +57,9 @@
       "./node": [
         "./dist/node/mod.d.ts"
       ],
+      "./bun": [
+        "./dist/bun/mod.d.ts"
+      ],
       "./node-vitest": [
         "./dist/node-vitest/mod.d.ts"
       ],
@@ -63,46 +69,63 @@
     }
   },
   "dependencies": {
-    "msgpackr": "^1.11.2",
-    "nanoid": "^5.0.7",
-    "pretty-bytes": "^6.1.1",
-    "@livestore/db-schema": "0.3.0-dev.3"
-  },
-  "peerDependencies": {
-    "@effect/cli": "^0.50.2",
-    "@effect/experimental": "^0.36.1",
-    "@effect/opentelemetry": "^0.42.1",
-    "@effect/platform": "^0.72.1",
-    "@effect/platform-browser": "^0.51.1",
-    "@effect/platform-bun": "^0.52.1",
-    "@effect/platform-node": "^0.68.1",
-    "@effect/vitest": "^0.16.1",
-    "@opentelemetry/api": "^1.9.0",
-    "effect": "^3.11.7"
+    "@standard-schema/spec": "1.0.0",
+    "msgpackr": "1.11.2",
+    "nanoid": "5.1.3",
+    "pretty-bytes": "6.1.1"
   },
   "devDependencies": {
-    "@effect/cli": "^0.51.1",
-    "@effect/experimental": "0.36.1",
-    "@effect/opentelemetry": "0.42.1",
-    "@effect/platform": "0.72.1",
-    "@effect/platform-browser": "0.51.1",
-    "@effect/platform-bun": "0.52.1",
-    "@effect/platform-node": "0.68.1",
-    "@effect/vitest": "0.16.1",
+    "@effect/cli": "^0.59.8",
+    "@effect/cluster": "^0.29.17",
+    "@effect/experimental": "^0.44.8",
+    "@effect/opentelemetry": "^0.46.4",
+    "@effect/platform": "^0.80.8",
+    "@effect/platform-browser": "^0.59.8",
+    "@effect/platform-bun": "^0.60.17",
+    "@effect/platform-node": "^0.76.17",
+    "@effect/printer": "^0.42.8",
+    "@effect/printer-ansi": "^0.42.8",
+    "@effect/rpc": "^0.55.12",
+    "@effect/sql": "^0.33.8",
+    "@effect/typeclass": "^0.33.8",
+    "@effect/vitest": "^0.20.8",
     "@opentelemetry/api": "^1.9.0",
-    "@opentelemetry/exporter-metrics-otlp-http": "0.57.0",
-    "@opentelemetry/exporter-trace-otlp-http": "0.57.0",
-    "@opentelemetry/sdk-metrics": "1.30.0",
-    "@opentelemetry/sdk-trace-base": "1.30.0",
-    "@opentelemetry/sdk-trace-node": "1.30.0",
-    "@types/node": "22.10.5",
-    "@types/web": "^0.0.175",
-    "effect": "3.12.1",
-    "vitest": "^2.1.4"
+    "@opentelemetry/exporter-metrics-otlp-http": "^0.200.0",
+    "@opentelemetry/exporter-trace-otlp-http": "^0.200.0",
+    "@opentelemetry/resources": "^2.0.0",
+    "@opentelemetry/sdk-metrics": "^2.0.0",
+    "@opentelemetry/sdk-trace-base": "^2.0.0",
+    "@opentelemetry/sdk-trace-node": "^2.0.0",
+    "@types/bun": "^1.2.4",
+    "@types/jsdom": "^21.1.7",
+    "@types/node": "^22.13.10",
+    "@types/web": "^0.0.203",
+    "effect": "^3.14.8",
+    "jsdom": "^26.0.0",
+    "vitest": "^3.1.1"
+  },
+  "peerDependencies": {
+    "@effect/cli": "~0.59.8",
+    "@effect/cluster": "~0.29.17",
+    "@effect/experimental": "~0.44.8",
+    "@effect/opentelemetry": "~0.46.4",
+    "@effect/platform": "~0.80.8",
+    "@effect/platform-browser": "~0.59.8",
+    "@effect/platform-bun": "~0.60.17",
+    "@effect/platform-node": "~0.76.17",
+    "@effect/printer": "~0.42.8",
+    "@effect/printer-ansi": "~0.42.8",
+    "@effect/rpc": "~0.55.12",
+    "@effect/sql": "~0.33.8",
+    "@effect/typeclass": "~0.33.8",
+    "@effect/vitest": "~0.20.8",
+    "@opentelemetry/api": "~1.9.0",
+    "effect": "~3.14.8"
   },
   "publishConfig": {
     "access": "public"
   },
+  "react-native": "./dist/index.js",
   "scripts": {
     "test": "vitest"
   }

package/src/bun/mod.ts

@@ -0,0 +1,12 @@
+import { $ } from 'bun'
+import { Effect } from 'effect'
+
+export * as PlatformBun from '@effect/platform-bun'
+
+export const cmd = (_: string) =>
+  Effect.promise(() => {
+    console.log(`Running command: ${_}`)
+    return $`${{ raw: _ }}`
+  })
+
+export { $ } from 'bun'

package/src/effect/BucketQueue.ts

@@ -1,4 +1,4 @@
-import { Array, STM, TRef } from 'effect'
+import { Array, Effect, STM, TRef } from 'effect'
 
 export type BucketQueue<A> = TRef.TRef<A[]>
 
@@ -7,16 +7,43 @@ export const make = <A>(): STM.STM<BucketQueue<A>> => TRef.make<A[]>([])
 export const offerAll = <A>(self: BucketQueue<A>, elements: ReadonlyArray<A>) =>
   TRef.update(self, (bucket) => Array.appendAll(bucket, elements))
 
+export const replace = <A>(self: BucketQueue<A>, elements: ReadonlyArray<A>) => TRef.set(self, elements as A[])
+
 export const clear = <A>(self: BucketQueue<A>) => TRef.set(self, [])
 
-export const takeBetween = <A>(self: BucketQueue<A>, min: number, max: number) =>
+export const takeBetween = <A>(
+  bucket: BucketQueue<A>,
+  min: number,
+  max: number,
+): STM.STM<ReadonlyArray<A>, never, never> =>
   STM.gen(function* () {
-    const bucket = yield* TRef.get(self)
-    if (bucket.length < min) {
+    const bucketValue = yield* TRef.get(bucket)
+    if (bucketValue.length < min) {
       return yield* STM.retry
     } else {
-      const elements = bucket.splice(0, Math.min(max, bucket.length))
-      yield* TRef.set(self, bucket)
+      const elements = bucketValue.splice(0, Math.min(max, bucketValue.length))
+      yield* TRef.set(bucket, bucketValue)
       return elements
     }
   })
+
+export const peekAll = <A>(bucket: BucketQueue<A>) => TRef.get(bucket)
+
+/** Returns the elements up to the first element that matches the predicate, the rest is left in the queue
+ *
+ * @example
+ * ```ts
+ * const [elements, rest] = yield* BucketQueue.takeSplitWhere(bucket, (a) => a > 3)
+ * assert.deepStrictEqual(elements, [1, 2, 3])
+ * assert.deepStrictEqual(rest, [4, 5, 6])
+ * ```
+ */
+export const takeSplitWhere = <A>(bucket: BucketQueue<A>, predicate: (a: A) => boolean) =>
+  STM.gen(function* () {
+    const bucketValue = yield* TRef.get(bucket)
+    const [elements, rest] = Array.splitWhere(bucketValue, predicate)
+    yield* TRef.set(bucket, rest)
+    return elements
+  })
+
+export const size = <A>(bucket: BucketQueue<A>) => TRef.get(bucket).pipe(Effect.map((_) => _.length))

package/src/effect/Effect.ts

@@ -1,11 +1,11 @@
 import * as OtelTracer from '@effect/opentelemetry/Tracer'
-import type { Context, Duration, Scope, Stream } from 'effect'
-import { Cause, Deferred, Effect, Fiber, FiberRef, HashSet, Logger, pipe } from 'effect'
+import type { Context, Duration, Stream } from 'effect'
+import { Cause, Deferred, Effect, Fiber, FiberRef, HashSet, Logger, pipe, Scope } from 'effect'
 import type { UnknownException } from 'effect/Cause'
 import { log } from 'effect/Console'
 import type { LazyArg } from 'effect/Function'
 
-import { isNonEmptyString, isPromise } from '../index.js'
+import { isPromise } from '../index.js'
 import { UnknownError } from './Error.js'
 
 export * from 'effect/Effect'
@@ -25,6 +25,18 @@ export * from 'effect/Effect'
 //     console.error(message, ...rest)
 //   })
 
+/** Same as `Effect.scopeWith` but with a `CloseableScope` instead of a `Scope`. */
+export const scopeWithCloseable = <R, E, A>(
+  fn: (scope: Scope.CloseableScope) => Effect.Effect<A, E, R | Scope.Scope>,
+): Effect.Effect<A, E, R | Scope.Scope> =>
+  Effect.gen(function* () {
+    // const parentScope = yield* Scope.Scope
+    // const scope = yield* Scope.fork(parentScope, ExecutionStrategy.sequential)
+    const scope = yield* Scope.make()
+    yield* Effect.addFinalizer((exit) => Scope.close(scope, exit))
+    return yield* fn(scope).pipe(Scope.extend(scope))
+  })
+
 export const tryAll = <Res>(
   fn: () => Res,
 ): Res extends Effect.Effect<infer A, infer E, never>
@@ -42,17 +54,6 @@ export const tryAll = <Res>(
     ),
   ) as any
 
-const getThreadName = () => {
-  // @ts-expect-error TODO fix types
-  const globalName = globalThis.name
-  return isNonEmptyString(globalName)
-    ? globalName
-    : // eslint-disable-next-line unicorn/prefer-global-this
-      typeof window === 'object'
-      ? 'Main Thread'
-      : 'unknown-thread'
-}
-
 export const acquireReleaseLog = (label: string) =>
   Effect.acquireRelease(Effect.log(`${label} acquire`), (_, ex) => Effect.log(`${label} release`, ex))
 
@@ -76,9 +77,8 @@ export const tapCauseLogPretty = <R, E, A>(eff: Effect.Effect<A, E, R>): Effect.
         Effect.catchTag('NoSuchElementException', (_) => Effect.succeed(undefined)),
       )
 
-      const threadName = getThreadName()
       const firstErrLine = cause.toString().split('\n')[0]
-      yield* Effect.logError(`Error on ${threadName}: ${firstErrLine}`, cause).pipe((_) =>
+      yield* Effect.logError(firstErrLine, cause).pipe((_) =>
         span === undefined
           ? _
           : Effect.annotateLogs({ spanId: span.spanContext().spanId, traceId: span.spanContext().traceId })(_),
@@ -113,11 +113,11 @@ export const logWarnIfTakesLongerThan =
     Effect.gen(function* () {
       const runtime = yield* Effect.runtime<never>()
 
-      let timedOut = false
+      let tookLongerThanTimer = false
 
       const timeoutFiber = Effect.sleep(duration).pipe(
         Effect.tap(() => {
-          timedOut = true
+          tookLongerThanTimer = true
           // TODO include span info
           return Effect.logWarning(`${label}: Took longer than ${duration}ms`)
         }),
@@ -126,9 +126,22 @@ export const logWarnIfTakesLongerThan =
       )
 
       const start = Date.now()
-      const res = yield* eff.pipe(Effect.exit)
+      const res = yield* eff.pipe(
+        Effect.exit,
+        Effect.onInterrupt(
+          Effect.fn(function* () {
+            const end = Date.now()
+
+            yield* Fiber.interrupt(timeoutFiber)
+
+            if (tookLongerThanTimer) {
+              yield* Effect.logWarning(`${label}: Interrupted after ${end - start}ms`)
+            }
+          }),
+        ),
+      )
 
-      if (timedOut) {
+      if (tookLongerThanTimer) {
         const end = Date.now()
         yield* Effect.logWarning(`${label}: Actual duration: ${end - start}ms`)
       }

package/src/effect/Logger.ts

@@ -1,4 +1,4 @@
-import { Logger } from 'effect'
+import { Cause, HashMap, Logger, LogLevel } from 'effect'
 
 export * from 'effect/Logger'
 
@@ -14,4 +14,26 @@ export const prettyWithThread = (threadName: string) =>
     Logger.prettyLogger({
       formatDate: (date) => `${defaultDateFormat(date)} ${threadName}`,
     }),
+    // consoleLogger(threadName),
   )
+
+export const consoleLogger = (threadName: string) =>
+  Logger.make(({ message, annotations, date, logLevel, cause }) => {
+    const consoleFn =
+      logLevel === LogLevel.Debug
+        ? console.debug
+        : logLevel === LogLevel.Info
+          ? console.info
+          : logLevel === LogLevel.Warning
+            ? console.warn
+            : console.error
+
+    const annotationsObj = Object.fromEntries(HashMap.entries(annotations))
+
+    const messages = Array.isArray(message) ? message : [message]
+    if (Cause.isEmpty(cause) === false) {
+      messages.push(Cause.pretty(cause, { renderErrorCause: true }))
+    }
+
+    consoleFn(`[${defaultDateFormat(date)} ${threadName}]`, ...messages, annotationsObj)
+  })

package/src/effect/Schema/index.ts

@@ -1,8 +1,11 @@
 import { Transferable } from '@effect/platform'
+import type { SchemaAST } from 'effect'
 import { Effect, Hash, ParseResult, Schema } from 'effect'
 import type { ParseError } from 'effect/ParseResult'
 import type { ParseOptions } from 'effect/SchemaAST'
 
+import { shouldNeverHappen } from '../../index.js'
+
 export * from 'effect/Schema'
 export * from './debug-diff.js'
 export * from './msgpack.js'
@@ -34,6 +37,30 @@ export const encodeWithTransferables =
       return [encoded, collector.unsafeRead() as Transferable[]]
     })
 
+export const decodeSyncDebug: <A, I>(
+  schema: Schema.Schema<A, I, never>,
+  options?: SchemaAST.ParseOptions,
+) => (i: I, overrideOptions?: SchemaAST.ParseOptions) => A = (schema, options) => (input, overrideOptions) => {
+  const res = Schema.decodeEither(schema, options)(input, overrideOptions)
+  if (res._tag === 'Left') {
+    return shouldNeverHappen(`decodeSyncDebug failed:`, res.left)
+  } else {
+    return res.right
+  }
+}
+
+export const encodeSyncDebug: <A, I>(
+  schema: Schema.Schema<A, I, never>,
+  options?: SchemaAST.ParseOptions,
+) => (a: A, overrideOptions?: SchemaAST.ParseOptions) => I = (schema, options) => (input, overrideOptions) => {
+  const res = Schema.encodeEither(schema, options)(input, overrideOptions)
+  if (res._tag === 'Left') {
+    return shouldNeverHappen(`encodeSyncDebug failed:`, res.left)
+  } else {
+    return res.right
+  }
+}
+
 export const swap = <A, I, R>(schema: Schema.Schema<A, I, R>): Schema.Schema<I, A, R> =>
   Schema.transformOrFail(Schema.typeSchema(schema), Schema.encodedSchema(schema), {
     decode: ParseResult.encode(schema),

package/src/effect/Subscribable.ts

@@ -0,0 +1,150 @@
+// Fork of effect/Subscribable.ts which makes Subscribable yieldable
+
+/**
+ * @since 2.0.0
+ */
+
+import type { SubscriptionRef } from 'effect'
+import { Effect, Effectable, Readable, Stream } from 'effect'
+import { dual } from 'effect/Function'
+import { hasProperty } from 'effect/Predicate'
+
+/**
+ * @since 2.0.0
+ * @category type ids
+ */
+export const TypeId: unique symbol = Symbol.for('effect/Subscribable')
+
+/**
+ * @since 2.0.0
+ * @category type ids
+ */
+export type TypeId = typeof TypeId
+
+/**
+ * @since 2.0.0
+ * @category models
+ */
+export interface Subscribable<A, E = never, R = never> extends Readable.Readable<A, E, R>, Effect.Effect<A, E, R> {
+  readonly [TypeId]: TypeId
+  readonly changes: Stream.Stream<A, E, R>
+}
+
+/**
+ * @since 2.0.0
+ * @category refinements
+ */
+export const isSubscribable = (u: unknown): u is Subscribable<unknown, unknown, unknown> => hasProperty(u, TypeId)
+
+// const Proto: Omit<Subscribable<any>, 'get' | 'changes'> = {
+//   [Readable.TypeId]: Readable.TypeId,
+//   [TypeId]: TypeId,
+//   pipe() {
+//     return pipeArguments(this, arguments)
+//   },
+// }
+
+class SubscribableImpl<in out A> extends Effectable.Class<A> implements Subscribable<A> {
+  // @ts-expect-error type symbol
+  readonly [TypeId] = TypeId
+  // @ts-expect-error type symbol
+  readonly [Readable.TypeId] = Readable.TypeId
+  constructor(
+    readonly get: Effect.Effect<A>,
+    readonly changes: Stream.Stream<A>,
+  ) {
+    super()
+  }
+  // eslint-disable-next-line prefer-arrow/prefer-arrow-functions
+  commit() {
+    return this.get
+  }
+}
+
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+// export const make = <A, E, R>(options: {
+//   readonly get: Effect.Effect<A, E, R>
+//   readonly changes: Stream.Stream<A, E, R>
+// }): Subscribable<A, E, R> => Object.assign(Object.create(Proto), options)
+
+export const make = <A, E, R>(options: {
+  readonly get: Effect.Effect<A, E, R>
+  readonly changes: Stream.Stream<A, E, R>
+}): Subscribable<A, E, R> => new SubscribableImpl(options.get as any, options.changes as any) as Subscribable<A, E, R>
+
+export const fromSubscriptionRef = <A>(ref: SubscriptionRef.SubscriptionRef<A>): Subscribable<A> =>
+  make({
+    get: ref.get,
+    changes: ref.changes,
+  })
+
+/**
+ * @since 2.0.0
+ * @category combinators
+ */
+export const map: {
+  /**
+   * @since 2.0.0
+   * @category combinators
+   */
+  <A, B>(f: (a: NoInfer<A>) => B): <E, R>(fa: Subscribable<A, E, R>) => Subscribable<B, E, R>
+  /**
+   * @since 2.0.0
+   * @category combinators
+   */
+  <A, E, R, B>(self: Subscribable<A, E, R>, f: (a: NoInfer<A>) => B): Subscribable<B, E, R>
+} = dual(
+  2,
+  <A, E, R, B>(self: Subscribable<A, E, R>, f: (a: NoInfer<A>) => B): Subscribable<B, E, R> =>
+    make({
+      get: Effect.map(self.get, f),
+      changes: Stream.map(self.changes, f),
+    }),
+)
+
+/**
+ * @since 2.0.0
+ * @category combinators
+ */
+export const mapEffect: {
+  /**
+   * @since 2.0.0
+   * @category combinators
+   */
+  <A, B, E2, R2>(
+    f: (a: NoInfer<A>) => Effect.Effect<B, E2, R2>,
+  ): <E, R>(fa: Subscribable<A, E, R>) => Subscribable<B, E | E2, R | R2>
+  /**
+   * @since 2.0.0
+   * @category combinators
+   */
+  <A, E, R, B, E2, R2>(
+    self: Subscribable<A, E, R>,
+    f: (a: NoInfer<A>) => Effect.Effect<B, E2, R2>,
+  ): Subscribable<B, E | E2, R | R2>
+} = dual(
+  2,
+  <A, E, R, B, E2, R2>(
+    self: Subscribable<A, E, R>,
+    f: (a: NoInfer<A>) => Effect.Effect<B, E2, R2>,
+  ): Subscribable<B, E | E2, R | R2> =>
+    make({
+      get: Effect.flatMap(self.get, f),
+      changes: Stream.mapEffect(self.changes, f),
+    }),
+)
+
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+export const unwrap = <A, E, R, E1, R1>(
+  effect: Effect.Effect<Subscribable<A, E, R>, E1, R1>,
+): Subscribable<A, E | E1, R | R1> =>
+  make({
+    get: Effect.flatMap(effect, (s) => s.get),
+    changes: Stream.unwrap(Effect.map(effect, (s) => s.changes)),
+  })

package/src/effect/WebChannel/WebChannel.test.ts

@@ -0,0 +1,106 @@
+import * as Vitest from '@effect/vitest'
+import { Effect, Schema, Stream } from 'effect'
+import { JSDOM } from 'jsdom'
+
+import * as WebChannel from './WebChannel.js'
+
+Vitest.describe('WebChannel', () => {
+  Vitest.describe('windowChannel', () => {
+    Vitest.scopedLive('should work with 2 windows', () =>
+      Effect.gen(function* () {
+        const windowA = new JSDOM().window as unknown as globalThis.Window
+        const windowB = new JSDOM().window as unknown as globalThis.Window
+
+        const codeSideA = Effect.gen(function* () {
+          const channelToB = yield* WebChannel.windowChannel2({
+            listenWindow: windowA,
+            sendWindow: windowB,
+            ids: { own: 'a', other: 'b' },
+            schema: Schema.Number,
+          })
+
+          const msgFromBFiber = yield* channelToB.listen.pipe(
+            Stream.flatten(),
+            Stream.runHead,
+            Effect.flatten,
+            Effect.fork,
+          )
+
+          yield* channelToB.send(1)
+
+          Vitest.expect(yield* msgFromBFiber).toEqual(2)
+        })
+
+        const codeSideB = Effect.gen(function* () {
+          const channelToA = yield* WebChannel.windowChannel2({
+            listenWindow: windowB,
+            sendWindow: windowA,
+            ids: { own: 'b', other: 'a' },
+            schema: Schema.Number,
+          })
+
+          const msgFromAFiber = yield* channelToA.listen.pipe(
+            Stream.flatten(),
+            Stream.runHead,
+            Effect.flatten,
+            Effect.fork,
+          )
+
+          yield* channelToA.send(2)
+
+          Vitest.expect(yield* msgFromAFiber).toEqual(1)
+        })
+
+        yield* Effect.all([codeSideA, codeSideB], { concurrency: 'unbounded' })
+      }),
+    )
+
+    Vitest.scopedLive('should work with the same window', () =>
+      Effect.gen(function* () {
+        const window = new JSDOM().window as unknown as globalThis.Window
+
+        const codeSideA = Effect.gen(function* () {
+          const channelToB = yield* WebChannel.windowChannel2({
+            listenWindow: window,
+            sendWindow: window,
+            ids: { own: 'a', other: 'b' },
+            schema: Schema.Number,
+          })
+
+          const msgFromBFiber = yield* channelToB.listen.pipe(
+            Stream.flatten(),
+            Stream.runHead,
+            Effect.flatten,
+            Effect.fork,
+          )
+
+          yield* channelToB.send(1)
+
+          Vitest.expect(yield* msgFromBFiber).toEqual(2)
+        })
+
+        const codeSideB = Effect.gen(function* () {
+          const channelToA = yield* WebChannel.windowChannel2({
+            listenWindow: window,
+            sendWindow: window,
+            ids: { own: 'b', other: 'a' },
+            schema: Schema.Number,
+          })
+
+          const msgFromAFiber = yield* channelToA.listen.pipe(
+            Stream.flatten(),
+            Stream.runHead,
+            Effect.flatten,
+            Effect.fork,
+          )
+
+          yield* channelToA.send(2)
+
+          Vitest.expect(yield* msgFromAFiber).toEqual(1)
+        })
+
+        yield* Effect.all([codeSideA, codeSideB], { concurrency: 'unbounded' })
+      }),
+    )
+  })
+})