@livestore/utils 0.4.0-dev.8 → 0.4.0

package/src/effect/Effect.ts

@@ -6,9 +6,6 @@ import {
   Duration,
   Effect,
   Fiber,
-  FiberRef,
-  HashSet,
-  Logger,
   pipe,
   Scope,
   type Stream,
@@ -18,10 +15,11 @@ import { log } from 'effect/Console'
 import { dual, type LazyArg } from 'effect/Function'
 import type { Predicate, Refinement } from 'effect/Predicate'
 
-import { isPromise } from '../mod.ts'
+import { isDevEnv, isPromise, objectToString } from '../mod.ts'
 import { UnknownError } from './Error.ts'
 
 export * from 'effect/Effect'
+export { spanEvent } from './spanEvent.ts'
 
 // export const log = <A>(message: A, ...rest: any[]): Effect.Effect<void> =>
 //   Effect.sync(() => {
@@ -57,16 +55,16 @@ export type SyncOrPromiseOrEffect<TResult, TError = never, TContext = never> =
 
 export const tryAll = <Res>(
   fn: () => Res,
-): Res extends Effect.Effect<infer A, infer E, never>
-  ? Effect.Effect<A, E | UnknownException, never>
+): Res extends Effect.Effect<infer A, infer E>
+  ? Effect.Effect<A, E | UnknownException>
   : Res extends Promise<infer A>
