@livestore/utils 0.3.0-dev.19 → 0.3.0-dev.20

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@livestore/utils",
-  "version": "0.3.0-dev.19",
+  "version": "0.3.0-dev.20",
   "type": "module",
   "sideEffects": [
     "./dist/global.js",
@@ -19,7 +19,6 @@
     },
     "./nanoid": {
       "types": "./dist/nanoid/index.d.ts",
-      "react-native": "./dist/nanoid/index.browser.js",
       "default": "./dist/nanoid/index.js"
     },
     "./effect": {
@@ -70,42 +69,51 @@
     }
   },
   "dependencies": {
+    "@standard-schema/spec": "1.0.0",
     "msgpackr": "1.11.2",
-    "nanoid": "5.1.0",
+    "nanoid": "5.1.3",
     "pretty-bytes": "6.1.1"
   },
   "devDependencies": {
-    "@effect/cli": "^0.56.1",
-    "@effect/experimental": "^0.41.1",
-    "@effect/opentelemetry": "^0.44.1",
-    "@effect/platform": "^0.77.1",
-    "@effect/platform-browser": "^0.56.1",
-    "@effect/platform-bun": "^0.57.1",
-    "@effect/platform-node": "^0.73.1",
-    "@effect/vitest": "^0.18.1",
+    "@effect/cli": "^0.57.1",
+    "@effect/experimental": "^0.42.1",
+    "@effect/opentelemetry": "^0.44.8",
+    "@effect/platform": "^0.78.1",
+    "@effect/platform-browser": "^0.57.1",
+    "@effect/platform-bun": "^0.58.1",
+    "@effect/platform-node": "^0.74.1",
+    "@effect/printer": "^0.41.8",
+    "@effect/printer-ansi": "^0.41.8",
+    "@effect/typeclass": "^0.32.8",
+    "@effect/vitest": "^0.19.6",
     "@opentelemetry/api": "^1.9.0",
-    "@opentelemetry/exporter-metrics-otlp-http": "^0.57.0",
+    "@opentelemetry/exporter-metrics-otlp-http": "^0.57.2",
     "@opentelemetry/exporter-trace-otlp-http": "^0.57.2",
-    "@opentelemetry/sdk-metrics": "^1.30.0",
+    "@opentelemetry/sdk-metrics": "^1.30.1",
     "@opentelemetry/sdk-trace-base": "^1.30.1",
-    "@opentelemetry/sdk-trace-node": "^1.30.0",
-    "@types/bun": "^1.1.12",
-    "@types/node": "^22.10.10",
+    "@opentelemetry/sdk-trace-node": "^1.30.1",
+    "@types/bun": "^1.2.4",
+    "@types/jsdom": "^21.1.7",
+    "@types/node": "^22.13.10",
     "@types/web": "^0.0.203",
-    "effect": "^3.13.1",
-    "vitest": "^2.1.4"
+    "effect": "^3.13.8",
+    "jsdom": "^26.0.0",
+    "vitest": "^3.0.8"
   },
   "peerDependencies": {
-    "@effect/cli": "~0.56.1",
-    "@effect/experimental": "~0.41.1",
-    "@effect/opentelemetry": "~0.44.1",
-    "@effect/platform": "~0.77.1",
-    "@effect/platform-browser": "~0.56.1",
-    "@effect/platform-bun": "~0.57.1",
-    "@effect/platform-node": "~0.73.1",
-    "@effect/vitest": "~0.18.1",
+    "@effect/cli": "~0.57.1",
+    "@effect/experimental": "~0.42.1",
+    "@effect/opentelemetry": "~0.44.8",
+    "@effect/platform": "~0.78.1",
+    "@effect/platform-browser": "~0.57.1",
+    "@effect/platform-bun": "~0.58.1",
+    "@effect/platform-node": "~0.74.1",
+    "@effect/printer": "~0.41.8",
+    "@effect/printer-ansi": "~0.41.8",
+    "@effect/typeclass": "~0.32.8",
+    "@effect/vitest": "~0.19.6",
     "@opentelemetry/api": "~1.9.0",
-    "effect": "~3.13.1"
+    "effect": "~3.13.8"
   },
   "publishConfig": {
     "access": "public"

package/src/effect/Subscribable.ts

@@ -4,6 +4,7 @@
  * @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'
@@ -74,6 +75,12 @@ export const make = <A, E, R>(options: {
   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

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' })
+      }),
+    )
+  })
+})

