@effect-agent/testing 0.0.1-beta.5 → 0.1.0-beta.10

package/dist/index.mjs

@@ -2,9 +2,10 @@ import { McpConnectionRequest, McpConnector, McpServerIdentity, McpToolkitMismat
 import { Agent, AgentId, AgentPolicy, ConversationId, IdGenerator, RunId, SubmissionId, ToolCallId, TurnId } from "@effect-agent/core";
 import { DurableStep, DurableStepError, ToolExecutionClass } from "@effect-agent/engine";
 import { AbortCommand, AgentBindingResolver, ApprovalDecisionCommand, BatchId, CanonicalBatch, CanonicalRecordEnvelope, CertificationReport, CertificationSweepResult, CertificationTierThreeReport, CertifiedAdapterIdentity, ConversationCheckpoint, ConversationExportRequest, ConversationProjection, ConversationStore, DEFAULT_OWNERSHIP_LEASE_DURATION, DefinitionDigests, DeploymentId, Digest, DurableAgentRuntime, DurableRuntimeConfig, DurableRuntimeFailpoint, DurableRuntimeFailpointError, DurableRuntimeFailpointLocation, DurableRuntimeFailpointTestControl, DurableWorkerBinding, IdempotencyKey, LoadCheckpointRequest, ObligationThresholds, PersistedJson, Principal, ProducerId, ReconciliationCompleted, ReconciliationSafeToRetry, ReconciliationUncertain, RecordEnvelope, RecordId, ResolutionAbortSubmission, ResolutionCompletedWithResult, ResolutionNeverHappened, ResolutionSafeToRetry, SubmissionLedger, SubmissionLookupById, ToolReconciler, ToolReconcilerError, UnknownResolutionCommand, WakeScheduler, certifyPorts, childConversationIdFor, verifyConversationInvariants } from "@effect-agent/session";
-import { Cause, Clock, Context, DateTime, Deferred, Duration, Effect, Exit, Layer, Option, Ref, Schema, Stream } from "effect";
+import { Cause, Clock, Context, DateTime, Deferred, Duration, Effect, Exit, Fiber, Layer, Option, Queue, Ref, Schema, Stream } from "effect";
 import { FastCheck, TestClock } from "effect/testing";
 import { AiError, LanguageModel, Model, Response, Tool, Toolkit } from "effect/unstable/ai";
+import { CodeExecutionHost, CodeExecutionLimits, CodeExecutionNamespace, CodeExecutionProtocolError, CodeExecutionRequest, CodeExecutionResourceUse, CodeExecutionResult, CodeExecutionTimeoutError, CodeExecutor, CodeExecutorUnsupportedError, CodeHostCall, CodeHostCallFailure, CodeHostCallLimitError, CodeHostCallResult, CodeHostCallSuccess, CodeOutputLimitError, CodeProgramFailedError, CodeSourceError, NetworkAllowlist, NetworkDisabled, SandboxImplementation } from "@effect-agent/sandbox";
 import * as McpSchema from "effect/unstable/ai/McpSchema";
 //#region src/certification.ts
 /** The six Tier-2 scenario shapes in sweep order. */
@@ -28,6 +29,7 @@ const CERTIFICATION_SCENARIOS = [
 */
 const TIER2_UNREACHED_LOCATIONS = [
 	"abort:after-intent",
+	"compaction:after-canonical-append",
 	"resolve:after-intent",
 	"subagent:after-child-abort-intent"
 ];
@@ -1260,6 +1262,566 @@ const runChaosPlan = Effect.fn("Chaos.runChaosPlan")(function* (plan, options) {
 	});
 });
 //#endregion
