@effect-agent/platform-cloudflare 0.0.1-beta.5 → 0.1.0-beta.6

package/dist/index.mjs

@@ -1,10 +1,12 @@
-import { Clock, Context, Duration, Effect, Layer, ManagedRuntime, Option, PubSub, Random, Ref, Schema, Stream } from "effect";
+import { Clock, Context, Duration, Effect, Fiber, Layer, Option, PubSub, Random, Ref, Schema, Stream } from "effect";
 import { AbortCommand, AbortIntent, AdmissionConflict, AgentBindingResolver, AppendConflict, ApprovalConflict, ApprovalDecisionCommand, ApprovalDecisionIntent, CanonicalRecordEnvelope, CanonicalSequence, ConversationNotMaterialized, ConversationRead, ConversationStore, ConversationStoreError, DEFAULT_OWNERSHIP_LEASE_DURATION, DefinitionDigests, DeploymentId, DigestError, DurableAgentRuntime, DurableRuntimeConfig, DurableRuntimeFailpoint, DurableRuntimeFailpointError, FenceRejected, IdempotencyKey, IntegrityReport, JoinedToHost, LedgerError, ObligationReport, ObligationThresholds, OperationAuthorizationRequest, OperationAuthorizer, OperationDenied, OwnershipLost, PersistedJson, Principal, ProducerId, Receipt, RecoveryExplanation, RecoveryReport, RetryCommand, RetryRefused, RunJournalError, Settlement, SettlementConflict, SubmissionLedger, SubmissionLookupByKey, ToolReconciler, UnknownResolutionCommand, UnknownResolutionConflict, UnknownResolutionIntent, WakeScheduler } from "@effect-agent/session";
 import { ConversationPortTransport, DEFAULT_MAX_STORED_VALUE_BYTES, conversationStoreLayer, handleEncodedPortRequest, portTransportFailure, routedConversationStoreLayer, routedSubmissionLedgerLayer, storageConfigLayer, storageFailpointLayer, submissionLedgerLayer } from "@effect-agent/storage-cloudflare";
 import { AgentId, AgentInputError, ConversationId, SubmissionId } from "@effect-agent/core";
 import { BrowserCrypto } from "@effect/platform-browser";
 import { SqliteClient } from "@effect/sql-sqlite-do";
-import { DurableObject } from "cloudflare:workers";
+import { DurableObject, DurableObjectState, WorkerEnvironment } from "effect-cf";
+import { CodeExecutionHost, CodeExecutionProtocolError, CodeExecutionResourceUse, CodeExecutionResult, CodeExecutionTimeoutError, CodeExecutor, CodeExecutorStartError, CodeExecutorTerminatedError, CodeExecutorUnsupportedError, CodeHostCall, CodeHostCallLimitError, CodeOutputLimitError, CodeProgramFailedError, CodeSourceError, SandboxImplementation } from "@effect-agent/sandbox";
+import { WorkerEntrypoint } from "cloudflare:workers";
 //#region src/bindings.ts
 /**
 * Cloudflare platform bindings as Effect services (DEPLOY-010: "Cloudflare platform bindings
@@ -1017,62 +1019,618 @@ const gateEndpoint = Effect.gen(function* () {
 	yield* (yield* ConversationMaintenance).ensureAlarm;
 });
 /**
-* Build the application's Conversation Object class (export it from the
-* Worker entry). The explicit return type is what makes declaration emit
-* possible: the class body carries a private runtime field, and TS4094
-* rejects inferring an exported anonymous class type around it.
+* Adapter from effect-cf's native Durable Object services to Effect Agent's existing platform
+* ports. effect-cf owns the cached ManagedRuntime and supplies these values once per Object
+* incarnation; the durable runtime continues to depend only on the narrow services below.
 */
