@livestore/utils 0.4.0-dev.2 → 0.4.0-dev.20

package/src/effect/WebChannel/WebChannel.ts

@@ -38,127 +38,6 @@ 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,
-}: {
-  channelName: 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 channel = new BroadcastChannel(channelName)
-
-      yield* Effect.addFinalizer(() => Effect.try(() => channel.close()).pipe(Effect.ignoreLogged))
-
-      const send = (message: MsgSend) =>
-        Effect.gen(function* () {
-          const messageEncoded = yield* Schema.encode(schema.send)(message)
-          channel.postMessage(messageEncoded)
-        })
-
-      // TODO also listen to `messageerror` in parallel
-      const listen = Stream.fromEventListener<MessageEvent>(channel, 'message').pipe(
-        Stream.map((_) => Schema.decodeEither(schema.listen)(_.data)),
-        listenToDebugPing(channelName),
-      )
-
-      const closedDeferred = yield* Deferred.make<void>().pipe(Effect.acquireRelease(Deferred.done(Exit.void)))
-      const supportsTransferables = false
-
-      return {
-        [WebChannelSymbol]: WebChannelSymbol,
-        send,
-        listen,
-        closedDeferred,
-        shutdown: Scope.close(scope, Exit.succeed('shutdown')),
-        schema,
-        supportsTransferables,
-      }
-    }).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 windowChannel = <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 messagePortChannel: <MsgListen, MsgSend, MsgListenEncoded, MsgSendEncoded>(args: {
   port: MessagePort
   schema: InputSchema<MsgListen, MsgSend, MsgListenEncoded, MsgSendEncoded>
@@ -225,10 +104,7 @@ export const sameThreadChannel = <MsgListen, MsgSend, MsgListenEncoded, MsgSendE
 
       const schema = mapSchema(inputSchema)
 
-      const send = (message: MsgSend) =>
-        Effect.gen(function* () {
-          yield* PubSub.publish(pubSub, message)
-        })
+      const send = (message: MsgSend) => PubSub.publish(pubSub, message)
 
       const listen = Stream.fromPubSub(pubSub).pipe(Stream.map(Either.right), listenToDebugPing(channelName))
 
@@ -408,8 +284,8 @@ export const queueChannelProxy = <MsgListen, MsgSend>({
 /**
  * Eagerly starts listening to a channel by buffering incoming messages in a queue.
  */
-export const toOpenChannel = (
-  channel: WebChannel<any, any>,
+export const toOpenChannel = <MsgListen, MsgSend>(
+  channel: WebChannel<MsgListen, MsgSend>,
   options?: {
     /**
      * Sends a heartbeat message to the other end of the channel every `interval`.
@@ -420,9 +296,14 @@ export const toOpenChannel = (
       timeout: DurationInput
     }
   },
-): Effect.Effect<WebChannel<any, any>, never, Scope.Scope> =>
+): Effect.Effect<WebChannel<MsgListen, MsgSend>, never, Scope.Scope> =>
   Effect.gen(function* () {
-    const queue = yield* Queue.unbounded<Either.Either<any, any>>().pipe(Effect.acquireRelease(Queue.shutdown))
+    const queue = yield* Queue.unbounded<Either.Either<MsgListen, any>>().pipe(Effect.acquireRelease(Queue.shutdown))
+
+    const heartbeatChannel = channel as WebChannel<
+      MsgListen | typeof WebChannelHeartbeat.Type,
+      MsgSend | typeof WebChannelHeartbeat.Type
+    >
 
     const pendingPingDeferredRef = {
       current: undefined as { deferred: Deferred.Deferred<void>; requestId: string } | undefined,
@@ -435,7 +316,7 @@ export const toOpenChannel = (
             Effect.fn(function* (msg) {
               if (msg._tag === 'Right' && Schema.is(WebChannelHeartbeat)(msg.right)) {
                 if (msg.right._tag === 'WebChannel.Ping') {
-                  yield* channel.send(WebChannelPong.make({ requestId: msg.right.requestId }))
+                  yield* heartbeatChannel.send(WebChannelPong.make({ requestId: msg.right.requestId }))
                 } else {
                   const { deferred, requestId } = pendingPingDeferredRef.current ?? shouldNeverHappen('No pending ping')
                   if (requestId !== msg.right.requestId) {
@@ -461,7 +342,7 @@ export const toOpenChannel = (
         while (true) {
           yield* Effect.sleep(interval)
           const requestId = crypto.randomUUID()
-          yield* channel.send(WebChannelPing.make({ requestId }))
+          yield* heartbeatChannel.send(WebChannelPing.make({ requestId }))
           const deferred = yield* Deferred.make<void>()
           pendingPingDeferredRef.current = { deferred, requestId }
           yield* deferred.pipe(
@@ -492,7 +373,4 @@ export const toOpenChannel = (
     }
   })
 
-export const sendDebugPing = (channel: WebChannel<any, any>) =>
-  Effect.gen(function* () {
-    yield* channel.send(DebugPingMessage.make({ message: 'ping' }))
-  })
+export const sendDebugPing = (channel: WebChannel<any, any>) => channel.send(DebugPingMessage.make({ message: 'ping' }))

package/src/effect/WebChannel/common.ts

@@ -15,7 +15,7 @@ export interface WebChannel<MsgListen, MsgSend, E = never> {
   closedDeferred: Deferred.Deferred<void>
   shutdown: Effect.Effect<void>
   schema: { listen: Schema.Schema<MsgListen, any>; send: Schema.Schema<MsgSend, any> }
-  debugInfo?: Record<string, any>
+  debugInfo?: Record<string, any> | undefined
 }
 
 export const DebugPingMessage = Schema.TaggedStruct('WebChannel.DebugPing', {

package/src/effect/WebSocket.ts

@@ -81,16 +81,17 @@ export const makeWebSocket = ({
      */
     yield* Effect.addFinalizer(
       Effect.fn(function* (exit) {
-        try {
-          if (Exit.isFailure(exit)) {
-            socket.close(3000)
-          } else {
-            socket.close(1000)
-          }
-        } catch (error) {
-          yield* Effect.die(new WebSocketError({ cause: error }))
-        }
-      }),
+        yield* Effect.try({
+          try: () => {
+            if (Exit.isFailure(exit)) {
+              socket.close(3000)
+            } else {
+              socket.close(1000)
+            }
+          },
+          catch: (error) => new WebSocketError({ cause: error }),
+        })
+      }, Effect.orDie),
     )
 
     return socket

package/src/effect/{index.ts → mod.ts}

@@ -1,6 +1,22 @@
 import '../global.ts'
 
-export * as OtelTracer from '@effect/opentelemetry/Tracer'
+export {
+  AiError,
+  LanguageModel,
+  LanguageModel as AiLanguageModel,
+  McpSchema,
+  McpServer,
+  Model,
+  Model as AiModel,
+  Prompt,
+  Tool,
+  Tool as AiTool,
+  Toolkit,
+  Toolkit as AiToolkit,
+} from '@effect/ai'
+// export { DevTools as EffectDevtools } from '@effect/experimental'
+export { Sse } from '@effect/experimental'
+export * as Otlp from '@effect/opentelemetry/Otlp'
 export {
   Command,
   CommandExecutor,
@@ -8,6 +24,11 @@ export {
   FetchHttpClient,
   FileSystem,
   Headers,
+  HttpApi,
+  HttpApiClient,
+  HttpApiEndpoint,
+  HttpApiGroup,
+  HttpApp,
   HttpClient,
   HttpClientError,
   HttpClientRequest,
@@ -18,6 +39,7 @@ export {
   HttpServerRequest,
   HttpServerResponse,
   KeyValueStore,
+  MsgPack,
   Socket,
   Terminal,
   Transferable,
@@ -26,10 +48,10 @@ export {
   WorkerError,
   WorkerRunner,
 } from '@effect/platform'
-export { BrowserWorker, BrowserWorkerRunner } from '@effect/platform-browser'
 export {
   Rpc,
-  RpcClient,
+  // RpcClient, // TODO bring back "original" RpcClient from effect/rpc
+  RpcClientError,
   RpcGroup,
   RpcMessage,
   RpcMiddleware,
@@ -47,8 +69,9 @@ export {
   Cause,
   Channel,
   Chunk,
-  // Logger,
   Config,
+  ConfigError,
+  ConfigProvider,
   Console,
   Context,
   Data,
@@ -58,6 +81,7 @@ export {
   Equal,
   ExecutionStrategy,
   Exit,
+  FastCheck,
   Fiber,
   FiberHandle,
   FiberId,
@@ -84,6 +108,7 @@ export {
   MutableHashMap,
   MutableHashSet,
   Option,
+  Order,
   ParseResult,
   Predicate,
   Pretty,
@@ -98,6 +123,8 @@ export {
   Runtime,
   RuntimeFlags,
   Scope,
+  ScopedRef,
+  Sink,
   SortedMap,
   STM,
   SynchronizedRef,
@@ -107,26 +134,26 @@ export {
   Tracer,
   Types,
 } from 'effect'
-export { dual } from 'effect/Function'
+export type { NonEmptyArray } from 'effect/Array'
+export { constVoid, dual } from 'effect/Function'
+export * as Graph from 'effect/Graph'
 export { TreeFormatter } from 'effect/ParseResult'
 export type { Serializable, SerializableWithResult } from 'effect/Schema'
-
 export * as SchemaAST from 'effect/SchemaAST'
 export * as BucketQueue from './BucketQueue.ts'
+export * as Debug from './Debug.ts'
+export * as Effect from './Effect.ts'
+export * from './Error.ts'
 export * as Logger from './Logger.ts'
+export * as OtelTracer from './OtelTracer.ts'
+export * as RpcClient from './RpcClient.ts'
+export * as Schedule from './Schedule.ts'
+export * as Scheduler from './Scheduler.ts'
 export * as Schema from './Schema/index.ts'
+export * as ServiceContext from './ServiceContext.ts'
 export * as Stream from './Stream.ts'
 export * as Subscribable from './Subscribable.ts'
 export * as SubscriptionRef from './SubscriptionRef.ts'
 export * as TaskTracing from './TaskTracing.ts'
 export * as WebChannel from './WebChannel/mod.ts'
 export * as WebSocket from './WebSocket.ts'
-
-// export { DevTools as EffectDevtools } from '@effect/experimental'
-
-export * as Effect from './Effect.ts'
-export * from './Error.ts'
-export * as Schedule from './Schedule.ts'
-export * as Scheduler from './Scheduler.ts'
-export * as ServiceContext from './ServiceContext.ts'
-export * as WebLock from './WebLock.ts'

package/src/global.ts

@@ -1,5 +1,6 @@
 declare global {
   export type TODO<_Reason extends string = 'unknown'> = any
+  export type UNUSED<_Reason extends string = 'unknown'> = any
 }
 
 export {}

package/src/misc.ts

@@ -10,7 +10,7 @@ export const isDevEnv = () => {
   }
 
   // @ts-expect-error Only exists in Expo / RN
-  if (typeof globalThis !== 'undefined' && globalThis.__DEV__) {
+  if (globalThis?.__DEV__) {
     return true
   }
 

package/src/mod.ts

@@ -1,7 +1,6 @@
 export { default as prettyBytes } from 'pretty-bytes'
 export * as base64 from './base64.ts'
 export * from './binary.ts'
-export * from './browser.ts'
 export * from './Deferred.ts'
 export * from './env.ts'
 export * from './fast-deep-equal.ts'
@@ -10,6 +9,7 @@ export * from './misc.ts'
 export * from './NoopTracer.ts'
 export * from './object/index.ts'
 export * from './promise.ts'
+export * as QR from './qr.ts'
 export * from './set.ts'
 export * from './string.ts'
 export * from './time.ts'
@@ -234,4 +234,13 @@ export const isPromise = (value: any): value is Promise<unknown> => typeof value
 
 export const isIterable = <T>(value: any): value is Iterable<T> => typeof value?.[Symbol.iterator] === 'function'
 
+/** This utility "lies" as a means of compat with libs that don't explicitly type optionals as unioned with `undefined`. */
+export const omitUndefineds = <T extends Record<keyof any, unknown>>(
+  rec: T,
+): {
+  [K in keyof T]: Exclude<T[K], undefined>
+} => {
+  return rec as never
+}
+
 export { objectToString as errorToString } from './misc.ts'

package/src/node/ChildProcessRunner/ChildProcessRunner.ts

@@ -13,6 +13,53 @@ import * as Layer from 'effect/Layer'
 import * as Runtime from 'effect/Runtime'
 import * as Scope from 'effect/Scope'
 
+// Parent death monitoring setup
+let parentDeathDetectionEnabled = false
+let parentDeathTimer: NodeJS.Timeout | null = null
+
+const stopParentDeathMonitoring = () => {
+  parentDeathDetectionEnabled = false
+  if (parentDeathTimer) {
+    clearTimeout(parentDeathTimer)
+    parentDeathTimer = null
+  }
+}
+
+const setupParentDeathMonitoring = (parentPid: number) => {
+  if (parentDeathDetectionEnabled) return
+  parentDeathDetectionEnabled = true
+
+  let consecutiveFailures = 0
+  const maxFailures = 3 // Require 3 consecutive failures before self-terminating
+
+  // Check if parent is still alive every 2 seconds (more conservative)
+  const checkParentAlive = () => {
+    if (!parentDeathDetectionEnabled) return
+    try {
+      // Send signal 0 to check if process exists (doesn't actually send signal)
+      process.kill(parentPid, 0)
+      // If we reach here, parent is still alive, reset failure counter and check again later
+      consecutiveFailures = 0
+      parentDeathTimer = setTimeout(checkParentAlive, 2000)
+    } catch {
+      consecutiveFailures++
+      console.warn(`[Worker ${process.pid}] Parent check failed (${consecutiveFailures}/${maxFailures})`)
+
+      if (consecutiveFailures >= maxFailures) {
+        // Parent process has been gone for multiple checks, self-terminate
+        console.error(`[Worker ${process.pid}] Parent process ${parentPid} confirmed dead, self-terminating`)
+        process.exit(0)
+      } else {
+        // Try again sooner on failure
+        parentDeathTimer = setTimeout(checkParentAlive, 1000)
+      }
+    }
+  }
+
+  // Start monitoring after a longer initial delay to let things settle
+  parentDeathTimer = setTimeout(checkParentAlive, 5000)
+}
+
 const platformRunnerImpl = Runner.PlatformRunner.of({
   [Runner.PlatformRunnerTypeId]: Runner.PlatformRunnerTypeId,
   start<I, O>(closeLatch: typeof CloseLatch.Service) {
@@ -43,18 +90,32 @@ const platformRunnerImpl = Runner.PlatformRunner.of({
             Deferred.unsafeDone(closeLatch, Exit.die(exit.cause))
           }
         }
-        port.on('message', (message: Runner.BackingRunner.Message<I>) => {
+        port.on('message', (message: Runner.BackingRunner.Message<I> | any) => {
           // console.log('message', message)
-          if (message[0] === 0) {
-            const result = handler(0, message[1])
-            if (Effect.isEffect(result)) {
-              const fiber = runFork(result)
-              fiber.addObserver(onExit)
-              FiberSet.unsafeAdd(fiberSet, fiber)
+
+          // Handle parent death detection setup messages
+          if (Array.isArray(message) && message[0] === 'setup-parent-death-detection' && message[1]?.parentPid) {
+            const parentPid = message[1].parentPid
+            // console.log(`[Worker ${process.pid}] Setting up parent death detection for parent ${parentPid}`)
+            setupParentDeathMonitoring(parentPid)
+            return
+          }
+
+          // Handle normal Effect worker messages
+          if (Array.isArray(message) && typeof message[0] === 'number') {
+            if (message[0] === 0) {
+              const result = handler(0, message[1])
+              if (Effect.isEffect(result)) {
+                const fiber = runFork(result)
+                fiber.addObserver(onExit)
+                FiberSet.unsafeAdd(fiberSet, fiber)
+              }
+            } else {
+              // Graceful shutdown requested by parent: stop monitoring and close port
+              stopParentDeathMonitoring()
+              Deferred.unsafeDone(closeLatch, Exit.void)
+              port.close()
             }
-          } else {
-            Deferred.unsafeDone(closeLatch, Exit.void)
-            port.close()
           }
         })
         port.on('messageerror', (cause) => {