-    ? Effect.Effect<A, UnknownException, never>
-    : Effect.Effect<Res, UnknownException, never> =>
+    ? Effect.Effect<A, UnknownException>
+    : Effect.Effect<Res, UnknownException> =>
   Effect.try(() => fn()).pipe(
     Effect.andThen((fnRes) =>
-      Effect.isEffect(fnRes)
+      Effect.isEffect(fnRes) === true
         ? (fnRes as any as Effect.Effect<any>)
-        : isPromise(fnRes)
+        : isPromise(fnRes) === true
           ? Effect.promise(() => fnRes)
           : Effect.succeed(fnRes),
     ),
@@ -89,7 +87,7 @@ export const logBefore =
 export const tapCauseLogPretty = <R, E, A>(eff: Effect.Effect<A, E, R>): Effect.Effect<A, E, R> =>
   Effect.tapErrorCause(eff, (cause) =>
     Effect.gen(function* () {
-      if (Cause.isInterruptedOnly(cause)) {
+      if (Cause.isInterruptedOnly(cause) === true) {
         // console.log('interrupted', Cause.pretty(err), err)
         return
       }
@@ -107,6 +105,47 @@ export const tapCauseLogPretty = <R, E, A>(eff: Effect.Effect<A, E, R>): Effect.
     }),
   )
 
+/**
+ * Creates a defect, pausing at a breakpoint in development.
+ *
+ * @param msg - The error message to include in the defect.
+ * @param args - Arbitrary arguments available for inspection during debugging.
+ *
+ * @see {@link shouldNeverHappen} for the non-Effect equivalent that throws synchronously.
+ * @see {@link orDieDebugger}
+ */
+export const dieDebugger = (msg: string, ...args: ReadonlyArray<unknown>): Effect.Effect<never> =>
+  Effect.suspend(() => {
+    if (isDevEnv() === true) {
+      // oxlint-disable-next-line eslint(no-debugger) -- intentional breakpoint during development
+      debugger
+      void args // Keeps the variable in scope so it's inspectable when the debugger pauses
+    }
+    return Effect.dieMessage(msg)
+  })
+
+/**
+ * Converts a failure into a defect, pausing at a breakpoint in development.
+ *
+ * @param self - The effect on which to apply the operation.
+ *
+ * @see {@link Effect.orDie}
+ * @see {@link dieDebugger}
+ */
+export const orDieDebugger = <A, E, R>(self: Effect.Effect<A, E, R>): Effect.Effect<A, never, R> =>
+  Effect.matchEffect(self, {
+    onFailure: (error) =>
+      // Keep the debugger hook so that `debugger` runs only when the wrapped effect actually fails, not while building the wrapper.
+      Effect.dieSync(() => {
+        if (isDevEnv() === true) {
+          // oxlint-disable-next-line eslint(no-debugger) -- intentional breakpoint for impossible states during development
+          debugger
+        }
+        return error
+      }),
+    onSuccess: Effect.succeed,
+  })
+
 export const ignoreIf: {
   <E, EB extends E>(
     refinement: Refinement<NoInfer<E>, EB>,
@@ -124,11 +163,11 @@ export const ignoreIf: {
 export const eventListener = <TEvent = unknown>(
   target: Stream.EventListener<TEvent>,
   type: string,
-  handler: (event: TEvent) => Effect.Effect<void, never, never>,
+  handler: (event: TEvent) => Effect.Effect<void>,
   options?: { once?: boolean },
 ) =>
   Effect.gen(function* () {
-    const runtime = yield* Effect.runtime<never>()
+    const runtime = yield* Effect.runtime()
 
     const handlerFn = (event: TEvent) => handler(event).pipe(Effect.provide(runtime), Effect.runFork)
 
@@ -137,16 +176,11 @@ export const eventListener = <TEvent = unknown>(
     yield* Effect.addFinalizer(() => Effect.sync(() => target.removeEventListener(type, handlerFn)))
   })
 
-export const spanEvent = (message: any, attributes?: Record<string, any>) =>
-  Effect.locallyWith(Effect.log(message).pipe(Effect.annotateLogs(attributes ?? {})), FiberRef.currentLoggers, () =>
-    HashSet.make(Logger.tracerLogger),
-  )
-
 export const logWarnIfTakesLongerThan =
   ({ label, duration }: { label: string; duration: Duration.DurationInput }) =>
   <R, E, A>(eff: Effect.Effect<A, E, R>): Effect.Effect<A, E, R> =>
     Effect.gen(function* () {
-      const runtime = yield* Effect.runtime<never>()
+      const runtime = yield* Effect.runtime()
 
       let tookLongerThanTimer = false
 
@@ -154,7 +188,7 @@ export const logWarnIfTakesLongerThan =
         Effect.tap(() => {
           tookLongerThanTimer = true
           // TODO include span info
-          return Effect.logWarning(`${label}: Took longer than ${duration}ms`)
+          return Effect.logWarning(`${label}: Took longer than ${objectToString(duration)}ms`)
         }),
         Effect.provide(runtime),
         Effect.runFork,
@@ -169,13 +203,14 @@ export const logWarnIfTakesLongerThan =
 
             yield* Fiber.interrupt(timeoutFiber)
 
-            if (tookLongerThanTimer) {
+            if (tookLongerThanTimer === true) {
               yield* Effect.logWarning(`${label}: Interrupted after ${end - start}ms`)
             }
           }),
         ),
       )
 
+      // eslint-disable-next-line overeng/explicit-boolean-compare -- mutated in forked fiber; TS can't see the mutation
       if (tookLongerThanTimer) {
         const end = Date.now()
         yield* Effect.logWarning(`${label}: Actual duration: ${end - start}ms`)
@@ -208,19 +243,61 @@ export const debugLogEnv = (msg?: string): Effect.Effect<Context.Context<never>>
     Effect.tap((env) => log(msg ?? 'debugLogEnv', env)),
   )
 
-export const timeoutDie =
-  <E1>(options: { onTimeout: LazyArg<E1>; duration: Duration.DurationInput }) =>
-  <R, E, A>(self: Effect.Effect<A, E, R>): Effect.Effect<A, E, R> =>
-    Effect.orDie(Effect.timeoutFail(options)(self))
-
-export const timeoutDieMsg =
-  (options: { error: string; duration: Duration.DurationInput }) =>
-  <R, E, A>(self: Effect.Effect<A, E, R>): Effect.Effect<A, E, R> =>
-    Effect.orDie(
-      Effect.timeoutFail({ onTimeout: () => new UnknownError({ cause: options.error }), duration: options.duration })(
-        self,
-      ),
-    )
+/**
+ * Enforces a time limit on an effect, triggering a defect on timeout.
+ *
+ * @remarks
+ *
+ * This function allows you to enforce a time limit on the execution of an
+ * effect. If the effect does not complete within the given duration, it dies
+ * with a {@link Cause.TimeoutException} as an unchecked defect. Unlike
+ * {@link Effect.timeout}, which adds `TimeoutException` to the error channel,
+ * this function keeps the error channel unchanged by treating the timeout as
+ * a defect.
+ *
+ * The returned effect will either:
+ * - Succeed with the original effect's result if it completes within the
+ *   specified duration.
+ * - Die with a {@link Cause.TimeoutException} defect if the time limit is exceeded.
+ *
+ * @see {@link timeoutOrDieMessage} for a version with a custom message.
+ * @see {@link Effect.timeout} for a version that raises a `TimeoutException` as a typed error.
+ * @see {@link Effect.timeoutFailCause} for a version that raises a custom defect.
+ */
+export const timeoutOrDie = (duration: Duration.DurationInput) =>
+  <A, E, R>(self: Effect.Effect<A, E, R>): Effect.Effect<A, E, R> =>
+    Effect.timeoutFailCause(self, {
+      duration,
+      onTimeout: () => Cause.die(new Cause.TimeoutException())
+    })
+
+/**
+ * Enforces a time limit on an effect, triggering a defect with a custom
+ * message on timeout.
+ *
+ * @remarks
+ *
+ * This function behaves like {@link timeoutOrDie}, but allows you to provide
+ * a custom message for the {@link Cause.TimeoutException} defect. This is useful
+ * for adding context about which operation timed out, making it easier to
+ * diagnose issues in logs or error reports.
+ *
+ * The returned effect will either:
+ * - Succeed with the original effect's result if it completes within the
+ *   specified duration.
+ * - Die with a {@link Cause.TimeoutException} defect containing the provided
+ *   message if the time limit is exceeded.
+ *
+ * @see {@link timeoutOrDie} for a version without a custom message.
+ * @see {@link Effect.timeout} for a version that raises a `TimeoutException` as a typed error.
+ * @see {@link Effect.timeoutFailCause} for a version that raises a custom defect.
+ */
+export const timeoutOrDieMessage = (duration: Duration.DurationInput, message: string) =>
+  <A, E, R>(self: Effect.Effect<A, E, R>): Effect.Effect<A, E, R> =>
+    Effect.timeoutFailCause(self, {
+      duration,
+      onTimeout: () => Cause.die(new Cause.TimeoutException(message))
+    })
 
 export const toForkedDeferred = <R, E, A>(
   eff: Effect.Effect<A, E, R>,
@@ -274,7 +351,12 @@ const getSpanTrace = () => {
 
 const logSpanTrace = () => console.log(getSpanTrace())
 
-// @ts-expect-error TODO fix types
+declare global {
+  /** Debug helper: returns the current Effect span trace */
+  var getSpanTrace: () => string
+  /** Debug helper: logs the current Effect span trace */
+  var logSpanTrace: () => void
+}
+
 globalThis.getSpanTrace = getSpanTrace
-// @ts-expect-error TODO fix types
 globalThis.logSpanTrace = logSpanTrace

package/src/effect/Error.ts

@@ -1,6 +1,6 @@
 import { Schema } from 'effect'
 
-export class UnknownError extends Schema.TaggedError<UnknownError>()('UnknownError', {
+export class UnknownError extends Schema.TaggedError<UnknownError>('~@livestore/utils/UnknownError')('UnknownError', {
   cause: Schema.Any,
   payload: Schema.optional(Schema.Any),
 }) {}

package/src/effect/Logger.ts

@@ -23,7 +23,7 @@ export const consoleLogger = (threadName: string) =>
     const consoleFn =
       logLevel === LogLevel.Debug
         ? // Cloudflare Workers doesn't support console.debug 🤷
-          isCloudflareWorker
+          isCloudflareWorker === true
           ? console.log
           : console.debug
         : logLevel === LogLevel.Info
@@ -34,7 +34,7 @@ export const consoleLogger = (threadName: string) =>
 
     const annotationsObj = Object.fromEntries(HashMap.entries(annotations))
 
-    const messages = Array.isArray(message) ? message : [message]
+    const messages = Array.isArray(message) === true ? message : [message]
     if (Cause.isEmpty(cause) === false) {
       messages.push(Cause.pretty(cause, { renderErrorCause: true }))
     }

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:
@@ -40,6 +41,10 @@ export const makeProtocolSocketWithIsConnected = (options: {
       const pinger = yield* makePinger(write(parser.encode(constPing)!), options?.pingSchedule)
 
       yield* Effect.suspend(() => {
+        // We rely on the heartbeat watchdog while streaming arbitrarily long payloads.
+        // Reset the timer as soon as _any_ frame arrives so that large batches which
+        // don't contain explicit `Pong` messages don't trigger the open-timeout defect.
+        // (The actual pong handler still calls `onPong()` to resolve manual pings.)
         // CHANGED: don't reset parser on every message
         // parser = serialization.unsafeMake()
         pinger.reset()
@@ -53,6 +58,9 @@ export const makeProtocolSocketWithIsConnected = (options: {
                 while: () => i < responses.length,
                 body: () => {
                   const response = responses[i++]!
+                  // Keep extending the watchdog for each data frame to avoid
+                  // disconnecting mid-stream when the server is busy sending batches.
+                  pinger.reset()
                   if (response._tag === 'Pong') {
                     pinger.onPong()
                   }
@@ -112,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
@@ -130,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',
@@ -164,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()
@@ -181,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(
@@ -195,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.test.ts

@@ -75,8 +75,8 @@ describe('debug-diff', () => {
 
   test('tagged union', () => {
     const schema = Schema.Union(
-      Schema.Struct({ _tag: Schema.Literal('a'), a: Schema.String }),
-      Schema.Struct({ _tag: Schema.Literal('b'), b: Schema.Number }),
+      Schema.TaggedStruct('a', { a: Schema.String }),
+      Schema.TaggedStruct('b', { b: Schema.Number }),
     )
     const a = { _tag: 'a', a: 'hello' } as const
     const b = { _tag: 'b', b: 1 } as const

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)
@@ -96,4 +99,4 @@ export const JsonValue: Schema.Schema<JsonValue> = Schema.Union(
   Schema.Null,
   Schema.Array(Schema.suspend(() => JsonValue)),
   Schema.Record({ key: Schema.String, value: Schema.suspend(() => JsonValue) }),
-).annotations({ title: 'JsonValue' })
+).annotations({ identifier: 'JsonValue' })

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.test.ts

@@ -2,7 +2,7 @@ import * as Vitest from '@effect/vitest'
 import { Effect, Schema, Stream } from 'effect'
 import { JSDOM } from 'jsdom'
 
-import * as WebChannel from './WebChannel.ts'
+import * as WebChannel from '../../browser/WebChannelBrowser.ts'
 
 Vitest.describe('WebChannel', () => {
   Vitest.describe('windowChannel', () => {