@yielded/agent-platform-cloudflare 0.1.0-beta.167 → 0.1.0-beta.168

package/src/internal/layers.ts

@@ -1,4 +1,3 @@
-import { BrowserCrypto } from "@effect/platform-browser";
 import { SqliteClient } from "@effect/sql-sqlite-do";
 import { doMessageDeliveryStoreLayer } from "@yielded/agent-storage-cloudflare/do-message-delivery-store";
 import {
@@ -24,6 +23,7 @@ import {
   routedMessageDeliveryStoreLayer,
   routedThreadStoreLayer,
   routedSubmissionLedgerLayer,
+  routedSettlementPublisherLayer,
   routedWorkerAdmissionLayer,
 } from "@yielded/agent-storage-cloudflare/port-routing";
 import {
@@ -70,6 +70,9 @@ import {
   RunToolAuthorization,
   toolFailureObserverLayer,
 } from "@yielded/agent/run-options";
+import type { RunStorage } from "@yielded/agent/run-storage";
+import { layer as runStorageLayer, StorageOwner } from "@yielded/agent/run-storage";
+import { SettlementPublisher, validatePublication } from "@yielded/agent/settlement-publisher";
 import { SqlStorageOwner } from "@yielded/agent/sql-memory-store";
 import {
   LedgerError,
@@ -80,7 +83,8 @@ import {
   type WorkerStopCommand,
 } from "@yielded/agent/submission-ledger";
 import { ThreadProjectionMaintenance } from "@yielded/agent/thread-projection-maintenance";
-import { ThreadStoreError, ThreadStore } from "@yielded/agent/thread-store";
+import type { ThreadReader } from "@yielded/agent/thread-store";
+import { AppendResult, ThreadStoreError, ThreadStore } from "@yielded/agent/thread-store";
 import { ToolReconciler } from "@yielded/agent/tool-reconciler";
 import { type WakeScheduler } from "@yielded/agent/wake-scheduler";
 import {
@@ -125,7 +129,9 @@ import {
 } from "../CloudflareConfig.ts";
 import { CloudflareThreadClient } from "../CloudflareThreadClient.ts";
 import { cloudflareWakeSchedulerLayer } from "../WakeScheduler.ts";
+import { cloudflareCryptoLayer } from "./crypto.ts";
 import * as DueQueue from "./due-queue.ts";
+import { LiveTextHub } from "./live-text.ts";
 import {
   guardedMessageDeliveryStoreLayer,
   threadMessageDeliveryLayer,
@@ -144,16 +150,12 @@ export interface CloudflareDurableRuntimeOptions {
   readonly deploymentId: string;
   /** Head of the minted producer identity `{producerPrefix}:{threadId}`. */
   readonly producerPrefix: string;
-  /** Milliseconds; default 30s (D5). */
-  readonly ownershipLeaseDuration?: number | undefined;
   /** Milliseconds; default 100. */
   readonly alarmBackoffBase?: number | undefined;
   /** Failed/no-progress exponential backoff ceiling in milliseconds; default 5000. */
   readonly alarmBackoffCap?: number | undefined;
   /** Milliseconds; default 500. */
   readonly settlementPollInterval?: number | undefined;
-  /** Milliseconds; default 10000. */
-  readonly leaseRenewalInterval?: number | undefined;
   /** Milliseconds; default 500. */
   readonly abortPollInterval?: number | undefined;
   /** Deployment-owned pricing authority used by durable cost budgets and settlements. */
@@ -210,7 +212,8 @@ export type CloudflareBootstrapServices =
   | ThreadMaintenanceFailpoint
   | RunContextPreparation
   | RunToolAuthorization
-  | ToolReconciler;
+  | ToolReconciler
+  | LiveTextHub;
 
 /** Every construction failure of the assembled Cloudflare durable runtime stack. */
 export type CloudflareDurableRuntimeInitializationError =
@@ -228,6 +231,10 @@ export type CloudflareDurableRuntimeServices =
   | DurableAgentRuntime
   | SubmissionLedger
   | ThreadStore
+  | ThreadReader
+  | RunStorage
+  | StorageOwner
+  | SettlementPublisher
   | MessageDeliveryStore
   | WakeScheduler
   | DurableAlarmService
@@ -269,14 +276,10 @@ const configFromOptions = (
   decodeConfigValue({
     deploymentId: options.deploymentId,
     producerPrefix: options.producerPrefix,
-    ownershipLeaseDuration:
-      options.ownershipLeaseDuration ?? CLOUDFLARE_RUNTIME_DEFAULTS.ownershipLeaseDuration,
     alarmBackoffBase: options.alarmBackoffBase ?? CLOUDFLARE_RUNTIME_DEFAULTS.alarmBackoffBase,
     alarmBackoffCap: options.alarmBackoffCap ?? CLOUDFLARE_RUNTIME_DEFAULTS.alarmBackoffCap,
     settlementPollInterval:
       options.settlementPollInterval ?? CLOUDFLARE_RUNTIME_DEFAULTS.settlementPollInterval,
-    leaseRenewalInterval:
-      options.leaseRenewalInterval ?? CLOUDFLARE_RUNTIME_DEFAULTS.leaseRenewalInterval,
     abortPollInterval: options.abortPollInterval ?? CLOUDFLARE_RUNTIME_DEFAULTS.abortPollInterval,
     observationPollInterval:
       options.observationPollInterval ?? CLOUDFLARE_RUNTIME_DEFAULTS.observationPollInterval,
@@ -353,13 +356,13 @@ const runtimeConfigLayer = (
           deploymentId: config.deploymentId,
           producerId,
           settlementPollInterval: Duration.millis(config.settlementPollInterval),
-          leaseRenewalInterval: Duration.millis(config.leaseRenewalInterval),
           abortPollInterval: Duration.millis(config.abortPollInterval),
           ...(options.estimateCostMicrousd === undefined
             ? {}
             : { estimateCostMicrousd: options.estimateCostMicrousd }),
         }),
-        BrowserCrypto.layer,
+        cloudflareCryptoLayer,
+        LiveTextHub.layer,
         storageFailpointLayer({ storage: ctx.storage, failpoint: options.storageFailpoint?.(ctx) }),
         options.runtimeFailpoint === undefined
           ? DurableRuntimeFailpoint.layer
@@ -405,7 +408,10 @@ export const layerConfig = (
       return Layer.mergeAll(
         runtimeConfigLayer(options, producerId),
         Layer.succeed(ThreadObjectIdentity, { threadId, producerId }),
-        Layer.succeed(ThreadObjectPlacement, { ownsThread: (target) => target === threadId }),
+        Layer.succeed(ThreadObjectPlacement, {
+          threadId,
+          ownsThread: (target) => target === threadId,
+        }),
       );
     }),
   );
@@ -609,12 +615,12 @@ const sharedLayer = <A, E, R, PE = never, PR = never>(
     Effect.gen(function* () {
       const { ctx } = yield* DurableObjectContext;
       const config = yield* CloudflareDurableRuntimeConfig;
-      const { ownsThread } = yield* ThreadObjectPlacement;
+      const placement = yield* ThreadObjectPlacement;
+      const { ownsThread } = placement;
 
       const storageOptions: DoStorageOptions = {
         storage: ctx.storage,
         observationPollInterval: config.observationPollInterval,
-        ownershipLeaseDuration: config.ownershipLeaseDuration,
         maxStoredValueBytes: config.maxStoredValueBytes,
         verifyOnOpen: config.verifyOnOpen,
       };
@@ -748,6 +754,8 @@ const sharedLayer = <A, E, R, PE = never, PR = never>(
               Effect.gen(function* () {
                 const store = yield* ThreadStore;
                 const ledger = yield* SubmissionLedger;
+                const storageOwner = yield* StorageOwner;
+                const settlementPublisher = yield* SettlementPublisher;
                 const mutations = yield* ThreadMutationGate;
                 const index = yield* ThreadProjectionMaintenance;
                 const publish = yield* Effect.context<ThreadPublication>();
@@ -879,6 +887,64 @@ const sharedLayer = <A, E, R, PE = never, PR = never>(
                 const stopWorker = ledger.stopWorker;
 
                 return Context.make(ThreadStore, observedStore).pipe(
+                  Context.add(StorageOwner, storageOwner),
+                  Context.add(SettlementPublisher, {
+                    publish: (input) =>
+                      Effect.gen(function* () {
+                        const { request } = yield* validatePublication(input);
+
+                        return yield* mutations
+                          .withMutation(
+                            sourceCommits
+                              .withPermit(
+                                settlementPublisher.publish(request).pipe(
+                                  Effect.tap((result) =>
+                                    result.replayed
+                                      ? Effect.void
+                                      : index
+                                          .applyCommitted(
+                                            request.append,
+                                            AppendResult.make({
+                                              firstSequence: result.tailSequence,
+                                              lastSequence: result.tailSequence,
+
+                                              replayed: false,
+                                            }),
+                                          )
+                                          .pipe(
+                                            Effect.catchCause((cause) =>
+                                              Cause.hasInterrupts(cause)
+                                                ? Effect.interrupt
+                                                : Effect.logError(
+                                                    "Thread projection deferred after settlement publication",
+                                                    cause,
+                                                  ),
+                                            ),
+                                          ),
+                                  ),
+                                ),
+                              )
+                              .pipe(Effect.tap(() => afterCommit)),
+                            {
+                              lanes: [
+                                ...(options.projection === undefined ? [] : [DueQueue.Projection]),
+                                ...(options.lifecyclePublication === undefined
+                                  ? []
+                                  : [DueQueue.Lifecycle]),
+                              ],
+                            },
+                          )
+                          .pipe(
+                            Effect.catchTag("DurableAlarmError", (cause) =>
+                              ThreadStoreError.make({
+                                operation: "prearm settlement publication",
+                                message: cause.message,
+                                cause,
+                              }),
+                            ),
+                          );
+                      }),
+                  }),
                   Context.add(SubmissionLedger, {
                     ...ledger,
                     ...(options.hostLanesForMutation === undefined
@@ -936,6 +1002,7 @@ const sharedLayer = <A, E, R, PE = never, PR = never>(
         Effect.gen(function* () {
           const local = yield* Effect.context<
             | SubmissionLedger
+            | SettlementPublisher
             | ThreadStore
             | MessageDeliveryStore
             | WakeScheduler
@@ -953,7 +1020,9 @@ const sharedLayer = <A, E, R, PE = never, PR = never>(
       ).pipe(Layer.provide(localPorts), Layer.provide(messageStore), Layer.provide(wakes));
 
       const routedPorts = Layer.mergeAll(
+        Layer.effect(StorageOwner, StorageOwner),
         routedSubmissionLedgerLayer({ ownsThread }),
+        routedSettlementPublisherLayer({ ownsThread }),
         routedThreadStoreLayer({ ownsThread }),
         routedWorkerAdmissionLayer({ ownsThread }),
       ).pipe(Layer.provide(localPorts), Layer.provide(threadPortTransportLayer));
@@ -964,6 +1033,7 @@ const sharedLayer = <A, E, R, PE = never, PR = never>(
       );
 
       const runtimeStack = application.pipe(
+        Layer.provideMerge(runStorageLayer()),
         Layer.provide(
           cloudflarePreparedInputAdmissionLayer.pipe(Layer.provide(CloudflareThreadClient.layer)),
         ),
@@ -986,7 +1056,7 @@ const sharedLayer = <A, E, R, PE = never, PR = never>(
                   const storage = store.lifecyclePublications;
 
                   const context = yield* Effect.context<
-                    LifecyclePublicationHandler | ThreadStore | SubmissionLedger
+                    LifecyclePublicationHandler | ThreadStore | ThreadReader | SubmissionLedger
                   >();
 
                   const failure = (cause: unknown) => {
@@ -1050,6 +1120,19 @@ const sharedLayer = <A, E, R, PE = never, PR = never>(
         maintenanceRuntime,
         ThreadMaintenance.layer.pipe(
           Layer.provide(options.recoveryEvents ?? Layer.empty),
+          Layer.provide(
+            Layer.effect(ThreadNativeMaintenance)(
+              Effect.gen(function* () {
+                const previous = yield* ThreadNativeMaintenance;
+                const runtime = yield* DurableAgentRuntime;
+
+                return {
+                  lanes: previous.lanes,
+                  ...(placement.threadId === undefined ? {} : { singleThreadRuntime: runtime }),
+                };
+              }),
+            ),
+          ),
           Layer.provide(maintenanceRuntime),
           Layer.provide(messageRecovery),
         ),

package/src/internal/live-text-protocol.ts

@@ -0,0 +1,51 @@
+import { ThreadId } from "@yielded/agent/identifiers";
+import { Event } from "@yielded/agent/provisional-text";
+import { Schema } from "effect";
+
+export const MAX_FRAME_BYTES = 32 * 1_024;
+export const MAX_ID_LENGTH = 256;
+export const MAX_DELTA_LENGTH = 4_096;
+export const BUFFER_SIZE = 32;
+export const MAX_OBSERVERS = 8;
+export const MAX_DRAFT_PARTS = 32;
+export const MAX_DRAFT_LENGTH = 2 * 1_024 * 1_024;
+
+const streamId = Schema.NonEmptyString.check(Schema.isMaxLength(MAX_ID_LENGTH));
+
+export const Request = Schema.Struct({ schemaVersion: Schema.Literal(1) });
+
+/**
+ * Reset replaces all drafts with a snapshot, streamed as native Text parts before live deltas.
+ * Each snapshot starts a fresh streamId. Its sequences are unrelated to canonical sequences.
+ */
+export const Frame = Schema.Union([
+  Schema.TaggedStruct("Reset", {
+    schemaVersion: Schema.Literal(1),
+    streamId,
+    threadId: ThreadId,
+    sequence: Schema.Literal(0),
+  }),
+  Schema.TaggedStruct("Event", {
+    schemaVersion: Schema.Literal(1),
+    streamId,
+    sequence: Schema.Int.check(Schema.isGreaterThan(0)),
+    event: Event,
+  }),
+]);
+
+export type Frame = typeof Frame.Type;
+
+/** Bounds are checked before queueing; provider metadata is deliberately absent. */
+export const isBoundedEvent = (event: Event): boolean => {
+  const ids: string[] = [event.threadId, event.submissionId, event.attemptId];
+
+  if (event._tag !== "AttemptEnded") ids.push(event.runId, event.turnId);
+  if (ids.some((id) => id.length > MAX_ID_LENGTH)) return false;
+
+  return (
+    event._tag !== "Text" ||
+    (event.part.id.length <= MAX_ID_LENGTH &&
+      Object.keys(event.part.metadata).length === 0 &&
+      (event.part.type !== "text-delta" || event.part.delta.length <= MAX_DELTA_LENGTH))
+  );
+};

package/src/internal/live-text.ts

@@ -0,0 +1,256 @@
+import { type ThreadId } from "@yielded/agent/identifiers";
+import { Publisher, type Event } from "@yielded/agent/provisional-text";
+import { Cause, Context, Effect, Exit, Layer, Queue, Schema, Scope, Stream } from "effect";
+import * as Response from "effect/ai/Response";
+
+import { HostProtocolError } from "../CloudflareThreadClient.ts";
+import {
+  BUFFER_SIZE,
+  Frame,
+  isBoundedEvent,
+  MAX_DELTA_LENGTH,
+  MAX_DRAFT_LENGTH,
+  MAX_DRAFT_PARTS,
+  MAX_FRAME_BYTES,
+  MAX_ID_LENGTH,
+  MAX_OBSERVERS,
+} from "./live-text-protocol.ts";
+
+type TextEvent = Extract<Event, { readonly _tag: "Text" }>;
+
+interface Draft {
+  readonly start: TextEvent;
+  text: string;
+  ended: boolean;
+}
+
+interface Observer {
+  readonly threadId: ThreadId;
+  readonly queue: Queue.Queue<Event | undefined, HostProtocolError>;
+  snapshot: boolean;
+  streamId: string;
+  sequence: number;
+}
+
+/** One Object incarnation; owns drafts and subscriptions independently of RPC event scopes. */
+export class LiveTextHub extends Context.Service<
+  LiveTextHub,
+  {
+    readonly open: (
+      threadId: ThreadId,
+    ) => Effect.Effect<ReadableStream<Uint8Array>, HostProtocolError>;
+  }
+>()("@effect-agent/platform-cloudflare/LiveTextHub") {
+  static readonly layer: Layer.Layer<LiveTextHub> = Layer.effectContext(
+    Effect.gen(function* () {
+      const owner = yield* Effect.scope;
+      const observers = new Set<Observer>();
+      const drafts = new Map<string, Draft>();
+      let length = 0;
+
+      let unavailable:
+        | { readonly error: HostProtocolError; readonly attemptId: Event["attemptId"] }
+        | undefined;
+
+      const encode = Schema.encodeEffect(Schema.fromJsonString(Frame));
+      const encoder = new TextEncoder();
+
+      yield* Effect.addFinalizer(() => Effect.sync(() => drafts.clear()));
+
+      const fail = (attemptId: Event["attemptId"]) => {
+        const error = HostProtocolError.make({
+          message:
+            "Provisional text exceeds its draft bounds or is invalid; read canonical records",
+        });
+
+        unavailable = { error, attemptId };
+        drafts.clear();
+        length = 0;
+        for (const observer of observers) {
+          observer.snapshot = true;
+          Queue.failCauseUnsafe(observer.queue, Cause.fail(error));
+          Queue.shutdownUnsafe(observer.queue);
+        }
+
+        return false;
+      };
+
+      const offerUnsafe = (event: Event): boolean => {
+        // Retain drafts even without subscribers. Invalid input disables previews until an
+        // offending Attempt ends; canonical execution never depends on the observer's state.
+        if (event._tag === "AttemptEnded" && event.attemptId === unavailable?.attemptId)
+          unavailable = undefined;
+        if (unavailable !== undefined) return false;
+        if (!isBoundedEvent(event)) {
+          // Drop an oversized terminal frame without disabling an already-ended Attempt.
+          return event._tag === "AttemptEnded" ? false : fail(event.attemptId);
+        }
+
+        if (event._tag === "Text") {
+          const key = JSON.stringify([
+            event.threadId,
+            event.submissionId,
+            event.attemptId,
+            event.runId,
+            event.turnId,
+            event.generation,
+            event.part.id,
+          ]);
+
+          const draft = drafts.get(key);
+
+          if (event.part.type === "text-start") {
+            if (draft !== undefined || drafts.size >= MAX_DRAFT_PARTS) return fail(event.attemptId);
+            drafts.set(key, { start: event, text: "", ended: false });
+          } else {
+            // After invalidation, never expose an orphaned suffix as a complete prefix.
+            if (draft === undefined) return false;
+            if (draft.ended) return fail(event.attemptId);
+            if (event.part.type === "text-delta") {
+              if (length + event.part.delta.length > MAX_DRAFT_LENGTH) return fail(event.attemptId);
+              draft.text += event.part.delta;
+              length += event.part.delta.length;
+            } else {
+              draft.ended = true;
+            }
+          }
+        } else {
+          for (const [key, draft] of drafts) {
+            const start = draft.start;
+
+            if (
+              start.threadId === event.threadId &&
+              start.submissionId === event.submissionId &&
+              start.attemptId === event.attemptId &&
+              (event._tag === "AttemptEnded" ||
+                (start.runId === event.runId &&
+                  start.turnId === event.turnId &&
+                  start.generation === event.generation))
+            ) {
+              drafts.delete(key);
+              length -= draft.text.length;
+            }
+          }
+        }
+
+        // No snapshot copying, encoding, I/O or awaited work on the producer's path.
+        for (const observer of observers) {
+          if (observer.threadId !== event.threadId) continue;
+          if (!Queue.offerUnsafe(observer.queue, event)) observer.snapshot = true;
+        }
+
+        return true;
+      };
+
+      const open = Effect.fnUntraced(function* (threadId: ThreadId) {
+        if (unavailable !== undefined) return yield* unavailable.error;
+        if (threadId.length > MAX_ID_LENGTH || observers.size >= MAX_OBSERVERS)
+          return yield* HostProtocolError.make({
+            message: "Provisional text observation capacity exceeded",
+          });
+        const scope = yield* Scope.fork(owner);
+        const queue = yield* Queue.dropping<Event | undefined, HostProtocolError>(BUFFER_SIZE);
+
+        const observer: Observer = {
+          threadId,
+          queue,
+          snapshot: true,
+          streamId: "",
+          sequence: 0,
+        };
+
+        const close = Scope.close(scope, Exit.void);
+
+        yield* Scope.addFinalizer(
+          scope,
+          Effect.sync(() => {
+            observer.snapshot = true;
+            observers.delete(observer);
+            Queue.shutdownUnsafe(queue);
+          }),
+        );
+        observers.add(observer);
+        Queue.offerUnsafe(queue, undefined);
+
+        const frame = (event: Event): Frame => ({
+          _tag: "Event",
+          schemaVersion: 1,
+          streamId: observer.streamId,
+          sequence: ++observer.sequence,
+          event,
+        });
+
+        const snapshot = function* (): Generator<Frame> {
+          // Capture immutable strings once, then encode bounded slices on consumer pulls.
+          // Queue drain and capture are synchronous so no delta can straddle the snapshot.
+          while (Queue.sizeUnsafe(queue) > 0) Queue.takeUnsafe(queue);
+
+          const current = Array.from(drafts.values())
+            .filter((draft) => draft.start.threadId === threadId)
+            .map((draft) => ({ ...draft }));
+
+          observer.snapshot = false;
+          observer.streamId = crypto.randomUUID();
+          observer.sequence = 0;
+          yield {
+            _tag: "Reset",
+            schemaVersion: 1,
+            streamId: observer.streamId,
+            threadId,
+            sequence: 0,
+          };
+          for (const draft of current) {
+            yield frame(draft.start);
+            for (let offset = 0; offset < draft.text.length; offset += MAX_DELTA_LENGTH) {
+              yield frame({
+                ...draft.start,
+                part: Response.makePart("text-delta", {
+                  id: draft.start.part.id,
+                  delta: draft.text.slice(offset, offset + MAX_DELTA_LENGTH),
+                }),
+              });
+            }
+            if (draft.ended)
+              yield frame({
+                ...draft.start,
+                part: Response.makePart("text-end", { id: draft.start.part.id }),
+              });
+          }
+        };
+
+        const toBytes = Effect.fnUntraced(function* (value: Frame) {
+          const json = yield* encode(value).pipe(
+            Effect.mapError(() =>
+              HostProtocolError.make({ message: "Provisional text frame is invalid" }),
+            ),
+          );
+
+          const bytes = encoder.encode(json + "\n");
+
+          if (bytes.byteLength > MAX_FRAME_BYTES)
+            return yield* HostProtocolError.make({
+              message: "Provisional text frame exceeds its wire bound",
+            });
+
+          return bytes;
+        });
+
+        const frames = Stream.fromEffectRepeat(Queue.take(queue)).pipe(
+          Stream.flatMap((event) =>
+            observer.snapshot || event === undefined
+              ? Stream.fromIterable(snapshot(), { chunkSize: 1 }).pipe(
+                  Stream.takeWhile(() => !observer.snapshot),
+                )
+              : Stream.succeed(frame(event)),
+          ),
+          Stream.mapEffect(toBytes),
+          Stream.ensuring(close),
+        );
+
+        return yield* Stream.toReadableStreamEffect(frames);
+      });
+
+      return Context.make(LiveTextHub, { open }).pipe(Context.add(Publisher, { offerUnsafe }));
+    }),
+  );
+}

package/src/internal/page-function.ts

@@ -0,0 +1,12 @@
+/**
+ * Puppeteer sends a page function's source to the browser. Bundlers that keep function names,
+ * including Wrangler by default, insert `__name(...)` calls into that source, and the page has no
+ * such helper. The returned function's source declares a local no-op `__name` first.
+ */
+export const pageFunction = <A extends ReadonlyArray<unknown>, R>(
+  fn: (...args: A) => R,
+): ((...args: A) => R) =>
+  Object.assign((...args: A) => fn(...args), {
+    toString: () =>
+      `(...args) => { const __name = (target) => target; return (${Function.prototype.toString.call(fn)})(...args); }`,
+  });

package/src/internal/prepared-admission.ts

@@ -78,7 +78,7 @@ export const cloudflarePreparedInputAdmissionLayer: Layer.Layer<
                 ScheduleStorageError.make({ operation: "prepared admission", reason: "corrupt" }),
               ThreadNotMaterialized: () => ScheduledInputRetryable.make({ reason: "storage" }),
               AppendConflict: () => ScheduledInputRetryable.make({ reason: "ambiguous" }),
-              FenceRejected: () => ScheduledInputRetryable.make({ reason: "ambiguous" }),
+              OwnershipLost: () => ScheduledInputRetryable.make({ reason: "ambiguous" }),
               DurableRuntimeFailpointError: () =>
                 ScheduledInputRetryable.make({ reason: "ambiguous" }),
             }),

package/src/internal/progress-wait.ts

@@ -48,39 +48,34 @@ export class ProgressWaitRegistry extends Context.Service<
           return next;
         });
 
-      const subscribe = Effect.fn("ProgressWaitRegistry.subscribe")(
-        (waiterId: string): Effect.Effect<Effect.Effect<void>, never, Scope.Scope> =>
-          Effect.gen(function* () {
-            const deferred = yield* Deferred.make<void>();
+      const subscribe = Effect.fnUntraced(function* (
+        waiterId: string,
+      ): Effect.fn.Return<Effect.Effect<void>, never, Scope.Scope> {
+        const deferred = yield* Deferred.make<void>();
 
-            yield* Effect.addFinalizer(() => remove(waiterId, deferred));
+        yield* Effect.addFinalizer(() => remove(waiterId, deferred));
 
-            const cancelled = yield* Ref.modify(registrations, (current) => {
-              const existing = current.get(waiterId);
-              const next = new Map(current);
+        const cancelled = yield* Ref.modify(registrations, (current) => {
+          const existing = current.get(waiterId);
+          const next = new Map(current);
 
-              if (existing === "cancelled") {
-                return [true, current] as const;
-              }
-              const active = new Set(existing ?? []);
+          if (existing === "cancelled") {
+            return [true, current] as const;
+          }
+          const active = new Set(existing ?? []);
 
-              active.add(deferred);
-              next.set(waiterId, active);
+          active.add(deferred);
+          next.set(waiterId, active);
 
-              return [false, next] as const;
-            });
+          return [false, next] as const;
+        });
 
-            return { cancelled, deferred };
-          }).pipe(
-            Effect.map(({ cancelled, deferred }) =>
-              cancelled ? Effect.void : Deferred.await(deferred),
-            ),
-          ),
-      );
+        return cancelled ? Effect.void : Deferred.await(deferred);
+      });
 
       // Updating the registry and completing captured signals form one nonblocking operation;
       // interruption between them must not strand attempts removed from the active registry.
-      const cancel = Effect.fn("ProgressWaitRegistry.cancel")(function* (waiterId: string) {
+      const cancel = Effect.fnUntraced(function* (waiterId: string) {
         const waiters = yield* Ref.modify(
           registrations,
           (current): readonly [ReadonlyArray<Deferred.Deferred<void>>, Registrations] => {

package/src/internal/transport.ts

@@ -33,7 +33,7 @@ export const threadPortTransportLayer: Layer.Layer<
     const { rpcTracing } = namespace;
 
     return ThreadPortTransport.of({
-      call: Effect.fn(
+      call: Effect.fnUntraced(
         function* (threadId: ThreadId, request: unknown) {
           const traceArgs =
             rpcTracing === undefined ? [] : yield* RpcTracing.withRpcTraceContext([]);