@livestore/utils 0.4.0-dev.8 → 0.4.0

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'
@@ -19,49 +19,118 @@ import type { Types } from 'effect'
 
 import { objectToString } from './misc.ts'
 
+/**
+ * Recursively expands type aliases for better IDE hover display.
+ *
+ * Transforms `{ a: string } & { b: number }` into `{ a: string; b: number }`.
+ */
 export type Prettify<T> = T extends infer U ? { [K in keyof U]: Prettify<U[K]> } : never
 
+/**
+ * Type-level equality check. Returns `true` if `A` and `B` are exactly the same type.
+ *
+ * @example
+ * ```ts
+ * type Test1 = TypeEq<string, string> // true
+ * type Test2 = TypeEq<string, number> // false
+ * type Test3 = TypeEq<{ a: 1 }, { a: 1 }> // true
+ * ```
+ */
 export type TypeEq<A, B> = (<T>() => T extends A ? 1 : 2) extends <T>() => T extends B ? 1 : 2 ? true : false
 
-/** `A` is subtype of `B` */
+/**
+ * Type-level subtype check. Returns `true` if `A` extends `B`.
+ *
+ * @example
+ * ```ts
+ * type Test1 = IsSubtype<'foo', string> // true
+ * type Test2 = IsSubtype<string, 'foo'> // false
+ * ```
+ */
 export type IsSubtype<A, B> = A extends B ? true : false
+
+/** Compile-time assertion that `T` is `true`. Useful for type tests. */
 export type AssertTrue<T extends true> = T
 
+/** Removes `readonly` modifier from all properties of `T`. */
 export type Writeable<T> = { -readonly [P in keyof T]: T[P] }
+
+/** Recursively removes `readonly` modifier from all properties. */
 export type DeepWriteable<T> = { -readonly [P in keyof T]: DeepWriteable<T[P]> }
 
+/** Makes all properties of `T` nullable (allows `null`). */
 export type Nullable<T> = { [K in keyof T]: T[K] | null }
 
+/** Union of JavaScript primitive types. */
 export type Primitive = null | undefined | string | number | boolean | symbol | bigint
 
+/**
+ * Creates a union type that allows specific literals while still accepting the base type.
+ * Useful for string/number enums with autocomplete support.
+ *
+ * @example
+ * ```ts
+ * type Status = LiteralUnion<'pending' | 'active', string>
+ * // Allows 'pending', 'active', or any other string
+ * ```
+ */
 export type LiteralUnion<LiteralType, BaseType extends Primitive> = LiteralType | (BaseType & Record<never, never>)
 
+/** Extracts the value type for key `K` from object type `T`, or `never` if key doesn't exist. */
 export type GetValForKey<T, K> = K extends keyof T ? T[K] : never
 
+/** Accepts either a single value or a readonly array of values. */
 export type SingleOrReadonlyArray<T> = T | ReadonlyArray<T>
 
+/** Returns a Promise that resolves after `ms` milliseconds. */
 export const sleep = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms))
 
+/**
+ * Creates a mutable reference object with a `current` property.
+ * Similar to React's `useRef` but works outside of React.
+ *
+ * @example
+ * ```ts
+ * const counter = ref(0)
+ * counter.current += 1
+ * ```
+ */
 export const ref = <T>(val: T): { current: T } => ({ current: val })
 
+/**
+ * Calls a function `n` times with the current index.
+ *
+ * @example
+ * ```ts
+ * times(3, (i) => console.log(i)) // logs 0, 1, 2
+ * ```
+ */
 export const times = (n: number, fn: (index: number) => {}): void => {
   for (let i = 0; i < n; i++) {
     fn(i)
   }
 }
 
+/**
+ * Wraps a function call in a try/catch that triggers the debugger on error.
+ * Useful for debugging exceptions during development.
+ */
 export const debugCatch = <T>(try_: () => T): T => {
   try {
     return try_()
   } catch (e: any) {
-    // biome-ignore lint/suspicious/noDebugger: debugging
+    // oxlint-disable-next-line eslint(no-debugger) -- intentional breakpoint for debugging exceptions
     debugger
     throw e
   }
 }
 
