@effect-agent/platform-cloudflare 0.1.0-beta.24 → 0.1.0-beta.26

package/src/code-mode-executor.ts

@@ -18,56 +18,52 @@ import {
   type CodeExecutorExecute,
   type CodeExecutionRequest,
 } from "@effect-agent/sandbox";
-import { WorkerEntrypoint } from "cloudflare:workers";
-import { Duration, Effect, Exit, Fiber, Layer, Option, Queue, Schema } from "effect";
+import { RpcTarget } from "cloudflare:workers";
+import { Clock, Duration, Effect, Exit, Fiber, Layer, Option, Queue, Schema } from "effect";
+
+import { safeCauseDiagnostic, safeCauseMessage } from "./boundary.ts";
 
 /**
  * The Cloudflare Dynamic Worker `CodeExecutor` adapter (C4 of ADR-0017;
  * DEPLOY-011). Each pass loads one fresh Worker through the Worker Loader
  * with `globalOutbound: null`, so generated code has no ambient network,
- * bindings, or secrets; its only authority is the pass-scoped host stub that
- * routes back to `CodeModeHostEntrypoint` and, from there, into the pass's
- * `CodeExecutionHost` service. Platform CPU limits stop synchronous runaway
- * programs; the executor-owned wall-clock deadline interrupts asynchronously
- * suspended passes. Deployment class `E` only: the adapter records no
- * persistent state and a later pass may run in a completely different
- * isolate.
+ * bindings, or secrets; its only authority is the pass-scoped RPC target that
+ * routes back into the owning event's `CodeExecutionHost` service. Platform
+ * CPU limits stop synchronous runaway programs; the executor-owned wall-clock
+ * deadline interrupts asynchronously suspended passes. Deployment class `E`
+ * only: the adapter records no persistent state and a later pass may run in a
+ * completely different isolate.
  */
 export const dynamicWorkerImplementation = SandboxImplementation.make({
   isolation: "isolated",
   identity: "cloudflare-dynamic-worker",
 });
 