package/src/effect/WebChannel/WebChannel.ts

@@ -1,4 +1,4 @@
-import { Deferred, Either, Exit, Option, Queue, Scope } from 'effect'
+import { Deferred, Either, Exit, GlobalValue, Option, PubSub, Queue, Scope } from 'effect'
 
 import * as Effect from '../Effect.js'
 import * as Schema from '../Schema/index.js'
@@ -27,6 +27,7 @@ export const noopChannel = <MsgListen, MsgSend>(): Effect.Effect<WebChannel<MsgL
     }).pipe(Effect.withSpan(`WebChannel:noopChannel`)),
   )
 
+/** Only works in browser environments */
 export const broadcastChannel = <MsgListen, MsgSend, MsgListenEncoded, MsgSendEncoded>({
   channelName,
   schema: inputSchema,
@@ -69,6 +70,84 @@ export const broadcastChannel = <MsgListen, MsgSend, MsgListenEncoded, MsgSendEn
     }).pipe(Effect.withSpan(`WebChannel:broadcastChannel(${channelName})`)),
   )
 
+/**
+ * NOTE the `listenName` and `sendName` is needed for cases where both sides are using the same window
+ * e.g. for a browser extension, so we need a way to know for which side a message is intended for.
+ */
+export const windowChannel2 = <MsgListen, MsgSend, MsgListenEncoded, MsgSendEncoded>({
+  listenWindow,
+  sendWindow,
+  targetOrigin = '*',
+  ids,
+  schema: inputSchema,
+}: {
+  listenWindow: Window
+  sendWindow: Window
+  targetOrigin?: string
+  ids: { own: string; other: string }
+  schema: InputSchema<MsgListen, MsgSend, MsgListenEncoded, MsgSendEncoded>
+}): Effect.Effect<WebChannel<MsgListen, MsgSend>, never, Scope.Scope> =>
+  Effect.scopeWithCloseable((scope) =>
+    Effect.gen(function* () {
+      const schema = mapSchema(inputSchema)
+
+      const debugInfo = {
+        sendTotal: 0,
+        listenTotal: 0,
+        targetOrigin,
+        ids,
+      }
+
+      const WindowMessageListen = Schema.Struct({
+        message: schema.listen,
+        from: Schema.Literal(ids.other),
+        to: Schema.Literal(ids.own),
+      }).annotations({ title: 'webmesh.WindowMessageListen' })
+
+      const WindowMessageSend = Schema.Struct({
+        message: schema.send,
+        from: Schema.Literal(ids.own),
+        to: Schema.Literal(ids.other),
+      }).annotations({ title: 'webmesh.WindowMessageSend' })
+
+      const send = (message: MsgSend) =>
+        Effect.gen(function* () {
+          debugInfo.sendTotal++
+
+          const [messageEncoded, transferables] = yield* Schema.encodeWithTransferables(WindowMessageSend)({
+            message,
+            from: ids.own,
+            to: ids.other,
+          })
+          sendWindow.postMessage(messageEncoded, targetOrigin, transferables)
+        })
+
+      const listen = Stream.fromEventListener<MessageEvent>(listenWindow, 'message').pipe(
+        // Stream.tap((_) => Effect.log(`${ids.other}→${ids.own}:message`, _.data)),
+        Stream.filter((_) => Schema.is(Schema.encodedSchema(WindowMessageListen))(_.data)),
+        Stream.map((_) => {
+          debugInfo.listenTotal++
+          return Schema.decodeEither(schema.listen)(_.data.message)
+        }),
+        listenToDebugPing('window'),
+      )
+
+      const closedDeferred = yield* Deferred.make<void>().pipe(Effect.acquireRelease(Deferred.done(Exit.void)))
+      const supportsTransferables = true
+
+      return {
+        [WebChannelSymbol]: WebChannelSymbol,
+        send,
+        listen,
+        closedDeferred,
+        shutdown: Scope.close(scope, Exit.succeed('shutdown')),
+        schema,
+        supportsTransferables,
+        debugInfo,
+      }
+    }).pipe(Effect.withSpan(`WebChannel:windowChannel`)),
+  )
+
 export const windowChannel = <MsgListen, MsgSend, MsgListenEncoded, MsgSendEncoded>({
   window,
   targetOrigin = '*',
@@ -154,6 +233,49 @@ export const messagePortChannel: {
     }).pipe(Effect.withSpan(`WebChannel:messagePortChannel`)),
   )
 