+//#region src/code-executor-conformance.ts
+/**
+* Shared `CodeExecutor` conformance (TEST-015). Every adapter — the
+* deterministic `unisolated` substitute and each isolated adapter — runs
+* `codeExecutorConformanceCases` verbatim. Enforcement cases that only genuine
+* isolation can prove (ambient network denial, synchronous CPU runaway
+* termination) are NOT here; they belong to isolated adapters only
+* (testing spec §8.1).
+*
+* Cases assume the live `Clock` (the wall-clock case uses a short real
+* deadline) and take one fresh executor pass per case, so a suite may share
+* one executor Layer across cases.
+*/
+var CodeExecutorConformanceViolation = class extends Schema.TaggedError()("CodeExecutorConformanceViolation", {
+	caseName: Schema.String,
+	message: Schema.String
+}) {};
+const baseLimits = CodeExecutionLimits.make({
+	maxSourceBytes: 64 * 1024,
+	maxWallTime: Duration.seconds(10),
+	maxLogBytes: 16 * 1024,
+	maxResultBytes: 64 * 1024,
+	maxHostCalls: 8,
+	maxHostCallArgumentBytes: 16 * 1024,
+	maxHostCallResultBytes: 32 * 1024
+});
+const warehouseNamespace = CodeExecutionNamespace.make({
+	name: "warehouse",
+	methods: ["query", "count"]
+});
+const makeRequest = (source, overrides) => CodeExecutionRequest.make({
+	language: "javascript",
+	source,
+	namespaces: overrides?.namespaces ?? [],
+	network: overrides?.network ?? NetworkDisabled.make(),
+	limits: overrides?.limits ?? baseLimits
+});
+const unusedHost = { call: () => Effect.die(/* @__PURE__ */ new Error("this conformance case expected no host call to reach the CodeExecutionHost")) };
+const respondingHost = (respond) => {
+	const calls = [];
+	return {
+		calls,
+		host: { call: (call) => Effect.sync(() => {
+			calls.push(call);
+			return respond(call);
+		}) }
+	};
+};
+const runPass = (request, host) => Effect.gen(function* () {
+	return yield* (yield* CodeExecutor).execute(request).pipe(Effect.provideService(CodeExecutionHost, CodeExecutionHost.of(host)));
+}).pipe(Effect.scoped);
+const violation = (caseName, message) => CodeExecutorConformanceViolation.make({
+	caseName,
+	message
+});
+const preview = (value) => {
+	try {
+		return JSON.stringify(value)?.slice(0, 200) ?? String(value).slice(0, 200);
+	} catch {
+		return String(value).slice(0, 200);
+	}
+};
+const expectSuccess = (caseName, request, host, check) => runPass(request, host).pipe(Effect.mapError((error) => violation(caseName, `expected success, got ${error._tag}: ${preview(error)}`)), Effect.flatMap((result) => {
+	const complaint = check(result);
+	return complaint === void 0 ? Effect.void : Effect.fail(violation(caseName, complaint));
+}));
+const expectFailure = (caseName, request, host, tag, check) => runPass(request, host).pipe(Effect.flip, Effect.mapError((result) => violation(caseName, `expected ${tag}, but the pass succeeded with ${preview(result.value)}`)), Effect.flatMap((error) => {
+	if (error._tag !== tag) return Effect.fail(violation(caseName, `expected ${tag}, got ${error._tag}: ${preview(error)}`));
+	const complaint = check?.(error);
+	return complaint === void 0 ? Effect.void : Effect.fail(violation(caseName, complaint));
+}));
+const codeExecutorConformanceCases = (options) => {
+	const posture = options.implementation;
+	return [
+		{
+			name: "TEST-015 executes bounded JSON computation and returns the program value",
+			run: expectSuccess("TEST-015 executes bounded JSON computation and returns the program value", makeRequest("async () => { const xs = [1, 2, 3].map((n) => n * 2); return { xs, sum: xs.reduce((a, b) => a + b, 0) }; }"), unusedHost, (result) => JSON.stringify(result.value) === JSON.stringify({
+				xs: [
+					2,
+					4,
+					6
+				],
+				sum: 12
+			}) ? void 0 : `unexpected program value ${preview(result.value)}`)
+		},
+		{
+			name: "CAP-015 reports its isolation posture honestly in results and errors",
+			run: Effect.gen(function* () {
+				const caseName = "CAP-015 reports its isolation posture honestly in results and errors";
+				const result = yield* runPass(makeRequest("async () => 1"), unusedHost).pipe(Effect.mapError((error) => violation(caseName, `expected success, got ${error._tag}`)));
+				if (result.implementation.isolation !== posture.isolation || result.implementation.identity !== posture.identity) return yield* violation(caseName, `result posture ${preview(result.implementation)} does not match the declared ${preview(posture)}`);
+				const error = yield* runPass(makeRequest("async () => {"), unusedHost).pipe(Effect.flip, Effect.mapError(() => violation(caseName, "expected the invalid-source pass to fail")));
+				if (error.implementation === void 0 || error.implementation.isolation !== posture.isolation || error.implementation.identity !== posture.identity) return yield* violation(caseName, `error posture ${preview(error.implementation)} does not match the declared ${preview(posture)}`);
+			})
+		},
+		{
+			name: "TEST-015 routes host calls through the CodeExecutionHost in program order",
+			run: Effect.gen(function* () {
+				const caseName = "TEST-015 routes host calls through the CodeExecutionHost in program order";
+				const { host, calls } = respondingHost((call) => call.method === "query" ? CodeHostCallSuccess.make({ value: { rows: [
+					1,
+					2,
+					3
+				] } }) : CodeHostCallSuccess.make({ value: 3 }));
+				const result = yield* runPass(makeRequest("async () => { const q = await warehouse.query({ sql: 'select' }); const c = await warehouse.count({ table: 't' }); return { rows: q.rows, count: c }; }", { namespaces: [warehouseNamespace] }), host).pipe(Effect.mapError((error) => violation(caseName, `expected success, got ${error._tag}: ${preview(error)}`)));
+				if (JSON.stringify(result.value) !== JSON.stringify({
+					rows: [
+						1,
+						2,
+						3
+					],
+					count: 3
+				})) return yield* violation(caseName, `unexpected value ${preview(result.value)}`);
+				const observed = calls.map((call) => `${call.namespace}.${call.method}`);
+				if (JSON.stringify(observed) !== JSON.stringify(["warehouse.query", "warehouse.count"])) return yield* violation(caseName, `unexpected host call order ${preview(observed)}`);
+				if (result.resourceUse.hostCalls !== 2) return yield* violation(caseName, `expected 2 accounted host calls, got ${result.resourceUse.hostCalls}`);
+			})
+		},
+		{
+			name: "TEST-015 a caught failed host call lets the program branch on the envelope",
+			run: expectSuccess("TEST-015 a caught failed host call lets the program branch on the envelope", makeRequest("async () => { try { await warehouse.query({ sql: 'x' }); return 'unreachable'; } catch (envelope) { return { caught: envelope }; } }", { namespaces: [warehouseNamespace] }), respondingHost(() => CodeHostCallFailure.make({ error: {
+				_tag: "ToolInputError",
+				message: "bad input"
+			} })).host, (result) => JSON.stringify(result.value) === JSON.stringify({ caught: {
+				_tag: "ToolInputError",
+				message: "bad input"
+			} }) ? void 0 : `the envelope did not round-trip: ${preview(result.value)}`)
+		},
+		{
+			name: "TEST-015 an uncaught failed host call fails the program with the envelope",
+			run: expectFailure("TEST-015 an uncaught failed host call fails the program with the envelope", makeRequest("async () => warehouse.query({ sql: 'x' })", { namespaces: [warehouseNamespace] }), respondingHost(() => CodeHostCallFailure.make({ error: {
+				_tag: "PolicyDenied",
+				message: "denied"
+			} })).host, "CodeProgramFailedError", (error) => error._tag === "CodeProgramFailedError" && error.reason === "rejected" && JSON.stringify(error.thrown) === JSON.stringify({
+				_tag: "PolicyDenied",
+				message: "denied"
+			}) ? void 0 : `unexpected failure detail ${preview(error)}`)
+		},
+		{
+			name: "TEST-015 fails typed on syntactically invalid source",
+			run: expectFailure("TEST-015 fails typed on syntactically invalid source", makeRequest("async () => {"), unusedHost, "CodeSourceError", (error) => error._tag === "CodeSourceError" && error.reason === "invalid" ? void 0 : `expected reason invalid, got ${preview(error)}`)
+		},
+		{
+			name: "TEST-015 fails typed when the expression is not one async function",
+			run: expectFailure("TEST-015 fails typed when the expression is not one async function", makeRequest("1 + 1"), unusedHost, "CodeSourceError", (error) => error._tag === "CodeSourceError" && error.reason === "not-a-function" ? void 0 : `expected reason not-a-function, got ${preview(error)}`)
+		},
+		{
+			name: "TEST-015 fails typed on source larger than the declared byte limit",
+			run: expectFailure("TEST-015 fails typed on source larger than the declared byte limit", makeRequest(`async () => "${"x".repeat(2e3)}"`, { limits: CodeExecutionLimits.make({
+				...baseLimits,
+				maxSourceBytes: 256
+			}) }), unusedHost, "CodeSourceError", (error) => error._tag === "CodeSourceError" && error.reason === "oversized" ? void 0 : `expected reason oversized, got ${preview(error)}`)
+		},
+		{
+			name: "TEST-015 terminates a never-settling program at the wall-clock deadline",
+			run: expectFailure("TEST-015 terminates a never-settling program at the wall-clock deadline", makeRequest("async () => { await new Promise(() => {}); return 1; }", { limits: CodeExecutionLimits.make({
+				...baseLimits,
+				maxWallTime: Duration.millis(250)
+			}) }), unusedHost, "CodeExecutionTimeoutError")
+		},
+		{
+			name: "TEST-015 fails typed when console output exceeds its byte budget",
+			run: expectFailure("TEST-015 fails typed when console output exceeds its byte budget", makeRequest("async () => { for (let i = 0; i < 64; i += 1) { console.log('x'.repeat(256)); } return 1; }", { limits: CodeExecutionLimits.make({
+				...baseLimits,
+				maxLogBytes: 2048
+			}) }), unusedHost, "CodeOutputLimitError", (error) => error._tag === "CodeOutputLimitError" && error.surface === "logs" ? void 0 : `expected surface logs, got ${preview(error)}`)
+		},
+		{
+			name: "TEST-015 fails typed when the final result exceeds its byte budget",
+			run: expectFailure("TEST-015 fails typed when the final result exceeds its byte budget", makeRequest("async () => 'y'.repeat(4096)", { limits: CodeExecutionLimits.make({
+				...baseLimits,
+				maxResultBytes: 1024
+			}) }), unusedHost, "CodeOutputLimitError", (error) => error._tag === "CodeOutputLimitError" && error.surface === "result" ? void 0 : `expected surface result, got ${preview(error)}`)
+		},
+		{
+			name: "TEST-015 fails typed when host calls exceed the executor cap",
+			run: Effect.gen(function* () {
+				const caseName = "TEST-015 fails typed when host calls exceed the executor cap";
+				const { host, calls } = respondingHost(() => CodeHostCallSuccess.make({ value: null }));
+				yield* expectFailure(caseName, makeRequest("async () => { await warehouse.query({}); await warehouse.query({}); await warehouse.query({}); return 1; }", {
+					namespaces: [warehouseNamespace],
+					limits: CodeExecutionLimits.make({
+						...baseLimits,
+						maxHostCalls: 2
+					})
+				}), host, "CodeHostCallLimitError");
+				if (calls.length !== 2) return yield* violation(caseName, `expected exactly 2 dispatched host calls under a cap of 2, observed ${calls.length}`);
+			})
+		},
+		{
+			name: "TEST-015 fails typed on a host outcome outside the protocol schema",
+			run: expectFailure("TEST-015 fails typed on a host outcome outside the protocol schema", makeRequest("async () => warehouse.query({})", { namespaces: [warehouseNamespace] }), { call: () => Effect.succeed({ bogus: true }) }, "CodeExecutionProtocolError")
+		},
+		{
+			name: "TEST-015 surfaces an uncaught program throw with its bounded log capture",
+			run: expectFailure("TEST-015 surfaces an uncaught program throw with its bounded log capture", makeRequest("async () => { console.log('before the failure'); throw new Error('deliberate'); }"), unusedHost, "CodeProgramFailedError", (error) => error._tag === "CodeProgramFailedError" && error.reason === "threw" && error.logs.some((line) => line.includes("before the failure")) ? void 0 : `expected a threw failure carrying the log capture, got ${preview(error)}`)
+		},
+		{
+			name: "TEST-015 fails typed when the program returns a non-JSON value",
+			run: expectFailure("TEST-015 fails typed when the program returns a non-JSON value", makeRequest("async () => (() => 1)"), unusedHost, "CodeProgramFailedError", (error) => error._tag === "CodeProgramFailedError" && error.reason === "non-json-result" ? void 0 : `expected reason non-json-result, got ${preview(error)}`)
+		},
+		{
+			name: "CAP-015 rejects a network allowlist it cannot enforce with a typed unsupported error",
+			run: expectFailure("CAP-015 rejects a network allowlist it cannot enforce with a typed unsupported error", makeRequest("async () => 1", { network: NetworkAllowlist.make({
+				domains: ["example.com"],
+				ports: [443]
+			}) }), unusedHost, "CodeExecutorUnsupportedError", (error) => error._tag === "CodeExecutorUnsupportedError" && error.feature === "network" ? void 0 : `expected feature network, got ${preview(error)}`)
+		},
+		{
+			name: "TEST-015 interruption reaches in-flight host calls and pass teardown",
+			run: Effect.gen(function* () {
+				const caseName = "TEST-015 interruption reaches in-flight host calls and pass teardown";
+				const started = yield* Deferred.make();
+				const witness = { hostCallInterrupted: false };
+				const fiber = yield* runPass(makeRequest("async () => warehouse.query({})", { namespaces: [warehouseNamespace] }), { call: () => Deferred.succeed(started, void 0).pipe(Effect.andThen(Effect.never), Effect.ensuring(Effect.sync(() => {
+					witness.hostCallInterrupted = true;
+				}))) }).pipe(Effect.forkChild);
+				if ((yield* Effect.raceFirst(Deferred.await(started).pipe(Effect.as("started")), Fiber.join(fiber).pipe(Effect.exit, Effect.as("exited")))) === "exited") return yield* violation(caseName, "the pass settled before any host call reached the CodeExecutionHost");
+				yield* Fiber.interrupt(fiber);
+				if (!witness.hostCallInterrupted) return yield* violation(caseName, "interrupting the pass did not interrupt the in-flight host call");
+			})
+		}
+	];
+};
+//#endregion
+//#region src/code-executor-substitute.ts
+/**
+* The deterministic in-process executor substitute (C1 of ADR-0017). It runs
+* the generated program on the host JavaScript engine with best-effort global
+* shadowing only, so it self-identifies as `unisolated` and is never a
+* security boundary (CAP-010, CAP-015). It exists to prove the public
+* `CodeExecutor` contract and to drive deterministic capability tests.
+*/
+const inProcessCodeExecutorImplementation = SandboxImplementation.make({
+	isolation: "unisolated",
+	identity: "in-process-javascript"
+});
+const MAX_LOG_LINES = 4096;
+const MAX_LOG_LINE_CHARACTERS = 16e3;
+const MAX_THROWN_CHARACTERS = 4e3;
+const utf8ByteLength = (value) => new TextEncoder().encode(value).byteLength;
+/**
+* Ambient globals shadowed inside the harness. Shadowing blocks the obvious
+* identifier paths only; a determined program can still escape, which is
+* exactly why this executor reports `unisolated` and the isolated network and
+* CPU enforcement conformance cases run only against isolated adapters.
+*/
+const shadowedGlobals = [
+	"fetch",
+	"process",
+	"require",
+	"module",
+	"exports",
+	"global",
+	"globalThis",
+	"XMLHttpRequest",
+	"WebSocket",
+	"Deno",
+	"Bun"
+];
+var LogLimitSignal = class {
+	observed;
+	constructor(observed) {
+		this.observed = observed;
+	}
+};
+var EvaluationThrew = class {
+	inner;
+	constructor(inner) {
+		this.inner = inner;
+	}
+};
+var NotAFunction = class {
+	actual;
+	constructor(actual) {
+		this.actual = actual;
+	}
+};
+/**
+* Total, defect-free rendering of untrusted values: a hostile Proxy can throw
+* from property access, `toString`, and `Symbol.toPrimitive`, and an expected
+* program failure must never escape the typed channel as a defect while its
+* diagnostics are being serialized.
+*/
+const formatLogValue = (value) => {
+	try {
+		if (typeof value === "string") return value;
+		return JSON.stringify(value) ?? String(value);
+	} catch {
+		try {
+			return String(value);
+		} catch {
+			return "[unprintable value]";
+		}
+	}
+};
+const makeConsole = (capture, limits) => {
+	const write = (...values) => {
+		const joined = values.map(formatLogValue).join(" ");
+		const line = joined.length > MAX_LOG_LINE_CHARACTERS ? `${joined.slice(0, MAX_LOG_LINE_CHARACTERS - 1)}…` : joined;
+		const bytes = utf8ByteLength(line);
+		if (capture.lines.length >= MAX_LOG_LINES || capture.bytes + bytes > limits.maxLogBytes) throw new LogLimitSignal(capture.bytes + bytes);
+		capture.lines.push(line);
+		capture.bytes += bytes;
+	};
+	return {
+		debug: write,
+		error: write,
+		info: write,
+		log: write,
+		warn: write
+	};
+};
+const buildNamespaceObject = (namespace, offer) => {
+	const methods = {};
+	for (const method of namespace.methods) methods[method] = (argument) => new Promise((resolve, reject) => {
+		offer({
+			namespace: namespace.name,
+			method,
+			argument,
+			resolve,
+			reject
+		});
+	});
+	return methods;
+};
+const boundedText = (value) => {
+	try {
+		return (value instanceof Error ? `${value.name}: ${value.message}` : formatLogValue(value)).slice(0, MAX_THROWN_CHARACTERS);
+	} catch {
+		return "[unserializable thrown value]";
+	}
+};
+/** Schema decoding of hostile values may itself throw through trap getters. */
+const safeDecodeJson = (value) => {
+	try {
+		return Schema.decodeUnknownOption(Schema.Json)(value);
+	} catch {
+		return Option.none();
+	}
+};
+const boundedThrown = (value) => {
+	const decoded = safeDecodeJson(value);
+	if (Option.isSome(decoded)) try {
+		const encoded = JSON.stringify(decoded.value);
+		if (encoded !== void 0 && encoded.length <= MAX_THROWN_CHARACTERS) return decoded.value;
+	} catch {}
+	return boundedText(value);
+};
+const encodedJsonByteLength = (value) => {
+	try {
+		const encoded = JSON.stringify(value);
+		return encoded === void 0 ? void 0 : utf8ByteLength(encoded);
+	} catch {
+		return;
+	}
+};
+/** Host outcomes are protocol input; a hostile value must not defect mid-decode. */
+const decodeHostOutcome = (value) => {
+	try {
+		return Schema.decodeUnknownOption(CodeHostCallResult)(value);
+	} catch {
+		return Option.none();
+	}
+};
+const validateRequest = (request) => Effect.gen(function* () {
+	if (request.network._tag !== "NetworkDisabled") return yield* CodeExecutorUnsupportedError.make({
+		implementation: inProcessCodeExecutorImplementation,
+		feature: "network",
+		message: "The unisolated in-process executor cannot enforce an egress allowlist; only NetworkDisabled is accepted, and even that is shadowed rather than enforced"
+	});
+	if (request.limits.cpuMillis !== void 0) return yield* CodeExecutorUnsupportedError.make({
+		implementation: inProcessCodeExecutorImplementation,
+		feature: "cpu-limit",
+		message: "The unisolated in-process executor shares the host engine and cannot enforce a CPU limit"
+	});
+	const reservedNames = /* @__PURE__ */ new Set([...shadowedGlobals, "console"]);
+	const seen = /* @__PURE__ */ new Set();
+	for (const namespace of request.namespaces) {
+		if (reservedNames.has(namespace.name) || seen.has(namespace.name)) return yield* CodeExecutorUnsupportedError.make({
+			implementation: inProcessCodeExecutorImplementation,
+			feature: "namespaces",
+			message: `Namespace ${namespace.name} collides with a harness binding or another namespace`
+		});
+		seen.add(namespace.name);
+	}
+	const sourceBytes = utf8ByteLength(request.source);
+	if (sourceBytes > request.limits.maxSourceBytes) return yield* CodeSourceError.make({
+		implementation: inProcessCodeExecutorImplementation,
+		reason: "oversized",
+		message: `Source is ${sourceBytes} bytes; the request allows ${request.limits.maxSourceBytes}`
+	});
+});
+const serveHostCalls = (host, queue, limits, capture, counter) => Effect.gen(function* () {
+	while (true) {
+		const pending = yield* Queue.take(queue);
+		counter.calls += 1;
+		if (counter.calls > limits.maxHostCalls) return yield* CodeHostCallLimitError.make({
+			implementation: inProcessCodeExecutorImplementation,
+			limit: limits.maxHostCalls,
+			logs: [...capture.lines]
+		});
+		const argument = safeDecodeJson(pending.argument);
+		if (Option.isNone(argument)) {
+			pending.reject(/* @__PURE__ */ new TypeError("host call arguments must be JSON values"));
+			continue;
+		}
+		const argumentBytes = encodedJsonByteLength(argument.value);
+		if (argumentBytes === void 0 || argumentBytes > limits.maxHostCallArgumentBytes) return yield* CodeOutputLimitError.make({
+			implementation: inProcessCodeExecutorImplementation,
+			surface: "host-call-argument",
+			limit: limits.maxHostCallArgumentBytes,
+			observed: argumentBytes ?? 0,
+			logs: [...capture.lines]
+		});
+		const rawOutcome = yield* host.call(CodeHostCall.make({
+			namespace: pending.namespace,
+			method: pending.method,
+			argument: argument.value
+		}));
+		const outcome = decodeHostOutcome(rawOutcome);
+		if (Option.isNone(outcome)) return yield* CodeExecutionProtocolError.make({
+			implementation: inProcessCodeExecutorImplementation,
+			message: "The execution host returned a value outside the CodeHostCallResult schema"
+		});
+		if (outcome.value._tag === "CodeHostCallFailure") {
+			pending.reject(outcome.value.error);
+			continue;
+		}
+		const resultBytes = encodedJsonByteLength(outcome.value.value);
+		if (resultBytes === void 0 || resultBytes > limits.maxHostCallResultBytes) return yield* CodeOutputLimitError.make({
+			implementation: inProcessCodeExecutorImplementation,
+			surface: "host-call-result",
+			limit: limits.maxHostCallResultBytes,
+			observed: resultBytes ?? 0,
+			logs: [...capture.lines]
+		});
+		pending.resolve(outcome.value.value);
+	}
+});
+const classifyProgramFailure = (thrown, limits, capture) => {
+	const inner = thrown instanceof EvaluationThrew ? thrown.inner : thrown;
+	if (inner instanceof LogLimitSignal) return CodeOutputLimitError.make({
+		implementation: inProcessCodeExecutorImplementation,
+		surface: "logs",
+		limit: limits.maxLogBytes,
+		observed: inner.observed,
+		logs: [...capture.lines]
+	});
+	if (inner instanceof NotAFunction) return CodeSourceError.make({
+		implementation: inProcessCodeExecutorImplementation,
+		reason: "not-a-function",
+		message: `The source expression evaluated to ${inner.actual}; it must evaluate to one async function`
+	});
+	const reason = thrown instanceof EvaluationThrew || inner instanceof Error ? "threw" : "rejected";
+	return CodeProgramFailedError.make({
+		implementation: inProcessCodeExecutorImplementation,
+		reason,
+		thrown: boundedThrown(inner),
+		message: boundedText(inner),
+		logs: [...capture.lines]
+	});
+};
+const executeInProcess = Effect.fn("InProcessCodeExecutor.execute")(function* (request) {
+	yield* validateRequest(request);
+	const host = yield* CodeExecutionHost;
+	const capture = {
+		lines: [],
+		bytes: 0
+	};
+	const counter = { calls: 0 };
+	const queue = yield* Queue.unbounded();
+	const factory = yield* Effect.try({
+		try: () => new Function(...shadowedGlobals, "console", ...request.namespaces.map((namespace) => namespace.name), `"use strict";\nreturn (\n${request.source}\n);`),
+		catch: (cause) => CodeSourceError.make({
+			implementation: inProcessCodeExecutorImplementation,
+			reason: "invalid",
+			message: boundedText(cause)
+		})
+	});
+	const harnessConsole = makeConsole(capture, request.limits);
+	let issuedHostCalls = 0;
+	const namespaceObjects = request.namespaces.map((namespace) => buildNamespaceObject(namespace, (pending) => {
+		issuedHostCalls += 1;
+		if (issuedHostCalls > request.limits.maxHostCalls + 1) {
+			pending.reject(/* @__PURE__ */ new Error(`host-call limit of ${request.limits.maxHostCalls} exceeded`));
+			return;
+		}
+		Queue.offerUnsafe(queue, pending);
+	}));
+	const server = yield* serveHostCalls(host, queue, request.limits, capture, counter).pipe(Effect.forkScoped);
+	const program = Effect.tryPromise({
+		try: async () => {
+			let candidate;
+			try {
+				candidate = factory(...shadowedGlobals.map(() => void 0), harnessConsole, ...namespaceObjects);
+			} catch (cause) {
+				throw new EvaluationThrew(cause);
+			}
+			if (typeof candidate !== "function") throw new EvaluationThrew(new NotAFunction(typeof candidate));
+			let outcome;
+			try {
+				outcome = candidate();
+			} catch (cause) {
+				throw new EvaluationThrew(cause);
+			}
+			return await Promise.resolve(outcome);
+		},
+		catch: (thrown) => classifyProgramFailure(thrown, request.limits, capture)
+	});
+	const startedAt = yield* Clock.currentTimeMillis;
+	const returned = yield* Effect.raceFirst(program, Fiber.join(server)).pipe(Effect.timeoutOrElse({
+		duration: request.limits.maxWallTime,
+		orElse: () => CodeExecutionTimeoutError.make({
+			implementation: inProcessCodeExecutorImplementation,
+			kind: "wall-clock",
+			maxWallTime: request.limits.maxWallTime,
+			logs: [...capture.lines]
+		})
+	}), Effect.ensuring(Fiber.interrupt(server)));
+	const finishedAt = yield* Clock.currentTimeMillis;
+	if (issuedHostCalls > request.limits.maxHostCalls) return yield* CodeHostCallLimitError.make({
+		implementation: inProcessCodeExecutorImplementation,
+		limit: request.limits.maxHostCalls,
+		logs: [...capture.lines]
+	});
+	const value = yield* Schema.decodeUnknownEffect(Schema.Json)(returned).pipe(Effect.mapError(() => CodeProgramFailedError.make({
+		implementation: inProcessCodeExecutorImplementation,
+		reason: "non-json-result",
+		thrown: null,
+		message: "The program must return a JSON value",
+		logs: [...capture.lines]
+	})));
+	const resultBytes = encodedJsonByteLength(value);
+	if (resultBytes === void 0 || resultBytes > request.limits.maxResultBytes) return yield* CodeOutputLimitError.make({
+		implementation: inProcessCodeExecutorImplementation,
+		surface: "result",
+		limit: request.limits.maxResultBytes,
+		observed: resultBytes ?? 0,
+		logs: [...capture.lines]
+	});
+	return CodeExecutionResult.make({
+		implementation: inProcessCodeExecutorImplementation,
+		value,
+		logs: [...capture.lines],
+		resourceUse: CodeExecutionResourceUse.make({
+			wallTime: Duration.millis(Math.max(0, finishedAt - startedAt)),
+			hostCalls: counter.calls,
+			logBytes: capture.bytes,
+			resultBytes
+		})
+	});
+});
+/**
+* Layer providing the unisolated in-process `CodeExecutor` substitute. The
+* per-pass `CodeExecutionHost` stays in the caller's requirement channel, the
+* same as every real adapter.
+*/
+const inProcessCodeExecutorLayer = Layer.succeed(CodeExecutor)(CodeExecutor.of({ execute: executeInProcess }));
+//#endregion
 //#region src/fixtures/docs-researcher/definition.ts
 const ResearchDocumentId = Schema.NonEmptyString.check(Schema.isMaxLength(64)).pipe(Schema.brand("@effect-agent/testing/docs-researcher/ResearchDocumentId"));
 const BoundedTitle = Schema.NonEmptyString.check(Schema.isMaxLength(120));
