@livestore/utils 0.4.0-dev.21 → 0.4.0-dev.23

package/src/mod.ts

@@ -119,7 +119,7 @@ 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
   }
@@ -130,7 +130,7 @@ export const debugCatch = <T>(try_: () => T): T => {
  * 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) => {
@@ -173,8 +173,8 @@ 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)}`)
 }
@@ -189,7 +189,7 @@ export function casesHandled(unexpectedCase: never): never {
  */
 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}`)
   }
@@ -204,7 +204,7 @@ export const assertNever = (failIfFalse: boolean, msg?: string): void => {
  * ```
  */
 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
 }
@@ -231,7 +231,7 @@ const truncate = (str: string, length: number): string => {
  * ```
  */
 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}`)
 }
@@ -303,7 +303,7 @@ export const throttle = (fn: () => void, ms: number) => {
   let shouldCallAgain = false
 
   const timeoutFunc = () => {
-    if (shouldCallAgain) {
+    if (shouldCallAgain === true) {
       fn()
       shouldCallAgain = false
       setTimeout(timeoutFunc, ms)
@@ -313,7 +313,7 @@ export const throttle = (fn: () => void, ms: number) => {
   }
 
   return () => {
-    if (shouldWait) {
+    if (shouldWait === true) {
       shouldCallAgain = true
       return
     }
@@ -374,7 +374,7 @@ export const memoizeByStringifyArgs = <T extends (...args: any[]) => any>(fn: T)
 
   return ((...args: any[]) => {
     const key = JSON.stringify(args)
-    if (cache.has(key)) {
+    if (cache.has(key) === true) {
       return cache.get(key)
     }
 
@@ -400,7 +400,7 @@ 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)
     }
 

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, Deferred, 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'
@@ -84,7 +88,7 @@ describe('ChildProcessRunner', { timeout: 10_000 }, () => {
         const workerPid = yield* Deferred.await(workerPidDeferred).pipe(
           Effect.raceFirst(
             Fiber.join(fiber).pipe(
-              Effect.flatMap(() => Effect.fail(new Error('testEffect completed before reporting worker PID'))),
+              Effect.flatMap(() => new TestError({ message: 'testEffect completed before reporting worker PID' })),
             ),
           ),
           Effect.timeout(10_000),
@@ -120,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)
@@ -130,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,
@@ -189,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,
@@ -274,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')
           }
 
@@ -293,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.pipe(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* () {

package/src/node/ChildProcessRunner/ChildProcessWorker.ts

@@ -1,4 +1,5 @@
 import type * as ChildProcess from 'node:child_process'
+
 import * as Worker from '@effect/platform/Worker'
 import { WorkerError } from '@effect/platform/WorkerError'
 import * as Deferred from 'effect/Deferred'
@@ -14,7 +15,7 @@ const childProcesses = new Set<ChildProcess.ChildProcess>()
 const forceCleanupChildren = (signal: NodeJS.Signals = 'SIGKILL') => {
   for (const child of childProcesses) {
     try {
-      if (!child.killed) {
+      if (child.killed === false) {
         child.kill(signal)
       }
     } catch {
@@ -28,7 +29,7 @@ const forceCleanupChildren = (signal: NodeJS.Signals = 'SIGKILL') => {
 let signalHandlersInstalled = false
 
 const installSignalHandlers = () => {
-  if (signalHandlersInstalled) return
+  if (signalHandlersInstalled === true) return
   signalHandlersInstalled = true
 
   // Use 'beforeExit' instead of signal handlers since tests may interfere with signals
@@ -95,14 +96,14 @@ const platformWorkerImpl = Worker.makePlatform<ChildProcess.ChildProcess>()({
             Effect.catchAllCause(() =>
               Effect.sync(() => {
                 // Enhanced cleanup with escalating signals
-                if (!childProcess.killed) {
+                if (childProcess.killed === false) {
                   try {
                     // First try SIGTERM
                     childProcess.kill('SIGTERM')
 
                     // If still running after a short delay, use SIGKILL
                     setTimeout(() => {
-                      if (!childProcess.killed) {
+                      if (childProcess.killed === false) {
                         childProcess.kill('SIGKILL')
                       }
                     }, 1000)

package/src/node/mod.ts

@@ -1,7 +1,8 @@
 import * as http from 'node:http'
-import * as PlatformNode from '@effect/platform-node'
+
 import { layer as ParcelWatcherLayer } from '@effect/platform-node/NodeFileSystem/ParcelWatcher'
 import { Effect, Layer } from 'effect'
+
 import { OtelTracer, UnknownError } from '../effect/mod.ts'
 import { makeNoopTracer } from '../NoopTracer.ts'
 
@@ -28,7 +29,7 @@ export const getFreePort: Effect.Effect<number, UnknownError> = Effect.async<num
   server.listen(0, () => {
     const address = server.address()
 
-    if (address && typeof address === 'object') {
+    if (address !== null && typeof address === 'object') {
       const port = address.port
       server.close(() => cb(Effect.succeed(port)))
     } else {
@@ -53,8 +54,39 @@ export const OtelLiveDummy: Layer.Layer<OtelTracer.OtelTracer> = Layer.suspend((
 })
 
 /**
- * Layer that enables recursive file watching by combining the Node filesystem implementation with
- * the Parcel-based watch backend. Mirrored from Effect’s platform-node Parcel watcher layer:
- * https://github.com/Effect-TS/effect/blob/main/packages/platform-node/src/NodeFileSystem/ParcelWatcher.ts
+ * Layer that provides WatchBackend for recursive file watching via @parcel/watcher.
+ * This layer alone does NOT provide FileSystem - it only provides the watch backend.
+ *
+ * IMPORTANT: Layer ordering matters! When composing with NodeFileSystem.layer, use
+ * `NodeFileSystemWithWatch` instead, or ensure WatchBackend is available when FileSystem
+ * is constructed by using `Layer.provideMerge`:
+ *
+ * ```ts
+ * // ✅ CORRECT: Use the pre-composed layer
+ * Effect.provide(NodeFileSystemWithWatch)
+ *
+ * // ✅ CORRECT: Manual composition with Layer.provideMerge
+ * const layer = PlatformNode.NodeFileSystem.layer.pipe(Layer.provideMerge(NodeRecursiveWatchLayer))
+ * Effect.provide(layer)
+ *
+ * // ❌ WRONG: Chained Effect.provide - WatchBackend won't be used!
+ * Effect.provide(NodeRecursiveWatchLayer).pipe(Effect.provide(PlatformNode.NodeFileSystem.layer))
+ * ```
+ *
+ * @see https://github.com/Effect-TS/effect/issues/5913
  */
-export const NodeRecursiveWatchLayer = Layer.mergeAll(PlatformNode.NodeFileSystem.layer, ParcelWatcherLayer)
+export const NodeRecursiveWatchLayer = ParcelWatcherLayer
+
+/**
+ * Pre-composed layer providing FileSystem with recursive file watching via @parcel/watcher.
+ * This is the recommended way to get a FileSystem that supports recursive watching.
+ *
+ * Use this layer when you need to watch files recursively (e.g., watching nested directories).
+ * Without recursive watching, Node.js's built-in fs.watch only detects changes in the
+ * immediate directory, not in subdirectories.
+ */
+export { NodeFileSystem } from '@effect/platform-node'
+
+import { NodeFileSystem } from '@effect/platform-node'
+
+export const NodeFileSystemWithWatch = NodeFileSystem.layer.pipe(Layer.provideMerge(ParcelWatcherLayer))

package/src/object/index.ts

@@ -22,4 +22,4 @@ export const keyObjectFromObject = <TObj extends Record<string, any>>(obj: TObj)
   pipe(
     objectEntries(obj).map(([k]) => [k, k]),
     Object.fromEntries,
-  ) as any
+  )

package/src/object/omit.ts

@@ -9,7 +9,7 @@ export const omit = <Obj extends Record<string, any>, Keys extends keyof Obj>(
   keys: Keys[],
 ): Omit<Obj, Keys> => {
   return Object.keys(obj).reduce((acc, key: any) => {
-    if (!keys.includes(key)) {
+    if (keys.includes(key) === false) {
       acc[key] = (obj as any)[key]
     }
     return acc

package/src/object/stringify-object.test.ts

@@ -1,4 +1,5 @@
 import { describe, expect, it } from 'vitest'
+
 import { stringifyObject } from './stringify-object.ts'
 
 describe('stringifyObject', () => {

package/src/object/stringify-object.ts

@@ -11,10 +11,10 @@ export const stringifyObject = (obj: object, prefix = ''): string => {
   for (const [key, value] of Object.entries(obj)) {
     const fullKey = prefix !== '' ? `${prefix}.${key}` : key
 
-    if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+    if (typeof value === 'object' && value !== null && Array.isArray(value) === false) {
       // Recursively stringify nested objects with dot notation
       entries.push(stringifyObject(value, fullKey))
-    } else if (Array.isArray(value)) {
+    } else if (Array.isArray(value) === true) {
       // Arrays get converted to comma-separated values
       entries.push(`${fullKey}=${value.join(',')}`)
     } else {

package/src/qr.ts

@@ -61,7 +61,7 @@ export const printQrTerminal = (text: string, options?: PrintQrTerminalOptions):
     const col = x - margin
     if (row < 0 || col < 0 || row >= size || col >= size) return false
     const bit = qr.isDark(row, col)
-    return invert ? !bit : bit
+    return invert === true ? !bit : bit
   }
 
   const lines: string[] = []
@@ -87,8 +87,8 @@ export const printQrTerminal = (text: string, options?: PrintQrTerminalOptions):
     let currentStyle = ''
     const setStyle = (style: string) => {
       if (style !== currentStyle) {
-        if (currentStyle) row += RESET
-        if (style) row += style
+        if (currentStyle !== undefined) row += RESET
+        if (style !== undefined) row += style
         currentStyle = style
       }
     }
@@ -97,26 +97,26 @@ export const printQrTerminal = (text: string, options?: PrintQrTerminalOptions):
       const top = isDarkAt(x, y)
       const bottom = isDarkAt(x, y + 1)
 
-      if (useAnsi) {
+      if (useAnsi === true) {
         // Represent two stacked modules with a single `▀` character.
         // Foreground corresponds to the top pixel; background to the bottom pixel.
         // Always paint both halves to enforce a white quiet zone even on dark terminals.
-        const fg = top ? FG_BLACK : FG_WHITE
-        const bg = bottom ? BG_BLACK : BG_WHITE
+        const fg = top === true ? FG_BLACK : FG_WHITE
+        const bg = bottom === true ? BG_BLACK : BG_WHITE
         setStyle(fg + bg)
         row += '▀'
       } else {
         // No ANSI: approximate using block characters.
         let ch = ' '
-        if (top && bottom) ch = '█'
-        else if (top && !bottom) ch = '▀'
-        else if (!top && bottom) ch = '▄'
+        if (top === true && bottom === true) ch = '█'
+        else if (top === true && bottom === false) ch = '▀'
+        else if (top === false && bottom === true) ch = '▄'
         row += ch
       }
     }
 
-    if (useAnsi) {
-      if (currentStyle) row += RESET
+    if (useAnsi === true) {
+      if (currentStyle !== undefined) row += RESET
     }
     lines.push(row)
   }

package/src/set.ts

@@ -1,7 +1,7 @@
 export const difference = <T>(a: Set<T>, b: Set<T>) => {
   const diff = new Set<T>()
   for (const item of a) {
-    if (!b.has(item)) {
+    if (b.has(item) === false) {
       diff.add(item)
     }
   }

package/src/time.ts

@@ -17,7 +17,7 @@ export const msAsTimeString = (ms: number) => {
   const remainingSeconds = (seconds % 60).toString().padStart(2, '0')
   const remainingMinutes = hours > 0 ? (minutes % 60).toString().padStart(2, '0') : minutes % 60
 
-  const timeString = [hours > 0 ? `${hours}:` : '', `${remainingMinutes}:`, `${remainingSeconds}`]
+  const timeString = [hours > 0 ? `${hours}:` : '', `${remainingMinutes}:`, remainingSeconds]
     .filter((val) => val !== '')
     .join('')