+const sameThreadChannels = GlobalValue.globalValue(
+  'livestore:sameThreadChannels',
+  () => new Map<string, PubSub.PubSub<any>>(),
+)
+
+export const sameThreadChannel = <MsgListen, MsgSend, MsgListenEncoded, MsgSendEncoded>({
+  schema: inputSchema,
+  channelName,
+}: {
+  schema: InputSchema<MsgListen, MsgSend, MsgListenEncoded, MsgSendEncoded>
+  channelName: string
+}): Effect.Effect<WebChannel<MsgListen, MsgSend>, never, Scope.Scope> =>
+  Effect.scopeWithCloseable((scope) =>
+    Effect.gen(function* () {
+      let pubSub = sameThreadChannels.get(channelName)
+      if (pubSub === undefined) {
+        pubSub = yield* PubSub.unbounded<any>().pipe(Effect.acquireRelease(PubSub.shutdown))
+        sameThreadChannels.set(channelName, pubSub)
+      }
+
+      const schema = mapSchema(inputSchema)
+
+      const send = (message: MsgSend) =>
+        Effect.gen(function* () {
+          yield* PubSub.publish(pubSub, message)
+        })
+
+      const listen = Stream.fromPubSub(pubSub).pipe(Stream.map(Either.right), listenToDebugPing(channelName))
+
+      const closedDeferred = yield* Deferred.make<void>().pipe(Effect.acquireRelease(Deferred.done(Exit.void)))
+
+      return {
+        [WebChannelSymbol]: WebChannelSymbol,
+        send,
+        listen,
+        closedDeferred,
+        shutdown: Scope.close(scope, Exit.succeed('shutdown')),
+        schema,
+        supportsTransferables: false,
+      }
+    }),
+  )
+
 export const messagePortChannelWithAck: {
   <MsgListen, MsgSend, MsgListenEncoded, MsgSendEncoded>(args: {
     port: MessagePort

package/src/effect/WebChannel/common.ts

@@ -1,5 +1,5 @@
-import type { Deferred, Effect, Either, ParseResult } from 'effect'
-import { Predicate, Schema, Stream } from 'effect'
+import type { Deferred, Either, ParseResult } from 'effect'
+import { Effect, Predicate, Schema, Stream } from 'effect'
 
 export const WebChannelSymbol = Symbol('WebChannel')
 export type WebChannelSymbol = typeof WebChannelSymbol
@@ -46,26 +46,19 @@ export const mapSchema = <MsgListen, MsgSend, MsgListenEncoded, MsgSendEncoded>(
     ? (schemaWithDebugPing(schema) as any)
     : (schemaWithDebugPing({ send: schema, listen: schema }) as any)
 
-export const listenToDebugPing = (channelName: string) => {
-  const threadName = (() => {
-    if (typeof globalThis !== 'undefined' && Predicate.hasProperty(globalThis, 'name') && self.name !== '') {
-      return self.name
-    } else if (typeof globalThis !== 'undefined') {
-      return 'window'
-    }
-    return 'unknown thread'
-  })()
-
-  return <MsgListen>(
+export const listenToDebugPing =
+  (channelName: string) =>
+  <MsgListen>(
     stream: Stream.Stream<Either.Either<MsgListen, ParseResult.ParseError>, never>,
   ): Stream.Stream<Either.Either<MsgListen, ParseResult.ParseError>, never> =>
     stream.pipe(
-      Stream.filter((msg) => {
-        if (msg._tag === 'Right' && Schema.is(DebugPingMessage)(msg.right)) {
-          console.log(`[${threadName}] WebChannel:ping [${channelName}]`, msg.right.message, msg.right.payload)
-          return false
-        }
-        return true
-      }),
+      Stream.filterEffect(
+        Effect.fn(function* (msg) {
+          if (msg._tag === 'Right' && Schema.is(DebugPingMessage)(msg.right)) {
+            yield* Effect.logDebug(`WebChannel:ping [${channelName}] ${msg.right.message}`, msg.right.payload)
+            return false
+          }
+          return true
+        }),
+      ),
     )
-}

package/src/effect/index.ts

@@ -59,8 +59,11 @@ export {
   ExecutionStrategy,
   PrimaryKey,
   Types,
+  Cache,
 } from 'effect'
 
+export * as StandardSchema from '@standard-schema/spec'
+
 export { dual } from 'effect/Function'
 
 export * as Stream from './Stream.js'

package/src/env.ts

@@ -26,8 +26,8 @@ export const isDevEnv = () => {
   return false
 }
 
-export const TRACE_VERBOSE = true
-// export const TRACE_VERBOSE = env('LS_TRACE_VERBOSE') !== undefined || env('VITE_LS_TRACE_VERBOSE') !== undefined
+// export const TRACE_VERBOSE = true
+export const TRACE_VERBOSE = env('LS_TRACE_VERBOSE') !== undefined || env('VITE_LS_TRACE_VERBOSE') !== undefined
 
 export const LS_DEV = env('LS_DEV') !== undefined || env('VITE_LS_DEV') !== undefined
 

package/src/node/ChildProcessRunner/ChildProcessWorker.ts

@@ -23,8 +23,8 @@ const platformWorkerImpl = Worker.makePlatform<ChildProcess.ChildProcess>()({
             childProcess.send([1])
             return Deferred.await(exitDeferred)
           }).pipe(
-            Effect.interruptible,
             Effect.timeout(5000),
+            Effect.interruptible,
             Effect.catchAllCause(() => Effect.sync(() => childProcess.kill())),
           ),
         ),

package/dist/nanoid/index.browser.d.ts

@@ -1,2 +0,0 @@
-export { nanoid } from 'nanoid/index.browser.js';
-//# sourceMappingURL=index.browser.d.ts.map

package/dist/nanoid/index.browser.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.browser.d.ts","sourceRoot":"","sources":["../../src/nanoid/index.browser.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,MAAM,EAAE,MAAM,yBAAyB,CAAA"}

package/dist/nanoid/index.browser.js

@@ -1,3 +0,0 @@
-// @ts-expect-error TODO
-export { nanoid } from 'nanoid/index.browser.js';
-//# sourceMappingURL=index.browser.js.map

package/dist/nanoid/index.browser.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.browser.js","sourceRoot":"","sources":["../../src/nanoid/index.browser.ts"],"names":[],"mappings":"AAAA,wBAAwB;AACxB,OAAO,EAAE,MAAM,EAAE,MAAM,yBAAyB,CAAA"}

package/src/nanoid/index.browser.ts

@@ -1,2 +0,0 @@
-// @ts-expect-error TODO
-export { nanoid } from 'nanoid/index.browser.js'