@@ -3958,6 +4520,8 @@ const phase6TravelPlannerGoldenEvidence = [
 				runId: "run:{submissionId}",
 				turnId: "turn:run:{submissionId}:1",
 				turn: 1,
+				inputTokens: 128,
+				outputTokens: 96,
 				messages: { content: [
 					{
 						options: {},
@@ -4099,6 +4663,8 @@ const phase6TravelPlannerGoldenEvidence = [
 				runId: "run:{submissionId}",
 				turnId: "turn:run:{submissionId}:2",
 				turn: 2,
+				inputTokens: 128,
+				outputTokens: 96,
 				messages: { content: [{
 					options: {},
 					role: "assistant",
@@ -4200,6 +4766,6 @@ const PHASE7_LIVE_CREDENTIAL_ENV = "OPENAI_API_KEY";
 */
 const phase7LiveProfileEnabled = (env) => env["EFFECT_AGENT_LIVE"] === "1" && (env["OPENAI_API_KEY"] ?? "") !== "";
 //#endregion
-export { ActivityCatalog, ActivityCatalogLayer, ActivityQuery, ActivitySearchResult, ActivityUnavailable, AirportCode, BookFlight, BookItinerary, BookingRef, BoundedSummary, CERTIFICATION_SCENARIOS, CancelBooking, CancelBookingRequest, CancellationConfirmation, CatalogLifecycle, CatalogLifecycleCounts, ChaosApprovalDecision, ChaosConvergenceFailure, ChaosLaneReport, ChaosPlan, ChaosPlanReport, ChaosResolutionKind, ChaosScenarioKind, ChaosSubmissionSpec, DEFAULT_CHAOS_SEED, DestinationBrief, DestinationFacts, DestinationGuide, DestinationGuideLayer, DestinationGuideUnavailable, DestinationQuery, DestinationRecommendation, DestinationReport, DestinationResearchFailed, DestinationResearchFindings, DestinationResearchRequest, DestinationResearchSupportLayer, DestinationResearcher, DestinationResearcherToolkit, DestinationResearcherToolkitLayer, DestinationShortlist, DeterministicIdGeneratorLayer, DocContentToolkit, DocSummarizer, DocsMcpDiscoveryEvidence, DocsResearcher, DocsResearcherToolkit, DocumentLibrary, DocumentQuery, DocumentSummary, DocumentSummaryFailed, DocumentUnavailable, DurableSearchActivities, DurableSearchFlights, DurableSearchLodging, FetchDocument, FlightBookingRequest, FlightCatalog, FlightCatalogLayer, FlightOption, FlightQuery, FlightUnavailable, GuidanceFailure, HoldItinerary, Itinerary, ItineraryBookingRequest, ItineraryConfirmation, ItineraryHold, ItineraryHoldGateway, ItineraryHoldRequest, ItineraryHoldUnavailable, LodgingCatalog, LodgingCatalogLayer, LodgingOption, LodgingQuery, LodgingUnavailable, LookupDestination, PHASE7_LIVE_CREDENTIAL_ENV, PHASE7_LIVE_GATE_ENV, QuoteId, ResearchDigest, ResearchDispatchGate, ResearchDocument, ResearchDocumentId, ResearchMission, ResearchRequest, ReverseCompletionToolkitLayer, ScriptedGeneratePart, ScriptedGenerateTurn, ScriptedModel, ScriptedStreamPart, ScriptedStreamTermination, ScriptedStreamTurn, ScriptedTurn, SearchActivities, SearchFlights, SearchLodging, SummaryBrief, SummaryFinding, SummaryRequest, SupplierBookingConfirmation, SupplierBookingDesk, SupplierBookingRecord, SupplierOperation, SupplierUnavailable, TIER2_UNREACHED_LOCATIONS, TravelBookingReport, TravelCoordinator, TravelCoordinatorToolkit, TravelGuidance, TravelGuidanceLayer, TravelPlan, TravelPlanner, TravelPlannerBookingEvidenceError, TravelPlannerBookingProfile, TravelPlannerCloudflareProfile, TravelPlannerDurabilityProfile, TravelPlannerDurableEvidenceError, TravelPlannerPersistenceProfile, TravelPlannerPhase2, TravelPlannerPhase2Toolkit, TravelPlannerPhase2ToolkitLayer, TravelPlannerPhase4, TravelPlannerPhase4Toolkit, TravelPlannerPhase4ToolkitLayer, TravelPlannerPhase5, TravelPlannerPhase5Toolkit, TravelPlannerPhase5ToolkitLayer, TravelPlannerPhase7Profile, TravelPlannerProjectionError, TravelPlannerRuntimeLayer, TravelPlannerSubagentDurabilityProfile, TravelPlannerToolkit, TravelPlannerToolkitLayer, TravelSupplierReconcilerLayer, TravelerRef, TripRequest, assertDiscoveryMatchesAuthoredToolkit, assertSettledBookingsExistAtSupplier, bookFlightIdempotencyKey, cancelBookingIdempotencyKey, certifyDurableAdapters, chaosSeedFromEnv, coordinatorConfidentialMarker, coordinatorResearchTurn, coordinatorShortlistTurn, delegateDocumentSummary, destinationLookup, destinationReportFor, destinationResearchDelegation, destinationResearchHandlersLayer, destinationResearchPolicy, docContentToolkitLayer, docsCoordinatorConfidentialMarker, docsCoordinatorDigests, docsDocumentBodySecret, docsMcpConnectorLayer, docsMcpIdentity, docsMcpMismatchedConnectorLayer, docsMcpOversizedConnectorLayer, docsMcpRequest, docsMissionConfidentialMarker, docsResearcherDeploymentId, docsResearcherPrincipal, docsResearcherProducerId, docsResearcherSubmitAgent, docsResearcherSubmitOptions, docsSummarizerDigestStrings, docsSummarizerDigests, docsSummaryHandlersLayer, documentBodyPhrase, documentSummaryFor, documentSummaryPolicy, durableChildLookupCallId, durableDestinationResearchHandlersLayer, durableResearchAllocation, durableResearchCallId, durableResearchFinding, durableResearchShortlist, encodedDestinationFacts, encodedDestinationReport, encodedDocumentSummary, expectedDestinationShortlist, expectedResearchDigest, expectedTravelPlan, fetchCallId, generateChaosPlans, itineraryStepIdempotencyKey, makeDestinationResearcherModel, makeDocsResearcherHarness, makeDurableResearchHarness, makeInvocationCountingModel, makePhase3TravelPlannerCheckpoint, makePhase4TravelPlannerAgent, makePhase6TravelPlannerBindings, mapResearchChildFailure, mapSummaryChildFailure, missionConfidentialMarker, normalizeCrossPlatformTravelPlannerEvidence, normalizeDurableTravelPlannerEvidence, phase0HappyPathTurns, phase0Trip, phase1HappyPathTurns, phase1Trip, phase3TravelPlannerBatches, phase3TravelPlannerCompletionBatch, phase3TravelPlannerConversationId, phase3TravelPlannerDefinitionDigests, phase3TravelPlannerEncodedFixture, phase3TravelPlannerInitialBatch, phase3TravelPlannerProducerId, phase3TravelPlannerProfile, phase3TravelPlannerRunId, phase4TravelPlannerDefinitionDigests, phase4TravelPlannerDeploymentId, phase4TravelPlannerPrincipal, phase4TravelPlannerProducerId, phase4TravelPlannerProfile, phase4TravelPlannerSubmitOptions, phase4TravelPlannerWorkerLayer, phase5TravelPlannerDefinitionDigests, phase5TravelPlannerDeploymentId, phase5TravelPlannerPrincipal, phase5TravelPlannerProducerId, phase5TravelPlannerProfile, phase5TravelPlannerSubmitOptions, phase5TravelPlannerWorkerLayer, phase6ActivityCallId, phase6BookingModel, phase6BookingRef, phase6BookingToolCallId, phase6BookingTrip, phase6ChildLookupCallId, phase6CoordinatorModel, phase6FlightCallId, phase6GatedPlannerDefinitionDigests, phase6GatedPlannerModel, phase6GatedTrip, phase6GuideInvocationCount, phase6LodgingCallId, phase6PlannerModel, phase6ResearchDestination, phase6ResearchMission, phase6ResearcherModel, phase6SupplierDesk, phase6SupplierDeskLayer, phase6SupplierReconcilerLayer, phase6TravelPlannerDeploymentId, phase6TravelPlannerGoldenEvidence, phase6TravelPlannerProducerId, phase6TravelPlannerProducerPrefix, phase6TravelPlannerProfile, phase7LiveProfileEnabled, phase7TravelPlannerProfile, redactedDocumentPreview, releasePhase6PlannerGate, releasePhase6ResearcherGate, researchCorpusDocumentIds, researchDocumentFor, researchDocumentLookup, researchMission, researchMissionRequest, researcherHappyPathTurns, resetPhase6PlannerGate, resetPhase6ResearcherGate, resolveTierThree, runChaosPlan, s2CoordinatorDigests, s2CoordinatorSubmitAgent, s2ResearcherDigestStrings, s2ResearcherDigests, s2TravelPlannerDeploymentId, s2TravelPlannerPrincipal, s2TravelPlannerProducerId, s2TravelPlannerProfile, s2TravelPlannerSubmitOptions, summarizeCallId, supplierBookingRefFor, tier2NeverFiredLocations, travelPlanFromDurableSettlement, travelPlanFromProjection };
+export { ActivityCatalog, ActivityCatalogLayer, ActivityQuery, ActivitySearchResult, ActivityUnavailable, AirportCode, BookFlight, BookItinerary, BookingRef, BoundedSummary, CERTIFICATION_SCENARIOS, CancelBooking, CancelBookingRequest, CancellationConfirmation, CatalogLifecycle, CatalogLifecycleCounts, ChaosApprovalDecision, ChaosConvergenceFailure, ChaosLaneReport, ChaosPlan, ChaosPlanReport, ChaosResolutionKind, ChaosScenarioKind, ChaosSubmissionSpec, CodeExecutorConformanceViolation, DEFAULT_CHAOS_SEED, DestinationBrief, DestinationFacts, DestinationGuide, DestinationGuideLayer, DestinationGuideUnavailable, DestinationQuery, DestinationRecommendation, DestinationReport, DestinationResearchFailed, DestinationResearchFindings, DestinationResearchRequest, DestinationResearchSupportLayer, DestinationResearcher, DestinationResearcherToolkit, DestinationResearcherToolkitLayer, DestinationShortlist, DeterministicIdGeneratorLayer, DocContentToolkit, DocSummarizer, DocsMcpDiscoveryEvidence, DocsResearcher, DocsResearcherToolkit, DocumentLibrary, DocumentQuery, DocumentSummary, DocumentSummaryFailed, DocumentUnavailable, DurableSearchActivities, DurableSearchFlights, DurableSearchLodging, FetchDocument, FlightBookingRequest, FlightCatalog, FlightCatalogLayer, FlightOption, FlightQuery, FlightUnavailable, GuidanceFailure, HoldItinerary, Itinerary, ItineraryBookingRequest, ItineraryConfirmation, ItineraryHold, ItineraryHoldGateway, ItineraryHoldRequest, ItineraryHoldUnavailable, LodgingCatalog, LodgingCatalogLayer, LodgingOption, LodgingQuery, LodgingUnavailable, LookupDestination, PHASE7_LIVE_CREDENTIAL_ENV, PHASE7_LIVE_GATE_ENV, QuoteId, ResearchDigest, ResearchDispatchGate, ResearchDocument, ResearchDocumentId, ResearchMission, ResearchRequest, ReverseCompletionToolkitLayer, ScriptedGeneratePart, ScriptedGenerateTurn, ScriptedModel, ScriptedStreamPart, ScriptedStreamTermination, ScriptedStreamTurn, ScriptedTurn, SearchActivities, SearchFlights, SearchLodging, SummaryBrief, SummaryFinding, SummaryRequest, SupplierBookingConfirmation, SupplierBookingDesk, SupplierBookingRecord, SupplierOperation, SupplierUnavailable, TIER2_UNREACHED_LOCATIONS, TravelBookingReport, TravelCoordinator, TravelCoordinatorToolkit, TravelGuidance, TravelGuidanceLayer, TravelPlan, TravelPlanner, TravelPlannerBookingEvidenceError, TravelPlannerBookingProfile, TravelPlannerCloudflareProfile, TravelPlannerDurabilityProfile, TravelPlannerDurableEvidenceError, TravelPlannerPersistenceProfile, TravelPlannerPhase2, TravelPlannerPhase2Toolkit, TravelPlannerPhase2ToolkitLayer, TravelPlannerPhase4, TravelPlannerPhase4Toolkit, TravelPlannerPhase4ToolkitLayer, TravelPlannerPhase5, TravelPlannerPhase5Toolkit, TravelPlannerPhase5ToolkitLayer, TravelPlannerPhase7Profile, TravelPlannerProjectionError, TravelPlannerRuntimeLayer, TravelPlannerSubagentDurabilityProfile, TravelPlannerToolkit, TravelPlannerToolkitLayer, TravelSupplierReconcilerLayer, TravelerRef, TripRequest, assertDiscoveryMatchesAuthoredToolkit, assertSettledBookingsExistAtSupplier, bookFlightIdempotencyKey, cancelBookingIdempotencyKey, certifyDurableAdapters, chaosSeedFromEnv, codeExecutorConformanceCases, coordinatorConfidentialMarker, coordinatorResearchTurn, coordinatorShortlistTurn, delegateDocumentSummary, destinationLookup, destinationReportFor, destinationResearchDelegation, destinationResearchHandlersLayer, destinationResearchPolicy, docContentToolkitLayer, docsCoordinatorConfidentialMarker, docsCoordinatorDigests, docsDocumentBodySecret, docsMcpConnectorLayer, docsMcpIdentity, docsMcpMismatchedConnectorLayer, docsMcpOversizedConnectorLayer, docsMcpRequest, docsMissionConfidentialMarker, docsResearcherDeploymentId, docsResearcherPrincipal, docsResearcherProducerId, docsResearcherSubmitAgent, docsResearcherSubmitOptions, docsSummarizerDigestStrings, docsSummarizerDigests, docsSummaryHandlersLayer, documentBodyPhrase, documentSummaryFor, documentSummaryPolicy, durableChildLookupCallId, durableDestinationResearchHandlersLayer, durableResearchAllocation, durableResearchCallId, durableResearchFinding, durableResearchShortlist, encodedDestinationFacts, encodedDestinationReport, encodedDocumentSummary, expectedDestinationShortlist, expectedResearchDigest, expectedTravelPlan, fetchCallId, generateChaosPlans, inProcessCodeExecutorImplementation, inProcessCodeExecutorLayer, itineraryStepIdempotencyKey, makeDestinationResearcherModel, makeDocsResearcherHarness, makeDurableResearchHarness, makeInvocationCountingModel, makePhase3TravelPlannerCheckpoint, makePhase4TravelPlannerAgent, makePhase6TravelPlannerBindings, mapResearchChildFailure, mapSummaryChildFailure, missionConfidentialMarker, normalizeCrossPlatformTravelPlannerEvidence, normalizeDurableTravelPlannerEvidence, phase0HappyPathTurns, phase0Trip, phase1HappyPathTurns, phase1Trip, phase3TravelPlannerBatches, phase3TravelPlannerCompletionBatch, phase3TravelPlannerConversationId, phase3TravelPlannerDefinitionDigests, phase3TravelPlannerEncodedFixture, phase3TravelPlannerInitialBatch, phase3TravelPlannerProducerId, phase3TravelPlannerProfile, phase3TravelPlannerRunId, phase4TravelPlannerDefinitionDigests, phase4TravelPlannerDeploymentId, phase4TravelPlannerPrincipal, phase4TravelPlannerProducerId, phase4TravelPlannerProfile, phase4TravelPlannerSubmitOptions, phase4TravelPlannerWorkerLayer, phase5TravelPlannerDefinitionDigests, phase5TravelPlannerDeploymentId, phase5TravelPlannerPrincipal, phase5TravelPlannerProducerId, phase5TravelPlannerProfile, phase5TravelPlannerSubmitOptions, phase5TravelPlannerWorkerLayer, phase6ActivityCallId, phase6BookingModel, phase6BookingRef, phase6BookingToolCallId, phase6BookingTrip, phase6ChildLookupCallId, phase6CoordinatorModel, phase6FlightCallId, phase6GatedPlannerDefinitionDigests, phase6GatedPlannerModel, phase6GatedTrip, phase6GuideInvocationCount, phase6LodgingCallId, phase6PlannerModel, phase6ResearchDestination, phase6ResearchMission, phase6ResearcherModel, phase6SupplierDesk, phase6SupplierDeskLayer, phase6SupplierReconcilerLayer, phase6TravelPlannerDeploymentId, phase6TravelPlannerGoldenEvidence, phase6TravelPlannerProducerId, phase6TravelPlannerProducerPrefix, phase6TravelPlannerProfile, phase7LiveProfileEnabled, phase7TravelPlannerProfile, redactedDocumentPreview, releasePhase6PlannerGate, releasePhase6ResearcherGate, researchCorpusDocumentIds, researchDocumentFor, researchDocumentLookup, researchMission, researchMissionRequest, researcherHappyPathTurns, resetPhase6PlannerGate, resetPhase6ResearcherGate, resolveTierThree, runChaosPlan, s2CoordinatorDigests, s2CoordinatorSubmitAgent, s2ResearcherDigestStrings, s2ResearcherDigests, s2TravelPlannerDeploymentId, s2TravelPlannerPrincipal, s2TravelPlannerProducerId, s2TravelPlannerProfile, s2TravelPlannerSubmitOptions, summarizeCallId, supplierBookingRefFor, tier2NeverFiredLocations, travelPlanFromDurableSettlement, travelPlanFromProjection };
 
 //# sourceMappingURL=index.mjs.map