@livestore/utils 0.4.0-dev.1 → 0.4.0-dev.11

package/src/effect/Stream.test.ts

@@ -0,0 +1,127 @@
+import { Effect, Option, Stream } from 'effect'
+import { describe, expect, it } from 'vitest'
+import { concatWithLastElement, runCollectReadonlyArray } from './Stream.ts'
+
+describe('concatWithLastElement', () => {
+  it('should concatenate streams with access to last element of first stream', async () => {
+    const stream1 = Stream.make(1, 2, 3)
+    const result = concatWithLastElement(stream1, (lastElement) =>
+      lastElement.pipe(
+        Option.match({
+          onNone: () => Stream.make('no-previous'),
+          onSome: (last) => Stream.make(`last-was-${last}`, 'continuing'),
+        }),
+      ),
+    )
+
+    const collected = await Effect.runPromise(runCollectReadonlyArray(result))
+    expect(collected).toEqual([1, 2, 3, 'last-was-3', 'continuing'])
+  })
+
+  it('should handle empty first stream', async () => {
+    const stream1 = Stream.empty
+    const result = concatWithLastElement(stream1, (lastElement) =>
+      lastElement.pipe(
+        Option.match({
+          onNone: () => Stream.make('no-previous-element'),
+          onSome: (last) => Stream.make(`last-was-${last}`),
+        }),
+      ),
+    )
+
+    const collected = await Effect.runPromise(runCollectReadonlyArray(result))
+    expect(collected).toEqual(['no-previous-element'])
+  })
+
+  it('should handle single element first stream', async () => {
+    const stream1 = Stream.make('single')
+    const result = concatWithLastElement(stream1, (lastElement) =>
+      lastElement.pipe(
+        Option.match({
+          onNone: () => Stream.make('unexpected'),
+          onSome: (last) => Stream.make(`after-${last}`),
+        }),
+      ),
+    )
+
+    const collected = await Effect.runPromise(runCollectReadonlyArray(result))
+    expect(collected).toEqual(['single', 'after-single'])
+  })
+
+  it('should handle empty second stream', async () => {
+    const stream1 = Stream.make(1, 2, 3)
+    const result = concatWithLastElement(stream1, () => Stream.empty)
+
+    const collected = await Effect.runPromise(runCollectReadonlyArray(result))
+    expect(collected).toEqual([1, 2, 3])
+  })
+
+  it('should preserve error handling from first stream', async () => {
+    const stream1 = Stream.fail('first-error')
+    const result = concatWithLastElement(stream1, () => Stream.make('should-not-reach'))
+
+    const outcome = await Effect.runPromise(Effect.either(runCollectReadonlyArray(result)))
+    expect(outcome._tag).toBe('Left')
+    if (outcome._tag === 'Left') {
+      expect(outcome.left).toBe('first-error')
+    }
+  })
+
+  it('should preserve error handling from second stream', async () => {
+    const stream1 = Stream.make(1, 2)
+    const result = concatWithLastElement(stream1, () => Stream.fail('second-error'))
+
+    const outcome = await Effect.runPromise(Effect.either(runCollectReadonlyArray(result)))
+    expect(outcome._tag).toBe('Left')
+    if (outcome._tag === 'Left') {
+      expect(outcome.left).toBe('second-error')
+    }
+  })
+
+  it('should work with different types in streams', async () => {
+    const stream1 = Stream.make(1, 2, 3)
+    const result = concatWithLastElement(stream1, (lastElement) =>
+      lastElement.pipe(
+        Option.match({
+          onNone: () => Stream.make('no-number') as Stream.Stream<number | string, never, never>,
+          onSome: (last) => Stream.make(last * 10, last * 100),
+        }),
+      ),
+    )
+
+    const collected = await Effect.runPromise(runCollectReadonlyArray(result))
+    expect(collected).toEqual([1, 2, 3, 30, 300])
+  })
+
+  it('should handle async effects in streams', async () => {
+    const stream1 = Stream.fromEffect(Effect.succeed('async-value'))
+    const result = concatWithLastElement(stream1, (lastElement) =>
+      lastElement.pipe(
+        Option.match({
+          onNone: () => Stream.fromEffect(Effect.succeed('no-async')),
+          onSome: (last) => Stream.fromEffect(Effect.succeed(`processed-${last}`)),
+        }),
+      ),
+    )
+
+    const collected = await Effect.runPromise(runCollectReadonlyArray(result))
+    expect(collected).toEqual(['async-value', 'processed-async-value'])
+  })
+
+  it('should work with dual function - piped style', async () => {
+    const stream1 = Stream.make('a', 'b', 'c')
+    const result = stream1.pipe(
+      concatWithLastElement((lastElement) =>
+        lastElement.pipe(
+          Option.match({
+            onNone: () => Stream.make('no-last'),
+            onSome: (last) => Stream.make(`last-${last}`, 'done'),
+          }),
+        ),
+      ),
+    )
+
+    const collected = await Effect.runPromise(runCollectReadonlyArray(result))
+    expect(collected).toEqual(['a', 'b', 'c', 'last-c', 'done'])
+  })
+})

