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

package/src/effect/RpcClient.ts

@@ -6,6 +6,7 @@ import { Protocol } from '@effect/rpc/RpcClient'
 import { constPing, type FromServerEncoded } from '@effect/rpc/RpcMessage'
 import { Cause, Deferred, Effect, Layer, Option, Schedule, type Scope } from 'effect'
 import { constVoid, identity } from 'effect/Function'
+
 import * as SubscriptionRef from './SubscriptionRef.ts'
 
 // This is based on `makeProtocolSocket` / `layerProtocolSocket` from `@effect/rpc` in order to:
@@ -119,8 +120,8 @@ export const makeProtocolSocketWithIsConnected = (options: {
 
             const error = Cause.failureOption(cause)
             if (
-              options?.retryTransientErrors &&
-              Option.isSome(error) &&
+              options?.retryTransientErrors !== undefined &&
+              Option.isSome(error) === true &&
               (error.value.reason === 'Open' || error.value.reason === 'OpenTimeout')
             ) {
               return
@@ -137,7 +138,7 @@ export const makeProtocolSocketWithIsConnected = (options: {
           }),
         ),
         // CHANGED: make configurable via schedule
-        options?.retryTransientErrors ? Effect.retry(options.retryTransientErrors) : identity,
+        options?.retryTransientErrors !== undefined ? Effect.retry(options.retryTransientErrors) : identity,
         Effect.annotateLogs({
           module: 'RpcClient',
           method: 'makeProtocolSocket',
@@ -171,7 +172,7 @@ const makePinger = Effect.fnUntraced(function* <A, E, R>(
   pingSchedule: Schedule.Schedule<unknown> = Schedule.spaced(10000).pipe(Schedule.addDelay(() => 5000)),
 ) {
   // CHANGED: add manual ping deferreds
-  const manualPingDeferreds = new Set<Deferred.Deferred<void, never>>()
+  const manualPingDeferreds = new Set<Deferred.Deferred<void>>()
 
   let recievedPong = true
   const latch = Effect.unsafeMakeLatch()
@@ -188,7 +189,7 @@ const makePinger = Effect.fnUntraced(function* <A, E, R>(
   }
   yield* Effect.suspend(() => {
     // Starting new ping
-    if (!recievedPong) return latch.open
+    if (recievedPong === false) return latch.open
     recievedPong = false
     return writePing
   }).pipe(
@@ -202,7 +203,7 @@ const makePinger = Effect.fnUntraced(function* <A, E, R>(
 
   // CHANGED: add manual ping
   const ping = Effect.gen(function* () {
-    const deferred = yield* Deferred.make<void, never>()
+    const deferred = yield* Deferred.make<void>()
     manualPingDeferreds.add(deferred)
     yield* deferred
     manualPingDeferreds.delete(deferred)

package/src/effect/Schema/debug-diff.ts

@@ -23,8 +23,8 @@ const debugDiffImpl = (ast: SchemaAST.AST, a: any, b: any, path: string, bag: Di
   if (eq(a, b) === false) {
     // bag.push({ path, a, b, ast })
 
-    if (SchemaAST.isUnion(ast)) {
-      if (isTaggedUnion(ast)) {
+    if (SchemaAST.isUnion(ast) === true) {
+      if (isTaggedUnion(ast) === true) {
         bag.push({ path, a, b, ast })
         return
       } else {
@@ -35,7 +35,7 @@ const debugDiffImpl = (ast: SchemaAST.AST, a: any, b: any, path: string, bag: Di
           } catch {}
         }
       }
-    } else if (SchemaAST.isTypeLiteral(ast)) {
+    } else if (SchemaAST.isTypeLiteral(ast) === true) {
       const props = SchemaAST.getPropertySignatures(ast)
       for (const prop of props) {
         debugDiffImpl(prop.type, a[prop.name], b[prop.name], `${path}.${prop.name.toString()}`, bag)
@@ -47,12 +47,13 @@ const debugDiffImpl = (ast: SchemaAST.AST, a: any, b: any, path: string, bag: Di
   }
 }
 
-const isTaggedUnion = (ast: SchemaAST.AST) => {
-  if (SchemaAST.isUnion(ast)) {
+const isTaggedUnion = (ast: SchemaAST.AST): boolean => {
+  if (SchemaAST.isUnion(ast) === true) {
     return ast.types.every((type) => {
       if (SchemaAST.isTypeLiteral(type) === false) return false
       const props = SchemaAST.getPropertySignatures(type)
       return props.some((prop) => prop.name.toString() === '_tag')
     })
   }
+  return false
 }

package/src/effect/Schema/index.ts

@@ -24,7 +24,7 @@ export const hash = (schema: Schema.Schema<any>) => {
 }
 
 const resolveStructAst = (ast: SchemaAST.AST): SchemaAST.AST => {
-  if (SchemaAST.isTransformation(ast)) {
+  if (SchemaAST.isTransformation(ast) === true) {
     return resolveStructAst(ast.from)
   }
 
@@ -38,9 +38,12 @@ export const getResolvedPropertySignatures = (
   return SchemaAST.getPropertySignatures(resolvedAst)
 }
 
+/** Objects that can be transferred between contexts (workers, etc.) */
+type TransferableObject = ArrayBuffer | MessagePort
+
 export const encodeWithTransferables =
-  <A, I, R>(schema: Schema.Schema<A, I, R>, options?: ParseOptions | undefined) =>
-  (a: A, overrideOptions?: ParseOptions | undefined): Effect.Effect<[I, Transferable[]], ParseError, R> =>
+  <A, I, R>(schema: Schema.Schema<A, I, R>, options?: ParseOptions) =>
+  (a: A, overrideOptions?: ParseOptions): Effect.Effect<[I, TransferableObject[]], ParseError, R> =>
     Effect.gen(function* () {
       const collector = yield* Transferable.makeCollector
 
@@ -48,11 +51,11 @@ export const encodeWithTransferables =
         Effect.provideService(Transferable.Collector, collector),
       )
 
-      return [encoded, collector.unsafeRead() as Transferable[]]
+      return [encoded, collector.unsafeRead() as TransferableObject[]]
     })
 
 export const decodeSyncDebug: <A, I>(
-  schema: Schema.Schema<A, I, never>,
+  schema: Schema.Schema<A, I>,
   options?: SchemaAST.ParseOptions,
 ) => (i: I, overrideOptions?: SchemaAST.ParseOptions) => A = (schema, options) => (input, overrideOptions) => {
   const res = Schema.decodeEither(schema, options)(input, overrideOptions)
@@ -64,7 +67,7 @@ export const decodeSyncDebug: <A, I>(
 }
 
 export const encodeSyncDebug: <A, I>(
-  schema: Schema.Schema<A, I, never>,
+  schema: Schema.Schema<A, I>,
   options?: SchemaAST.ParseOptions,
 ) => (a: A, overrideOptions?: SchemaAST.ParseOptions) => I = (schema, options) => (input, overrideOptions) => {
   const res = Schema.encodeEither(schema, options)(input, overrideOptions)

package/src/effect/ServiceContext.ts

@@ -24,13 +24,13 @@ export const make = <TStaticData, Ctx>(
   close: Effect.Effect<void> = Effect.dieMessage('close not implemented'),
 ): ServiceContext<Ctx, TStaticData> => {
   return {
-    provide: (self) => Effect.provide(runtime)(self),
-    runWithErrorLog: <E, A>(self: Effect.Effect<A, E, Ctx>) => runWithErrorLog(Effect.provide(runtime)(self)),
-    runSync: <E, A>(self: Effect.Effect<A, E, Ctx>) => Effect.runSync(Effect.provide(runtime)(self)),
+    provide: (self) => self.pipe(Effect.provide(runtime)),
+    runWithErrorLog: <E, A>(self: Effect.Effect<A, E, Ctx>) => runWithErrorLog(self.pipe(Effect.provide(runtime))),
+    runSync: <E, A>(self: Effect.Effect<A, E, Ctx>) => Effect.runSync(self.pipe(Effect.provide(runtime))),
     runPromiseWithErrorLog: <E, A>(self: Effect.Effect<A, E, Ctx>) =>
-      runPromiseWithErrorLog(Effect.provide(runtime)(self)),
-    runPromiseExit: <E, A>(self: Effect.Effect<A, E, Ctx>) => Effect.runPromiseExit(Effect.provide(runtime)(self)),
-    runPromise: <E, A>(self: Effect.Effect<A, E, Ctx>) => Effect.runPromise(Effect.provide(runtime)(self)),
+      runPromiseWithErrorLog(self.pipe(Effect.provide(runtime))),
+    runPromiseExit: <E, A>(self: Effect.Effect<A, E, Ctx>) => Effect.runPromiseExit(self.pipe(Effect.provide(runtime))),
+    runPromise: <E, A>(self: Effect.Effect<A, E, Ctx>) => Effect.runPromise(self.pipe(Effect.provide(runtime))),
     withRuntime: (fn) => fn(runtime),
     close: close,
     closePromise: () => Effect.runPromise(close),

package/src/effect/Stream.test.ts

@@ -1,5 +1,6 @@
 import { Effect, Option, Stream } from 'effect'
 import { describe, expect, it } from 'vitest'
+
 import { concatWithLastElement, runCollectReadonlyArray } from './Stream.ts'
 
 describe('concatWithLastElement', () => {
@@ -9,7 +10,7 @@ describe('concatWithLastElement', () => {
       lastElement.pipe(
         Option.match({
           onNone: () => Stream.make('no-previous'),
-          onSome: (last) => Stream.make(`last-was-${last}`, 'continuing'),
+          onSome: (last) => Stream.make(`last-was-${String(last)}`, 'continuing'),
         }),
       ),
     )
@@ -24,7 +25,7 @@ describe('concatWithLastElement', () => {
       lastElement.pipe(
         Option.match({
           onNone: () => Stream.make('no-previous-element'),
-          onSome: (last) => Stream.make(`last-was-${last}`),
+          onSome: (last) => Stream.make(`last-was-${String(last)}`),
         }),
       ),
     )
@@ -39,7 +40,7 @@ describe('concatWithLastElement', () => {
       lastElement.pipe(
         Option.match({
           onNone: () => Stream.make('unexpected'),
-          onSome: (last) => Stream.make(`after-${last}`),
+          onSome: (last) => Stream.make(`after-${String(last)}`),
         }),
       ),
     )
@@ -83,7 +84,7 @@ describe('concatWithLastElement', () => {
     const result = concatWithLastElement(stream1, (lastElement) =>
       lastElement.pipe(
         Option.match({
-          onNone: () => Stream.make('no-number') as Stream.Stream<number | string, never, never>,
+          onNone: () => Stream.make('no-number') as Stream.Stream<number | string>,
           onSome: (last) => Stream.make(last * 10, last * 100),
         }),
       ),

package/src/effect/SubscriptionRef.ts

@@ -5,17 +5,17 @@ import type { Predicate, Refinement } from 'effect/Predicate'
 export * from 'effect/SubscriptionRef'
 
 export const waitUntil: {
-  <A, B extends A>(
+    <A, B extends A>(
     refinement: Refinement<NoInfer<A>, B>,
-  ): (sref: SubscriptionRef.SubscriptionRef<A>) => Effect.Effect<B, never, never>
+  ): (sref: SubscriptionRef.SubscriptionRef<A>) => Effect.Effect<B>
   <A, B extends A>(
     predicate: Predicate<B>,
-  ): (sref: SubscriptionRef.SubscriptionRef<A>) => Effect.Effect<A, never, never>
+  ): (sref: SubscriptionRef.SubscriptionRef<A>) => Effect.Effect<A>
   <A, B extends A>(
     sref: SubscriptionRef.SubscriptionRef<A>,
     refinement: Refinement<NoInfer<A>, B>,
-  ): Effect.Effect<B, never, never>
-  <A, B extends A>(sref: SubscriptionRef.SubscriptionRef<A>, predicate: Predicate<B>): Effect.Effect<A, never, never>
+  ): Effect.Effect<B>
+  <A, B extends A>(sref: SubscriptionRef.SubscriptionRef<A>, predicate: Predicate<B>): Effect.Effect<A>
 } = 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)),
 )

package/src/effect/WebChannel/WebChannel.ts

@@ -41,7 +41,7 @@ export const noopChannel = <MsgListen, MsgSend>(): Effect.Effect<WebChannel<MsgL
 export const messagePortChannel: <MsgListen, MsgSend, MsgListenEncoded, MsgSendEncoded>(args: {
   port: MessagePort
   schema: InputSchema<MsgListen, MsgSend, MsgListenEncoded, MsgSendEncoded>
-  debugId?: string | number
+  debugId?: string | number | undefined
 }) => Effect.Effect<WebChannel<MsgListen, MsgSend>, never, Scope.Scope> = ({ port, schema: inputSchema, debugId }) =>
   Effect.scopeWithCloseable((scope) =>
     Effect.gen(function* () {
@@ -125,7 +125,7 @@ export const sameThreadChannel = <MsgListen, MsgSend, MsgListenEncoded, MsgSendE
 export const messagePortChannelWithAck: <MsgListen, MsgSend, MsgListenEncoded, MsgSendEncoded>(args: {
   port: MessagePort
   schema: InputSchema<MsgListen, MsgSend, MsgListenEncoded, MsgSendEncoded>
-  debugId?: string | number
+  debugId?: string | number | undefined
 }) => Effect.Effect<WebChannel<MsgListen, MsgSend>, never, Scope.Scope> = ({ port, schema: inputSchema, debugId }) =>
   Effect.scopeWithCloseable((scope) =>
     Effect.gen(function* () {
@@ -191,7 +191,7 @@ export const messagePortChannelWithAck: <MsgListen, MsgSend, MsgListenEncoded, M
                 yield* Deferred.succeed(requestAckMap.get(msg.right.reqId)!, void 0)
               } else if (msg.right._tag === 'ChannelRequest') {
                 debugInfo.listenTotal++
-                port.postMessage(Schema.encodeSync(ChannelMessage)({ _tag: 'ChannelRequestAck', reqId: msg.right.id }))
+                port.postMessage(yield* Schema.encode(ChannelMessage)({ _tag: 'ChannelRequestAck', reqId: msg.right.id }))
               }
             }
           }),
@@ -311,10 +311,10 @@ export const toOpenChannel = <MsgListen, MsgSend>(
 
     yield* channel.listen.pipe(
       // TODO implement this on the "chunk" level for better performance
-      options?.heartbeat
+      options?.heartbeat !== undefined
         ? Stream.filterEffect(
             Effect.fn(function* (msg) {
-              if (msg._tag === 'Right' && Schema.is(WebChannelHeartbeat)(msg.right)) {
+              if (msg._tag === 'Right' && Schema.is(WebChannelHeartbeat)(msg.right) === true) {
                 if (msg.right._tag === 'WebChannel.Ping') {
                   yield* heartbeatChannel.send(WebChannelPong.make({ requestId: msg.right.requestId }))
                 } else {
@@ -336,7 +336,7 @@ export const toOpenChannel = <MsgListen, MsgSend>(
       Effect.forkScoped,
     )
 
-    if (options?.heartbeat) {
+    if (options?.heartbeat !== undefined) {
       const { interval, timeout } = options.heartbeat
       yield* Effect.gen(function* () {
         while (true) {

package/src/effect/WebChannel/broadcastChannelWithAck.ts

@@ -69,7 +69,7 @@ export const broadcastChannelWithAck = <MsgListen, MsgSend, MsgListenEncoded, Ms
                 peerIdRef.current = data.from
                 postMessage(ConnectAckMessage.make({ from: connectionId, to: data.from }))
                 yield* connectedLatch.open
-                break
+                return undefined
               }
               // Case: other side sends connect-ack message (because otherside was already online when this side connected)
               case 'ConnectAckMessage': {
@@ -77,7 +77,7 @@ export const broadcastChannelWithAck = <MsgListen, MsgSend, MsgListenEncoded, Ms
                   peerIdRef.current = data.from
                   yield* connectedLatch.open
                 }
-                break
+                return undefined
               }
               case 'DisconnectMessage': {
                 if (data.from === peerIdRef.current) {
@@ -85,13 +85,13 @@ export const broadcastChannelWithAck = <MsgListen, MsgSend, MsgListenEncoded, Ms
                   yield* connectedLatch.close
                   yield* establishConnection
                 }
-                break
+                return undefined
               }
               case 'PayloadMessage': {
                 if (data.to === connectionId) {
                   return Schema.decodeEither(schema.listen)(data.payload)
                 }
-                break
+                return undefined
               }
             }
           }),

package/src/effect/WebChannel/common.ts

@@ -54,19 +54,19 @@ export type OutputSchema<MsgListen, MsgSend, MsgListenEncoded, MsgSendEncoded> =
 export const mapSchema = <MsgListen, MsgSend, MsgListenEncoded, MsgSendEncoded>(
   schema: InputSchema<MsgListen, MsgSend, MsgListenEncoded, MsgSendEncoded>,
 ): OutputSchema<MsgListen, MsgSend, MsgListenEncoded, MsgSendEncoded> =>
-  Predicate.hasProperty(schema, 'send') && Predicate.hasProperty(schema, 'listen')
+  Predicate.hasProperty(schema, 'send') === true && Predicate.hasProperty(schema, 'listen') === true
     ? (schemaWithWebChannelMessages(schema) as any)
     : (schemaWithWebChannelMessages({ send: schema, listen: schema }) as any)
 
 export const listenToDebugPing =
   (channelName: string) =>
   <MsgListen>(
-    stream: Stream.Stream<Either.Either<MsgListen, ParseResult.ParseError>, never>,
-  ): Stream.Stream<Either.Either<MsgListen, ParseResult.ParseError>, never> =>
+    stream: Stream.Stream<Either.Either<MsgListen, ParseResult.ParseError>>,
+  ): Stream.Stream<Either.Either<MsgListen, ParseResult.ParseError>> =>
     stream.pipe(
       Stream.filterEffect(
         Effect.fn(function* (msg) {
-          if (msg._tag === 'Right' && Schema.is(DebugPingMessage)(msg.right)) {
+          if (msg._tag === 'Right' && Schema.is(DebugPingMessage)(msg.right) === true) {
             yield* Effect.logDebug(`WebChannel:ping [${channelName}] ${msg.right.message}`, msg.right.payload)
             return false
           }

package/src/effect/WebSocket.ts

@@ -2,7 +2,7 @@ import { HttpClient } from '@effect/platform'
 import type { Schedule, Scope } from 'effect'
 import { Effect, Exit, identity, Schema } from 'effect'
 
-export class WebSocketError extends Schema.TaggedError<WebSocketError>()('WebSocketError', {
+export class WebSocketError extends Schema.TaggedError<WebSocketError>('~@livestore/utils/WebSocketError')('WebSocketError', {
   cause: Schema.Defect,
 }) {}
 
@@ -63,7 +63,7 @@ export const makeWebSocket = ({
       }
     }).pipe(
       Effect.tapErrorTag('WebSocketError', () => tryLogWebsocketConnectError(url)),
-      reconnect ? Effect.retry(reconnect) : identity,
+      reconnect !== undefined ? Effect.retry(reconnect) : identity,
     )
 
     /**
@@ -83,7 +83,7 @@ export const makeWebSocket = ({
       Effect.fn(function* (exit) {
         yield* Effect.try({
           try: () => {
-            if (Exit.isFailure(exit)) {
+            if (Exit.isFailure(exit) === true) {
               socket.close(3000)
             } else {
               socket.close(1000)

package/src/effect/mod.ts

@@ -131,6 +131,7 @@ export {
   SortedMap,
   STM,
   SynchronizedRef,
+  TestClock,
   TestServices,
   TQueue,
   TRef,

package/src/effect/spanEvent.test.ts

@@ -0,0 +1,95 @@
+import { it, describe, expect } from '@effect/vitest'
+import { Effect, Tracer } from 'effect'
+
+import { spanEvent } from './spanEvent.ts'
+
+type RecordedEvent = { name: string; attributes: Record<string, unknown> | undefined }
+
+/**
+ * Creates a test tracer that captures span events for assertion,
+ * using only the public `Tracer` API (no internal NativeSpan access).
+ * Each span records its own events, retrievable by span name.
+ */
+const makeTestTracer = () => {
+  const spanEvents = new Map<string, Array<RecordedEvent>>()
+
+  const tracer = Tracer.make({
+    span(name, parent, context, links, startTime, kind) {
+      const events: Array<RecordedEvent> = []
+      spanEvents.set(name, events)
+      const attributes = new Map<string, unknown>()
+      return {
+        _tag: 'Span' as const,
+        name,
+        spanId: `test-${name}`,
+        traceId: 'test-trace',
+        parent,
+        context,
+        status: { _tag: 'Started' as const, startTime },
+        attributes,
+        links: [...links],
+        sampled: true,
+        kind,
+        end() {},
+        attribute(key: string, value: unknown) {
+          attributes.set(key, value)
+        },
+        event(eventName: string, _startTime: bigint, attrs?: Record<string, unknown>) {
+          events.push({ name: eventName, attributes: attrs })
+        },
+        addLinks() {},
+      }
+    },
+    context(f) {
+      return f()
+    },
+  })
+
+  return {
+    tracer,
+    getEvents: (spanName: string): Array<RecordedEvent> => spanEvents.get(spanName) ?? [],
+  }
+}
+
+describe('spanEvent', () => {
+  it.effect('should emit a span event with the given message', () => {
+    const { tracer, getEvents } = makeTestTracer()
+    return Effect.gen(function* () {
+      yield* spanEvent('test-event')
+      const events = getEvents('test-span')
+      expect(events).toHaveLength(1)
+      expect(events[0]!.name).toBe('test-event')
+    }).pipe(Effect.withSpan('test-span'), Effect.withTracer(tracer))
+  })
+
+  it.effect('should emit a span event with attributes', () => {
+    const { tracer, getEvents } = makeTestTracer()
+    return Effect.gen(function* () {
+      yield* spanEvent('event-with-attrs', { key1: 'value1', key2: 42 })
+      const events = getEvents('test-span')
+      expect(events).toHaveLength(1)
+      expect(events[0]!.name).toBe('event-with-attrs')
+      expect(events[0]!.attributes).toMatchObject({ key1: 'value1', key2: 42 })
+    }).pipe(Effect.withSpan('test-span'), Effect.withTracer(tracer))
+  })
+
+  it.effect('should emit to the nearest enclosing span', () => {
+    const { tracer, getEvents } = makeTestTracer()
+    return Effect.gen(function* () {
+      yield* spanEvent('outer-event')
+
+      yield* spanEvent('inner-event').pipe(Effect.withSpan('inner-span'))
+
+      const outerEvents = getEvents('outer-span')
+      const innerEvents = getEvents('inner-span')
+
+      expect(outerEvents).toHaveLength(1)
+      expect(outerEvents[0]!.name).toBe('outer-event')
+
+      expect(innerEvents).toHaveLength(1)
+      expect(innerEvents[0]!.name).toBe('inner-event')
+    }).pipe(Effect.withSpan('outer-span'), Effect.withTracer(tracer))
+  })
+
+  it.effect('should be a no-op when no span is in context', () => spanEvent('orphan-event'))
+})

package/src/effect/spanEvent.ts

@@ -0,0 +1,15 @@
+import { Effect, FiberRef, HashSet, Logger } from 'effect'
+
+/**
+ * Emits a span event on the current Effect span via the tracer logger.
+ *
+ * @remarks
+ *
+ * Unlike raw `otelSpan.addEvent`, this doesn't require manual span threading —
+ * it automatically targets the nearest enclosing `Effect.withSpan`. If no span
+ * is in context, the call is a no-op.
+ */
+export const spanEvent = (message: any, attributes?: Record<string, unknown>) =>
+  Effect.locallyWith(Effect.log(message).pipe(Effect.annotateLogs(attributes ?? {})), FiberRef.currentLoggers, () =>
+    HashSet.make(Logger.tracerLogger),
+  )

package/src/env.ts

@@ -26,4 +26,5 @@ export const IS_CI = envTruish(env('CI'))
 
 export const IS_BUN = typeof Bun !== 'undefined'
 
-export const IS_REACT_NATIVE = typeof navigator !== 'undefined' && navigator.product === 'ReactNative'
+export const IS_REACT_NATIVE =
+  typeof navigator !== 'undefined' && (navigator as unknown as Record<string, unknown>)['product'] === 'ReactNative'

package/src/fast-deep-equal.ts

@@ -4,36 +4,36 @@
 export const deepEqual = <T>(a: T, b: T): boolean => {
   if (a === b) return true
 
-  if (a && b && typeof a === 'object' && typeof b === 'object') {
+  if (a != null && b != null && typeof a === 'object' && typeof b === 'object') {
     if (a.constructor !== b.constructor) return false
 
     let length: number
     let i: any
     let keys: any
-    if (Array.isArray(a)) {
+    if (Array.isArray(a) === true) {
       length = a.length
       // @ts-expect-error ...
       if (length !== b.length) return false
       for (i = length; i-- !== 0; )
         // @ts-expect-error ...
-        if (!deepEqual(a[i], b[i])) return false
+        if (deepEqual(a[i], b[i]) === false) return false
       return true
     }
 
     if (a instanceof Map && b instanceof Map) {
       if (a.size !== b.size) return false
-      for (i of a.entries()) if (!b.has(i[0])) return false
-      for (i of a.entries()) if (!deepEqual(i[1], b.get(i[0]))) return false
+      for (i of a.entries()) if (b.has(i[0]) === false) return false
+      for (i of a.entries()) if (deepEqual(i[1], b.get(i[0])) === false) return false
       return true
     }
 
     if (a instanceof Set && b instanceof Set) {
       if (a.size !== b.size) return false
-      for (i of a.entries()) if (!b.has(i[0])) return false
+      for (i of a.entries()) if (b.has(i[0]) === false) return false
       return true
     }
 
-    if (ArrayBuffer.isView(a) && ArrayBuffer.isView(b)) {
+    if (ArrayBuffer.isView(a) === true && ArrayBuffer.isView(b) === true) {
       // @ts-expect-error ...
       length = a.length
       // @ts-expect-error ...
@@ -53,13 +53,13 @@ export const deepEqual = <T>(a: T, b: T): boolean => {
     length = keys.length
     if (length !== Object.keys(b).length) return false
 
-    for (i = length; i-- !== 0; ) if (!Object.hasOwn(b, keys[i])) return false
+    for (i = length; i-- !== 0; ) if (Object.prototype.hasOwnProperty.call(b, keys[i]) === false) return false
 
     for (i = length; i-- !== 0; ) {
       const key = keys[i]
 
       // @ts-expect-error ...
-      if (!deepEqual(a[key], b[key])) return false
+      if (deepEqual(a[key], b[key]) === false) return false
     }
 
     return true

package/src/global.ts

@@ -6,5 +6,3 @@ declare global {
     main: boolean
   }
 }
-
-export {}

package/src/misc.ts

@@ -10,7 +10,7 @@ export const isDevEnv = () => {
   }
 
   // @ts-expect-error Only exists in Expo / RN
-  if (globalThis?.__DEV__) {
+  if (globalThis?.__DEV__ === true) {
     return true
   }
 
@@ -46,10 +46,18 @@ export const tryAsFunctionAndNew = <TArg, TResult>(
 export const envTruish = (env: string | undefined) =>
   env !== undefined && env.toLowerCase() !== 'false' && env.toLowerCase() !== '0'
 
-export const shouldNeverHappen = (msg?: string, ...args: any[]): never => {
+/**
+ * Logs and throws for impossible states, pausing at a breakpoint in development.
+ *
+ * @param msg - The error message to log and pass to the error.
+ * @param args - Arbitrary arguments to include in the log.
+ *
+ * @see {@link dieDebugger} for the Effect equivalent.
+ */
+export const shouldNeverHappen = (msg?: string, ...args: ReadonlyArray<unknown>): never => {
   console.error(msg, ...args)
-  if (isDevEnv()) {
-    // biome-ignore lint/suspicious/noDebugger: debugging
+  if (isDevEnv() === true) {
+    // oxlint-disable-next-line eslint(no-debugger) -- intentional breakpoint during development
     debugger
   }