-/** The narrow host stub the dynamic worker receives (Workers RPC). */
-export interface CodeModeHostStub {
-  readonly call: (passId: string, hostCall: unknown) => Promise<unknown>;
+interface CodeModePassHost extends Rpc.RpcTargetBranded {
+  readonly call: (hostCall: unknown) => Promise<unknown>;
 }
 
-interface RegisteredPass {
-  readonly dispatch: (hostCall: unknown) => Promise<unknown>;
+interface CodeModeHarnessEntrypoint extends Rpc.WorkerEntrypointBranded {
+  readonly run: (host: CodeModePassHost) => Promise<unknown>;
 }
 
 /**
- * Live passes by identity. Entries are Scope-managed: registered when a pass
- * opens and removed by its finalizer, so a stale harness (or a forged
- * `passId`) cannot reach any host authority.
+ * One object-capability endpoint for one execution pass. Workers RPC invokes
+ * the target in the request context where it was created, so the native
+ * Promise returned by `dispatch` and the Effect fiber that settles it share
+ * one I/O owner. Passing the target as `run()`'s argument also scopes the
+ * remote stub to that RPC call; no request state lives at module scope.
  */
-const passRegistry = new Map<string, RegisteredPass>();
+class CodeModePassHostTarget extends RpcTarget implements CodeModePassHost {
+  readonly #dispatch: (hostCall: unknown) => Promise<unknown>;
 
-/**
- * The host-side RPC target for dynamic workers. The application exposes it
- * from its Worker entry (`export { CodeModeHostEntrypoint }`) and hands the
- * adapter a same-instance stub — `ctx.exports.CodeModeHostEntrypoint()` in
- * production (a self service binding may reach a different instance and must
- * not be used there); tests bind it through Miniflare's `kCurrentWorker`.
- */
-export class CodeModeHostEntrypoint extends WorkerEntrypoint {
-  async call(passId: unknown, hostCall: unknown): Promise<unknown> {
-    const pass = passRegistry.get(String(passId));
-    if (pass === undefined) {
-      throw new Error("Unknown Code Mode pass");
-    }
-    return pass.dispatch(hostCall);
+  constructor(dispatch: (hostCall: unknown) => Promise<unknown>) {
+    super();
+    this.#dispatch = dispatch;
+  }
+
+  call(hostCall: unknown): Promise<unknown> {
+    return this.#dispatch(hostCall);
   }
 }
 
@@ -103,9 +99,8 @@ const safeJson = (value) => {
 };
 
 export default class CodeModeHarness extends WorkerEntrypoint {
-  async run() {
-    const config = JSON.parse(this.env.CODE_MODE_PASS);
-    const host = this.env.CODE_MODE_HOST;
+  async run(host) {
+    const config = this.env.CODE_MODE_PASS;
     const limits = config.limits;
     const logs = [];
     let logBytes = 0;
@@ -143,7 +138,7 @@ export default class CodeModeHarness extends WorkerEntrypoint {
         };
         throw new Error("code-mode host-call argument limit exceeded");
       }
-      const outcome = await host.call(config.passId, {
+      const outcome = await host.call({
         namespace,
         method,
         argument: JSON.parse(argText),
@@ -227,50 +222,41 @@ const BoundedLogs = Schema.Array(Schema.String.check(Schema.isMaxLength(16 * 102
   Schema.isMaxLength(4_096),
 );
 
-const HarnessCompleted = Schema.Struct({
-  _tag: Schema.Literal("completed"),
+const HarnessCompleted = Schema.TaggedStruct("completed", {
   value: Schema.Json,
   logs: BoundedLogs,
   hostCalls: Schema.Natural,
   logBytes: Schema.Natural,
   resultBytes: Schema.Natural,
 });
-const HarnessSourceInvalid = Schema.Struct({
-  _tag: Schema.Literal("source-invalid"),
+const HarnessSourceInvalid = Schema.TaggedStruct("source-invalid", {
   message: Schema.String,
 });
-const HarnessNotAFunction = Schema.Struct({
-  _tag: Schema.Literal("source-not-a-function"),
+const HarnessNotAFunction = Schema.TaggedStruct("source-not-a-function", {
   actual: Schema.String,
 });
-const HarnessProgramFailed = Schema.Struct({
-  _tag: Schema.Literal("program-failed"),
+const HarnessProgramFailed = Schema.TaggedStruct("program-failed", {
   reason: Schema.Literals(["threw", "rejected", "non-json-result"]),
   thrown: Schema.Json,
   message: Schema.String,
   logs: BoundedLogs,
 });
-const HarnessLogLimit = Schema.Struct({
-  _tag: Schema.Literal("log-limit"),
+const HarnessLogLimit = Schema.TaggedStruct("log-limit", {
   observed: Schema.Natural,
   logs: BoundedLogs,
 });
-const HarnessArgumentLimit = Schema.Struct({
-  _tag: Schema.Literal("argument-limit"),
+const HarnessArgumentLimit = Schema.TaggedStruct("argument-limit", {
   observed: Schema.Natural,
   logs: BoundedLogs,
 });
-const HarnessResultLimit = Schema.Struct({
-  _tag: Schema.Literal("result-limit"),
+const HarnessResultLimit = Schema.TaggedStruct("result-limit", {
   observed: Schema.Natural,
   logs: BoundedLogs,
 });
-const HarnessHostCallLimit = Schema.Struct({
-  _tag: Schema.Literal("host-call-limit"),
+const HarnessHostCallLimit = Schema.TaggedStruct("host-call-limit", {
   logs: BoundedLogs,
 });
-const HarnessProtocol = Schema.Struct({
-  _tag: Schema.Literal("protocol"),
+const HarnessProtocol = Schema.TaggedStruct("protocol", {
   message: Schema.String,
 });
 const HarnessOutcome = Schema.Union([
@@ -285,6 +271,25 @@ const HarnessOutcome = Schema.Union([
   HarnessProtocol,
 ]);
 
+const HarnessPassConfig = Schema.Struct({
+  namespaces: Schema.Array(
+    Schema.Struct({
+      name: Schema.NonEmptyString,
+      methods: Schema.Array(Schema.NonEmptyString).check(Schema.isMaxLength(64)),
+    }),
+  ).check(Schema.isMaxLength(32)),
+  limits: Schema.Struct({
+    maxLogBytes: Schema.Natural,
+    maxResultBytes: Schema.Natural,
+    maxHostCalls: Schema.Natural,
+    maxHostCallArgumentBytes: Schema.Natural,
+  }),
+});
+
+const encodeHarnessPassConfig = Schema.encodeSync(HarnessPassConfig);
+const encodeJsonPayload = Schema.encodeSync(Schema.fromJsonString(Schema.Json));
+const decodeJsonPayload = Schema.decodeUnknownOption(Schema.fromJsonString(Schema.Json));
+
 const decodeHarnessOutcome = (value: unknown) => {
   try {
     return Schema.decodeUnknownOption(HarnessOutcome)(value);
@@ -309,6 +314,27 @@ const decodeHostCallResult = (value: unknown) => {
   }
 };
 
+/** Dispose a Cloudflare RPC handle when the runtime supplies its untyped disposal hook. @internal */
+export const disposeRpcHandle = (handle: unknown): Effect.Effect<void> =>
+  Effect.try({
+    try: () => {
+      if ((typeof handle !== "object" && typeof handle !== "function") || handle === null) return;
+      if (!(Symbol.dispose in handle)) return;
+      const dispose = Reflect.get(handle, Symbol.dispose);
+      if (typeof dispose === "function") {
+        Reflect.apply(dispose, handle, []);
+      }
+    },
+    catch: (cause) =>
+      safeCauseDiagnostic(cause, "The Cloudflare RPC disposal hook failed without a diagnostic"),
+  }).pipe(
+    Effect.catch((diagnostic) =>
+      Effect.logWarning(`Cloudflare RPC handle disposal failed: ${diagnostic}`).pipe(
+        Effect.ignoreCause,
+      ),
+    ),
+  );
+
 /**
  * Project a host outcome to the plain JSON envelope the harness reads. A
  * `CodeExecutionHost` may return either real `CodeHostCallResult` instances
@@ -326,8 +352,7 @@ const encodeHostResultPayload = (
 ): EncodedHostResultPayload | undefined => {
   try {
     const payload = outcome._tag === "CodeHostCallSuccess" ? outcome.value : outcome.error;
-    const encodedPayload = JSON.stringify(payload);
-    if (encodedPayload === undefined) return undefined;
+    const encodedPayload = encodeJsonPayload(payload);
     return {
       encodedPayload,
       resultBytes: utf8ByteLength(encodedPayload),
@@ -368,19 +393,14 @@ const reservedHarnessGlobals = new Set(["console"]);
 export interface DynamicWorkerCodeExecutorOptions {
   /** The `worker_loader` binding. */
   readonly loader: WorkerLoader;
-  /**
-   * A SAME-INSTANCE stub of `CodeModeHostEntrypoint`. In production create it
-   * with `ctx.exports.CodeModeHostEntrypoint()`; a cross-instance stub would
-   * dispatch host calls into an isolate without this pass's registry entry.
-   */
-  readonly hostStub: CodeModeHostStub;
   /** Compatibility date for dynamic workers; defaults to `2025-05-01`. */
   readonly compatibilityDate?: string | undefined;
 }
 
-const passCounterState = { next: 0 };
-
-const makeExecute = (options: DynamicWorkerCodeExecutorOptions): CodeExecutorExecute =>
+const makeExecute = (
+  options: DynamicWorkerCodeExecutorOptions,
+  clock: Clock.Clock,
+): CodeExecutorExecute =>
   Effect.fn("DynamicWorkerCodeExecutor.execute")(function* (request: CodeExecutionRequest) {
     if (request.network._tag !== "NetworkDisabled") {
       return yield* CodeExecutorUnsupportedError.make({
@@ -407,20 +427,16 @@ const makeExecute = (options: DynamicWorkerCodeExecutorOptions): CodeExecutorExe
         });
       }
     }
-
     const host = yield* CodeExecutionHost;
-    passCounterState.next += 1;
-    // The pass id is the only credential a loaded program presents to reach
-    // its host authority, so it must be unguessable: a program cannot forge
-    // another pass's id even if two passes were ever concurrent (the broker
-    // keeps them sequential, but the id must not rely on that). The counter
-    // prefix keeps ids debuggable; the random suffix makes them unforgeable.
-    const passId = `code-mode-pass-${passCounterState.next}-${crypto.randomUUID()}`;
-
-    const startedAt = performance.now();
-    const passDeadline = startedAt + Duration.toMillis(request.limits.maxWallTime);
-    const remainingPassWallTime = (): Duration.Duration =>
-      Duration.millis(Math.max(0, passDeadline - performance.now()));
+
+    // This synchronous clock access is confined to callbacks that must compute a timeout
+    // immediately. The Clock service remains the authority, so tests and hosts can replace it.
+    const startedAt = clock.monotonicTimeNanosUnsafe();
+    const passDeadline = startedAt + Duration.toNanosUnsafe(request.limits.maxWallTime);
+    const remainingPassWallTime = (): Duration.Duration => {
+      const now = clock.monotonicTimeNanosUnsafe();
+      return Duration.nanos(passDeadline > now ? passDeadline - now : 0n);
+    };
     let issuedHostCalls = 0;
     let passOpen = true;
     const queuedHostCalls: Array<QueuedHostCall> = [];
@@ -461,11 +477,19 @@ const makeExecute = (options: DynamicWorkerCodeExecutorOptions): CodeExecutorExe
           failPass(error);
           return yield* error;
         }
-        const normalizedPayload: unknown = JSON.parse(encoded.encodedPayload);
+        const normalizedPayload = decodeJsonPayload(encoded.encodedPayload);
+        if (Option.isNone(normalizedPayload)) {
+          const error = CodeExecutionProtocolError.make({
+            implementation: dynamicWorkerImplementation,
+            message: "The execution host returned a result that could not cross the JSON boundary",
+          });
+          failPass(error);
+          return yield* error;
+        }
         queued.resolve(
           decoded.value._tag === "CodeHostCallSuccess"
-            ? { _tag: "CodeHostCallSuccess", value: normalizedPayload }
-            : { _tag: "CodeHostCallFailure", error: normalizedPayload },
+            ? { _tag: "CodeHostCallSuccess", value: normalizedPayload.value }
+            : { _tag: "CodeHostCallFailure", error: normalizedPayload.value },
         );
       });
 
@@ -539,22 +563,15 @@ const makeExecute = (options: DynamicWorkerCodeExecutorOptions): CodeExecutorExe
 
     const closeAdmission = Effect.sync(() => {
       passOpen = false;
-      passRegistry.delete(passId);
       rejectQueuedHostCalls(new Error("Code Mode pass is closing"));
     });
-
-    yield* Effect.acquireRelease(
-      Effect.sync(() => {
-        passRegistry.set(passId, { dispatch });
-      }),
-      () => closeAdmission.pipe(Effect.andThen(Fiber.interrupt(server))),
-    );
+    yield* Effect.addFinalizer(() => closeAdmission.pipe(Effect.andThen(Fiber.interrupt(server))));
 
     // No `allowExperimental`: the runtime only accepts it when the CALLING
     // worker carries the `experimental` compatibility flag, which deployed
     // consumers cannot set — the option would reject every pass in
     // production. The harness needs no experimental runtime features.
-    const workerCode = {
+    const workerCode: WorkerLoaderWorkerCode = {
       compatibilityDate: options.compatibilityDate ?? "2025-05-01",
       mainModule: "harness.js",
       modules: {
@@ -562,9 +579,7 @@ const makeExecute = (options: DynamicWorkerCodeExecutorOptions): CodeExecutorExe
         "program.js": `export default (\n${request.source}\n);`,
       },
       env: {
-        CODE_MODE_HOST: options.hostStub,
-        CODE_MODE_PASS: JSON.stringify({
-          passId,
+        CODE_MODE_PASS: encodeHarnessPassConfig({
           namespaces: request.namespaces.map((namespace) => ({
             name: namespace.name,
             methods: namespace.methods,
@@ -590,9 +605,9 @@ const makeExecute = (options: DynamicWorkerCodeExecutorOptions): CodeExecutorExe
 
     const worker = yield* Effect.acquireRelease(
       Effect.try({
-        try: () => options.loader.load(workerCode as never),
+        try: () => options.loader.load(workerCode),
         catch: (cause) => {
-          const text = cause instanceof Error ? cause.message : String(cause);
+          const text = safeCauseMessage(cause, "The Worker Loader failed without a diagnostic");
           // Blame the program's source ONLY on a genuine compile diagnostic;
           // any other load rejection is an infrastructure start failure, not
           // the model's fault (see classifyWorkerFailure for the same split).
@@ -610,19 +625,19 @@ const makeExecute = (options: DynamicWorkerCodeExecutorOptions): CodeExecutorExe
           });
         },
       }),
-      (stub) =>
-        Effect.sync(() => {
-          (stub as Partial<Record<typeof Symbol.dispose, () => void>>)[Symbol.dispose]?.();
-        }),
+      disposeRpcHandle,
+    );
+
+    const entrypoint = yield* Effect.acquireRelease(
+      Effect.try({
+        try: () => worker.getEntrypoint<CodeModeHarnessEntrypoint>(),
+        catch: (cause) => classifyWorkerFailure(cause, request.limits.maxWallTime),
+      }),
+      disposeRpcHandle,
     );
 
     const rpc = Effect.tryPromise({
-      try: async () => {
-        const entrypoint = worker.getEntrypoint() as unknown as {
-          run(): Promise<unknown>;
-        };
-        return await entrypoint.run();
-      },
+      try: () => entrypoint.run(new CodeModePassHostTarget(dispatch)),
       catch: (cause) => classifyWorkerFailure(cause, request.limits.maxWallTime),
     });
 
@@ -650,7 +665,7 @@ const makeExecute = (options: DynamicWorkerCodeExecutorOptions): CodeExecutorExe
       return yield* Effect.failCause(exit.cause);
     }
     const raw = exit.value;
-    const finishedAt = performance.now();
+    const finishedAt = clock.monotonicTimeNanosUnsafe();
 
     const outcome = decodeHarnessOutcome(raw);
     if (Option.isNone(outcome)) {
@@ -666,7 +681,7 @@ const makeExecute = (options: DynamicWorkerCodeExecutorOptions): CodeExecutorExe
           value: outcome.value.value,
           logs: outcome.value.logs,
           resourceUse: CodeExecutionResourceUse.make({
-            wallTime: Duration.millis(Math.max(0, finishedAt - startedAt)),
+            wallTime: Duration.nanos(finishedAt > startedAt ? finishedAt - startedAt : 0n),
             hostCalls: outcome.value.hostCalls,
             logBytes: outcome.value.logBytes,
             resultBytes: outcome.value.resultBytes,
@@ -752,13 +767,7 @@ const classifyWorkerFailure = (
   | CodeExecutorTerminatedError
   | CodeExecutorStartError
   | CodeSourceError => {
-  const text = (() => {
-    try {
-      return cause instanceof Error ? `${cause.name}: ${cause.message}` : String(cause);
-    } catch {
-      return "[unserializable worker failure]";
-    }
-  })();
+  const text = safeCauseDiagnostic(cause, "[unserializable worker failure]");
   // `WorkerLoader.load()` is lazy, so a module-compile error in the generated
   // program surfaces here at first use. Blame the program's source ONLY on a
   // genuine compile diagnostic (a `SyntaxError` or an explicit compile
@@ -798,4 +807,10 @@ const classifyWorkerFailure = (
 export const dynamicWorkerCodeExecutorLayer = (
   options: DynamicWorkerCodeExecutorOptions,
 ): Layer.Layer<CodeExecutor> =>
-  Layer.succeed(CodeExecutor)(CodeExecutor.of({ execute: makeExecute(options) }));
+  Layer.effect(
+    CodeExecutor,
+    Effect.gen(function* () {
+      const clock = yield* Clock.Clock;
+      return CodeExecutor.of({ execute: makeExecute(options, clock) });
+    }),
+  );

package/src/conversation-object.ts

@@ -30,6 +30,11 @@ import {
   WakeScheduler,
   type DurableSubmitAgent,
 } from "@effect-agent/session";
+import {
+  decodePortRequest,
+  encodePortResponse,
+  type PortRequest,
+} from "@effect-agent/storage-cloudflare";
 import type { DurableObject as CloudflareDurableObject } from "cloudflare:workers";
 import { Effect, Layer, Option, Schema, Stream } from "effect";
 import {
@@ -120,22 +125,26 @@ type ConversationObjectInitializationError =
   | CloudflareBindingError
   | MaintenancePassFailure;
 
-/** Port envelope tags whose owner-side execution durably mutates this Object's lane. */
-const MUTATING_PORT_TAGS: ReadonlySet<string> = new Set([
-  "LedgerAdmit",
-  "LedgerMarkReady",
-  "LedgerRequestAbort",
-  "LedgerRecordChildSettled",
-  "StoreMaterialize",
-  "StoreAppend",
-]);
-
-const isMutatingPortRequest = (encoded: unknown): boolean =>
-  typeof encoded === "object" &&
-  encoded !== null &&
-  "_tag" in encoded &&
-  typeof encoded._tag === "string" &&
-  MUTATING_PORT_TAGS.has(encoded._tag);
+/** Classify only a decoded port request so new protocol members cannot bypass pre-arming. */
+const isMutatingPortRequest = (request: PortRequest): boolean => {
+  switch (request._tag) {
+    case "LedgerAdmit":
+    case "LedgerMarkReady":
+    case "LedgerRequestAbort":
+    case "LedgerRecordChildSettled":
+    case "StoreMaterialize":
+    case "StoreAppend":
+      return true;
+    case "LedgerLookup":
+    case "LedgerResolveAdmission":
+    case "StoreReadPage":
+    case "StoreInspectTail":
+    case "StoreExport":
+      return false;
+  }
+  request satisfies never;
+  return false;
+};
 
 /** The literal encoded `PortFailed(PortProtocolError)` fallback (same shape as WP2's). */
 const encodedPortProtocolFailure = (message: string): unknown => ({
@@ -171,7 +180,7 @@ const encodeResponse = (response: HostResponse): Effect.Effect<unknown> =>
     ),
   );
 
-const utf8Bytes = (value: unknown): number =>
+const utf8Bytes = (value: PersistedJson): number =>
   new TextEncoder().encode(JSON.stringify(value)).length;
 
 /**
@@ -593,9 +602,20 @@ const portCallEndpoint = (encoded: unknown): Effect.Effect<unknown, never, Endpo
     const ports = yield* ConversationObjectPorts;
     const maintenance = yield* ConversationMaintenance;
     const alarm = yield* DurableAlarmService;
-    const mutating = isMutatingPortRequest(encoded);
+    const decoded = yield* decodePortRequest(encoded).pipe(
+      Effect.map((request) => ({ _tag: "success" as const, request })),
+      Effect.catch((error) => Effect.succeed({ _tag: "failure" as const, message: error.message })),
+    );
+    if (decoded._tag === "failure") {
+      return encodedPortProtocolFailure(
+        `The port request could not be decoded: ${decoded.message}`,
+      );
+    }
+    const mutating = isMutatingPortRequest(decoded.request);
     const handled = yield* (
-      mutating ? maintenance.withMutation(ports.handle(encoded)) : ports.handle(encoded)
+      mutating
+        ? maintenance.withMutation(ports.handle(decoded.request))
+        : ports.handle(decoded.request)
     ).pipe(Effect.exit);
     if (handled._tag === "Failure") {
       // Without the committed generation/alarm the invariant cannot be promised; refuse before
@@ -604,7 +624,13 @@ const portCallEndpoint = (encoded: unknown): Effect.Effect<unknown, never, Endpo
         "The owner Object could not arm its maintenance alarm before the mutation.",
       );
     }
-    const response = handled.value;
+    const response = yield* encodePortResponse(handled.value).pipe(
+      Effect.catch((error) =>
+        Effect.succeed(
+          encodedPortProtocolFailure(`The port response could not be encoded: ${error.message}`),
+        ),
+      ),
+    );
     if (mutating) {
       // Prompt processing hint; the pre-armed alarm already guarantees convergence.
       yield* alarm.scheduleNow.pipe(

package/src/layers.ts

@@ -18,7 +18,7 @@ import {
 } from "@effect-agent/session";
 import {
   conversationStoreLayer,
-  handleEncodedPortRequest,
+  executePortRequest,
   routedConversationStoreLayer,
   routedSubmissionLedgerLayer,
   storageConfigLayer,
@@ -27,6 +27,8 @@ import {
   type DoStorageFailpointHandler,
   type DoStorageInitializationError,
   type DoStorageOptions,
+  type PortRequest,
+  type PortResponse,
 } from "@effect-agent/storage-cloudflare";
 import { BrowserCrypto } from "@effect/platform-browser";
 import { SqliteClient } from "@effect/sql-sqlite-do";
@@ -114,10 +116,9 @@ export interface CloudflareDurableRuntimeOptions {
   readonly toolReconciler?: Layer.Layer<ToolReconciler> | undefined;
   /**
    * Registered worker Bindings resolved at durable claim time (S2, spec/subagents.md §11):
-   * build each with `DurableWorkerBinding.make(binding, digests)`. An Effect or callback form is
-   * accepted because capture can be effectful. The callback receives the live Object context and
-   * derived identities and is evaluated once per incarnation during Layer construction. Defaults
-   * to the empty registration (every resolved claim fails closed).
+   * build each with `DurableWorkerBinding.make(binding, digests)`. The callback receives the live
+   * Object context and derived identities and is evaluated once per incarnation during Layer
+   * construction. Defaults to the empty registration (every resolved claim fails closed).
    */
   readonly bindings?: CloudflareBindingSource | undefined;
   /**
@@ -141,18 +142,10 @@ export interface CloudflareRuntimeSourceContext {
 /** Per-incarnation host values available while registered worker Bindings are captured. */
 export interface CloudflareBindingSourceContext extends CloudflareRuntimeSourceContext {}
 
-/**
- * Registered worker Bindings, or a closed Effect/callback that captures them once for each
- * Durable Object incarnation. Callback Effects cannot require services or fail typed.
- */
-export type CloudflareBindingSource =
-  | ReadonlyArray<ResolvedBinding>
-  | Effect.Effect<ReadonlyArray<ResolvedBinding>, never, never>
-  | ((
-      context: CloudflareBindingSourceContext,
-    ) =>
-      | ReadonlyArray<ResolvedBinding>
-      | Effect.Effect<ReadonlyArray<ResolvedBinding>, never, never>);
+/** Captures registered worker Bindings once for each Durable Object incarnation. */
+export type CloudflareBindingSource = (
+  context: CloudflareBindingSourceContext,
+) => Effect.Effect<ReadonlyArray<ResolvedBinding>, never, never>;
 
 /** A closed Run-context service whose only remaining requirement is platform Crypto. */
 export type CloudflareRunContextLayer = Layer.Layer<RunContextPreparation, never, Crypto.Crypto>;
@@ -183,15 +176,15 @@ export type CloudflareDurableRuntimeServices =
   | ProgressWaitRegistry;
 
 /**
- * Owner-side endpoint body for the Conversation Object's `portCall` (plan §1.3): decode,
- * execute against THIS Object's LOCAL port facets — never the routed decorators, so a
- * request cannot bounce between Objects — and answer the encoded response envelope. Total by
- * construction (protocol anomalies answer `PortFailed(PortProtocolError)`).
+ * Owner-side execution port for a `portCall` request the wire endpoint has already decoded.
+ * It executes against THIS Object's LOCAL port facets — never the routed decorators, so a
+ * request cannot bounce between Objects — and returns the typed response for the endpoint to
+ * encode.
  */
 export class ConversationObjectPorts extends Context.Service<
   ConversationObjectPorts,
   {
-    readonly handle: (encoded: unknown) => Effect.Effect<unknown>;
+    readonly handle: (request: PortRequest) => Effect.Effect<PortResponse>;
   }
 >()("@effect-agent/platform-cloudflare/ConversationObjectPorts") {}
 
@@ -267,16 +260,7 @@ const resolveBindings = (
   source: CloudflareDurableRuntimeOptions["bindings"],
   context: CloudflareBindingSourceContext,
 ): Effect.Effect<ReadonlyArray<ResolvedBinding>> =>
-  source === undefined
-    ? Effect.succeed([])
-    : Effect.isEffect(source)
-      ? source
-      : typeof source === "function"
-        ? Effect.suspend(() => {
-            const bindings = source(context);
-            return Effect.isEffect(bindings) ? bindings : Effect.succeed(bindings);
-          })
-        : Effect.succeed(source);
+  source === undefined ? Effect.succeed([]) : Effect.suspend(() => source(context));
 
 const resolveRunContext = (
   source: CloudflareRunContextSource,
@@ -358,7 +342,7 @@ export class CloudflareDurableRuntime {
           Effect.gen(function* () {
             const local = yield* Effect.context<SubmissionLedger | ConversationStore>();
             return ConversationObjectPorts.of({
-              handle: (encoded) => handleEncodedPortRequest(encoded).pipe(Effect.provide(local)),
+              handle: (request) => executePortRequest(request).pipe(Effect.provide(local)),
             });
           }),
         ).pipe(Layer.provide(localPorts));

package/src/wake-scheduler.ts

@@ -4,6 +4,7 @@ import { Effect, Layer, PubSub, Schema, Stream } from "effect";
 
 import { DurableAlarmService } from "./alarm.ts";
 import { ConversationObjectIdentity, ConversationObjectNamespace } from "./bindings.ts";
+import { safeCauseMessage } from "./boundary.ts";
 
 /**
  * Bounded in-memory wake buffer for same-incarnation `awaitSettlement` subscribers. Wake
@@ -63,7 +64,7 @@ export const cloudflareWakeSchedulerLayer: Layer.Layer<
         catch: (cause) =>
           RemoteWakeDropped.make({
             conversationId,
-            message: cause instanceof Error ? cause.message : String(cause),
+            message: safeCauseMessage(cause, "The remote wake failed without a diagnostic"),
             cause,
           }),
       }).pipe(