package/src/effect/Stream.ts

@@ -1,7 +1,8 @@
+/** biome-ignore-all lint/suspicious/useIterableCallbackReturn: Biome bug */
 export * from 'effect/Stream'
 
-import type { Chunk } from 'effect'
-import { Effect, Option, pipe, Ref, Stream } from 'effect'
+import { type Cause, Chunk, Effect, Option, pipe, Ref, Stream } from 'effect'
+import { dual } from 'effect/Function'
 
 export const tapLog = <R, E, A>(stream: Stream.Stream<A, E, R>): Stream.Stream<A, E, R> =>
   tapChunk<never, never, A, void>(Effect.forEach((_) => Effect.succeed(console.log(_))))(stream)
@@ -61,3 +62,111 @@ export const skipRepeated_ = <R, E, A>(
       ),
     ),
   )
+
+/**
+ * Returns the first element of the stream or `None` if the stream is empty.
+ * It's different than `Stream.runHead` which runs the stream to completion.
+ * */
+export const runFirst = <A, E, R>(stream: Stream.Stream<A, E, R>): Effect.Effect<Option.Option<A>, E, R> =>
+  stream.pipe(Stream.take(1), Stream.runCollect, Effect.map(Chunk.head))
+
+/**
+ * Returns the first element of the stream or throws a `NoSuchElementException` if the stream is empty.
+ * It's different than `Stream.runHead` which runs the stream to completion.
+ * */
+export const runFirstUnsafe = <A, E, R>(
+  stream: Stream.Stream<A, E, R>,
+): Effect.Effect<A, Cause.NoSuchElementException | E, R> => runFirst(stream).pipe(Effect.flatten)
+
+export const runCollectReadonlyArray = <A, E, R>(stream: Stream.Stream<A, E, R>): Effect.Effect<readonly A[], E, R> =>
+  stream.pipe(Stream.runCollect, Effect.map(Chunk.toReadonlyArray))
+
+/**
+ * Concatenates two streams where the second stream has access to the last element
+ * of the first stream as an `Option`. If the first stream is empty, the callback
+ * receives `Option.none()`.
+ *
+ * @param stream - The first stream to consume
+ * @param getStream2 - Function that receives the last element from the first stream
+ *   and returns the second stream to concatenate
+ * @returns A new stream containing all elements from both streams
+ *
+ * @example
+ * ```ts
+ * // Direct usage
+ * const result = concatWithLastElement(
+ *   Stream.make(1, 2, 3),
+ *   lastElement => lastElement.pipe(
+ *     Option.match({
+ *       onNone: () => Stream.make('empty'),
+ *       onSome: last => Stream.make(`last-was-${last}`)
+ *     })
+ *   )
+ * )
+ *
+ * // Piped usage
+ * const result = Stream.make(1, 2, 3).pipe(
+ *   concatWithLastElement(lastElement =>
+ *     Stream.make(lastElement.pipe(Option.getOrElse(() => 0)) * 10)
+ *   )
+ * )
+ * ```
+ */
+export const concatWithLastElement: {
+  <A1, A2, E2, R2>(
+    getStream2: (lastElement: Option.Option<A1>) => Stream.Stream<A2, E2, R2>,
+  ): <E1, R1>(stream: Stream.Stream<A1, E1, R1>) => Stream.Stream<A1 | A2, E1 | E2, R1 | R2>
+  <A1, E1, R1, A2, E2, R2>(
+    stream: Stream.Stream<A1, E1, R1>,
+    getStream2: (lastElement: Option.Option<A1>) => Stream.Stream<A2, E2, R2>,
+  ): Stream.Stream<A1 | A2, E1 | E2, R1 | R2>
+} = dual(
+  2,
+  <A1, E1, R1, A2, E2, R2>(
+    stream1: Stream.Stream<A1, E1, R1>,
+    getStream2: (lastElement: Option.Option<A1>) => Stream.Stream<A2, E2, R2>,
+  ): Stream.Stream<A1 | A2, E1 | E2, R1 | R2> =>
+    pipe(
+      Ref.make<Option.Option<A1>>(Option.none()),
+      Stream.fromEffect,
+      Stream.flatMap((lastRef) =>
+        pipe(
+          stream1,
+          Stream.tap((value) => Ref.set(lastRef, Option.some(value))),
+          Stream.concat(pipe(Ref.get(lastRef), Effect.map(getStream2), Stream.unwrap)),
+        ),
+      ),
+    ),
+)
+
+/**
+ * Emits a default value if the stream is empty, otherwise passes through all elements.
+ * Uses `concatWithLastElement` internally to detect if the stream was empty.
+ *
+ * @param fallbackValue - The value to emit if the stream is empty
+ * @returns A dual function that can be used in pipe or direct call
+ *
+ * @example
+ * ```ts
+ * // Direct usage
+ * const result = emitIfEmpty(Stream.empty, 'default')
+ * // Emits: 'default'
+ *
+ * // Piped usage
+ * const result = Stream.make(1, 2, 3).pipe(emitIfEmpty('fallback'))
+ * // Emits: 1, 2, 3
+ *
+ * const empty = Stream.empty.pipe(emitIfEmpty('fallback'))
+ * // Emits: 'fallback'
+ * ```
+ */
+export const emitIfEmpty: {
+  <A>(fallbackValue: A): <E, R>(stream: Stream.Stream<A, E, R>) => Stream.Stream<A, E, R>
+  <A, E, R>(stream: Stream.Stream<A, E, R>, fallbackValue: A): Stream.Stream<A, E, R>
+} = dual(
+  2,
+  <A, E, R>(stream: Stream.Stream<A, E, R>, fallbackValue: A): Stream.Stream<A, E, R> =>
+    concatWithLastElement(stream, (lastElement) =>
+      lastElement._tag === 'None' ? Stream.make(fallbackValue) : Stream.empty,
+    ),
+)