+/**
+ * Recursively removes `undefined` values from an object or array in place.
+ * Mutates the input value.
+ */
 export const recRemoveUndefinedValues = (val: any): void => {
-  if (Array.isArray(val)) {
+  if (Array.isArray(val) === true) {
     val.forEach(recRemoveUndefinedValues)
   } else if (typeof val === 'object') {
     Object.keys(val).forEach((key) => {
@@ -79,13 +148,24 @@ export const recRemoveUndefinedValues = (val: any): void => {
  */
 export const sluggify = (str: string, separator = '-') => str.replace(/[^a-zA-Z0-9]/g, separator)
 
+/**
+ * Creates a property accessor function for use in pipelines.
+ *
+ * @example
+ * ```ts
+ * const users = [{ name: 'Alice' }, { name: 'Bob' }]
+ * const names = users.map(prop('name')) // ['Alice', 'Bob']
+ * ```
+ */
 export const prop =
   <T extends {}, K extends keyof T>(key: K) =>
   (obj: T): T[K] =>
     obj[key]
 
+/** Capitalizes the first letter of a string. */
 export const capitalizeFirstLetter = (str: string): string => str.charAt(0).toUpperCase() + str.slice(1)
 
+/** Type guard that checks if a value is a readonly array. */
 export const isReadonlyArray = <I, T>(value: ReadonlyArray<I> | T): value is ReadonlyArray<I> => Array.isArray(value)
 
 /**
@@ -93,22 +173,38 @@ export const isReadonlyArray = <I, T>(value: ReadonlyArray<I> | T): value is Rea
  * union have been accounted for.
  */
 
-export function casesHandled(unexpectedCase: never): never {
-  // biome-ignore lint/suspicious/noDebugger: debugging
+export const casesHandled = (unexpectedCase: never): never => {
+  // oxlint-disable-next-line eslint(no-debugger) -- intentional breakpoint for unhandled cases
   debugger
   throw new Error(`A case was not handled for value: ${truncate(objectToString(unexpectedCase), 1000)}`)
 }
 
+/**
+ * Throws if the condition is false. Use for runtime assertions that should never fail.
+ *
+ * @example
+ * ```ts
+ * assertNever(user !== undefined, 'User must be loaded')
+ * ```
+ */
 export const assertNever = (failIfFalse: boolean, msg?: string): void => {
   if (failIfFalse === false) {
-    // biome-ignore lint/suspicious/noDebugger: debugging
+    // oxlint-disable-next-line eslint(no-debugger) -- intentional breakpoint for impossible states
     debugger
     throw new Error(`This should never happen: ${msg}`)
   }
 }
 
+/**
+ * Identity function that triggers the debugger. Useful for debugging pipelines.
+ *
+ * @example
+ * ```ts
+ * data.pipe(transform, debuggerPipe, format) // Pauses debugger here
+ * ```
+ */
 export const debuggerPipe = <T>(val: T): T => {
-  // biome-ignore lint/suspicious/noDebugger: debugging
+  // oxlint-disable-next-line eslint(no-debugger) -- intentional: this function's purpose is to trigger debugger
   debugger
   return val
 }
@@ -121,16 +217,40 @@ const truncate = (str: string, length: number): string => {
   }
 }
 
+/**
+ * Placeholder for unimplemented code paths. Triggers debugger and throws.
+ *
+ * @example
+ * ```ts
+ * const parseFormat = (format: Format) => {
+ *   switch (format) {
+ *     case 'json': return parseJson
+ *     case 'xml': return notYetImplemented('XML parsing')
+ *   }
+ * }
+ * ```
+ */
 export const notYetImplemented = (msg?: string): never => {
-  // biome-ignore lint/suspicious/noDebugger: debugging
+  // oxlint-disable-next-line eslint(no-debugger) -- intentional breakpoint for unimplemented code paths
   debugger
   throw new Error(`Not yet implemented: ${msg}`)
 }
 
+/** A function that does nothing. Useful as a default callback. */
 export const noop = () => {}
 
+/** A function that returns a value of type `T`. */
 export type Thunk<T> = () => T
 
+/**
+ * If the input is a function, calls it and returns the result. Otherwise returns the value directly.
+ *
+ * @example
+ * ```ts
+ * unwrapThunk(5) // 5
+ * unwrapThunk(() => 5) // 5
+ * ```
+ */
 export const unwrapThunk = <T>(_: T | (() => T)): T => {
   if (typeof _ === 'function') {
     return (_ as any)()
@@ -139,6 +259,10 @@ export const unwrapThunk = <T>(_: T | (() => T)): T => {
   }
 }
 
+/**
+ * Transforms nullable fields (those that include `null`) into optional fields.
+ * Useful for converting database schemas to TypeScript types.
+ */
 export type NullableFieldsToOptional<T> = Types.Simplify<
   Partial<T> & {
     [K in keyof T as null extends T[K] ? K : never]?: Exclude<T[K], null>
@@ -147,18 +271,39 @@ export type NullableFieldsToOptional<T> = Types.Simplify<
   }
 >
 
-/** `end` is not included */
+/**
+ * Creates an array of numbers from `start` (inclusive) to `end` (exclusive).
+ *
+ * @example
+ * ```ts
+ * range(0, 5) // [0, 1, 2, 3, 4]
+ * range(3, 7) // [3, 4, 5, 6]
+ * ```
+ */
 export const range = (start: number, end: number): number[] => {
   const length = end - start
   return Array.from({ length }, (_, i) => start + i)
 }
 
+/**
+ * Rate-limits function calls to at most once per `ms` milliseconds.
+ * Trailing calls are preserved—if called during the wait period, the function
+ * will be called again after the timeout.
+ *
+ * @example
+ * ```ts
+ * const throttledSave = throttle(() => saveData(), 1000)
+ * throttledSave() // Executes immediately
+ * throttledSave() // Queued, executes after 1 second
+ * throttledSave() // Ignored (already queued)
+ * ```
+ */
 export const throttle = (fn: () => void, ms: number) => {
   let shouldWait = false
   let shouldCallAgain = false
 
   const timeoutFunc = () => {
-    if (shouldCallAgain) {
+    if (shouldCallAgain === true) {
       fn()
       shouldCallAgain = false
       setTimeout(timeoutFunc, ms)
@@ -168,7 +313,7 @@ export const throttle = (fn: () => void, ms: number) => {
   }
 
   return () => {
-    if (shouldWait) {
+    if (shouldWait === true) {
       shouldCallAgain = true
       return
     }
@@ -179,13 +324,26 @@ export const throttle = (fn: () => void, ms: number) => {
   }
 }
 
+/**
+ * Generates a W3C Trace Context `traceparent` header from an OpenTelemetry span.
+ * @see https://www.w3.org/TR/trace-context/#examples-of-http-traceparent-headers
+ */
 export const getTraceParentHeader = (parentSpan: otel.Span) => {
   const spanContext = parentSpan.spanContext()
-  // Format: {version}-{trace_id}-{span_id}-{trace_flags}
-  // https://www.w3.org/TR/trace-context/#examples-of-http-traceparent-headers
   return `00-${spanContext.traceId}-${spanContext.spanId}-01`
 }
 
+/**
+ * Asserts that a tagged union value has a specific tag, narrowing its type.
+ * Throws if the tag doesn't match.
+ *
+ * @example
+ * ```ts
+ * type Result = { _tag: 'ok'; value: number } | { _tag: 'error'; message: string }
+ * const result: Result = ...
+ * const ok = assertTag(result, 'ok') // Type is { _tag: 'ok'; value: number }
+ * ```
+ */
 export const assertTag = <TObj extends { _tag: string }, TTag extends TObj['_tag']>(
   obj: TObj,
   tag: TTag,
@@ -197,12 +355,26 @@ export const assertTag = <TObj extends { _tag: string }, TTag extends TObj['_tag
   return obj as any
 }
 
+/**
+ * Memoizes a function by JSON-stringifying its arguments as the cache key.
+ * Suitable for functions with serializable arguments.
+ *
+ * @example
+ * ```ts
+ * const expensiveCalc = memoizeByStringifyArgs((a: number, b: number) => {
+ *   console.log('Computing...')
+ *   return a + b
+ * })
+ * expensiveCalc(1, 2) // logs 'Computing...', returns 3
+ * expensiveCalc(1, 2) // returns 3 (cached, no log)
+ * ```
+ */
 export const memoizeByStringifyArgs = <T extends (...args: any[]) => any>(fn: T): T => {
   const cache = new Map<string, ReturnType<T>>()
 
   return ((...args: any[]) => {
     const key = JSON.stringify(args)
-    if (cache.has(key)) {
+    if (cache.has(key) === true) {
       return cache.get(key)
     }
 
@@ -212,11 +384,23 @@ export const memoizeByStringifyArgs = <T extends (...args: any[]) => any>(fn: T)
   }) as any
 }
 
+/**
+ * Memoizes a single-argument function using reference equality for cache lookup.
+ * Suitable for functions where arguments are objects that should be compared by reference.
+ *
+ * @example
+ * ```ts
+ * const processUser = memoizeByRef((user: User) => expensiveTransform(user))
+ * processUser(userA) // Computes
+ * processUser(userA) // Returns cached (same reference)
+ * processUser(userB) // Computes (different reference)
+ * ```
+ */
 export const memoizeByRef = <T extends (arg: any) => any>(fn: T): T => {
   const cache = new Map<Parameters<T>[0], ReturnType<T>>()
 
   return ((arg: any) => {
-    if (cache.has(arg)) {
+    if (cache.has(arg) === true) {
       return cache.get(arg)
     }
 
@@ -226,15 +410,23 @@ export const memoizeByRef = <T extends (arg: any) => any>(fn: T): T => {
   }) as any
 }
 
+/** Type guard that checks if a value is a non-empty string. */
 export const isNonEmptyString = (str: string | undefined | null): str is string => {
   return typeof str === 'string' && str.length > 0
 }
 
+/** Type guard that checks if a value is a Promise (has a `then` method). */
 export const isPromise = (value: any): value is Promise<unknown> => typeof value?.then === 'function'
 
+/** Type guard that checks if a value is iterable (has a `Symbol.iterator` method). */
 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`. */
+/**
+ * Type-level utility that removes `undefined` from all property types.
+ * Used for compatibility with libraries that don't type optionals as `| undefined`.
+ *
+ * Note: This is a type-level lie—the runtime value is unchanged.
+ */
 export const omitUndefineds = <T extends Record<keyof any, unknown>>(
   rec: T,
 ): {

package/src/node/ChildProcessRunner/ChildProcessRunner.ts

@@ -17,16 +17,29 @@ import * as Scope from 'effect/Scope'
 let parentDeathDetectionEnabled = false
 let parentDeathTimer: NodeJS.Timeout | null = null
 
+type SetupParentDeathDetectionMessage = ['setup-parent-death-detection', { parentPid: number }]
+type RunnerMessage<I> = Runner.BackingRunner.Message<I> | SetupParentDeathDetectionMessage
+
+const isSetupParentDeathDetectionMessage = (
+  message: unknown,
+): message is SetupParentDeathDetectionMessage =>
+  Array.isArray(message) &&
+  message[0] === 'setup-parent-death-detection' &&
+  typeof message[1] === 'object' &&
+  message[1] !== null &&
+  'parentPid' in message[1] &&
+  typeof (message[1] as { parentPid: unknown }).parentPid === 'number'
+
 const stopParentDeathMonitoring = () => {
   parentDeathDetectionEnabled = false
-  if (parentDeathTimer) {
+  if (parentDeathTimer !== null) {
     clearTimeout(parentDeathTimer)
     parentDeathTimer = null
   }
 }
 
 const setupParentDeathMonitoring = (parentPid: number) => {
-  if (parentDeathDetectionEnabled) return
+  if (parentDeathDetectionEnabled === true) return
   parentDeathDetectionEnabled = true
 
   let consecutiveFailures = 0
@@ -34,7 +47,7 @@ const setupParentDeathMonitoring = (parentPid: number) => {
 
   // Check if parent is still alive every 2 seconds (more conservative)
   const checkParentAlive = () => {
-    if (!parentDeathDetectionEnabled) return
+    if (parentDeathDetectionEnabled === false) return
     try {
       // Send signal 0 to check if process exists (doesn't actually send signal)
       process.kill(parentPid, 0)
@@ -64,13 +77,13 @@ const platformRunnerImpl = Runner.PlatformRunner.of({
   [Runner.PlatformRunnerTypeId]: Runner.PlatformRunnerTypeId,
   start<I, O>(closeLatch: typeof CloseLatch.Service) {
     return Effect.gen(function* () {
-      if (!process.send) {
+      if (process.send == null) {
         return yield* new WorkerError({ reason: 'spawn', cause: new Error('not in a child process') })
       }
       const port = {
         postMessage: (message: any) => process.send!(message),
         on: (event: string, handler: (message: any) => void) => process.on(event, handler),
-        close: () => process.disconnect(),
+        close: () => process.disconnect?.(),
       }
       const send = (_portId: number, message: O, _transfers?: ReadonlyArray<unknown>) =>
         Effect.sync(() => port.postMessage([1, message] /*, transfers as any*/))
@@ -85,16 +98,16 @@ const platformRunnerImpl = Runner.PlatformRunner.of({
         const fiberSet = yield* FiberSet.make<any, WorkerError | E>()
         const runFork = Runtime.runFork(runtime)
         const onExit = (exit: Exit.Exit<any, E>) => {
-          if (exit._tag === 'Failure' && !Cause.isInterruptedOnly(exit.cause)) {
+          if (exit._tag === 'Failure' && Cause.isInterruptedOnly(exit.cause) === false) {
             // Deferred.unsafeDone(closeLatch, Exit.die(Cause.squash(exit.cause)))
             Deferred.unsafeDone(closeLatch, Exit.die(exit.cause))
           }
         }
-        port.on('message', (message: Runner.BackingRunner.Message<I> | any) => {
+         port.on('message', (message: RunnerMessage<I>) => {
           // console.log('message', message)
 
           // Handle parent death detection setup messages
-          if (Array.isArray(message) && message[0] === 'setup-parent-death-detection' && message[1]?.parentPid) {
+          if (isSetupParentDeathDetectionMessage(message) === true) {
             const parentPid = message[1].parentPid
             // console.log(`[Worker ${process.pid}] Setting up parent death detection for parent ${parentPid}`)
             setupParentDeathMonitoring(parentPid)
@@ -102,10 +115,10 @@ const platformRunnerImpl = Runner.PlatformRunner.of({
           }
 
           // Handle normal Effect worker messages
-          if (Array.isArray(message) && typeof message[0] === 'number') {
+          if (Array.isArray(message) === true && typeof message[0] === 'number') {
             if (message[0] === 0) {
               const result = handler(0, message[1])
-              if (Effect.isEffect(result)) {
+              if (Effect.isEffect(result) === true) {
                 const fiber = runFork(result)
                 fiber.addObserver(onExit)
                 FiberSet.unsafeAdd(fiberSet, fiber)

package/src/node/ChildProcessRunner/ChildProcessRunnerTest/ChildProcessRunner.test.ts

@@ -2,7 +2,11 @@ import * as ChildProcess from 'node:child_process'
 
 import * as EffectWorker from '@effect/platform/Worker'
 import { assert, describe, it } from '@effect/vitest'
-import { Chunk, Effect, Exit, Fiber, Scope, Stream } from 'effect'
+import { Chunk, Deferred, Effect, Exit, Fiber, Schema, Scope, Stream } from 'effect'
+
+export class TestError extends Schema.TaggedError<TestError>()('TestError', {
+  message: Schema.String,
+}) {}
 
 import * as ChildProcessWorker from '../ChildProcessWorker.ts'
 import type { WorkerMessage } from './schema.ts'
@@ -61,7 +65,7 @@ describe('ChildProcessRunner', { timeout: 10_000 }, () => {
 
     it('should clean up child processes when Effect is interrupted', () =>
       Effect.gen(function* () {
-        let workerPid: number | undefined
+        const workerPidDeferred = yield* Deferred.make<number>()
 
         const testEffect = Effect.gen(function* () {
           const pool = yield* EffectWorker.makePoolSerialized<WorkerMessage>({
@@ -69,34 +73,39 @@ describe('ChildProcessRunner', { timeout: 10_000 }, () => {
             initialMessage: () => new InitialMessage({ name: 'test', data: new Uint8Array([1, 2, 3]) }),
           })
           const result = yield* pool.executeEffect(new StartStubbornWorker({ blockDuration: 30_000 }))
-          workerPid = result.pid
+          yield* Deferred.succeed(workerPidDeferred, result.pid)
 
           // Verify the worker process is running
-          assert.strictEqual(isProcessRunning(workerPid), true, 'Worker process should be running')
+          assert.strictEqual(isProcessRunning(result.pid), true, 'Worker process should be running')
 
           // Start a long-running operation that we'll interrupt
           yield* Effect.sleep('60 seconds')
         }).pipe(Effect.scoped, Effect.provide(WorkerLive))
 
         // Run the test effect but interrupt it after 2 seconds
-        const fiber = yield* Effect.fork(testEffect)
+        const fiber = yield* Effect.forkScoped(testEffect)
+
+        const workerPid = yield* Deferred.await(workerPidDeferred).pipe(
+          Effect.raceFirst(
+            Fiber.join(fiber).pipe(
+              Effect.flatMap(() => new TestError({ message: 'testEffect completed before reporting worker PID' })),
+            ),
+          ),
+          Effect.timeout(10_000),
+        )
+
         yield* Effect.sleep('2 seconds')
         yield* Fiber.interrupt(fiber)
 
         // Wait a moment for cleanup to complete
         yield* Effect.sleep('1 second')
 
-        // Verify the child process was cleaned up
-        if (workerPid) {
-          assert.strictEqual(
-            isProcessRunning(workerPid),
-            false,
-            `Worker process ${workerPid} should be terminated after Effect interruption`,
-          )
-        } else {
-          assert.fail('Worker PID was not captured')
-        }
-      }).pipe(Effect.runPromise))
+        assert.strictEqual(
+          isProcessRunning(workerPid),
+          false,
+          `Worker process ${workerPid} should be terminated after Effect interruption`,
+        )
+      }).pipe(Effect.scoped, Effect.runPromise))
 
     it('should clean up child processes when scope is closed abruptly', () =>
       Effect.gen(function* () {
@@ -115,7 +124,7 @@ describe('ChildProcessRunner', { timeout: 10_000 }, () => {
           workerPid = result.pid
 
           // Verify the worker is running
-          assert.strictEqual(isProcessRunning(workerPid!), true, 'Worker process should be running')
+          assert.strictEqual(isProcessRunning(workerPid), true, 'Worker process should be running')
         } finally {
           // Abruptly close the scope (simulating test abortion)
           yield* Scope.close(scope, Exit.void)
@@ -125,7 +134,7 @@ describe('ChildProcessRunner', { timeout: 10_000 }, () => {
         yield* Effect.sleep('1 second')
 
         // This should pass but will initially fail due to zombie process issue
-        if (workerPid) {
+        if (workerPid !== undefined) {
           assert.strictEqual(
             isProcessRunning(workerPid),
             false,
@@ -184,7 +193,7 @@ describe('ChildProcessRunner', { timeout: 10_000 }, () => {
         yield* Effect.sleep('2 seconds')
 
         // This test should initially fail - child process will still be running
-        if (workerPid) {
+        if (workerPid !== undefined) {
           assert.strictEqual(
             isProcessRunning(workerPid),
             false,
@@ -269,7 +278,7 @@ describe('ChildProcessRunner', { timeout: 10_000 }, () => {
           yield* worker.executeEffect(new StartStubbornWorker({ blockDuration: 60_000 }))
 
           // Verify process is running
-          if (childPid) {
+          if (childPid !== undefined) {
             assert.strictEqual(isProcessRunning(childPid), true, 'Child process should be running')
           }
 
@@ -288,7 +297,7 @@ describe('ChildProcessRunner', { timeout: 10_000 }, () => {
         yield* Effect.sleep('3 seconds')
 
         // This test should initially fail - demonstrating the zombie process issue
-        if (childPid) {
+        if (childPid !== undefined) {
           assert.strictEqual(
             isProcessRunning(childPid),
             false,

package/src/node/ChildProcessRunner/ChildProcessRunnerTest/serializedWorker.ts

@@ -33,19 +33,18 @@ const WorkerLive = Runner.layerSerialized(WorkerMessage, {
   //       return req.name
   //     }),
   //   ),
-  GetSpan: (_) =>
-    Effect.gen(function* (_) {
-      const span = yield* _(Effect.currentSpan, Effect.orDie)
-      return {
+  GetSpan: Effect.fn('GetSpan')(function* (_) {
+    const span = yield* Effect.currentSpan.pipe(Effect.orDie)
+    return {
+      traceId: span.traceId,
+      spanId: span.spanId,
+      name: span.name,
+      parent: Option.map(span.parent, (span) => ({
         traceId: span.traceId,
         spanId: span.spanId,
-        name: span.name,
-        parent: Option.map(span.parent, (span) => ({
-          traceId: span.traceId,
-          spanId: span.spanId,
-        })),
-      }
-    }).pipe(Effect.withSpan('GetSpan')),
+      })),
+    }
+  }),
   RunnerInterrupt: () => Effect.interrupt,
   StartStubbornWorker: ({ blockDuration }) =>
     Effect.gen(function* () {