effect 4.0.0 → 4.0.2

package/src/reactivity/Atom.ts

@@ -818,7 +818,7 @@ export interface AtomRuntime<R, ER = never> extends Atom<AsyncResult.AsyncResult
       | ((
         get: AtomContext
       ) => Effect.Effect<SubscriptionRef.SubscriptionRef<A>, E, Scope.Scope | R | AtomRegistry | Reactivity.Reactivity>)
-  ) => Writable<AsyncResult.AsyncResult<A, E>, A>
+  ) => Writable<AsyncResult.AsyncResult<A, E | ER>, A>
 }
 
 /**
@@ -2774,18 +2774,21 @@ export const batch: (f: () => void) => void = Registry.batch
 // -----------------------------------------------------------------------------
 
 /**
- * Creates a browser-only signal atom that increments when the document becomes visible.
+ * Creates a signal atom that increments when the document becomes visible.
  *
  * **Details**
  *
  * It listens for `visibilitychange` events on `window` and removes the listener
- * when the atom is disposed.
+ * when the atom is disposed. Without `window`, it stays at `0` and adds no listener.
  *
  * @stability unstable
  * @category constants
  * @since 4.0.0
  */
 export const windowFocusSignal: Atom<number> = readable((get) => {
+  if (typeof window === "undefined") {
+    return 0
+  }
   let count = 0
   function update() {
     if (document.visibilityState === "visible") {
@@ -2825,8 +2828,8 @@ export const makeRefreshOnSignal = <_>(signal: Atom<_>) => <A extends Atom<any>>
  *
  * **Details**
  *
- * This helper is browser-only because `windowFocusSignal` depends on `window` and
- * `document.visibilityState`.
+ * Without `window`, this helper does not trigger refreshes. Source atom updates
+ * are still forwarded.
  *
  * @stability unstable
  * @category combinators
@@ -2991,7 +2994,8 @@ function updateSearchParams() {
     }
   }
   searchParamState.updates.clear()
-  const newUrl = `${window.location.pathname}?${searchParams.toString()}`
+  const search = searchParams.toString()
+  const newUrl = `${window.location.pathname}${search.length > 0 ? `?${search}` : ""}${window.location.hash}`
   window.history.pushState({}, "", newUrl)
   searchParamState.updating = false
 }

package/src/reactivity/AtomHttpApi.ts

@@ -57,7 +57,7 @@ export interface AtomHttpApiClient<Self, Id extends string, Groups extends HttpA
       HttpApiGroup.Endpoints<Group>,
       EndpointIdentifier
     >,
-    const ResponseMode extends HttpApiEndpoint.ClientResponseMode = HttpApiEndpoint.ClientResponseMode
+    const ResponseMode extends HttpApiEndpoint.ClientResponseMode = "decoded-only"
   >(
     group: GroupIdentifier,
     endpoint: EndpointIdentifier,
@@ -353,9 +353,7 @@ type ResponseByMode<
   Endpoint extends HttpApiEndpoint.Constraint,
   ResponseMode extends HttpApiEndpoint.ClientResponseMode
 > = HttpApiClient.Client.Response<
-  Effect.Success<
-    ReturnType<HttpApiClient.Client.Method<Extract<Endpoint, HttpApiEndpoint.ConstraintRequest>, never, never>>
-  >,
+  HttpApiClient.SuccessType<Extract<Endpoint, HttpApiEndpoint.ConstraintRequest>["~Success"]>,
   ResponseMode
 >
 

package/src/reactivity/AtomRegistry.ts

@@ -71,11 +71,13 @@ export interface AtomRegistry {
   readonly scheduler: Scheduler
   readonly schedulerAsync: Scheduler
   readonly getNodes: () => ReadonlyMap<Atom.Atom<any> | string, Node<any>>
+  readonly ensureNode: <A>(atom: Atom.Atom<A>) => Node<A>
   readonly get: <A>(atom: Atom.Atom<A>) => A
   readonly mount: <A>(atom: Atom.Atom<A>) => () => void
   readonly refresh: <A>(atom: Atom.Atom<A>) => void
   readonly set: <R, W>(atom: Atom.Writable<R, W>, value: W) => void
   readonly setSerializable: (key: string, encoded: unknown) => void
+  readonly preloadedSerializable: Map<string, unknown>
   readonly modify: <R, W, A>(atom: Atom.Writable<R, W>, f: (_: R) => [returnValue: A, nextValue: W]) => A
   readonly update: <R, W>(atom: Atom.Writable<R, W>, f: (_: R) => W) => void
   readonly subscribe: <A>(atom: Atom.Atom<A>, f: (_: A) => void, options?: {
@@ -83,6 +85,7 @@ export interface AtomRegistry {
   }) => () => void
   readonly reset: () => void
   readonly dispose: () => void
+  scheduleNodeRemoval(node: Node<any>): void
   onNodeAdded?: ((node: Node<any>) => void) | undefined
   onNodeRemoved?: ((node: Node<any>) => void) | undefined
 }
@@ -102,10 +105,14 @@ export interface AtomRegistry {
 export interface Node<A> {
   readonly atom: Atom.Atom<A>
   readonly value: () => A
+  readonly valueOption: () => Option.Option<A>
+  readonly canBeRemoved: boolean
   parents: Set<Node<any>>
   children: Set<Node<any>>
   listeners: Set<() => void>
   currentState(): "uninitialized" | "stale" | "valid" | "removed"
+  setInitialValue(value: A): void
+  subscribe(listener: () => void): () => void
 }
 
 /**

package/src/rpc/RpcClient.ts

@@ -13,8 +13,9 @@
  */
 import type { NonEmptyReadonlyArray } from "../Array.ts"
 import * as Cause from "../Cause.ts"
+import * as Clock from "../Clock.ts"
 import * as Context from "../Context.ts"
-import type * as Duration from "../Duration.ts"
+import * as Duration from "../Duration.ts"
 import * as Effect from "../Effect.ts"
 import * as Exit from "../Exit.ts"
 import * as Fiber from "../Fiber.ts"
@@ -42,6 +43,7 @@ import type { Span } from "../Tracer.ts"
 import * as Transferable from "../workers/Transferable.ts"
 import * as Worker from "../workers/Worker.ts"
 import type { WorkerError } from "../workers/WorkerError.ts"
+import * as RpcTracing from "./internal/tracing.ts"
 import * as Rpc from "./Rpc.ts"
 import { RpcClientDefect, RpcClientError } from "./RpcClientError.ts"
 import type * as RpcGroup from "./RpcGroup.ts"
@@ -267,7 +269,7 @@ export const makeNoSerialization: <Rpcs extends Rpc.Any, E, const Flatten extend
     readonly flatten?: Flatten | undefined
   }
 ) {
-  const spanPrefix = options?.spanPrefix ?? "RpcClient"
+  const spanPrefix = options.spanPrefix
   const supportsAck = options?.supportsAck ?? true
   const disableTracing = options?.disableTracing ?? false
   const generateRequestId = options?.generateRequestId ?? (() => requestIdCounter++ as RequestId)
@@ -335,8 +337,8 @@ export const makeNoSerialization: <Rpcs extends Rpc.Any, E, const Flatten extend
             opts?.discard ?? false
           )
         return disableTracing ? onRequest(undefined) : Effect.useSpan(
-          `${spanPrefix}.${rpc._tag}`,
-          { attributes: options.spanAttributes },
+          RpcTracing.spanName(spanPrefix, rpc._tag),
+          { kind: "client", attributes: RpcTracing.spanAttributes(rpc._tag, options.spanAttributes) },
           onRequest
         )
       }
@@ -447,16 +449,19 @@ export const makeNoSerialization: <Rpcs extends Rpc.Any, E, const Flatten extend
       return yield* Effect.interrupt
     }
 
-    const span = disableTracing ? undefined : yield* Effect.makeSpanScoped(`${spanPrefix}.${rpc._tag}`, {
-      attributes: options.spanAttributes
-    })
+    const span = disableTracing ? undefined : yield* Effect.makeSpanScoped(
+      RpcTracing.spanName(spanPrefix, rpc._tag),
+      { kind: "client", attributes: RpcTracing.spanAttributes(rpc._tag, options.spanAttributes) }
+    )
     const fiber = Fiber.getCurrent()!
     const id = generateRequestId()
 
     const scope = Context.getUnsafe(fiber.context, Scope.Scope)
+    const queue = yield* Queue.bounded<any, any>(streamBufferSize)
     yield* Scope.addFinalizerExit(
       scope,
       (exit) => {
+        Queue.shutdownUnsafe(queue)
         if (!entries.has(id)) return Effect.void
         entries.delete(id)
         return sendInterrupt(
@@ -469,7 +474,6 @@ export const makeNoSerialization: <Rpcs extends Rpc.Any, E, const Flatten extend
       }
     )
 
-    const queue = yield* Queue.bounded<any, any>(streamBufferSize)
     entries.set(id, {
       _tag: "Queue",
       rpc,
@@ -671,6 +675,12 @@ export const make: <Rpcs extends Rpc.Any, const Flatten extends boolean = false>
   }
   const entries = new Map<RequestId, ClientEntry>()
 
+  const interruptRequest = (requestId: RequestId): Effect.Effect<void, RpcClientError> => {
+    if (!entries.has(requestId)) return Effect.void
+    entries.delete(requestId)
+    return send(clientId, { _tag: "Interrupt", requestId }) as Effect.Effect<void, RpcClientError>
+  }
+
   const { client, write } = yield* makeNoSerialization(group, {
     ...options,
     supportsAck,
@@ -711,13 +721,7 @@ export const make: <Rpcs extends Rpc.Any, const Flatten extends boolean = false>
           }) as Effect.Effect<void, RpcClientError>
         }
         case "Interrupt": {
-          const entry = entries.get(message.requestId)
-          if (!entry) return Effect.void
-          entries.delete(message.requestId)
-          return send(clientId, {
-            _tag: "Interrupt",
-            requestId: message.requestId
-          }) as Effect.Effect<void, RpcClientError>
+          return interruptRequest(message.requestId)
         }
         case "Eof": {
           return Effect.void
@@ -732,19 +736,22 @@ export const make: <Rpcs extends Rpc.Any, const Flatten extends boolean = false>
         const requestId = RequestId(message.requestId)
         const entry = entries.get(requestId)
         if (!entry || Option.isNone(entry.schemas.decodeChunk)) return Effect.void
-        return entry.schemas.decodeChunk.value(message.values).pipe(
-          Effect.provideContext(entry.context),
-          Effect.orDie,
-          Effect.flatMap((chunk) =>
-            write({ _tag: "Chunk", clientId: 0, requestId: RequestId(message.requestId), values: chunk })
-          ),
-          Effect.onError((cause) =>
-            write({
-              _tag: "Exit",
-              clientId: 0,
-              requestId: RequestId(message.requestId),
-              exit: Exit.failCause(cause)
-            })
+        const decodeChunk = entry.schemas.decodeChunk.value
+        return Effect.uninterruptibleMask((restore) =>
+          restore(
+            decodeChunk(message.values).pipe(
+              Effect.provideContext(entry.context),
+              Effect.orDie,
+              Effect.flatMap((chunk) => write({ _tag: "Chunk", clientId: 0, requestId, values: chunk }))
+            )
+          ).pipe(
+            Effect.onError((cause) =>
+              write({ _tag: "Exit", clientId: 0, requestId, exit: Exit.failCause(cause) }).pipe(
+                Effect.andThen(Cause.hasInterrupts(cause) ? Effect.void : Effect.ignore(interruptRequest(requestId)))
+              )
+            ),
+            // a decode failure only ends its own request; interruption still propagates
+            Effect.catchCauseIf((cause) => !Cause.hasInterrupts(cause), () => Effect.void)
           )
         ) as Effect.Effect<void>
       }
@@ -768,7 +775,7 @@ export const make: <Rpcs extends Rpc.Any, const Flatten extends boolean = false>
       case "ClientProtocolError": {
         const exit = Exit.fail(message.error)
         return Effect.forEach(
-          entries.keys(),
+          Array.from(entries.keys()),
           (requestId) => write({ _tag: "Exit", clientId: 0, requestId, exit: exit as any })
         )
       }
@@ -1042,16 +1049,24 @@ export const layerProtocolHttp = (options: {
  * `RpcSerialization`, connection hooks, ping timeouts, and the configured retry
  * policy.
  *
+ * **Details**
+ *
+ * `pingInterval` defaults to 5 seconds. `pingTimeout` defaults to the interval
+ * and measures time since the last decoded server frame, not the last pong.
+ * The timeout is checked on each ping tick; any decoded frame counts as liveness.
+ *
  * @stability unstable
  * @category protocols
  * @since 4.0.0
  */
 export const makeProtocolSocket = (options?: {
+  readonly pingInterval?: Duration.Input | undefined
+  readonly pingTimeout?: Duration.Input | undefined
   readonly retryTransientErrors?: boolean | undefined
   readonly retryPolicy?: Schedule.Schedule<any, Socket.SocketError> | undefined
   /**
    * Runs for each retried `SocketOpenError` when `retryTransientErrors` is enabled.
-   * A missed pong fails in-flight calls and is not reported through this hook.
+   * A ping timeout fails in-flight calls and is not reported through this hook.
    * The returned `Effect<void>` cannot fail with a typed error or require
    * services; defects are logged and ignored so retries can continue.
    */
@@ -1074,7 +1089,7 @@ export const makeProtocolSocket = (options?: {
     // `parser` is replaced on every connect, and a stateful serialization
     // encodes against the connection it is writing to, so the ping is encoded
     // when it is sent rather than once up front.
-    const pinger = yield* makePinger(Effect.suspend(() => writer.write(parser.encode(constPing)!)))
+    const pinger = yield* makePinger(Effect.suspend(() => writer.write(parser.encode(constPing)!)), options)
     let currentError: RpcClientError | undefined
 
     const broadcast = (response: FromServerEncoded) =>
@@ -1091,15 +1106,13 @@ export const makeProtocolSocket = (options?: {
       try {
         const responses = parser.decode(data) as Array<FromServerEncoded>
         if (responses.length === 0) return Effect.void
+        pinger.onFrame()
         let i = 0
         return Effect.whileLoop({
           while: () => i < responses.length,
           body: () => {
             const response = responses[i++]
-            if (response._tag === "Pong") {
-              pinger.onPong()
-              return Effect.void
-            }
+            if (response._tag === "Pong") return Effect.void
             if (Object.hasOwn(response, "requestId")) {
               const requestId = (response as FromServerEncoded & { readonly requestId: string | number }).requestId
               const clientId = requestClientMap.get(requestId)
@@ -1214,43 +1227,58 @@ const defaultRetryPolicy = Schedule.min([
   Schedule.spaced(5000)
 ])
 
-const makePinger = Effect.fnUntraced(function*<A, E, R>(writePing: Effect.Effect<A, E, R>) {
-  let recievedPong = true
+const makePinger = Effect.fnUntraced(function*<A, E, R>(writePing: Effect.Effect<A, E, R>, options?: {
+  readonly pingInterval?: Duration.Input | undefined
+  readonly pingTimeout?: Duration.Input | undefined
+}) {
+  const clock = yield* Clock.Clock
+  const interval = options?.pingInterval ?? "5 seconds"
+  const timeoutMillis = Duration.toMillis(options?.pingTimeout ?? interval)
+  let lastSeen = clock.currentTimeMillisUnsafe()
   const latch = Latch.makeUnsafe()
+  const onFrame = () => {
+    lastSeen = clock.currentTimeMillisUnsafe()
+  }
   const reset = () => {
-    recievedPong = true
+    onFrame()
     latch.closeUnsafe()
   }
-  const onPong = () => {
-    recievedPong = true
-  }
   yield* Effect.suspend((): Effect.Effect<void, E, R> => {
-    if (!recievedPong) return latch.open
-    recievedPong = false
+    if (clock.currentTimeMillisUnsafe() - lastSeen > timeoutMillis) return latch.open
     return writePing
   }).pipe(
-    Effect.delay("5 seconds"),
+    Effect.delay(interval),
     Effect.ignore,
     Effect.forever,
     Effect.interruptible,
     Effect.forkScoped
   )
-  return { timeout: latch.await, reset, onPong } as const
+  return { timeout: latch.await, reset, onFrame } as const
 })
 
 /**
  * Provides a client `Protocol` backed by the current `Socket` and
  * `RpcSerialization` services.
  *
+ * **Details**
+ *
+ * `pingInterval` defaults to 5 seconds. `pingTimeout` defaults to the interval
+ * and measures time since the last decoded server frame, not the last pong.
+ * The timeout is checked on each ping tick; any decoded frame counts as liveness.
+ * `retryPolicy` configures retries after socket errors.
+ *
  * @stability unstable
  * @category layers
  * @since 4.0.0
  */
 export const layerProtocolSocket = (options?: {
+  readonly pingInterval?: Duration.Input | undefined
+  readonly pingTimeout?: Duration.Input | undefined
   readonly retryTransientErrors?: boolean | undefined
+  readonly retryPolicy?: Schedule.Schedule<any, Socket.SocketError> | undefined
   /**
    * Runs for each retried `SocketOpenError` when `retryTransientErrors` is enabled.
-   * A missed pong fails in-flight calls and is not reported through this hook.
+   * A ping timeout fails in-flight calls and is not reported through this hook.
    * The returned `Effect<void>` cannot fail with a typed error or require
    * services; defects are logged and ignored so retries can continue.
    */

package/src/rpc/RpcServer.ts

@@ -44,6 +44,7 @@ import type * as Types from "../Types.ts"
 import * as Transferable from "../workers/Transferable.ts"
 import type { WorkerError } from "../workers/WorkerError.ts"
 import * as WorkerRunner from "../workers/WorkerRunner.ts"
+import * as RpcTracing from "./internal/tracing.ts"
 import * as Rpc from "./Rpc.ts"
 import type * as RpcGroup from "./RpcGroup.ts"
 import type {
@@ -117,7 +118,7 @@ export const makeNoSerialization: <Rpcs extends Rpc.Any>(
   const enableTracing = options.disableTracing !== true
   const enableSpanPropagation = options.disableSpanPropagation !== true
   const supportsAck = options.disableClientAcks !== true
-  const spanPrefix = options.spanPrefix ?? "RpcServer"
+  const spanPrefix = options.spanPrefix
   const concurrency = options.concurrency ?? "unbounded"
   const disableFatalDefects = options.disableFatalDefects ?? false
   const services = yield* Effect.context<Rpc.ToHandler<Rpcs> | Scope.Scope>()
@@ -331,9 +332,10 @@ export const makeNoSerialization: <Rpcs extends Rpc.Any>(
         requestFiber.context,
         Tracer.ParentSpan
       )
-      effect = Effect.withSpan(effect, `${spanPrefix}.${request.tag}`, {
+      effect = Effect.withSpan(effect, RpcTracing.spanName(spanPrefix, request.tag), {
         captureStackTrace: false,
-        attributes: options.spanAttributes,
+        kind: "server",
+        attributes: RpcTracing.spanAttributes(request.tag, options.spanAttributes),
         parent: enableSpanPropagation && request.spanId
           ? Tracer.externalSpan({
             traceId: request.traceId!,
@@ -359,11 +361,14 @@ export const makeNoSerialization: <Rpcs extends Rpc.Any>(
     )
     const fiber = trackFiber(
       runFork(
-        effect,
+        // Register before the handler runs to catch synchronous cancellation.
+        Effect.withFiber((fiber) => {
+          client.fibers.set(request.id, fiber)
+          return effect
+        }),
         isUninterruptible ? { uninterruptible: true } : undefined
       )
     )
-    client.fibers.set(request.id, fiber)
     fiber.addObserver(function onExit(exit: Exit.Exit<any, any>): void {
       if (deferred) {
         const fiber = trackFiber(runFork(Effect.onExit(Deferred.await(deferred), (exit) =>
@@ -564,6 +569,10 @@ export const make: <Rpcs extends Rpc.Any>(
     supportsTransferables
   } = yield* Protocol
   const encodeDefectUnsafe = Schema.encodeSync(codecFor(Schema.Defect()))
+  // Unknown tags have no RPC schema, so use a defect-only exit schema.
+  const encodeUnknownRequestExit: Schemas["encodeExit"] = Schema.encodeUnknownEffect(
+    codecFor(Schema.Exit(Schema.Never, Schema.Never, Schema.Defect()))
+  ) as any
   const services = yield* Effect.context<Rpc.ToHandler<Rpcs> | Rpc.Middleware<Rpcs>>()
   const scope = yield* Scope.make()
 
@@ -629,7 +638,6 @@ export const make: <Rpcs extends Rpc.Any>(
       u: NonEmptyReadonlyArray<unknown>
     ) => Effect.Effect<NonEmptyReadonlyArray<unknown>, Schema.SchemaError>
     readonly encodeExit: (u: unknown) => Effect.Effect<ResponseExitEncoded["exit"], Schema.SchemaError>
-    readonly encodeDefect: (u: unknown) => Effect.Effect<unknown, Schema.SchemaError>
     readonly context: Context.Context<never>
     readonly collector?: Transferable.Collector["Service"] | undefined
   }
@@ -648,7 +656,6 @@ export const make: <Rpcs extends Rpc.Any>(
           )
         ) as any,
         encodeExit: Schema.encodeUnknownEffect(codecFor(Rpc.exitSchema(rpc as any))) as any,
-        encodeDefect: Schema.encodeUnknownEffect(codecFor(rpc.defectSchema)) as any,
         context: entry.context
       }
       schemasCache.set(rpc, schemas)
@@ -694,7 +701,7 @@ export const make: <Rpcs extends Rpc.Any>(
       client.schemas.delete(requestId)
       const defect = Cause.squash(Cause.map(cause, (e) => SchemaIssue.defaultFormatter(e.issue)))
       return Effect.andThen(
-        sendRequestDefect(client, requestId, schemas.encodeDefect, defect),
+        sendRequestDefect(client, requestId, schemas.encodeExit, defect),
         server.write(client.id, { _tag: "Interrupt", requestId, interruptors: [] })
       )
     })
@@ -703,22 +710,14 @@ export const make: <Rpcs extends Rpc.Any>(
   const sendRequestDefect = (
     client: Client,
     requestId: RequestId,
-    encodeDefect: (u: unknown) => Effect.Effect<unknown, Schema.SchemaError>,
+    encodeExit: Schemas["encodeExit"],
     defect: unknown
   ) =>
     Effect.catchCause(
-      Effect.flatMap(encodeDefect(defect), (encodedDefect) =>
-        send(client.id, {
-          _tag: "Exit",
-          requestId,
-          exit: {
-            _tag: "Failure",
-            cause: [{
-              _tag: "Die",
-              defect: encodedDefect
-            }]
-          }
-        })),
+      Effect.flatMap(
+        encodeExit(Exit.die(defect)),
+        (exit) => send(client.id, responseEnvelope(requestId, "Exit", exit))
+      ),
       (cause) => sendDefect(client, Cause.squash(cause))
     )
 
@@ -784,7 +783,7 @@ export const make: <Rpcs extends Rpc.Any>(
         }
         const rpc = group.requests.get(tag)
         if (!rpc) {
-          return sendRequestDefect(client, requestId, (defect) => Effect.succeed(defect), `Unknown request tag: ${tag}`)
+          return sendRequestDefect(client, requestId, encodeUnknownRequestExit, `Unknown request tag: ${tag}`)
         }
         const schemas = getSchemas(rpc as any)
         const decoded = schemas.decode(request.payload)
@@ -798,7 +797,7 @@ export const make: <Rpcs extends Rpc.Any>(
           Effect.provideContext(decoded, schemas.context),
           {
             onFailure: (error) =>
-              sendRequestDefect(client, requestId, schemas.encodeDefect, SchemaIssue.defaultFormatter(error.issue)),
+              sendRequestDefect(client, requestId, schemas.encodeExit, SchemaIssue.defaultFormatter(error.issue)),
             onSuccess: (payload) => writeDecodedRequest(client, requestId, schemas, request, payload)
           }
         )
@@ -1181,7 +1180,10 @@ export const makeProtocolWithHttpEffect: (
       })
     }
 
-    const initialChunk = yield* Queue.takeAll(queue) as any as Effect.Effect<NonEmptyReadonlyArray<Uint8Array>>
+    const initialChunk = yield* Pull.catchDone(
+      Queue.takeAll(queue as Queue.Dequeue<Uint8Array, Cause.Done>),
+      () => Effect.succeed([])
+    )
     if (queue.state._tag === "Done") {
       return HttpServerResponse.uint8Array(mergeUint8Arrays(initialChunk), {
         contentType: serialization.contentType
@@ -1392,13 +1394,14 @@ export const makeProtocolStdio = Effect.gen(function*() {
       Effect.sandbox,
       Effect.tapError(Effect.logError),
       Effect.retry(Schedule.spaced(500)),
-      Effect.ensuring(Effect.forkDetach(Fiber.interrupt(fiber), { startImmediately: true })),
+      Effect.andThen(() => writeRequest(0, constEof)),
       Effect.forkScoped
     )
 
     yield* Stream.fromQueue(queue).pipe(
       Stream.run(stdio.stdout()),
       Effect.retry(Schedule.spaced(500)),
+      Effect.ensuring(Effect.forkDetach(Fiber.interrupt(fiber), { startImmediately: true })),
       Effect.forkScoped
     )
 

package/src/rpc/Utils.ts

@@ -1,10 +1,5 @@
 /**
- * Helps RPC protocol services buffer messages until their receive loop starts.
- *
- * Client and server protocol constructors use these helpers to expose a stable
- * service before the active receiver is installed. Writes made before `run`
- * starts are buffered with their current `Context`, then replayed once the
- * receiver is ready.
+ * Buffers RPC protocol messages until their receive loop starts.
  *
  * @stability unstable
  * @since 4.0.0
@@ -16,9 +11,8 @@ import type { Protocol } from "./RpcClient.ts"
 import type { FromServerEncoded } from "./RpcMessage.ts"
 
 /**
- * Builds a service with a `run` method that buffers writes until `run` installs
- * a writer, replays buffered writes with their original contexts, and restores
- * the previous writer when the run ends.
+ * Buffers writes until `run` replays them with their original contexts and
+ * installs the writer. Restores the previous writer when `run` ends.
  *
  * @stability unstable
  * @category services
@@ -43,12 +37,12 @@ export const withRun = <
       run(f) {
         return semaphore.withPermits(1)(Effect.gen(function*() {
           const prev = write
-          write = f
 
           for (const [args, context] of buffer) {
             yield* Effect.provideContext(Effect.suspend(() => f(...args)), context)
           }
           buffer = []
+          write = f
 
           return yield* Effect.onExit(Effect.never, () => {
             write = prev

package/src/rpc/internal/tracing.ts

@@ -0,0 +1,22 @@
+/**
+ * Names the span after the RPC method, or `${spanPrefix}.${tag}` when a prefix
+ * is configured.
+ *
+ * @internal
+ */
+export const spanName = (spanPrefix: string | undefined, tag: string): string =>
+  spanPrefix === undefined ? tag : `${spanPrefix}.${tag}`
+
+/**
+ * Default RPC span attributes, overridden by user `spanAttributes`.
+ *
+ * @internal
+ */
+export const spanAttributes = (
+  tag: string,
+  attributes: Record<string, unknown> | undefined
+): Record<string, unknown> => ({
+  "rpc.system.name": "effect_rpc",
+  "rpc.method": tag,
+  ...attributes
+})

package/src/schema/SchemaCompiler/runtime.ts

@@ -65,12 +65,15 @@ const makeObjectBase = (
   const runFallback: SchemaIssueParser = (input, options) =>
     (fallback ??= ast.getParser(compile, compileField))(input, options)
   const resume = (
-    state: ObjectParserState,
+    snapshot: ObjectParserState,
     index: number,
     pending: Effect.Effect<unknown, SchemaIssue.Issue, any>
   ): Effect.Effect<unknown, SchemaIssue.Issue, any> => {
     const property = properties![index]
     return Effect.flatMap(Effect.exit(pending), (exit) => {
+      // Each execution gets its own output; `issues` is still undefined here
+      // because `errors: "all"` is routed to the fallback before suspending.
+      const state: ObjectParserState = { ...snapshot, out: { ...snapshot.out } }
       const terminal = SchemaAST.stepProperty(state, property, exit)
       if (terminal) return terminal
       const done = () => InternalParser.succeed(state.out)

package/src/sql/SqlClient.ts

@@ -394,7 +394,7 @@ export const makeWithTransaction = <I, S>(options: {
     Effect.uninterruptibleMask((restore) =>
       Effect.useSpan(
         "sql.transaction",
-        { kind: "client" },
+        { kind: "internal" },
         (span) =>
           Effect.withFiber<A, E | SqlError, R>((fiber) => {
             for (const [key, value] of options.spanAttributes) {
@@ -427,18 +427,18 @@ export const makeWithTransaction = <I, S>(options: {
                         let effect: Effect.Effect<void>
                         if (Exit.isSuccess(exit)) {
                           if (id === 0) {
-                            span.event("db.transaction.commit", clock.currentTimeNanosUnsafe())
+                            span.event("effect.sql.transaction.commit", clock.currentTimeNanosUnsafe())
                             const onCommitFailure = options.onCommitFailure
                             effect = Effect.orDie(options.commit(conn))
                             if (onCommitFailure) {
                               effect = Effect.onError(effect, () => Effect.orDie(onCommitFailure(conn)))
                             }
                           } else {
-                            span.event("db.transaction.savepoint", clock.currentTimeNanosUnsafe())
+                            span.event("effect.sql.transaction.savepoint", clock.currentTimeNanosUnsafe())
                             effect = Effect.void
                           }
                         } else {
-                          span.event("db.transaction.rollback", clock.currentTimeNanosUnsafe())
+                          span.event("effect.sql.transaction.rollback", clock.currentTimeNanosUnsafe())
                           effect = Effect.orDie(
                             id > 0
                               ? options.rollbackSavepoint(conn, id)