package/src/effect/SubscriptionRef.ts

@@ -1,5 +1,4 @@
-import type { SubscriptionRef } from 'effect'
-import { Chunk, Effect, pipe, Stream } from 'effect'
+import { Chunk, Effect, pipe, Stream, SubscriptionRef } from 'effect'
 import { dual } from 'effect/Function'
 import type { Predicate, Refinement } from 'effect/Predicate'
 
@@ -20,3 +19,16 @@ export const waitUntil: {
 } = dual(2, <A>(sref: SubscriptionRef.SubscriptionRef<A>, predicate: (a: A) => boolean) =>
   pipe(sref.changes, Stream.filter(predicate), Stream.take(1), Stream.runCollect, Effect.map(Chunk.unsafeHead)),
 )
+
+export const fromStream = <A>(stream: Stream.Stream<A>, initialValue: A) =>
+  Effect.gen(function* () {
+    const sref = yield* SubscriptionRef.make(initialValue)
+
+    yield* stream.pipe(
+      Stream.tap((a) => SubscriptionRef.set(sref, a)),
+      Stream.runDrain,
+      Effect.forkScoped,
+    )
+
+    return sref
+  })

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

@@ -88,7 +88,7 @@ export const makeWebSocket = ({
             socket.close(1000)
           }
         } catch (error) {
-          yield* Effect.die(new WebSocketError({ cause: error }))
+          return yield* Effect.die(new WebSocketError({ cause: error }))
         }
       }),
     )

package/src/effect/index.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,
@@ -29,7 +51,8 @@ export {
 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 +70,9 @@ export {
   Cause,
   Channel,
   Chunk,
-  // Logger,
   Config,
+  ConfigError,
+  ConfigProvider,
   Console,
   Context,
   Data,
@@ -58,6 +82,7 @@ export {
   Equal,
   ExecutionStrategy,
   Exit,
+  FastCheck,
   Fiber,
   FiberHandle,
   FiberId,
@@ -98,6 +123,7 @@ export {
   Runtime,
   RuntimeFlags,
   Scope,
+  Sink,
   SortedMap,
   STM,
   SynchronizedRef,
@@ -107,26 +133,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 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'
+export * as WebSocket from './WebSocket.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

@@ -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) => {