-const makeConversationObjectClass = (options) => {
-	class ConversationObject extends DurableObject {
-		#runtime;
-		constructor(ctx, env) {
-			super(ctx, env);
-			this.#runtime = ManagedRuntime.make(CloudflareDurableRuntime.layer(options).pipe(Layer.provideMerge(Layer.mergeAll(DurableObjectContext.layer(ctx, env), conversationNamespaceLayer(env, options.namespaceBinding)))));
-			ctx.blockConcurrencyWhile(() => this.#runtime.runPromise(gateEndpoint));
-		}
-		async submitEncoded(encoded) {
-			return this.#runtime.runPromise(submitEndpoint(encoded));
-		}
-		async awaitSettlementEncoded(encoded) {
-			return this.#runtime.runPromise(awaitSettlementEndpoint(encoded));
-		}
-		async observePage(encoded) {
-			return this.#runtime.runPromise(observePageEndpoint(encoded));
-		}
-		async abortEncoded(encoded) {
-			return this.#runtime.runPromise(abortEndpoint(encoded));
-		}
-		async resolveApprovalEncoded(encoded) {
-			return this.#runtime.runPromise(resolveApprovalEndpoint(encoded));
-		}
-		async resolveUnknownEncoded(encoded) {
-			return this.#runtime.runPromise(resolveUnknownEndpoint(encoded));
-		}
-		async explainEncoded(encoded) {
-			return this.#runtime.runPromise(explainEndpoint(encoded));
-		}
-		async verifyEncoded(encoded) {
-			return this.#runtime.runPromise(verifyEndpoint(encoded));
-		}
-		async retryEncoded(encoded) {
-			return this.#runtime.runPromise(retryEndpoint(encoded));
-		}
-		async obligationsEncoded(encoded) {
-			return this.#runtime.runPromise(obligationsEndpoint(encoded));
+const effectCfPlatformLayer = (namespaceBinding) => {
+	const context = Layer.effect(DurableObjectContext)(Effect.gen(function* () {
+		const state = yield* DurableObjectState.DurableObjectState;
+		const env = yield* WorkerEnvironment;
+		return DurableObjectContext.of({
+			ctx: state.raw,
+			env
+		});
+	}));
+	const namespace = Layer.effect(ConversationObjectNamespace)(Effect.gen(function* () {
+		const binding = yield* conversationNamespaceFromEnv(yield* WorkerEnvironment, namespaceBinding);
+		return ConversationObjectNamespace.of({ namespace: binding });
+	}));
+	return Layer.merge(context, namespace);
+};
+/**
+* Build the application's Conversation Object class (export it from the Worker entry).
+* effect-cf owns the cached ManagedRuntime, native RPC methods, event scopes, and post-handler
+* OTLP flush scheduling for RPC and alarm events. The optional outer Layer is built per native
+* event, so a host can install Tracer/Logger/Metric services and `OtlpExporter.Flusher` without
+* Effect Agent owning exporter lifecycle machinery.
+*/
+const makeConversationObjectClass = (options, observability) => {
+	const application = CloudflareDurableRuntime.layer(options).pipe(Layer.provideMerge(effectCfPlatformLayer(options.namespaceBinding)));
+	const runtime = Layer.effectContext(Effect.gen(function* () {
+		const state = yield* DurableObjectState.DurableObjectState;
+		const scope = yield* Effect.scope;
+		return yield* state.blockConcurrencyWhile(Effect.gen(function* () {
+			const services = yield* Layer.buildWithScope(application, scope);
+			yield* gateEndpoint.pipe(Effect.provide(services));
+			return services;
+		}));
+	}));
+	const rpc = {
+		submitEncoded: (encoded) => submitEndpoint(encoded),
+		awaitSettlementEncoded: (encoded) => awaitSettlementEndpoint(encoded),
+		observePage: (encoded) => observePageEndpoint(encoded),
+		abortEncoded: (encoded) => abortEndpoint(encoded),
+		resolveApprovalEncoded: (encoded) => resolveApprovalEndpoint(encoded),
+		resolveUnknownEncoded: (encoded) => resolveUnknownEndpoint(encoded),
+		explainEncoded: (encoded) => explainEndpoint(encoded),
+		verifyEncoded: (encoded) => verifyEndpoint(encoded),
+		retryEncoded: (encoded) => retryEndpoint(encoded),
+		obligationsEncoded: (encoded) => obligationsEndpoint(encoded),
+		portCall: (encoded) => portCallEndpoint(encoded),
+		wake: () => wakeEndpoint
+	};
+	const EffectCfConversationObject = DurableObject.make(runtime, {
+		...observability === void 0 ? {} : { eventLayer: observability },
+		initialize: Effect.void,
+		rpc,
+		alarm: () => alarmEndpoint
+	});
+	class ConversationObject extends EffectCfConversationObject {
+		alarm(alarmInfo) {
+			return super.alarm?.(alarmInfo);
 		}
-		async portCall(encoded) {
-			return this.#runtime.runPromise(portCallEndpoint(encoded));
+	}
+	return ConversationObject;
+};
+//#endregion
+//#region src/code-mode-executor.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.
+*/
+const dynamicWorkerImplementation = SandboxImplementation.make({
+	isolation: "isolated",
+	identity: "cloudflare-dynamic-worker"
+});
+/**
+* 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.
+*/
+const passRegistry = /* @__PURE__ */ new Map();
+/**
+* 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`.
+*/
+var CodeModeHostEntrypoint = class extends WorkerEntrypoint {
+	async call(passId, hostCall) {
+		const pass = passRegistry.get(String(passId));
+		if (pass === void 0) throw new Error("Unknown Code Mode pass");
+		return pass.dispatch(hostCall);
+	}
+};
+/**
+* The fixed harness loaded as the dynamic worker's main module. The generated
+* source becomes `program.mjs` (`export default (<expression>);`) — a module,
+* never `eval`. The harness installs namespace globals and a bounded console,
+* imports the program, invokes it exactly once, and returns one envelope the
+* host validates through Effect Schema.
+*/
+const HARNESS_MODULE = String.raw`
+import { WorkerEntrypoint } from "cloudflare:workers";
+import programDefault from "./program.js";
+
+const encoder = new TextEncoder();
+const utf8 = (text) => encoder.encode(text).byteLength;
+const safeText = (value) => {
+  try {
+    if (value instanceof Error) return (value.name + ": " + value.message).slice(0, 4000);
+    if (typeof value === "string") return value.slice(0, 4000);
+    const encoded = JSON.stringify(value);
+    return (encoded === undefined ? String(value) : encoded).slice(0, 4000);
+  } catch {
+    return "[unserializable value]";
+  }
+};
+const safeJson = (value) => {
+  try {
+    const encoded = JSON.stringify(value);
+    if (encoded !== undefined && encoded.length <= 4000) return JSON.parse(encoded);
+  } catch {}
+  return safeText(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;
+    const limits = config.limits;
+    const logs = [];
+    let logBytes = 0;
+    let fatal;
+    const boundedLogs = () => logs.slice(0, 4096);
+    const write = (...values) => {
+      const joined = values.map(safeText).join(" ");
+      const line = joined.length > 16000 ? joined.slice(0, 15999) + "…" : joined;
+      const bytes = utf8(line);
+      if (logs.length >= 4096 || logBytes + bytes > limits.maxLogBytes) {
+        fatal = fatal ?? { _tag: "log-limit", observed: logBytes + bytes, logs: boundedLogs() };
+        throw new Error("code-mode log limit exceeded");
+      }
+      logs.push(line);
+      logBytes += bytes;
+    };
+    globalThis.console = { log: write, info: write, warn: write, error: write, debug: write };
+
+    let hostCalls = 0;
+    const makeMethod = (namespace, method) => async (argument) => {
+      hostCalls += 1;
+      if (hostCalls > limits.maxHostCalls) {
+        fatal = fatal ?? { _tag: "host-call-limit", logs: boundedLogs() };
+        throw new Error("code-mode host-call limit exceeded");
+      }
+      let argText;
+      try {
+        argText = JSON.stringify(argument);
+      } catch {}
+      if (argText === undefined || utf8(argText) > limits.maxHostCallArgumentBytes) {
+        fatal = fatal ?? {
+          _tag: "argument-limit",
+          observed: argText === undefined ? 0 : utf8(argText),
+          logs: boundedLogs(),
+        };
+        throw new Error("code-mode host-call argument limit exceeded");
+      }
+      const outcome = await host.call(config.passId, {
+        namespace,
+        method,
+        argument: JSON.parse(argText),
+      });
+      if (outcome !== null && typeof outcome === "object" && outcome._tag === "CodeHostCallSuccess") {
+        return outcome.value;
+      }
+      if (outcome !== null && typeof outcome === "object" && outcome._tag === "CodeHostCallFailure") {
+        throw outcome.error;
+      }
+      fatal = fatal ?? { _tag: "protocol", message: "host returned an unrecognized outcome" };
+      throw new Error("code-mode host protocol violation");
+    };
+    for (const namespace of config.namespaces) {
+      const methods = {};
+      for (const method of namespace.methods) {
+        methods[method] = makeMethod(namespace.name, method);
+      }
+      globalThis[namespace.name] = methods;
+    }
+
+    // program.js is imported statically at the top of this module, so a
+    // syntactically invalid program fails the whole harness at load (mapped
+    // to a source error by the host). Using a static import keeps this module
+    // free of dynamic-import expressions, which single-script Miniflare hosts
+    // reject. The isolation boundary does NOT depend on the ordering of this
+    // import versus the console/namespace shims installed below: the loaded
+    // Worker has globalOutbound: null and no bindings, secrets, or env from
+    // the Worker Loader config BEFORE any module in the graph evaluates, so
+    // module-level program code has no ambient authority regardless. The
+    // shims below are usability wrappers (bounded console, namespace globals),
+    // and the accepted program is a single async-function expression whose
+    // body runs only when invoked here — after the shims exist.
+    const program = programDefault;
+    if (typeof program !== "function") {
+      return { _tag: "source-not-a-function", actual: typeof program };
+    }
+    try {
+      const value = await program();
+      if (fatal !== undefined) return fatal;
+      let text;
+      try {
+        text = JSON.stringify(value);
+      } catch {}
+      if (text === undefined) {
+        return {
+          _tag: "program-failed",
+          reason: "non-json-result",
+          thrown: null,
+          message: "The program must return a JSON value",
+          logs: boundedLogs(),
+        };
+      }
+      const resultBytes = utf8(text);
+      if (resultBytes > limits.maxResultBytes) {
+        return { _tag: "result-limit", observed: resultBytes, logs: boundedLogs() };
+      }
+      return {
+        _tag: "completed",
+        value: JSON.parse(text),
+        logs: boundedLogs(),
+        hostCalls,
+        logBytes,
+        resultBytes,
+      };
+    } catch (cause) {
+      if (fatal !== undefined) return fatal;
+      return {
+        _tag: "program-failed",
+        reason: cause instanceof Error ? "threw" : "rejected",
+        thrown: safeJson(cause),
+        message: safeText(cause),
+        logs: boundedLogs(),
+      };
+    }
+  }
+}
+`;
+const BoundedLogs = Schema.Array(Schema.String.check(Schema.isMaxLength(16 * 1024))).check(Schema.isMaxLength(4096));
+const HarnessCompleted = Schema.Struct({
+	_tag: Schema.Literal("completed"),
+	value: Schema.Json,
+	logs: BoundedLogs,
+	hostCalls: Schema.Natural,
+	logBytes: Schema.Natural,
+	resultBytes: Schema.Natural
+});
+const HarnessSourceInvalid = Schema.Struct({
+	_tag: Schema.Literal("source-invalid"),
+	message: Schema.String
+});
+const HarnessNotAFunction = Schema.Struct({
+	_tag: Schema.Literal("source-not-a-function"),
+	actual: Schema.String
+});
+const HarnessProgramFailed = Schema.Struct({
+	_tag: Schema.Literal("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"),
+	observed: Schema.Natural,
+	logs: BoundedLogs
+});
+const HarnessArgumentLimit = Schema.Struct({
+	_tag: Schema.Literal("argument-limit"),
+	observed: Schema.Natural,
+	logs: BoundedLogs
+});
+const HarnessResultLimit = Schema.Struct({
+	_tag: Schema.Literal("result-limit"),
+	observed: Schema.Natural,
+	logs: BoundedLogs
+});
+const HarnessHostCallLimit = Schema.Struct({
+	_tag: Schema.Literal("host-call-limit"),
+	logs: BoundedLogs
+});
+const HarnessProtocol = Schema.Struct({
+	_tag: Schema.Literal("protocol"),
+	message: Schema.String
+});
+const HarnessOutcome = Schema.Union([
+	HarnessCompleted,
+	HarnessSourceInvalid,
+	HarnessNotAFunction,
+	HarnessProgramFailed,
+	HarnessLogLimit,
+	HarnessArgumentLimit,
+	HarnessResultLimit,
+	HarnessHostCallLimit,
+	HarnessProtocol
+]);
+const decodeHarnessOutcome = (value) => {
+	try {
+		return Schema.decodeUnknownOption(HarnessOutcome)(value);
+	} catch {
+		return Option.none();
+	}
+};
+const decodeHostCall = (value) => {
+	try {
+		return Schema.decodeUnknownOption(CodeHostCall)(value);
+	} catch {
+		return Option.none();
+	}
+};
+/**
+* Project a host outcome to the plain JSON envelope the harness reads. A
+* `CodeExecutionHost` may return either real `CodeHostCallResult` instances
+* (the substitute and conformance kit) or plain-object equivalents (the Code
+* Mode capability's broker route), so this reads the shared fields rather than
+* `Schema.encodeSync`, which would reject a plain object.
+*/
+const hostResultEnvelope = (outcome) => outcome._tag === "CodeHostCallSuccess" ? {
+	_tag: "CodeHostCallSuccess",
+	value: outcome.value
+} : {
+	_tag: "CodeHostCallFailure",
+	error: outcome.error
+};
+const utf8ByteLength = (value) => {
+	let total = 0;
+	for (const character of value) {
+		const codePoint = character.codePointAt(0) ?? 0;
+		total += codePoint <= 127 ? 1 : codePoint <= 2047 ? 2 : codePoint <= 65535 ? 3 : 4;
+	}
+	return total;
+};
+const encodedJsonByteLength = (value) => {
+	try {
+		const encoded = JSON.stringify(value);
+		return encoded === void 0 ? void 0 : utf8ByteLength(encoded);
+	} catch {
+		return;
+	}
+};
+/** Reserved global names the harness owns inside the dynamic worker. */
+const reservedHarnessGlobals = /* @__PURE__ */ new Set(["console"]);
+const passCounterState = { next: 0 };
+const makeExecute = (options) => Effect.fn("DynamicWorkerCodeExecutor.execute")(function* (request) {
+	if (request.network._tag !== "NetworkDisabled") return yield* CodeExecutorUnsupportedError.make({
+		implementation: dynamicWorkerImplementation,
+		feature: "network",
+		message: "The Dynamic Worker executor denies all egress with globalOutbound: null; an allowlist is not supported in the first slice"
+	});
+	const sourceBytes = utf8ByteLength(request.source);
+	if (sourceBytes > request.limits.maxSourceBytes) return yield* CodeSourceError.make({
+		implementation: dynamicWorkerImplementation,
+		reason: "oversized",
+		message: `Source is ${sourceBytes} bytes; the request allows ${request.limits.maxSourceBytes}`
+	});
+	for (const namespace of request.namespaces) if (reservedHarnessGlobals.has(namespace.name)) return yield* CodeExecutorUnsupportedError.make({
+		implementation: dynamicWorkerImplementation,
+		feature: "namespaces",
+		message: `Namespace ${namespace.name} collides with a harness binding`
+	});
+	const host = yield* CodeExecutionHost;
+	passCounterState.next += 1;
+	const passId = `code-mode-pass-${passCounterState.next}-${crypto.randomUUID()}`;
+	const pending = [];
+	let wake;
+	let issuedHostCalls = 0;
+	const dispatch = (hostCall) => new Promise((resolve, reject) => {
+		issuedHostCalls += 1;
+		if (issuedHostCalls > request.limits.maxHostCalls + 1) {
+			reject(/* @__PURE__ */ new Error("host-call limit exceeded"));
+			return;
 		}
-		async wake() {
-			await this.#runtime.runPromise(wakeEndpoint);
+		pending.push({
+			hostCall,
+			resolve,
+			reject
+		});
+		wake?.();
+	});
+	yield* Effect.acquireRelease(Effect.sync(() => {
+		passRegistry.set(passId, { dispatch });
+	}), () => Effect.sync(() => {
+		passRegistry.delete(passId);
+	}));
+	const nextPending = Effect.suspend(() => {
+		const item = pending.shift();
+		if (item !== void 0) return Effect.succeed(item);
+		return Effect.callback((resume) => {
+			wake = () => {
+				wake = void 0;
+				const next = pending.shift();
+				if (next !== void 0) resume(Effect.succeed(next));
+			};
+		});
+	});
+	const serveHostCalls = Effect.gen(function* () {
+		let served = 0;
+		while (true) {
+			const item = yield* nextPending;
+			served += 1;
+			if (served > request.limits.maxHostCalls) return yield* CodeHostCallLimitError.make({
+				implementation: dynamicWorkerImplementation,
+				limit: request.limits.maxHostCalls,
+				logs: []
+			});
+			const decoded = decodeHostCall(item.hostCall);
+			if (Option.isNone(decoded)) {
+				item.reject(/* @__PURE__ */ new TypeError("host calls must match the CodeHostCall schema"));
+				continue;
+			}
+			const outcome = yield* host.call(decoded.value);
+			if (outcome._tag === "CodeHostCallSuccess") {
+				const bytes = encodedJsonByteLength(outcome.value);
+				if (bytes === void 0 || bytes > request.limits.maxHostCallResultBytes) return yield* CodeOutputLimitError.make({
+					implementation: dynamicWorkerImplementation,
+					surface: "host-call-result",
+					limit: request.limits.maxHostCallResultBytes,
+					observed: bytes ?? 0,
+					logs: []
+				});
+			}
+			item.resolve(hostResultEnvelope(outcome));
 		}
-		async alarm() {
-			await this.#runtime.runPromise(alarmEndpoint);
+	});
+	const workerCode = {
+		compatibilityDate: options.compatibilityDate ?? "2025-05-01",
+		allowExperimental: true,
+		mainModule: "harness.js",
+		modules: {
+			"harness.js": HARNESS_MODULE,
+			"program.js": `export default (\n${request.source}\n);`
+		},
+		env: {
+			CODE_MODE_HOST: options.hostStub,
+			CODE_MODE_PASS: JSON.stringify({
+				passId,
+				namespaces: request.namespaces.map((namespace) => ({
+					name: namespace.name,
+					methods: namespace.methods
+				})),
+				limits: {
+					maxLogBytes: request.limits.maxLogBytes,
+					maxResultBytes: request.limits.maxResultBytes,
+					maxHostCalls: request.limits.maxHostCalls,
+					maxHostCallArgumentBytes: request.limits.maxHostCallArgumentBytes
+				}
+			})
+		},
+		globalOutbound: null,
+		...request.limits.cpuMillis === void 0 ? {} : { limits: {
+			cpuMs: request.limits.cpuMillis,
+			subRequests: request.limits.maxHostCalls + 8
+		} }
+	};
+	const startedAt = yield* Clock.currentTimeMillis;
+	const worker = yield* Effect.acquireRelease(Effect.try({
+		try: () => options.loader.load(workerCode),
+		catch: (cause) => {
+			const text = cause instanceof Error ? cause.message : String(cause);
+			if (/syntaxerror|failed to (compile|parse)/i.test(text)) return CodeSourceError.make({
+				implementation: dynamicWorkerImplementation,
+				reason: "invalid",
+				message: text.slice(0, 8e3)
+			});
+			return CodeExecutorStartError.make({
+				implementation: dynamicWorkerImplementation,
+				message: `The Worker Loader rejected the pass: ${text}`.slice(0, 8e3),
+				cause
+			});
 		}
+	}), (stub) => Effect.sync(() => {
+		stub[Symbol.dispose]?.();
+	}));
+	const server = yield* serveHostCalls.pipe(Effect.forkScoped);
+	const rpc = Effect.tryPromise({
+		try: async () => {
+			return await worker.getEntrypoint().run();
+		},
+		catch: (cause) => classifyWorkerFailure(cause, request.limits.maxWallTime)
+	});
+	const raw = yield* Effect.raceFirst(rpc, Fiber.join(server)).pipe(Effect.timeoutOrElse({
+		duration: request.limits.maxWallTime,
+		orElse: () => CodeExecutionTimeoutError.make({
+			implementation: dynamicWorkerImplementation,
+			kind: "wall-clock",
+			maxWallTime: request.limits.maxWallTime,
+			logs: []
+		})
+	}), Effect.ensuring(Fiber.interrupt(server)));
+	const finishedAt = yield* Clock.currentTimeMillis;
+	const outcome = decodeHarnessOutcome(raw);
+	if (Option.isNone(outcome)) return yield* CodeExecutionProtocolError.make({
+		implementation: dynamicWorkerImplementation,
+		message: "The dynamic worker returned a value outside the harness envelope schema"
+	});
+	switch (outcome.value._tag) {
+		case "completed": return CodeExecutionResult.make({
+			implementation: dynamicWorkerImplementation,
+			value: outcome.value.value,
+			logs: outcome.value.logs,
+			resourceUse: CodeExecutionResourceUse.make({
+				wallTime: Duration.millis(Math.max(0, finishedAt - startedAt)),
+				hostCalls: outcome.value.hostCalls,
+				logBytes: outcome.value.logBytes,
+				resultBytes: outcome.value.resultBytes
+			})
+		});
+		case "source-invalid": return yield* CodeSourceError.make({
+			implementation: dynamicWorkerImplementation,
+			reason: "invalid",
+			message: outcome.value.message.slice(0, 8e3)
+		});
+		case "source-not-a-function": return yield* CodeSourceError.make({
+			implementation: dynamicWorkerImplementation,
+			reason: "not-a-function",
+			message: `The source expression evaluated to ${outcome.value.actual}; it must evaluate to one async function`
+		});
+		case "program-failed": return yield* CodeProgramFailedError.make({
+			implementation: dynamicWorkerImplementation,
+			reason: outcome.value.reason,
+			thrown: outcome.value.thrown,
+			message: outcome.value.message.slice(0, 8e3),
+			logs: outcome.value.logs
+		});
+		case "log-limit": return yield* CodeOutputLimitError.make({
+			implementation: dynamicWorkerImplementation,
+			surface: "logs",
+			limit: request.limits.maxLogBytes,
+			observed: outcome.value.observed,
+			logs: outcome.value.logs
+		});
+		case "argument-limit": return yield* CodeOutputLimitError.make({
+			implementation: dynamicWorkerImplementation,
+			surface: "host-call-argument",
+			limit: request.limits.maxHostCallArgumentBytes,
+			observed: outcome.value.observed,
+			logs: outcome.value.logs
+		});
+		case "result-limit": return yield* CodeOutputLimitError.make({
+			implementation: dynamicWorkerImplementation,
+			surface: "result",
+			limit: request.limits.maxResultBytes,
+			observed: outcome.value.observed,
+			logs: outcome.value.logs
+		});
+		case "host-call-limit": return yield* CodeHostCallLimitError.make({
+			implementation: dynamicWorkerImplementation,
+			limit: request.limits.maxHostCalls,
+			logs: outcome.value.logs
+		});
+		case "protocol": return yield* CodeExecutionProtocolError.make({
+			implementation: dynamicWorkerImplementation,
+			message: outcome.value.message.slice(0, 8e3)
+		});
 	}
-	return ConversationObject;
+});
+/**
+* Expected worker-level failures map into the typed union with bounded
+* diagnostics; anything unrecognized stays a start/termination error rather
+* than a fabricated program result.
+*/
+const classifyWorkerFailure = (cause, maxWallTime) => {
+	const text = (() => {
+		try {
+			return cause instanceof Error ? `${cause.name}: ${cause.message}` : String(cause);
+		} catch {
+			return "[unserializable worker failure]";
+		}
+	})();
+	if (/syntaxerror|failed to (compile|parse)/i.test(text)) return CodeSourceError.make({
+		implementation: dynamicWorkerImplementation,
+		reason: "invalid",
+		message: text.slice(0, 8e3)
+	});
+	if (/cpu/i.test(text)) return CodeExecutionTimeoutError.make({
+		implementation: dynamicWorkerImplementation,
+		kind: "cpu",
+		maxWallTime,
+		logs: []
+	});
+	if (/failed to start worker/i.test(text)) return CodeExecutorStartError.make({
+		implementation: dynamicWorkerImplementation,
+		message: text.slice(0, 8e3),
+		cause
+	});
+	return CodeExecutorTerminatedError.make({
+		implementation: dynamicWorkerImplementation,
+		message: text.slice(0, 8e3)
+	});
 };
+/** Layer building the Dynamic Worker `CodeExecutor` from resolved bindings. */
+const dynamicWorkerCodeExecutorLayer = (options) => Layer.succeed(CodeExecutor)(CodeExecutor.of({ execute: makeExecute(options) }));
 //#endregion
-export { AbortRecorded, AdminExplainRequest, AdminFailed, AdminFailure, AdminResponse, AdminVerifyRequest, AdmissionLimitExceeded, ApprovalRecorded, CLOUDFLARE_DATABASE_CAP_BYTES, CLOUDFLARE_RUNTIME_DEFAULTS, CloudflareAdmissionLimitsValue, CloudflareBindingError, CloudflareConversationClient, CloudflareDurableRuntime, CloudflareDurableRuntimeConfig, CloudflareDurableRuntimeConfigValue, CloudflarePlatformConfigError, ConversationClientError, ConversationMaintenance, ConversationObjectIdentity, ConversationObjectNamespace, ConversationObjectPorts, DEFAULT_MAX_DATABASE_BYTES, DurableAlarmError, DurableAlarmService, DurableObjectContext, ExplainedRecovery, HostFailed, HostFailure, HostProtocolError, HostResponse, MaintenancePassReport, ObligationsScanned, ObservePageRequest, ObservedPage, RetryExecuted, SettlementReached, SubmitRequest, SubmitSucceeded, UnknownResolutionRecorded, VerifiedIntegrity, boundHostDiagnostic, cloudflareWakeSchedulerLayer, conversationNamespaceFromEnv, conversationNamespaceLayer, conversationPortTransportLayer, decodeAbortCommand, decodeAdminExplainRequest, decodeAdminResponse, decodeAdminVerifyRequest, decodeApprovalDecisionCommand, decodeHostResponse, decodeObligationThresholds, decodeObservePageRequest, decodeReceipt, decodeRetryCommand, decodeSubmitRequest, decodeUnknownResolutionCommand, encodeAbortCommand, encodeAdminResponse, encodeApprovalDecisionCommand, encodeHostResponse, encodeObservePageRequest, encodeReceipt, encodeSubmitRequest, encodeUnknownResolutionCommand, makeConversationObjectClass };
+export { AbortRecorded, AdminExplainRequest, AdminFailed, AdminFailure, AdminResponse, AdminVerifyRequest, AdmissionLimitExceeded, ApprovalRecorded, CLOUDFLARE_DATABASE_CAP_BYTES, CLOUDFLARE_RUNTIME_DEFAULTS, CloudflareAdmissionLimitsValue, CloudflareBindingError, CloudflareConversationClient, CloudflareDurableRuntime, CloudflareDurableRuntimeConfig, CloudflareDurableRuntimeConfigValue, CloudflarePlatformConfigError, CodeModeHostEntrypoint, ConversationClientError, ConversationMaintenance, ConversationObjectIdentity, ConversationObjectNamespace, ConversationObjectPorts, DEFAULT_MAX_DATABASE_BYTES, DurableAlarmError, DurableAlarmService, DurableObjectContext, ExplainedRecovery, HostFailed, HostFailure, HostProtocolError, HostResponse, MaintenancePassReport, ObligationsScanned, ObservePageRequest, ObservedPage, RetryExecuted, SettlementReached, SubmitRequest, SubmitSucceeded, UnknownResolutionRecorded, VerifiedIntegrity, boundHostDiagnostic, cloudflareWakeSchedulerLayer, conversationNamespaceFromEnv, conversationNamespaceLayer, conversationPortTransportLayer, decodeAbortCommand, decodeAdminExplainRequest, decodeAdminResponse, decodeAdminVerifyRequest, decodeApprovalDecisionCommand, decodeHostResponse, decodeObligationThresholds, decodeObservePageRequest, decodeReceipt, decodeRetryCommand, decodeSubmitRequest, decodeUnknownResolutionCommand, dynamicWorkerCodeExecutorLayer, dynamicWorkerImplementation, encodeAbortCommand, encodeAdminResponse, encodeApprovalDecisionCommand, encodeHostResponse, encodeObservePageRequest, encodeReceipt, encodeSubmitRequest, encodeUnknownResolutionCommand, makeConversationObjectClass };
 
 //# sourceMappingURL=index.mjs.map