@caplets/core 0.23.0 → 0.24.1

package/dist/{service-CSRCJfpA.js → service-Cvnuu9wr.js}

@@ -9,7 +9,7 @@ import { spawn } from "node:child_process";
 import process$1 from "node:process";
 import { PassThrough } from "node:stream";
 import { createServer } from "node:http";
-import { createHash, randomBytes, randomUUID } from "node:crypto";
+import { createHash, createHmac, randomBytes, randomUUID } from "node:crypto";
 import { homedir } from "node:os";
 import { readFile } from "node:fs/promises";
 import ts from "typescript";
@@ -27102,6 +27102,16 @@ const publicCapletSetSchema = object$1({
 	});
 });
 const normalizedCapletSetSchema = publicCapletSetSchema.extend({ body: string().optional() });
+const CAPLET_BACKEND_KEYS = [
+	"mcpServers",
+	"openapiEndpoints",
+	"googleDiscoveryApis",
+	"graphqlEndpoints",
+	"httpApis",
+	"cliTools",
+	"capletSets"
+];
+const CAPLET_BACKEND_KEY_SET = new Set(CAPLET_BACKEND_KEYS);
 function configSchemaFor(serverValueSchema, openApiEndpointValueSchema, googleDiscoveryApiValueSchema, graphQlEndpointValueSchema, httpApiValueSchema, cliToolsValueSchema, capletSetValueSchema) {
 	return object$1({
 		$schema: string().optional().describe("Optional JSON Schema for editor validation."),
@@ -27555,8 +27565,11 @@ function loadLocalOverlayConfigWithSources(path = resolveConfigPath(), projectPa
 }
 function readBestEffortConfigInput(path, kind, warnings, transform) {
 	try {
-		const input = readPublicConfigInput(path);
-		return transform ? transform(input) : input;
+		const normalized = normalizeLocalPaths(readBestEffortJsonConfigInput(path), dirname(path));
+		const filtered = quarantineMissingEnvCaplets(transform ? transform(normalized) : normalized, kind, path, warnings);
+		const parsed = configFileSchema.safeParse(interpolateConfig(filtered));
+		if (!parsed.success) throw new CapletsError("CONFIG_INVALID", `Caplets config at ${path} is invalid`, parsed.error.issues);
+		return filtered;
 	} catch (error) {
 		warnings.push({
 			kind,
@@ -27566,6 +27579,55 @@ function readBestEffortConfigInput(path, kind, warnings, transform) {
 		return;
 	}
 }
+function readBestEffortJsonConfigInput(path) {
+	try {
+		return JSON.parse(readFileSync(path, "utf8"));
+	} catch (error) {
+		throw new CapletsError("CONFIG_INVALID", `Caplets config at ${path} is not valid JSON`, redactSecrets(error));
+	}
+}
+function quarantineMissingEnvCaplets(input, kind, sourcePath, warnings) {
+	let filtered = input;
+	for (const backend of CAPLET_BACKEND_KEYS) {
+		const caplets = filtered[backend];
+		if (!isPlainObject$5(caplets)) continue;
+		for (const [id, caplet] of Object.entries(caplets)) {
+			const missing = missingEnvReferences(caplet, [backend, id]);
+			if (missing.length === 0) continue;
+			filtered = removeCapletBackendId(filtered, backend, id);
+			warnings.push({
+				kind,
+				path: typeof sourcePath === "function" ? sourcePath(id) : sourcePath,
+				message: formatMissingEnvWarning(id, missing),
+				recoverable: true
+			});
+		}
+	}
+	return filtered;
+}
+function missingEnvReferences(value, path) {
+	if (isPublicMetadataPath(path)) return [];
+	if (typeof value === "string") return missingEnvReferencesInString(value, path.join("."));
+	if (Array.isArray(value)) return value.flatMap((item, index) => missingEnvReferences(item, [...path, String(index)]));
+	if (isPlainObject$5(value)) return Object.entries(value).flatMap(([key, nested]) => missingEnvReferences(nested, [...path, key]));
+	return [];
+}
+function missingEnvReferencesInString(value, path) {
+	const missing = [];
+	for (const match of value.matchAll(/\$\{([A-Za-z_][A-Za-z0-9_]*)\}|\$env:([A-Za-z_][A-Za-z0-9_]*)/g)) {
+		const name = match[1] ?? match[2];
+		if (name && process.env[name] === void 0) missing.push({
+			name,
+			path
+		});
+	}
+	return missing;
+}
+function formatMissingEnvWarning(id, missing) {
+	const names = [...new Set(missing.map((reference) => reference.name))];
+	const paths = [...new Set(missing.map((reference) => reference.path))];
+	return `Caplet ${id} references missing ${names.length === 1 ? "environment variable" : "environment variables"} ${names.join(", ")} at ${paths.join(", ")}; skipping Caplet ${id}.`;
+}
 function loadBestEffortCapletFiles(root, kind, warnings) {
 	const result = loadCapletFilesWithPathsBestEffort(root);
 	if (!result) return;
@@ -27574,9 +27636,11 @@ function loadBestEffortCapletFiles(root, kind, warnings) {
 		path: warning.path ?? root,
 		message: warning.message
 	});
+	const config = quarantineMissingEnvCaplets(result.config, kind, (id) => result.paths[id] ?? root, warnings);
+	const retainedIds = new Set(capletIds(config));
 	return {
-		config: result.config,
-		paths: result.paths
+		config,
+		paths: Object.fromEntries(Object.entries(result.paths).filter(([id]) => retainedIds.has(id)))
 	};
 }
 function errorMessage$3(error) {
@@ -27737,6 +27801,15 @@ function mergeConfigInputsWithSources(...inputs) {
 		shadows
 	};
 }
+function removeCapletBackendId(input, backend, id) {
+	const caplets = input[backend];
+	if (!isPlainObject$5(caplets)) return input;
+	const { [id]: _removed, ...remaining } = caplets;
+	return {
+		...input,
+		[backend]: remaining
+	};
+}
 function removeCapletId(input, id) {
 	const { [id]: _mcpServer, ...mcpServers } = input.mcpServers ?? {};
 	const { [id]: _openapiEndpoint, ...openapiEndpoints } = input.openapiEndpoints ?? {};
@@ -27867,7 +27940,7 @@ function interpolateConfig(value, path = []) {
 	return value;
 }
 function isPublicMetadataPath(path) {
-	if (path.length < 3 || path[0] !== "mcpServers" && path[0] !== "openapiEndpoints" && path[0] !== "googleDiscoveryApis" && path[0] !== "graphqlEndpoints" && path[0] !== "httpApis" && path[0] !== "cliTools" && path[0] !== "capletSets") return false;
+	if (path.length < 3 || !CAPLET_BACKEND_KEY_SET.has(path[0] ?? "")) return false;
 	return NON_INTERPOLATED_SERVER_FIELDS.has(path[2] ?? "");
 }
 function isPlainObject$5(value) {
@@ -28269,7 +28342,7 @@ async function writeMediaArtifact(input) {
 	const callId = safePathSegment(input.callId ?? defaultCallId(), "call");
 	const filename = safeFilename(input.suggestedFilename ?? (input.outputPath ? basename(input.outputPath) : "response.bin"));
 	const target = input.outputPath ? assertInsideRoot(rootDir, input.outputPath) : assertInsideRoot(rootDir, resolve(rootDir, capletId, callId, filename));
-	rejectSymlinkPathComponents(rootDir, target, true);
+	rejectSymlinkPathComponents$1(rootDir, target, true);
 	const uriParts = input.outputPath ? uriPartsForOutputPath(rootDir, target) : {
 		capletId,
 		callId,
@@ -28297,7 +28370,7 @@ function resolveMediaArtifact(uri, options = {}) {
 	const parsed = parseArtifactUri(uri);
 	const rootDir = resolve(options.artifactRoot ?? DEFAULT_ARTIFACT_DIR);
 	const path = assertInsideRoot(rootDir, resolve(rootDir, parsed.capletId, parsed.callId, parsed.filename));
-	rejectSymlinkPathComponents(rootDir, path, true);
+	rejectSymlinkPathComponents$1(rootDir, path, true);
 	if (!existsSync(path)) throw new CapletsError("REQUEST_INVALID", "Media artifact was not found");
 	const stat = statSync(path);
 	if (!stat.isFile()) throw new CapletsError("REQUEST_INVALID", "Media artifact must resolve to a file");
@@ -28356,9 +28429,9 @@ function assertInsideRoot(rootDir, candidate) {
 	if (rel.startsWith("..") || isAbsolute(rel)) throw new CapletsError("REQUEST_INVALID", "Media artifact outputPath must stay inside the artifact root");
 	return resolved;
 }
-function rejectSymlinkPathComponents(rootDir, target, includeTarget) {
+function rejectSymlinkPathComponents$1(rootDir, target, includeTarget) {
 	const resolvedRoot = resolve(rootDir);
-	rejectSymlinkRoot(resolvedRoot);
+	rejectSymlinkRoot$1(resolvedRoot);
 	const parts = relative(resolvedRoot, resolve(target)).split(/[\\/]+/u).filter(Boolean);
 	let current = resolvedRoot;
 	const limit = includeTarget ? parts.length : Math.max(0, parts.length - 1);
@@ -28373,7 +28446,7 @@ function rejectSymlinkPathComponents(rootDir, target, includeTarget) {
 		}
 	}
 }
-function rejectSymlinkRoot(rootDir) {
+function rejectSymlinkRoot$1(rootDir) {
 	try {
 		if (lstatSync(rootDir).isSymbolicLink()) throw new CapletsError("REQUEST_INVALID", "Media artifact root must not be a symlink");
 	} catch (error) {
@@ -63362,7 +63435,7 @@ var CapletsEngine = class {
 		}
 	}
 	async completeCliWords(words) {
-		const { completeCliWords } = await import("./completion-BC4BNWo0.js").then((n) => n.r);
+		const { completeCliWords } = await import("./completion-BeVXdm9q.js").then((n) => n.r);
 		return await completeCliWords(words, {
 			config: this.registry.config,
 			managers: {
@@ -63670,11 +63743,12 @@ function isRecord$2(value) {
 }
 //#endregion
 //#region src/code-mode/runtime-api.generated.ts
-const CODE_MODE_RUNTIME_API_DECLARATION = "type JsonPrimitive=string|number|boolean|null;type JsonValue=JsonPrimitive|JsonValue[]|{[key:string]:JsonValue};interface CapletHandle<Id extends string>{readonly id:Id;/** Show this Caplet card,without tool/resource/prompt schemas. */ inspect():Promise<CapletCard<Id>>;/** Check backend readiness/auth;expected unavailable states return ok:false. */ check():Promise<CapletsResult<BackendCheckResult>>;/** List tool summaries for the discovery pass;may be empty. */ tools(input?:PageInput):Promise<Page<ToolSummary>>;/** Search tool summaries for the discovery pass;may be empty. */ searchTools(query:string,input?:PageInput):Promise<Page<ToolSummary>>;/** Get schema,callSignature,types,examples;prefer outputSchema/outputTypeScript over observed hints. */ describeTool(name:string):Promise<CapletsResult<ToolDescriptor>>;/** Call one tool;expected failures return ok:false. Filter bulky data in script before returning. */ callTool(name:string,args?:unknown):Promise<CapletsResult<unknown>>;/** List readable resources for the discovery pass;many backends expose none. */ resources(input?:PageInput):Promise<Page<ResourceSummary>>;/** Search readable resources for the discovery pass;many backends expose none. */ searchResources(query:string,input?:PageInput):Promise<Page<ResourceSummary>>;/** List resource templates for the discovery pass;many backends expose none. */ resourceTemplates(input?:PageInput):Promise<Page<ResourceTemplateSummary>>;/** Read one resource by URI;unsupported/missing resources return ok:false. */ readResource(uri:string):Promise<CapletsResult<ResourceReadResult>>;/** List reusable prompts for the discovery pass;many backends expose none. */ prompts(input?:PageInput):Promise<Page<PromptSummary>>;/** Search reusable prompts for the discovery pass;many backends expose none. */ searchPrompts(query:string,input?:PageInput):Promise<Page<PromptSummary>>;/** Get one prompt by name and args;unsupported/missing prompts return ok:false. */ getPrompt(name:string,args?:unknown):Promise<CapletsResult<PromptResult>>;/** Complete a prompt or resource-template argument. */ complete(input:CompleteInput):Promise<CapletsResult<CompleteResult>>;}interface DebugApi{readLogs(input:ReadLogsInput):Promise<ReadLogsResult>;}type CapletCard<Id extends string>={id:Id;name:string;description:string;useWhen?:string;avoidWhen?:string;tags?:string[];backend?:unknown;};type PageInput={limit?:number;cursor?:string};type Page<T>={items:T[];nextCursor?:string;truncated?:boolean};type CapletsResult<T>=|{ok:true;data:T;meta?:CapletsMeta}|{ok:false;error:CapletsError;meta?:CapletsMeta};type CapletsMeta={[key:string]:unknown};type CapletsError={code:string;message:string;details?:unknown};type BackendCheckResult=unknown;type ToolSummary={/** Exact downstream tool identifier for describeTool(name)and callTool(name,args). */ name:string;title?:string;description?:string;/** Optional author-supplied hint for when to prefer this tool. */ useWhen?:string;/** Optional author-supplied hint for when to avoid this tool. */ avoidWhen?:string;/** True when the tool declares that it only reads data. */ readOnlyHint?:boolean;/** True when the tool declares that it may perform destructive writes. */ destructiveHint?:boolean;};type ToolDescriptor={id?:string;tool?:unknown;inputSchema?:unknown;outputSchema?:unknown;callSignature?:string;inputTypeScript?:string;outputTypeScript?:string;observedOutputShape?:ObservedOutputShape;examples?:unknown[];};type ObservedOutputShape={version:1;source:\"observed\";observedAt:string;sampleCount:number;typeScript:string;jsonShape:JsonShape;truncated:boolean;};type JsonShape=|{kind:\"null\"}|{kind:\"boolean\"}|{kind:\"number\"}|{kind:\"string\"}|{kind:\"unknown\"}|{kind:\"array\";element?:JsonShape;truncated?:boolean}|{kind:\"object\";fields:Record<string,{optional:boolean;shape:JsonShape}>;truncated?:boolean;}|{kind:\"union\";variants:JsonShape[]};type ResourceSummary={uri?:string;name?:string;title?:string;description?:string};type ResourceTemplateSummary={uriTemplate?:string;name?:string;title?:string;description?:string;};type ResourceReadResult=unknown;type PromptSummary={name?:string;title?:string;description?:string};type PromptResult=unknown;type CompleteInput={ref:{type:\"prompt\";name:string}|{type:\"resourceTemplate\";uri:string};argument:{name:string;value:string};};type CompleteResult=unknown;type ReadLogsInput={logRef:string;cursor?:string;limit?:number};type ReadLogsResult={entries:CodeModeLogEntry[];nextCursor?:string};type CodeModeLogEntry={level:\"log\"|\"info\"|\"warn\"|\"error\"|\"debug\";message:string;timestamp:string;};interface Console{log(...values:unknown[]):void;info(...values:unknown[]):void;warn(...values:unknown[]):void;error(...values:unknown[]):void;debug(...values:unknown[]):void;}declare const console:Console;";
+const CODE_MODE_RUNTIME_API_DECLARATION = "type JsonPrimitive=string|number|boolean|null;type JsonValue=JsonPrimitive|JsonValue[]|{[key:string]:JsonValue};interface CapletHandle<Id extends string>{readonly id:Id;/** Show this Caplet card,without tool/resource/prompt schemas. */ inspect():Promise<CapletCard<Id>>;/** Check backend readiness/auth;expected unavailable states return ok:false. */ check():Promise<CapletsResult<BackendCheckResult>>;/** List tool summaries for the discovery pass;may be empty. */ tools(input?:PageInput):Promise<Page<ToolSummary>>;/** Search tool summaries for the discovery pass;may be empty. */ searchTools(query:string,input?:PageInput):Promise<Page<ToolSummary>>;/** Get schema,callSignature,types,examples;prefer outputSchema/outputTypeScript over observed hints. */ describeTool(name:string):Promise<CapletsResult<ToolDescriptor>>;/** Call one tool;expected failures return ok:false. Filter bulky data in script before returning. */ callTool(name:string,args?:unknown):Promise<CapletsResult<unknown>>;/** List readable resources for the discovery pass;many backends expose none. */ resources(input?:PageInput):Promise<Page<ResourceSummary>>;/** Search readable resources for the discovery pass;many backends expose none. */ searchResources(query:string,input?:PageInput):Promise<Page<ResourceSummary>>;/** List resource templates for the discovery pass;many backends expose none. */ resourceTemplates(input?:PageInput):Promise<Page<ResourceTemplateSummary>>;/** Read one resource by URI;unsupported/missing resources return ok:false. */ readResource(uri:string):Promise<CapletsResult<ResourceReadResult>>;/** List reusable prompts for the discovery pass;many backends expose none. */ prompts(input?:PageInput):Promise<Page<PromptSummary>>;/** Search reusable prompts for the discovery pass;many backends expose none. */ searchPrompts(query:string,input?:PageInput):Promise<Page<PromptSummary>>;/** Get one prompt by name and args;unsupported/missing prompts return ok:false. */ getPrompt(name:string,args?:unknown):Promise<CapletsResult<PromptResult>>;/** Complete a prompt or resource-template argument. */ complete(input:CompleteInput):Promise<CapletsResult<CompleteResult>>;}interface DebugApi{readLogs(input:ReadLogsInput):Promise<ReadLogsResult>;readRecovery(input:ReadCodeModeRecoveryInput):Promise<ReadCodeModeRecoveryResult>;}type CapletCard<Id extends string>={id:Id;name:string;description:string;useWhen?:string;avoidWhen?:string;tags?:string[];backend?:unknown;};type PageInput={limit?:number;cursor?:string};type Page<T>={items:T[];nextCursor?:string;truncated?:boolean};type CapletsResult<T>=|{ok:true;data:T;meta?:CapletsMeta}|{ok:false;error:CapletsError;meta?:CapletsMeta};type CapletsMeta={[key:string]:unknown};type CapletsError={code:string;message:string;details?:unknown};type BackendCheckResult=unknown;type ToolSummary={/** Exact downstream tool identifier for describeTool(name)and callTool(name,args). */ name:string;title?:string;description?:string;/** Optional author-supplied hint for when to prefer this tool. */ useWhen?:string;/** Optional author-supplied hint for when to avoid this tool. */ avoidWhen?:string;/** True when the tool declares that it only reads data. */ readOnlyHint?:boolean;/** True when the tool declares that it may perform destructive writes. */ destructiveHint?:boolean;};type ToolDescriptor={id?:string;tool?:unknown;inputSchema?:unknown;outputSchema?:unknown;callSignature?:string;inputTypeScript?:string;outputTypeScript?:string;observedOutputShape?:ObservedOutputShape;examples?:unknown[];};type ObservedOutputShape={version:1;source:\"observed\";observedAt:string;sampleCount:number;typeScript:string;jsonShape:JsonShape;truncated:boolean;};type JsonShape=|{kind:\"null\"}|{kind:\"boolean\"}|{kind:\"number\"}|{kind:\"string\"}|{kind:\"unknown\"}|{kind:\"array\";element?:JsonShape;truncated?:boolean}|{kind:\"object\";fields:Record<string,{optional:boolean;shape:JsonShape}>;truncated?:boolean;}|{kind:\"union\";variants:JsonShape[]};type ResourceSummary={uri?:string;name?:string;title?:string;description?:string};type ResourceTemplateSummary={uriTemplate?:string;name?:string;title?:string;description?:string;};type ResourceReadResult=unknown;type PromptSummary={name?:string;title?:string;description?:string};type PromptResult=unknown;type CompleteInput={ref:{type:\"prompt\";name:string}|{type:\"resourceTemplate\";uri:string};argument:{name:string;value:string};};type CompleteResult=unknown;type ReadLogsInput={logRef:string;cursor?:string;limit?:number};type ReadLogsResult={entries:CodeModeLogEntry[];nextCursor?:string};type ReadCodeModeRecoveryInput={recoveryRef:string;cursor?:string;limit?:number};type CodeModeDiagnostic={code:string;message:string;severity:\"error\"|\"warning\"|\"info\";line?:number;column?:number;};type CodeModeRecoveryClassification=\"setup_like\"|\"side_effecting\"|\"unknown\";type CodeModeRecoveryEntry={timestamp:string;code:string;declarationHash:string;outcome:{ok:true}|{ok:false;code:string;message:string};diagnostics:Array<Pick<CodeModeDiagnostic,\"code\"|\"severity\"|\"message\">>;recoveryClassification:CodeModeRecoveryClassification;logsStored?:boolean;summary?:string;};type ReadCodeModeRecoveryResult={entries:CodeModeRecoveryEntry[];nextCursor?:string};type CodeModeLogEntry={level:\"log\"|\"info\"|\"warn\"|\"error\"|\"debug\";message:string;timestamp:string;};type CodeModeSessionStatus=\"created\"|\"reused\";type CodeModeRunMeta={runId:string;traceId:string;declarationHash:string;durationMs:number;timeoutMs:number;maxTimeoutMs:number;sessionId?:string|null;sessionStatus?:CodeModeSessionStatus|null;recoveryRef?:string|null;};interface Console{log(...values:unknown[]):void;info(...values:unknown[]):void;warn(...values:unknown[]):void;error(...values:unknown[]):void;debug(...values:unknown[]):void;}declare const console:Console;";
 //#endregion
 //#region src/code-mode/declarations.ts
 const JS_IDENTIFIER = /^[A-Za-z_$][\w$]*$/u;
 const MAX_JSDOC_CHARS = 180;
+const CODE_MODE_REPL_GUIDANCE = "REPL reuse: omit `sessionId` to start a fresh reusable Code Mode session; after a successful run, keep `meta.sessionId` and pass it as `sessionId` on later calls when you want to reuse live state. Reused sessions preserve successful top-level `var` bindings, function declarations, and runtime state only while the live session remains available and compatible. A supplied `sessionId` that is unknown or no longer available fails before executing your code instead of starting an empty context. Use `meta.recoveryRef` with `caplets.debug.readRecovery({ recoveryRef })` for audit and manual reconstruction; do not automatically replay recovery history.";
 function generateCodeModeDeclarations(input) {
 	const caplets = [...input.caplets].sort((left, right) => left.id.localeCompare(right.id));
 	const properties = caplets.map((caplet) => {
@@ -63694,6 +63768,7 @@ function generateCodeModeDeclarations(input) {
 function generateCodeModeRunToolDescription(declaration) {
 	return [
 		"Run TypeScript with generated `caplets.<id>` handles and declaration hints below. Prefer a compact one-pass script for most tasks: discover, filter, execute, and synthesize inside Code Mode, then return only decision-ready JSON. Do not return full tool lists, full descriptors, schemas, raw tool payloads, or exploratory transcripts unless the user specifically needs them; keep bulky intermediate data inside the script. For discovery, use tools/searchTools for names and arg hints, then describeTool only for short-listed operations needing exact schemas, nested args, fields, or disambiguation. Never invent tool names, resource URIs, prompt names, input args, output fields, or schemas; use requiredArgs/acceptedArgs for simple calls, otherwise use describeTool for the exact callSignature/inputSchema/inputTypeScript. For fallback, check candidate handles first: `for(const h of candidates){const ready=await h.check();if(!ready.ok)continue;}`. For triage, list broad candidate records and filter in script before targeted searches so adjacent relevant items are not missed. Execute with exact args, handle `{ok:false}`, and derive final recommendations from all relevant records, not the first matching record. If records disagree or have ranges/statuses, compute the strictest applicable conclusion and preserve only the compact evidence used. Return summaries, key ids/names/titles/statuses/urls, derived fields, recommendation, caveats, and residual missing data. Before returning, remove unused descriptors/schemas/raw content. Pattern: `const h=caplets[\"caplet-id\"];const tools=await h.searchTools(\"query\");const d=needSchema?await h.describeTool(\"tool_name\"):undefined;const r=await h.callTool(\"tool_name\",args);return {facts:[...],evidence:[...]};`",
+		CODE_MODE_REPL_GUIDANCE,
 		"",
 		"Generated declaration hints:",
 		"```ts",
@@ -63756,8 +63831,8 @@ function fnv1a32(value, seed) {
 //#endregion
 //#region src/code-mode/logs.ts
 const DEFAULT_LOG_REF_TTL_MS = 3600 * 1e3;
-const DEFAULT_PAGE_LIMIT = 100;
-const MAX_PAGE_LIMIT = 500;
+const DEFAULT_PAGE_LIMIT$1 = 100;
+const MAX_PAGE_LIMIT$1 = 500;
 const SECRET_KEY_VALUE_PATTERN = /\b(?:authorization|cookie|set-cookie|password|passphrase|secret|token|api[-_]?key|clientsecret|client_secret|privatekey|private_key|credential|refreshToken|accessToken)\b\s*[:=]\s*([^\s,;]+)/giu;
 const BEARER_PATTERN = /\bbearer\s+([a-z0-9._~+/=-]{8,})/giu;
 const BASIC_PATTERN = /\bbasic\s+([a-z0-9._~+/=-]{8,})/giu;
@@ -63798,8 +63873,8 @@ var CodeModeLogStore = class {
 		if (!existsSync(path)) return { entries: [] };
 		const parsed = parseStoredLogs(readFileSync(path, "utf8"));
 		if (!parsed || new Date(parsed.expiresAt).getTime() <= this.now().getTime()) return { entries: [] };
-		const offset = parseCursor(input.cursor);
-		const limit = Math.min(Math.max(input.limit ?? DEFAULT_PAGE_LIMIT, 0), MAX_PAGE_LIMIT);
+		const offset = parseCursor$1(input.cursor);
+		const limit = Math.min(Math.max(input.limit ?? DEFAULT_PAGE_LIMIT$1, 0), MAX_PAGE_LIMIT$1);
 		const entries = parsed.entries.slice(offset, offset + limit).map(redactEntry);
 		const nextOffset = offset + entries.length;
 		return nextOffset < parsed.entries.length ? {
@@ -63823,7 +63898,7 @@ function redactEntry(entry) {
 		message: redactCodeModeLogText(entry.message)
 	};
 }
-function parseCursor(cursor) {
+function parseCursor$1(cursor) {
 	if (!cursor) return 0;
 	const parsed = Number.parseInt(cursor, 10);
 	return Number.isFinite(parsed) && parsed > 0 ? parsed : 0;
@@ -63847,6 +63922,373 @@ function isLogEntry(value) {
 	return (entry.level === "log" || entry.level === "info" || entry.level === "warn" || entry.level === "error" || entry.level === "debug") && typeof entry.message === "string" && typeof entry.timestamp === "string";
 }
 //#endregion
+//#region src/code-mode/journal.ts
+const DEFAULT_JOURNAL_RETENTION_MS = 10080 * 60 * 1e3;
+const DEFAULT_MAX_ENTRIES = 100;
+const DEFAULT_MAX_CODE_BYTES = 64 * 1024;
+const DEFAULT_MAX_SUMMARY_BYTES = 16 * 1024;
+const DEFAULT_PAGE_LIMIT = 25;
+const MAX_PAGE_LIMIT = 100;
+const JOURNAL_VERSION = 1;
+var CodeModeJournalStore = class {
+	stateDir;
+	now;
+	retentionMs;
+	maxEntries;
+	maxCodeBytes;
+	maxSummaryBytes;
+	configuredSecret;
+	secret;
+	recoveryRefs = /* @__PURE__ */ new Map();
+	sessionRecoveryRefs = /* @__PURE__ */ new Map();
+	nextPruneAt = 0;
+	constructor(options = {}) {
+		this.stateDir = options.stateDir ?? join(defaultStateBaseDir(), "caplets");
+		this.now = options.now ?? (() => /* @__PURE__ */ new Date());
+		this.retentionMs = options.retentionMs ?? DEFAULT_JOURNAL_RETENTION_MS;
+		this.maxEntries = options.maxEntries ?? DEFAULT_MAX_ENTRIES;
+		this.maxCodeBytes = options.maxCodeBytes ?? DEFAULT_MAX_CODE_BYTES;
+		this.maxSummaryBytes = options.maxSummaryBytes ?? DEFAULT_MAX_SUMMARY_BYTES;
+		this.configuredSecret = options.secret;
+	}
+	async store(input) {
+		this.ensureJournalDir();
+		this.pruneExpired();
+		const now = this.now();
+		const expiresAt = new Date(now.getTime() + this.retentionMs).toISOString();
+		const journalKey = this.journalKey(input.sessionId, input.journalScope);
+		const recoveryRef = this.recoveryRefs.get(journalKey) ?? this.recoveryRefForJournalKey(journalKey);
+		this.recoveryRefs.set(journalKey, recoveryRef);
+		this.sessionRecoveryRefs.set(input.sessionId, {
+			recoveryRef,
+			expiresAt
+		});
+		const recoveryRefHash = this.recoveryRefHash(recoveryRef);
+		const path = this.journalPath(journalKey);
+		const existing = this.readJournalPath(path);
+		const entry = this.entryFromInput(input, now, recoveryRef);
+		const stored = {
+			version: JOURNAL_VERSION,
+			journalKey,
+			sessionIdHash: this.sessionIdHash(input.sessionId),
+			recoveryRefHashes: [...new Set([...existing?.recoveryRefHashes ?? [], recoveryRefHash])],
+			createdAt: existing?.createdAt ?? now.toISOString(),
+			updatedAt: now.toISOString(),
+			expiresAt,
+			entries: [...existing?.entries ?? [], entry].slice(-this.maxEntries)
+		};
+		this.writeJournal(path, stored);
+		this.writeIndex(this.recoveryIndexPath(recoveryRefHash), stored);
+		this.writeIndex(this.sessionIndexPath(stored.sessionIdHash), stored);
+		return {
+			recoveryRef,
+			expiresAt,
+			journalKey
+		};
+	}
+	async lookupSession(sessionId) {
+		this.ensureJournalDir();
+		this.pruneExpired();
+		const retained = this.sessionRecoveryRefs.get(sessionId);
+		if (retained && new Date(retained.expiresAt).getTime() > this.now().getTime()) return retained;
+		const scopedJournal = this.findBySessionIdHash(this.sessionIdHash(sessionId));
+		if (scopedJournal && !this.isExpired(scopedJournal)) return {
+			expiresAt: scopedJournal.expiresAt,
+			recoveryRef: this.recoveryRefForJournalKey(scopedJournal.journalKey)
+		};
+		const journal = this.readJournalPath(this.journalPath(this.journalKey(sessionId)));
+		if (!journal || this.isExpired(journal)) return void 0;
+		return { expiresAt: journal.expiresAt };
+	}
+	async lookupRecoveryRef(recoveryRef) {
+		if (!isRecoveryRef(recoveryRef)) return void 0;
+		this.ensureJournalDir();
+		this.pruneExpired();
+		const journal = this.findByRecoveryRefHash(this.recoveryRefHash(recoveryRef));
+		if (!journal || this.isExpired(journal)) return void 0;
+		return { expiresAt: journal.expiresAt };
+	}
+	async readRecovery(input) {
+		if (!isRecoveryRef(input.recoveryRef)) return { entries: [] };
+		this.ensureJournalDir();
+		this.pruneExpired();
+		const recoveryRefHash = this.recoveryRefHash(input.recoveryRef);
+		const journal = this.findByRecoveryRefHash(recoveryRefHash);
+		if (!journal || this.isExpired(journal)) return { entries: [] };
+		const offset = parseCursor(input.cursor);
+		if (input.limit !== void 0 && input.limit <= 0) return { entries: [] };
+		const limit = Math.min(Math.max(input.limit ?? DEFAULT_PAGE_LIMIT, 0), MAX_PAGE_LIMIT);
+		const entries = journal.entries.slice(offset, offset + limit);
+		const nextOffset = offset + entries.length;
+		return nextOffset < journal.entries.length ? {
+			entries,
+			nextCursor: String(nextOffset)
+		} : { entries };
+	}
+	entryFromInput(input, now, recoveryRef) {
+		const exactSecrets = [
+			input.sessionId,
+			recoveryRef,
+			input.logRef
+		].filter((value) => Boolean(value));
+		return {
+			timestamp: now.toISOString(),
+			code: truncateUtf8(redactJournalText(input.code, exactSecrets), this.maxCodeBytes),
+			declarationHash: input.declarationHash,
+			outcome: input.outcome.ok === true ? { ok: true } : {
+				ok: false,
+				code: input.outcome.code,
+				message: truncateUtf8(redactJournalText(input.outcome.message, exactSecrets), 2e3)
+			},
+			diagnostics: input.diagnostics.map((diagnostic) => ({
+				code: diagnostic.code,
+				severity: diagnostic.severity,
+				message: truncateUtf8(redactJournalText(diagnostic.message, exactSecrets), 2e3)
+			})),
+			recoveryClassification: input.recoveryClassification,
+			...input.logRef ? { logsStored: true } : {},
+			...input.summary ? { summary: truncateUtf8(redactJournalText(input.summary, exactSecrets), this.maxSummaryBytes) } : {}
+		};
+	}
+	findByRecoveryRefHash(recoveryRefHash) {
+		const indexed = this.readIndexPath(this.recoveryIndexPath(recoveryRefHash));
+		if (indexed) return this.readJournalPath(this.journalPath(indexed.journalKey));
+		return this.findByRecoveryRefHashSlow(recoveryRefHash);
+	}
+	findBySessionIdHash(sessionIdHash) {
+		const indexed = this.readIndexPath(this.sessionIndexPath(sessionIdHash));
+		if (indexed) return this.readJournalPath(this.journalPath(indexed.journalKey));
+		return this.findBySessionIdHashSlow(sessionIdHash);
+	}
+	findByRecoveryRefHashSlow(recoveryRefHash) {
+		for (const filename of readdirSync(this.journalDir())) {
+			if (!filename.endsWith(".json")) continue;
+			const journal = this.readJournalPath(join(this.journalDir(), filename));
+			if (journal?.recoveryRefHashes.includes(recoveryRefHash)) return journal;
+		}
+	}
+	findBySessionIdHashSlow(sessionIdHash) {
+		const journals = [];
+		for (const filename of readdirSync(this.journalDir())) {
+			if (!filename.endsWith(".json")) continue;
+			const journal = this.readJournalPath(join(this.journalDir(), filename));
+			if (journal?.sessionIdHash === sessionIdHash) journals.push(journal);
+		}
+		return journals.sort((left, right) => new Date(right.updatedAt).getTime() - new Date(left.updatedAt).getTime())[0];
+	}
+	writeIndex(path, journal) {
+		const index = {
+			version: JOURNAL_VERSION,
+			journalKey: journal.journalKey,
+			updatedAt: journal.updatedAt
+		};
+		rejectSymlinkPathComponents(this.journalDir(), path, true);
+		mkdirSync(dirname(path), {
+			recursive: true,
+			mode: 448
+		});
+		chmodSync(dirname(path), 448);
+		const tempPath = `${path}.${randomBytes(8).toString("hex")}.tmp`;
+		writeFileSync(tempPath, `${JSON.stringify(index, null, 2)}\n`, { mode: 384 });
+		chmodSync(tempPath, 384);
+		renameSync(tempPath, path);
+		chmodSync(path, 384);
+	}
+	readIndexPath(path) {
+		try {
+			rejectSymlinkPathComponents(this.journalDir(), path, true);
+			if (!existsSync(path)) return void 0;
+			const parsed = JSON.parse(readFileSync(path, "utf8"));
+			if (parsed.version !== JOURNAL_VERSION || typeof parsed.journalKey !== "string" || typeof parsed.updatedAt !== "string") return;
+			return {
+				version: JOURNAL_VERSION,
+				journalKey: parsed.journalKey,
+				updatedAt: parsed.updatedAt
+			};
+		} catch {
+			return;
+		}
+	}
+	readJournalPath(path) {
+		try {
+			rejectSymlinkPathComponents(this.journalDir(), path, true);
+			if (!existsSync(path)) return void 0;
+			const parsed = JSON.parse(readFileSync(path, "utf8"));
+			if (parsed.version !== JOURNAL_VERSION || typeof parsed.journalKey !== "string" || !Array.isArray(parsed.recoveryRefHashes) || typeof parsed.createdAt !== "string" || typeof parsed.updatedAt !== "string" || typeof parsed.expiresAt !== "string" || !Array.isArray(parsed.entries)) return;
+			return {
+				version: JOURNAL_VERSION,
+				journalKey: parsed.journalKey,
+				...typeof parsed.sessionIdHash === "string" ? { sessionIdHash: parsed.sessionIdHash } : {},
+				recoveryRefHashes: parsed.recoveryRefHashes.filter((hash) => typeof hash === "string"),
+				createdAt: parsed.createdAt,
+				updatedAt: parsed.updatedAt,
+				expiresAt: parsed.expiresAt,
+				entries: parsed.entries.filter(isJournalEntry)
+			};
+		} catch {
+			return;
+		}
+	}
+	writeJournal(path, journal) {
+		rejectSymlinkPathComponents(this.journalDir(), path, true);
+		mkdirSync(dirname(path), {
+			recursive: true,
+			mode: 448
+		});
+		chmodSync(dirname(path), 448);
+		const tempPath = `${path}.${randomBytes(8).toString("hex")}.tmp`;
+		writeFileSync(tempPath, `${JSON.stringify(journal, null, 2)}\n`, { mode: 384 });
+		chmodSync(tempPath, 384);
+		renameSync(tempPath, path);
+		chmodSync(path, 384);
+	}
+	pruneExpired() {
+		const dir = this.journalDir();
+		if (!existsSync(dir)) return;
+		const now = this.now().getTime();
+		if (now < this.nextPruneAt) return;
+		this.nextPruneAt = now + 6e4;
+		for (const filename of readdirSync(dir)) {
+			if (!filename.endsWith(".json")) continue;
+			const path = join(dir, filename);
+			const journal = this.readJournalPath(path);
+			if (!journal || this.isExpired(journal)) rmSync(path, { force: true });
+		}
+	}
+	isExpired(journal) {
+		return new Date(journal.expiresAt).getTime() <= this.now().getTime();
+	}
+	journalKey(sessionId, journalScope = "default") {
+		return this.hmac(`journal:${sessionId}:${journalScope}`);
+	}
+	recoveryRefHash(recoveryRef) {
+		return this.hmac(`recovery-ref:${recoveryRef}`);
+	}
+	recoveryRefForJournalKey(journalKey) {
+		return this.hmac(`recovery-ref-material:${journalKey}`).slice(0, 48);
+	}
+	sessionIdHash(sessionId) {
+		return this.hmac(`session-id:${sessionId}`);
+	}
+	hmac(value) {
+		return createHmac("sha256", this.loadSecret()).update(value).digest("hex");
+	}
+	loadSecret() {
+		if (this.configuredSecret) return this.configuredSecret;
+		if (this.secret) return this.secret;
+		this.ensureJournalDir();
+		const path = this.secretPath();
+		rejectSymlinkPathComponents(this.journalDir(), path, true);
+		if (existsSync(path)) {
+			this.secret = readFileSync(path, "utf8").trim();
+			return this.secret;
+		}
+		this.secret = randomBytes(32).toString("hex");
+		writeFileSync(path, `${this.secret}\n`, { mode: 384 });
+		chmodSync(path, 384);
+		return this.secret;
+	}
+	ensureJournalDir() {
+		const dir = this.journalDir();
+		rejectSymlinkRoot(resolve(this.stateDir));
+		rejectSymlinkPathComponents(resolve(this.stateDir), dir, true);
+		mkdirSync(dir, {
+			recursive: true,
+			mode: 448
+		});
+		rejectSymlinkPathComponents(resolve(this.stateDir), dir, true);
+		chmodSync(dir, 448);
+	}
+	journalDir() {
+		return join(this.stateDir, "code-mode", "journal");
+	}
+	journalPath(journalKey) {
+		return join(this.journalDir(), `${journalKey}.json`);
+	}
+	recoveryIndexPath(recoveryRefHash) {
+		return join(this.journalDir(), "recovery-index", `${recoveryRefHash}.json`);
+	}
+	sessionIndexPath(sessionIdHash) {
+		return join(this.journalDir(), "session-index", `${sessionIdHash ?? "unknown"}.json`);
+	}
+	secretPath() {
+		return join(this.journalDir(), "secret.key");
+	}
+};
+function classifyCodeModeRecovery(input) {
+	if (input.invokedCaplet) return "side_effecting";
+	if (input.sessionDisposedAfterRun) return "unknown";
+	return /\b(?:function|var|let|const|class)\b/u.test(input.code) ? "setup_like" : "unknown";
+}
+function isRecoveryRef(value) {
+	return /^[a-f0-9]{48}$/u.test(value);
+}
+function parseCursor(cursor) {
+	if (!cursor) return 0;
+	const parsed = Number.parseInt(cursor, 10);
+	return Number.isFinite(parsed) && parsed > 0 ? parsed : 0;
+}
+function truncateUtf8(value, maxBytes) {
+	let bytes = 0;
+	let output = "";
+	for (const char of value) {
+		const next = Buffer.byteLength(char, "utf8");
+		if (bytes + next > maxBytes) break;
+		output += char;
+		bytes += next;
+	}
+	return output;
+}
+function redactJournalText(text, exactSecrets) {
+	let redacted = redactCodeModeLogText(text);
+	for (const secret of exactSecrets) {
+		if (!secret) continue;
+		redacted = redacted.replaceAll(secret, "[REDACTED:capability]");
+	}
+	return redacted.replace(/\b[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\b/giu, "[REDACTED:capability]");
+}
+function isJournalEntry(value) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+	const entry = value;
+	return typeof entry.timestamp === "string" && typeof entry.code === "string" && typeof entry.declarationHash === "string" && isJournalOutcome(entry.outcome) && Array.isArray(entry.diagnostics) && entry.diagnostics.every(isJournalDiagnostic) && (entry.recoveryClassification === "setup_like" || entry.recoveryClassification === "side_effecting" || entry.recoveryClassification === "unknown") && (entry.logsStored === void 0 || typeof entry.logsStored === "boolean") && (entry.summary === void 0 || typeof entry.summary === "string");
+}
+function isJournalOutcome(value) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+	const outcome = value;
+	return outcome.ok === true || outcome.ok === false && typeof outcome.code === "string";
+}
+function isJournalDiagnostic(value) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+	const diagnostic = value;
+	return typeof diagnostic.code === "string" && typeof diagnostic.message === "string" && (diagnostic.severity === "error" || diagnostic.severity === "warning" || diagnostic.severity === "info");
+}
+function rejectSymlinkPathComponents(rootDir, target, includeTarget) {
+	const resolvedRoot = resolve(rootDir);
+	rejectSymlinkRoot(resolvedRoot);
+	const rel = relative(resolvedRoot, resolve(target));
+	if (rel.startsWith("..") || rel === "") return;
+	const parts = rel.split(/[\\/]+/u).filter(Boolean);
+	let current = resolvedRoot;
+	const limit = includeTarget ? parts.length : Math.max(0, parts.length - 1);
+	for (let index = 0; index < limit; index += 1) {
+		current = resolve(current, parts[index]);
+		try {
+			if (lstatSync(current).isSymbolicLink()) throw new Error("Code Mode journal path must not contain symlinks.");
+		} catch (error) {
+			if (error.code === "ENOENT") return;
+			throw error;
+		}
+	}
+}
+function rejectSymlinkRoot(rootDir) {
+	try {
+		if (lstatSync(rootDir).isSymbolicLink()) throw new Error("Code Mode journal root must not be a symlink.");
+	} catch (error) {
+		if (error.code === "ENOENT") return;
+		throw error;
+	}
+}
+//#endregion
 //#region src/code-mode/api.ts
 const MAX_TOOL_TEXT_CHARS = 2e3;
 const MAX_ERROR_MESSAGE_CHARS = 1e3;
@@ -63870,7 +64312,10 @@ function dedupeCallableCaplets(caplets) {
 function createCodeModeCapletsApi(input) {
 	const api = {};
 	for (const caplet of listCodeModeCallableCaplets(input.service)) api[caplet.id] = createHandle(input.service, caplet.id);
-	const debugApi = { readLogs: input.readLogs ?? defaultReadLogs };
+	const debugApi = {
+		readLogs: input.readLogs ?? defaultReadLogs,
+		readRecovery: input.readRecovery ?? defaultReadRecovery
+	};
 	api.debug = "debug" in api ? Object.assign(api.debug, debugApi) : debugApi;
 	return api;
 }
@@ -64199,6 +64644,9 @@ async function defaultReadLogs() {
 		timestamp: (/* @__PURE__ */ new Date(0)).toISOString()
 	}] };
 }
+async function defaultReadRecovery() {
+	return { entries: [] };
+}
 function resultIsError(result) {
 	if (!isPlainObject$1(result)) return false;
 	if (result.isError === true) return true;
@@ -77011,18 +77459,7 @@ function diagnoseCodeModeTypeScript(input) {
 	const startedAt = Date.now();
 	const diagnostics = [...preflightDiagnostics(input.code)];
 	if (diagnostics.length >= maxDiagnostics) return diagnostics.slice(0, maxDiagnostics);
-	const compilerOptions = {
-		target: ts.ScriptTarget.ES2022,
-		module: ts.ModuleKind.ESNext,
-		moduleResolution: ts.ModuleResolutionKind.Bundler,
-		lib: ["lib.es2022.d.ts"],
-		types: [],
-		strict: true,
-		noEmit: true,
-		skipLibCheck: true,
-		noErrorTruncation: true,
-		allowJs: false
-	};
+	const compilerOptions = codeModeCompilerOptions();
 	const wrappedCode = [
 		"async function __capletsCodeModeMain(): Promise<unknown> {",
 		input.code,
@@ -77031,7 +77468,7 @@ function diagnoseCodeModeTypeScript(input) {
 	const host = createVirtualCompilerHost(compilerOptions, {
 		[CODE_FILE]: wrappedCode,
 		[DECLARATION_FILE]: input.declaration,
-		[AMBIENT_FILE]: CODE_MODE_DIAGNOSTICS_BUILTINS_DECLARATION
+		[AMBIENT_FILE]: [CODE_MODE_DIAGNOSTICS_BUILTINS_DECLARATION, input.session?.declaration() ?? ""].join("\n")
 	});
 	const program = ts.createProgram([
 		CODE_FILE,
@@ -77062,6 +77499,172 @@ function diagnoseCodeModeTypeScript(input) {
 	}
 	return diagnostics.slice(0, maxDiagnostics);
 }
+function codeModeCompilerOptions() {
+	return {
+		target: ts.ScriptTarget.ES2022,
+		module: ts.ModuleKind.ESNext,
+		moduleResolution: ts.ModuleResolutionKind.Bundler,
+		lib: ["lib.es2022.d.ts"],
+		types: [],
+		strict: true,
+		noEmit: true,
+		skipLibCheck: true,
+		noErrorTruncation: true,
+		allowJs: false
+	};
+}
+var CodeModeDiagnosticsSession = class {
+	#declarations = /* @__PURE__ */ new Map();
+	declaration() {
+		return [...this.#declarations.values()].join("\n");
+	}
+	recordSuccessfulCell(code, declaration = "") {
+		const source = ts.createSourceFile("/caplets-code-mode/session-cell.ts", code, ts.ScriptTarget.ES2022, true);
+		const compilerOptions = codeModeCompilerOptions();
+		const ambientDeclarations = [
+			CODE_MODE_DIAGNOSTICS_BUILTINS_DECLARATION,
+			declaration,
+			this.declaration()
+		].join("\n");
+		const host = createVirtualCompilerHost(compilerOptions, {
+			[CODE_FILE]: code,
+			[AMBIENT_FILE]: ambientDeclarations
+		});
+		const program = ts.createProgram([CODE_FILE, AMBIENT_FILE], compilerOptions, host);
+		const checker = program.getTypeChecker();
+		const programSource = program.getSourceFile(CODE_FILE) ?? source;
+		for (const statement of programSource.statements) if (ts.isFunctionDeclaration(statement) && statement.name) {
+			const typeParameters = statement.typeParameters ? `<${statement.typeParameters.map((typeParameter) => typeParameter.getText(programSource)).join(", ")}>` : "";
+			const params = statement.parameters.map((parameter) => ambientParameter(parameter, programSource));
+			const signature = checker.getSignatureFromDeclaration(statement);
+			const inferredReturnType = signature ? safeAmbientFunctionReturnType(checker.getReturnTypeOfSignature(signature), checker, ambientDeclarations) : "unknown";
+			const returnType = statement.type ? statement.type.getText(programSource) : inferredReturnType;
+			this.#declarations.set(statement.name.text, `declare function ${statement.name.text}${typeParameters}(${params.join(", ")}): ${returnType};`);
+		}
+		const previousBindingNames = new Set(this.#declarations.keys());
+		const assignedNames = collectFunctionScopedAssignedNames(programSource);
+		for (const binding of collectFunctionScopedVarBindings(programSource, checker, {
+			ambientDeclarationFor: (name) => [
+				CODE_MODE_DIAGNOSTICS_BUILTINS_DECLARATION,
+				declaration,
+				this.declarationExcluding(name)
+			].filter(Boolean).join("\n"),
+			assignedNames,
+			previousBindingNames
+		})) this.#declarations.set(binding.name, `declare var ${binding.name}: ${binding.type};`);
+	}
+	clear() {
+		this.#declarations.clear();
+	}
+	declarationExcluding(name) {
+		const declarations = [CODE_MODE_DIAGNOSTICS_BUILTINS_DECLARATION];
+		for (const [declarationName, declaration] of this.#declarations) if (declarationName !== name) declarations.push(declaration);
+		return declarations.join("\n");
+	}
+};
+function collectFunctionScopedVarBindings(source, checker, options) {
+	const bindings = /* @__PURE__ */ new Map();
+	const visit = (node) => {
+		if (node !== source && (ts.isFunctionLike(node) || ts.isClassLike(node))) return;
+		if (ts.isVariableStatement(node)) collectVarDeclarationListBindings(node.declarationList, checker, bindings, options);
+		if ((ts.isForStatement(node) || ts.isForInStatement(node) || ts.isForOfStatement(node)) && node.initializer && ts.isVariableDeclarationList(node.initializer)) collectVarDeclarationListBindings(node.initializer, checker, bindings, options);
+		ts.forEachChild(node, visit);
+	};
+	visit(source);
+	return [...bindings.entries()].map(([name, type]) => ({
+		name,
+		type
+	}));
+}
+function collectVarDeclarationListBindings(declarationList, checker, bindings, options) {
+	if (!((ts.getCombinedNodeFlags(declarationList) & ts.NodeFlags.BlockScoped) === 0)) return;
+	for (const declaration of declarationList.declarations) for (const name of bindingNames$1(declaration.name)) {
+		const type = ambientTypeForBindingName(name, checker, options.ambientDeclarationFor(name.text));
+		if (options.previousBindingNames.has(name.text) && declaration.initializer === void 0 && !options.assignedNames.has(name.text)) continue;
+		bindings.set(name.text, type);
+	}
+}
+function bindingNames$1(name) {
+	if (ts.isIdentifier(name)) return [name];
+	return name.elements.flatMap((element) => {
+		if (ts.isOmittedExpression(element)) return [];
+		return bindingNames$1(element.name);
+	});
+}
+function collectFunctionScopedAssignedNames(source) {
+	const names = /* @__PURE__ */ new Set();
+	const visit = (node) => {
+		if (node !== source && (ts.isFunctionLike(node) || ts.isClassLike(node))) return;
+		if (ts.isBinaryExpression(node) && isAssignmentOperator(node.operatorToken.kind)) collectAssignedBindingNames(node.left, names);
+		if ((ts.isPrefixUnaryExpression(node) || ts.isPostfixUnaryExpression(node)) && (node.operator === ts.SyntaxKind.PlusPlusToken || node.operator === ts.SyntaxKind.MinusMinusToken)) collectAssignedBindingNames(node.operand, names);
+		ts.forEachChild(node, visit);
+	};
+	visit(source);
+	return names;
+}
+function isAssignmentOperator(kind) {
+	return kind >= ts.SyntaxKind.FirstAssignment && kind <= ts.SyntaxKind.LastAssignment;
+}
+function collectAssignedBindingNames(node, names) {
+	if (ts.isIdentifier(node)) {
+		names.add(node.text);
+		return;
+	}
+	if (ts.isPropertyAssignment(node)) {
+		collectAssignedBindingNames(node.initializer, names);
+		return;
+	}
+	if (ts.isShorthandPropertyAssignment(node)) {
+		names.add(node.name.text);
+		return;
+	}
+	if (ts.isSpreadAssignment(node)) {
+		collectAssignedBindingNames(node.expression, names);
+		return;
+	}
+	if (ts.isObjectLiteralExpression(node) || ts.isArrayLiteralExpression(node)) ts.forEachChild(node, (child) => collectAssignedBindingNames(child, names));
+}
+function ambientTypeForBindingName(name, checker, ambientDeclaration) {
+	const type = checker.getTypeAtLocation(name);
+	return safeAmbientType(name.text, type, checker, ambientDeclaration);
+}
+function safeAmbientType(name, type, checker, ambientDeclaration) {
+	return safeAmbientTypeText(type, checker, ambientDeclaration, (typeText) => isSelfContainedAmbientDeclaration(`declare let ${name}: ${typeText};`, ambientDeclaration));
+}
+function safeAmbientFunctionReturnType(type, checker, ambientDeclaration) {
+	return safeAmbientTypeText(type, checker, ambientDeclaration, (typeText) => isSelfContainedAmbientDeclaration(`declare function __caplets_return_probe__(): ${typeText};`, ambientDeclaration));
+}
+function safeAmbientTypeText(type, checker, ambientDeclaration, isSelfContained) {
+	if (isUnsafeAmbientType(type)) return "unknown";
+	const text = checker.typeToString(type, void 0, ts.TypeFormatFlags.NoTruncation | ts.TypeFormatFlags.UseAliasDefinedOutsideCurrentScope | ts.TypeFormatFlags.WriteArrayAsGenericType);
+	if (!text || text === "any" || text === "{}" || text === "never") return "unknown";
+	if (text.length > 500) return "unknown";
+	if (/\bimport\(/u.test(text)) return "unknown";
+	if (!isSelfContained(text)) return "unknown";
+	return text;
+}
+function isUnsafeAmbientType(type) {
+	return Boolean(type.flags & (ts.TypeFlags.Any | ts.TypeFlags.Unknown | ts.TypeFlags.Never));
+}
+function isSelfContainedAmbientDeclaration(candidateDeclaration, ambientDeclaration) {
+	const compilerOptions = codeModeCompilerOptions();
+	const host = createVirtualCompilerHost(compilerOptions, {
+		[CODE_FILE]: candidateDeclaration,
+		[AMBIENT_FILE]: ambientDeclaration
+	});
+	const program = ts.createProgram([CODE_FILE, AMBIENT_FILE], compilerOptions, host);
+	return program.getSemanticDiagnostics(program.getSourceFile(CODE_FILE)).length === 0;
+}
+function ambientParameter(parameter, source) {
+	return `${parameter.dotDotDotToken ? "..." : ""}${parameter.name.getText(source)}${parameter.questionToken || parameter.initializer ? "?" : ""}: ${parameter.type?.getText(source) ?? (parameter.initializer ? inferLiteralType(parameter.initializer) : "unknown")}`;
+}
+function inferLiteralType(initializer) {
+	if (!initializer) return "unknown";
+	if (ts.isNumericLiteral(initializer)) return "number";
+	if (ts.isStringLiteral(initializer)) return "string";
+	if (initializer.kind === ts.SyntaxKind.TrueKeyword || initializer.kind === ts.SyntaxKind.FalseKeyword) return "boolean";
+	return "unknown";
+}
 function preflightDiagnostics(code) {
 	const diagnostics = [];
 	if (!hasExecutableImport(code)) {} else diagnostics.push({
@@ -77192,10 +77795,393 @@ function resolveTimer(context, deferred, fired) {
 const CODE_MODE_PLATFORM_RUNTIME_SOURCE = "(function() {\n	//#region node_modules/.pnpm/@ungap+structured-clone@1.3.1/node_modules/@ungap/structured-clone/esm/deserialize.js\n	const env = typeof self === \"object\" ? self : globalThis;\n	const guard = (name, init) => {\n		switch (name) {\n			case \"Function\":\n			case \"SharedWorker\":\n			case \"Worker\":\n			case \"eval\":\n			case \"setInterval\":\n			case \"setTimeout\": throw new TypeError(\"unable to deserialize \" + name);\n		}\n		return new env[name](init);\n	};\n	const deserializer = ($, _) => {\n		const as = (out, index) => {\n			$.set(index, out);\n			return out;\n		};\n		const unpair = (index) => {\n			if ($.has(index)) return $.get(index);\n			const [type, value] = _[index];\n			switch (type) {\n				case 0:\n				case -1: return as(value, index);\n				case 1: {\n					const arr = as([], index);\n					for (const index of value) arr.push(unpair(index));\n					return arr;\n				}\n				case 2: {\n					const object = as({}, index);\n					for (const [key, index] of value) object[unpair(key)] = unpair(index);\n					return object;\n				}\n				case 3: return as(new Date(value), index);\n				case 4: {\n					const { source, flags } = value;\n					return as(new RegExp(source, flags), index);\n				}\n				case 5: {\n					const map = as(/* @__PURE__ */ new Map(), index);\n					for (const [key, index] of value) map.set(unpair(key), unpair(index));\n					return map;\n				}\n				case 6: {\n					const set = as(/* @__PURE__ */ new Set(), index);\n					for (const index of value) set.add(unpair(index));\n					return set;\n				}\n				case 7: {\n					const { name, message } = value;\n					return as(guard(name, message), index);\n				}\n				case 8: return as(BigInt(value), index);\n				case \"BigInt\": return as(Object(BigInt(value)), index);\n				case \"ArrayBuffer\": return as(new Uint8Array(value).buffer, value);\n				case \"DataView\": {\n					const { buffer } = new Uint8Array(value);\n					return as(new DataView(buffer), value);\n				}\n			}\n			return as(guard(type, value), index);\n		};\n		return unpair;\n	};\n	/**\n	* @typedef {Array<string,any>} Record a type representation\n	*/\n	/**\n	* Returns a deserialized value from a serialized array of Records.\n	* @param {Record[]} serialized a previously serialized value.\n	* @returns {any}\n	*/\n	const deserialize = (serialized) => deserializer(/* @__PURE__ */ new Map(), serialized)(0);\n	//#endregion\n	//#region node_modules/.pnpm/@ungap+structured-clone@1.3.1/node_modules/@ungap/structured-clone/esm/serialize.js\n	const EMPTY = \"\";\n	const { toString } = {};\n	const { keys } = Object;\n	const typeOf = (value) => {\n		const type = typeof value;\n		if (type !== \"object\" || !value) return [0, type];\n		const asString = toString.call(value).slice(8, -1);\n		switch (asString) {\n			case \"Array\": return [1, EMPTY];\n			case \"Object\": return [2, EMPTY];\n			case \"Date\": return [3, EMPTY];\n			case \"RegExp\": return [4, EMPTY];\n			case \"Map\": return [5, EMPTY];\n			case \"Set\": return [6, EMPTY];\n			case \"DataView\": return [1, asString];\n		}\n		if (asString.includes(\"Array\")) return [1, asString];\n		if (asString.includes(\"Error\")) return [7, asString];\n		return [2, asString];\n	};\n	const shouldSkip = ([TYPE, type]) => TYPE === 0 && (type === \"function\" || type === \"symbol\");\n	const serializer = (strict, json, $, _) => {\n		const as = (out, value) => {\n			const index = _.push(out) - 1;\n			$.set(value, index);\n			return index;\n		};\n		const pair = (value) => {\n			if ($.has(value)) return $.get(value);\n			let [TYPE, type] = typeOf(value);\n			switch (TYPE) {\n				case 0: {\n					let entry = value;\n					switch (type) {\n						case \"bigint\":\n							TYPE = 8;\n							entry = value.toString();\n							break;\n						case \"function\":\n						case \"symbol\":\n							if (strict) throw new TypeError(\"unable to serialize \" + type);\n							entry = null;\n							break;\n						case \"undefined\": return as([-1], value);\n					}\n					return as([TYPE, entry], value);\n				}\n				case 1: {\n					if (type) {\n						let spread = value;\n						if (type === \"DataView\") spread = new Uint8Array(value.buffer);\n						else if (type === \"ArrayBuffer\") spread = new Uint8Array(value);\n						return as([type, [...spread]], value);\n					}\n					const arr = [];\n					const index = as([TYPE, arr], value);\n					for (const entry of value) arr.push(pair(entry));\n					return index;\n				}\n				case 2: {\n					if (type) switch (type) {\n						case \"BigInt\": return as([type, value.toString()], value);\n						case \"Boolean\":\n						case \"Number\":\n						case \"String\": return as([type, value.valueOf()], value);\n					}\n					if (json && \"toJSON\" in value) return pair(value.toJSON());\n					const entries = [];\n					const index = as([TYPE, entries], value);\n					for (const key of keys(value)) if (strict || !shouldSkip(typeOf(value[key]))) entries.push([pair(key), pair(value[key])]);\n					return index;\n				}\n				case 3: return as([TYPE, value.toISOString()], value);\n				case 4: {\n					const { source, flags } = value;\n					return as([TYPE, {\n						source,\n						flags\n					}], value);\n				}\n				case 5: {\n					const entries = [];\n					const index = as([TYPE, entries], value);\n					for (const [key, entry] of value) if (strict || !(shouldSkip(typeOf(key)) || shouldSkip(typeOf(entry)))) entries.push([pair(key), pair(entry)]);\n					return index;\n				}\n				case 6: {\n					const entries = [];\n					const index = as([TYPE, entries], value);\n					for (const entry of value) if (strict || !shouldSkip(typeOf(entry))) entries.push(pair(entry));\n					return index;\n				}\n			}\n			const { message } = value;\n			return as([TYPE, {\n				name: type,\n				message\n			}], value);\n		};\n		return pair;\n	};\n	/**\n	* @typedef {Array<string,any>} Record a type representation\n	*/\n	/**\n	* Returns an array of serialized Records.\n	* @param {any} value a serializable value.\n	* @param {{json?: boolean, lossy?: boolean}?} options an object with a `lossy` or `json` property that,\n	*  if `true`, will not throw errors on incompatible types, and behave more\n	*  like JSON stringify would behave. Symbol and Function will be discarded.\n	* @returns {Record[]}\n	*/\n	const serialize = (value, { json, lossy } = {}) => {\n		const _ = [];\n		return serializer(!(json || lossy), !!json, /* @__PURE__ */ new Map(), _)(value), _;\n	};\n	//#endregion\n	//#region node_modules/.pnpm/@ungap+structured-clone@1.3.1/node_modules/@ungap/structured-clone/esm/index.js\n	/**\n	* @typedef {Array<string,any>} Record a type representation\n	*/\n	/**\n	* Returns an array of serialized Records.\n	* @param {any} any a serializable value.\n	* @param {{transfer?: any[], json?: boolean, lossy?: boolean}?} options an object with\n	* a transfer option (ignored when polyfilled) and/or non standard fields that\n	* fallback to the polyfill if present.\n	* @returns {Record[]}\n	*/\n	var esm_default = typeof structuredClone === \"function\" ? (any, options) => options && (\"json\" in options || \"lossy\" in options) ? deserialize(serialize(any, options)) : structuredClone(any) : (any, options) => deserialize(serialize(any, options));\n	//#endregion\n	//#region node_modules/.pnpm/formdata-node@6.0.3/node_modules/formdata-node/lib/form-data.js\n	var __accessCheck = (obj, member, msg) => {\n		if (!member.has(obj)) throw TypeError(\"Cannot \" + msg);\n	};\n	var __privateGet = (obj, member, getter) => {\n		__accessCheck(obj, member, \"read from private field\");\n		return getter ? getter.call(obj) : member.get(obj);\n	};\n	var __privateAdd = (obj, member, value) => {\n		if (member.has(obj)) throw TypeError(\"Cannot add the same private member more than once\");\n		member instanceof WeakSet ? member.add(obj) : member.set(obj, value);\n	};\n	var __privateSet = (obj, member, value, setter) => {\n		__accessCheck(obj, member, \"write to private field\");\n		setter ? setter.call(obj, value) : member.set(obj, value);\n		return value;\n	};\n	var __privateMethod = (obj, member, method) => {\n		__accessCheck(obj, member, \"access private method\");\n		return method;\n	};\n	var isFunction = (value) => typeof value === \"function\";\n	var isObject = (value) => typeof value === \"object\" && value != null && !Array.isArray(value);\n	var isAsyncIterable = (value) => isObject(value) && isFunction(value[Symbol.asyncIterator]);\n	var MAX_CHUNK_SIZE = 65536;\n	async function* clonePart(value) {\n		if (value.byteLength <= MAX_CHUNK_SIZE) {\n			yield value;\n			return;\n		}\n		let offset = 0;\n		while (offset < value.byteLength) {\n			const size = Math.min(value.byteLength - offset, MAX_CHUNK_SIZE);\n			const buffer = value.buffer.slice(offset, offset + size);\n			offset += buffer.byteLength;\n			yield new Uint8Array(buffer);\n		}\n	}\n	async function* readStream(readable) {\n		const reader = readable.getReader();\n		while (true) {\n			const { done, value } = await reader.read();\n			if (done) break;\n			yield value;\n		}\n	}\n	async function* chunkStream(stream) {\n		for await (const value of stream) yield* clonePart(value);\n	}\n	var getStreamIterator = (source) => {\n		if (isAsyncIterable(source)) return chunkStream(source);\n		if (isFunction(source.getReader)) return chunkStream(readStream(source));\n		throw new TypeError(\"Unsupported data source: Expected either ReadableStream or async iterable.\");\n	};\n	async function* consumeNodeBlob(blob) {\n		let position = 0;\n		while (position !== blob.size) {\n			const buffer = await blob.slice(position, Math.min(blob.size, position + MAX_CHUNK_SIZE)).arrayBuffer();\n			position += buffer.byteLength;\n			yield new Uint8Array(buffer);\n		}\n	}\n	async function* consumeBlobParts(parts, clone = false) {\n		for (const part of parts) if (ArrayBuffer.isView(part)) if (clone) yield* clonePart(part);\n		else yield part;\n		else if (isFunction(part.stream)) yield* getStreamIterator(part.stream());\n		else yield* consumeNodeBlob(part);\n	}\n	function* sliceBlob(blobParts, blobSize, start = 0, end) {\n		end ??= blobSize;\n		let relativeStart = start < 0 ? Math.max(blobSize + start, 0) : Math.min(start, blobSize);\n		let relativeEnd = end < 0 ? Math.max(blobSize + end, 0) : Math.min(end, blobSize);\n		const span = Math.max(relativeEnd - relativeStart, 0);\n		let added = 0;\n		for (const part of blobParts) {\n			if (added >= span) break;\n			const partSize = ArrayBuffer.isView(part) ? part.byteLength : part.size;\n			if (relativeStart && partSize <= relativeStart) {\n				relativeStart -= partSize;\n				relativeEnd -= partSize;\n			} else {\n				let chunk;\n				if (ArrayBuffer.isView(part)) {\n					chunk = part.subarray(relativeStart, Math.min(partSize, relativeEnd));\n					added += chunk.byteLength;\n				} else {\n					chunk = part.slice(relativeStart, Math.min(partSize, relativeEnd));\n					added += chunk.size;\n				}\n				relativeEnd -= partSize;\n				relativeStart = 0;\n				yield chunk;\n			}\n		}\n	}\n	var _parts, _type, _size;\n	var _Blob = class _Blob {\n		/**\n		* Returns a new [`Blob`](https://developer.mozilla.org/en-US/docs/Web/API/Blob) object.\n		* The content of the blob consists of the concatenation of the values given in the parameter array.\n		*\n		* @param blobParts An `Array` strings, or [`ArrayBuffer`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer), [`ArrayBufferView`](https://developer.mozilla.org/en-US/docs/Web/API/ArrayBufferView), [`Blob`](https://developer.mozilla.org/en-US/docs/Web/API/Blob) objects, or a mix of any of such objects, that will be put inside the [`Blob`](https://developer.mozilla.org/en-US/docs/Web/API/Blob).\n		* @param options An optional object of type `BlobPropertyBag`.\n		*/\n		constructor(blobParts = [], options = {}) {\n			/**\n			* An `Array` of [`ArrayBufferView`](https://developer.mozilla.org/en-US/docs/Web/API/ArrayBufferView) or [`Blob`](https://developer.mozilla.org/en-US/docs/Web/API/Blob) objects, or a mix of any of such objects, that will be put inside the [`Blob`](https://developer.mozilla.org/en-US/docs/Web/API/Blob).\n			*/\n			__privateAdd(this, _parts, []);\n			/**\n			* Returns the [`MIME type`](https://developer.mozilla.org/en-US/docs/Glossary/MIME_type) of the [`Blob`](https://developer.mozilla.org/en-US/docs/Web/API/Blob) or [`File`](https://developer.mozilla.org/en-US/docs/Web/API/File).\n			*/\n			__privateAdd(this, _type, \"\");\n			/**\n			* Returns the size of the [`Blob`](https://developer.mozilla.org/en-US/docs/Web/API/Blob) or [`File`](https://developer.mozilla.org/en-US/docs/Web/API/File) in bytes.\n			*/\n			__privateAdd(this, _size, 0);\n			options ??= {};\n			if (typeof blobParts !== \"object\" || blobParts === null) throw new TypeError(\"Failed to construct 'Blob': The provided value cannot be converted to a sequence.\");\n			if (!isFunction(blobParts[Symbol.iterator])) throw new TypeError(\"Failed to construct 'Blob': The object must have a callable @@iterator property.\");\n			if (typeof options !== \"object\" && !isFunction(options)) throw new TypeError(\"Failed to construct 'Blob': parameter 2 cannot convert to dictionary.\");\n			const encoder = new TextEncoder();\n			for (const raw of blobParts) {\n				let part;\n				if (ArrayBuffer.isView(raw)) part = new Uint8Array(raw.buffer.slice(raw.byteOffset, raw.byteOffset + raw.byteLength));\n				else if (raw instanceof ArrayBuffer) part = new Uint8Array(raw.slice(0));\n				else if (raw instanceof _Blob) part = raw;\n				else part = encoder.encode(String(raw));\n				__privateSet(this, _size, __privateGet(this, _size) + (ArrayBuffer.isView(part) ? part.byteLength : part.size));\n				__privateGet(this, _parts).push(part);\n			}\n			const type = options.type === void 0 ? \"\" : String(options.type);\n			__privateSet(this, _type, /^[\\x20-\\x7E]*$/.test(type) ? type : \"\");\n		}\n		static [Symbol.hasInstance](value) {\n			return Boolean(value && typeof value === \"object\" && isFunction(value.constructor) && (isFunction(value.stream) || isFunction(value.arrayBuffer)) && /^(Blob|File)$/.test(value[Symbol.toStringTag]));\n		}\n		/**\n		* Returns the [`MIME type`](https://developer.mozilla.org/en-US/docs/Glossary/MIME_type) of the [`Blob`](https://developer.mozilla.org/en-US/docs/Web/API/Blob) or [`File`](https://developer.mozilla.org/en-US/docs/Web/API/File).\n		*/\n		get type() {\n			return __privateGet(this, _type);\n		}\n		/**\n		* Returns the size of the [`Blob`](https://developer.mozilla.org/en-US/docs/Web/API/Blob) or [`File`](https://developer.mozilla.org/en-US/docs/Web/API/File) in bytes.\n		*/\n		get size() {\n			return __privateGet(this, _size);\n		}\n		/**\n		* Creates and returns a new [`Blob`](https://developer.mozilla.org/en-US/docs/Web/API/Blob) object which contains data from a subset of the blob on which it's called.\n		*\n		* @param start An index into the Blob indicating the first byte to include in the new Blob. If you specify a negative value, it's treated as an offset from the end of the Blob toward the beginning. For example, -10 would be the 10th from last byte in the Blob. The default value is 0. If you specify a value for start that is larger than the size of the source Blob, the returned Blob has size 0 and contains no data.\n		* @param end An index into the Blob indicating the first byte that will *not* be included in the new Blob (i.e. the byte exactly at this index is not included). If you specify a negative value, it's treated as an offset from the end of the Blob toward the beginning. For example, -10 would be the 10th from last byte in the Blob. The default value is size.\n		* @param contentType The content type to assign to the new Blob; this will be the value of its type property. The default value is an empty string.\n		*/\n		slice(start, end, contentType) {\n			return new _Blob(sliceBlob(__privateGet(this, _parts), this.size, start, end), { type: contentType });\n		}\n		/**\n		* Returns a [`Promise`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise) that resolves with a string containing the contents of the blob, interpreted as UTF-8.\n		*/\n		async text() {\n			const decoder = new TextDecoder();\n			let result = \"\";\n			for await (const chunk of consumeBlobParts(__privateGet(this, _parts))) result += decoder.decode(chunk, { stream: true });\n			result += decoder.decode();\n			return result;\n		}\n		/**\n		* Returns a [`Promise`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise) that resolves with the contents of the blob as binary data contained in an [`ArrayBuffer`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer).\n		*/\n		async arrayBuffer() {\n			const view = new Uint8Array(this.size);\n			let offset = 0;\n			for await (const chunk of consumeBlobParts(__privateGet(this, _parts))) {\n				view.set(chunk, offset);\n				offset += chunk.length;\n			}\n			return view.buffer;\n		}\n		/**\n		* Returns a [`ReadableStream`](https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream) which upon reading returns the data contained within the [`Blob`](https://developer.mozilla.org/en-US/docs/Web/API/Blob).\n		*/\n		stream() {\n			const iterator = consumeBlobParts(__privateGet(this, _parts), true);\n			return new ReadableStream({\n				async pull(controller) {\n					const { value, done } = await iterator.next();\n					if (done) return queueMicrotask(() => controller.close());\n					controller.enqueue(value);\n				},\n				async cancel() {\n					await iterator.return();\n				}\n			});\n		}\n		get [Symbol.toStringTag]() {\n			return \"Blob\";\n		}\n	};\n	_parts = /* @__PURE__ */ new WeakMap();\n	_type = /* @__PURE__ */ new WeakMap();\n	_size = /* @__PURE__ */ new WeakMap();\n	var Blob = _Blob;\n	Object.defineProperties(Blob.prototype, {\n		type: { enumerable: true },\n		size: { enumerable: true },\n		slice: { enumerable: true },\n		stream: { enumerable: true },\n		text: { enumerable: true },\n		arrayBuffer: { enumerable: true }\n	});\n	var isBlob = (value) => value instanceof Blob;\n	var _name, _lastModified;\n	var File = class extends Blob {\n		/**\n		* Creates a new File instance.\n		*\n		* @param fileBits An `Array` strings, or [`ArrayBuffer`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer), [`ArrayBufferView`](https://developer.mozilla.org/en-US/docs/Web/API/ArrayBufferView), [`Blob`](https://developer.mozilla.org/en-US/docs/Web/API/Blob) objects, or a mix of any of such objects, that will be put inside the [`File`](https://developer.mozilla.org/en-US/docs/Web/API/File).\n		* @param name The name of the file.\n		* @param options An options object containing optional attributes for the file.\n		*/\n		constructor(fileBits, name, options = {}) {\n			super(fileBits, options);\n			/**\n			* Returns the name of the file referenced by the File object.\n			*/\n			__privateAdd(this, _name, void 0);\n			/**\n			* The last modified date of the file as the number of milliseconds since the Unix epoch (January 1, 1970 at midnight). Files without a known last modified date return the current date.\n			*/\n			__privateAdd(this, _lastModified, 0);\n			if (arguments.length < 2) throw new TypeError(`Failed to construct 'File': 2 arguments required, but only ${arguments.length} present.`);\n			__privateSet(this, _name, String(name));\n			const lastModified = options.lastModified === void 0 ? Date.now() : Number(options.lastModified);\n			if (!Number.isNaN(lastModified)) __privateSet(this, _lastModified, lastModified);\n		}\n		static [Symbol.hasInstance](value) {\n			return value instanceof Blob && value[Symbol.toStringTag] === \"File\" && typeof value.name === \"string\";\n		}\n		/**\n		* Name of the file referenced by the File object.\n		*/\n		get name() {\n			return __privateGet(this, _name);\n		}\n		/* c8 ignore next 3 */\n		get webkitRelativePath() {\n			return \"\";\n		}\n		/**\n		* The last modified date of the file as the number of milliseconds since the Unix epoch (January 1, 1970 at midnight). Files without a known last modified date return the current date.\n		*/\n		get lastModified() {\n			return __privateGet(this, _lastModified);\n		}\n		get [Symbol.toStringTag]() {\n			return \"File\";\n		}\n	};\n	_name = /* @__PURE__ */ new WeakMap();\n	_lastModified = /* @__PURE__ */ new WeakMap();\n	var isFile = (value) => value instanceof File;\n	var _entries, _setEntry, setEntry_fn;\n	var FormData = class {\n		constructor() {\n			__privateAdd(this, _setEntry);\n			/**\n			* Stores internal data for every entry\n			*/\n			__privateAdd(this, _entries, /* @__PURE__ */ new Map());\n		}\n		static [Symbol.hasInstance](value) {\n			if (!value) return false;\n			const val = value;\n			return Boolean(isFunction(val.constructor) && val[Symbol.toStringTag] === \"FormData\" && isFunction(val.append) && isFunction(val.set) && isFunction(val.get) && isFunction(val.getAll) && isFunction(val.has) && isFunction(val.delete) && isFunction(val.entries) && isFunction(val.values) && isFunction(val.keys) && isFunction(val[Symbol.iterator]) && isFunction(val.forEach));\n		}\n		/**\n		* Appends a new value onto an existing key inside a FormData object,\n		* or adds the key if it does not already exist.\n		*\n		* The difference between `set()` and `append()` is that if the specified key already exists, `set()` will overwrite all existing values with the new one, whereas `append()` will append the new value onto the end of the existing set of values.\n		*\n		* @param name The name of the field whose data is contained in `value`.\n		* @param value The field's value. This can be [`Blob`](https://developer.mozilla.org/en-US/docs/Web/API/Blob)\n		or [`File`](https://developer.mozilla.org/en-US/docs/Web/API/File). If none of these are specified the value is converted to a string.\n		* @param fileName The filename reported to the server, when a Blob or File is passed as the second parameter. The default filename for Blob objects is \"blob\". The default filename for File objects is the file's filename.\n		*/\n		append(name, value, fileName) {\n			__privateMethod(this, _setEntry, setEntry_fn).call(this, {\n				name,\n				fileName,\n				append: true,\n				rawValue: value,\n				argsLength: arguments.length\n			});\n		}\n		/**\n		* Set a new value for an existing key inside FormData,\n		* or add the new field if it does not already exist.\n		*\n		* @param name The name of the field whose data is contained in `value`.\n		* @param value The field's value. This can be [`Blob`](https://developer.mozilla.org/en-US/docs/Web/API/Blob)\n		or [`File`](https://developer.mozilla.org/en-US/docs/Web/API/File). If none of these are specified the value is converted to a string.\n		* @param fileName The filename reported to the server, when a Blob or File is passed as the second parameter. The default filename for Blob objects is \"blob\". The default filename for File objects is the file's filename.\n		*\n		*/\n		set(name, value, fileName) {\n			__privateMethod(this, _setEntry, setEntry_fn).call(this, {\n				name,\n				fileName,\n				append: false,\n				rawValue: value,\n				argsLength: arguments.length\n			});\n		}\n		/**\n		* Returns the first value associated with a given key from within a `FormData` object.\n		* If you expect multiple values and want all of them, use the `getAll()` method instead.\n		*\n		* @param {string} name A name of the value you want to retrieve.\n		*\n		* @returns A `FormDataEntryValue` containing the value. If the key doesn't exist, the method returns null.\n		*/\n		get(name) {\n			const field = __privateGet(this, _entries).get(String(name));\n			if (!field) return null;\n			return field[0];\n		}\n		/**\n		* Returns all the values associated with a given key from within a `FormData` object.\n		*\n		* @param {string} name A name of the value you want to retrieve.\n		*\n		* @returns An array of `FormDataEntryValue` whose key matches the value passed in the `name` parameter. If the key doesn't exist, the method returns an empty list.\n		*/\n		getAll(name) {\n			const field = __privateGet(this, _entries).get(String(name));\n			if (!field) return [];\n			return field.slice();\n		}\n		/**\n		* Returns a boolean stating whether a `FormData` object contains a certain key.\n		*\n		* @param name A string representing the name of the key you want to test for.\n		*\n		* @return A boolean value.\n		*/\n		has(name) {\n			return __privateGet(this, _entries).has(String(name));\n		}\n		/**\n		* Deletes a key and its value(s) from a `FormData` object.\n		*\n		* @param name The name of the key you want to delete.\n		*/\n		delete(name) {\n			__privateGet(this, _entries).delete(String(name));\n		}\n		/**\n		* Returns an [`iterator`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols) allowing to go through all keys contained in this `FormData` object.\n		* Each key is a `string`.\n		*/\n		*keys() {\n			for (const key of __privateGet(this, _entries).keys()) yield key;\n		}\n		/**\n		* Returns an [`iterator`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols) allowing to go through the `FormData` key/value pairs.\n		* The key of each pair is a string; the value is a [`FormDataValue`](https://developer.mozilla.org/en-US/docs/Web/API/FormDataEntryValue).\n		*/\n		*entries() {\n			for (const name of this.keys()) {\n				const values = this.getAll(name);\n				for (const value of values) yield [name, value];\n			}\n		}\n		/**\n		* Returns an [`iterator`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols) allowing to go through all values contained in this object `FormData` object.\n		* Each value is a [`FormDataValue`](https://developer.mozilla.org/en-US/docs/Web/API/FormDataEntryValue).\n		*/\n		*values() {\n			for (const [, value] of this) yield value;\n		}\n		/**\n		* An alias for FormData#entries()\n		*/\n		[Symbol.iterator]() {\n			return this.entries();\n		}\n		/**\n		* Executes given callback function for each field of the FormData instance\n		*/\n		forEach(callback, thisArg) {\n			for (const [name, value] of this) callback.call(thisArg, value, name, this);\n		}\n		get [Symbol.toStringTag]() {\n			return \"FormData\";\n		}\n	};\n	_entries = /* @__PURE__ */ new WeakMap();\n	_setEntry = /* @__PURE__ */ new WeakSet();\n	setEntry_fn = function({ name, rawValue, append, fileName, argsLength }) {\n		const methodName = append ? \"append\" : \"set\";\n		if (argsLength < 2) throw new TypeError(`Failed to execute '${methodName}' on 'FormData': 2 arguments required, but only ${argsLength} present.`);\n		name = String(name);\n		let value;\n		if (isFile(rawValue)) value = fileName === void 0 ? rawValue : new File([rawValue], fileName, {\n			type: rawValue.type,\n			lastModified: rawValue.lastModified\n		});\n		else if (isBlob(rawValue)) value = new File([rawValue], fileName === void 0 ? \"blob\" : fileName, { type: rawValue.type });\n		else if (fileName) throw new TypeError(`Failed to execute '${methodName}' on 'FormData': parameter 2 is not of type 'Blob'.`);\n		else value = String(rawValue);\n		const values = __privateGet(this, _entries).get(name);\n		if (!values) {\n			__privateGet(this, _entries).set(name, [value]);\n			return;\n		}\n		if (!append) {\n			__privateGet(this, _entries).set(name, [value]);\n			return;\n		}\n		values.push(value);\n	};\n	/*! Based on fetch-blob. MIT License. Jimmy Wärting <https://jimmy.warting.se/opensource> & David Frank */\n	//#endregion\n	//#region node_modules/.pnpm/set-cookie-parser@3.1.0/node_modules/set-cookie-parser/lib/set-cookie.js\n	var defaultParseOptions = {\n		decodeValues: true,\n		map: false,\n		silent: false,\n		split: \"auto\"\n	};\n	function isForbiddenKey(key) {\n		return typeof key !== \"string\" || key in {};\n	}\n	function createNullObj() {\n		return Object.create(null);\n	}\n	function isNonEmptyString(str) {\n		return typeof str === \"string\" && !!str.trim();\n	}\n	function parseString(setCookieValue, options) {\n		var parts = setCookieValue.split(\";\").filter(isNonEmptyString);\n		var parsed = parseNameValuePair(parts.shift());\n		var name = parsed.name;\n		var value = parsed.value;\n		options = options ? Object.assign({}, defaultParseOptions, options) : defaultParseOptions;\n		if (isForbiddenKey(name)) return null;\n		try {\n			value = options.decodeValues ? decodeURIComponent(value) : value;\n		} catch (e) {\n			console.error(\"set-cookie-parser: failed to decode cookie value. Set options.decodeValues=false to disable decoding.\", e);\n		}\n		var cookie = createNullObj();\n		cookie.name = name;\n		cookie.value = value;\n		parts.forEach(function(part) {\n			var sides = part.split(\"=\");\n			var key = sides.shift().trimLeft().toLowerCase();\n			if (isForbiddenKey(key)) return;\n			var value = sides.join(\"=\");\n			if (key === \"expires\") cookie.expires = new Date(value);\n			else if (key === \"max-age\") {\n				var n = parseInt(value, 10);\n				if (!Number.isNaN(n)) cookie.maxAge = n;\n			} else if (key === \"secure\") cookie.secure = true;\n			else if (key === \"httponly\") cookie.httpOnly = true;\n			else if (key === \"samesite\") cookie.sameSite = value;\n			else if (key === \"partitioned\") cookie.partitioned = true;\n			else if (key) cookie[key] = value;\n		});\n		return cookie;\n	}\n	function parseNameValuePair(nameValuePairStr) {\n		var name = \"\";\n		var value = \"\";\n		var nameValueArr = nameValuePairStr.split(\"=\");\n		if (nameValueArr.length > 1) {\n			name = nameValueArr.shift();\n			value = nameValueArr.join(\"=\");\n		} else value = nameValuePairStr;\n		return {\n			name,\n			value\n		};\n	}\n	function parseSetCookie(input, options) {\n		options = options ? Object.assign({}, defaultParseOptions, options) : defaultParseOptions;\n		if (!input) if (!options.map) return [];\n		else return createNullObj();\n		if (input.headers) if (typeof input.headers.getSetCookie === \"function\") input = input.headers.getSetCookie();\n		else if (input.headers[\"set-cookie\"]) input = input.headers[\"set-cookie\"];\n		else {\n			var sch = input.headers[Object.keys(input.headers).find(function(key) {\n				return key.toLowerCase() === \"set-cookie\";\n			})];\n			if (!sch && input.headers.cookie && !options.silent) console.warn(\"Warning: set-cookie-parser appears to have been called on a request object. It is designed to parse Set-Cookie headers from responses, not Cookie headers from requests. Set the option {silent: true} to suppress this warning.\");\n			input = sch;\n		}\n		var split = options.split;\n		var isArray = Array.isArray(input);\n		if (split === \"auto\") split = !isArray;\n		if (!isArray) input = [input];\n		input = input.filter(isNonEmptyString);\n		if (split) input = input.map(splitCookiesString).flat();\n		if (!options.map) return input.map(function(str) {\n			return parseString(str, options);\n		}).filter(Boolean);\n		else {\n			var cookies = createNullObj();\n			return input.reduce(function(cookies, str) {\n				var cookie = parseString(str, options);\n				if (cookie && !isForbiddenKey(cookie.name)) cookies[cookie.name] = cookie;\n				return cookies;\n			}, cookies);\n		}\n	}\n	function splitCookiesString(cookiesString) {\n		if (Array.isArray(cookiesString)) return cookiesString;\n		if (typeof cookiesString !== \"string\") return [];\n		var cookiesStrings = [];\n		var pos = 0;\n		var start;\n		var ch;\n		var lastComma;\n		var nextStart;\n		var cookiesSeparatorFound;\n		function skipWhitespace() {\n			while (pos < cookiesString.length && /\\s/.test(cookiesString.charAt(pos))) pos += 1;\n			return pos < cookiesString.length;\n		}\n		function notSpecialChar() {\n			ch = cookiesString.charAt(pos);\n			return ch !== \"=\" && ch !== \";\" && ch !== \",\";\n		}\n		while (pos < cookiesString.length) {\n			start = pos;\n			cookiesSeparatorFound = false;\n			while (skipWhitespace()) {\n				ch = cookiesString.charAt(pos);\n				if (ch === \",\") {\n					lastComma = pos;\n					pos += 1;\n					skipWhitespace();\n					nextStart = pos;\n					while (pos < cookiesString.length && notSpecialChar()) pos += 1;\n					if (pos < cookiesString.length && cookiesString.charAt(pos) === \"=\") {\n						cookiesSeparatorFound = true;\n						pos = nextStart;\n						cookiesStrings.push(cookiesString.substring(start, lastComma));\n						start = pos;\n					} else pos = lastComma + 1;\n				} else pos += 1;\n			}\n			if (!cookiesSeparatorFound || pos >= cookiesString.length) cookiesStrings.push(cookiesString.substring(start, cookiesString.length));\n		}\n		return cookiesStrings;\n	}\n	parseSetCookie.parseSetCookie = parseSetCookie;\n	parseSetCookie.parse = parseSetCookie;\n	parseSetCookie.parseString = parseString;\n	parseSetCookie.splitCookiesString = splitCookiesString;\n	//#endregion\n	//#region node_modules/.pnpm/headers-polyfill@5.0.1/node_modules/headers-polyfill/lib/index.mjs\n	const HEADERS_INVALID_CHARACTERS = /[^a-z0-9\\-#$%&'*+.^_`|~]/i;\n	function normalizeHeaderName(name) {\n		if (HEADERS_INVALID_CHARACTERS.test(name) || name.trim() === \"\") throw new TypeError(\"Invalid character in header field name\");\n		return name.trim().toLowerCase();\n	}\n	const charCodesToRemove = [\n		String.fromCharCode(10),\n		String.fromCharCode(13),\n		String.fromCharCode(9),\n		String.fromCharCode(32)\n	];\n	const HEADER_VALUE_REMOVE_REGEXP = new RegExp(`(^[${charCodesToRemove.join(\"\")}]|$[${charCodesToRemove.join(\"\")}])`, \"g\");\n	/**\n	* Normalize the given header value.\n	* @see https://fetch.spec.whatwg.org/#concept-header-value-normalize\n	*/\n	function normalizeHeaderValue(value) {\n		return value.replace(HEADER_VALUE_REMOVE_REGEXP, \"\");\n	}\n	/**\n	* Validate the given header name.\n	* @see https://fetch.spec.whatwg.org/#header-name\n	*/\n	function isValidHeaderName(value) {\n		if (typeof value !== \"string\") return false;\n		if (value.length === 0) return false;\n		for (let i = 0; i < value.length; i++) {\n			const character = value.charCodeAt(i);\n			if (character > 127 || !isToken(character)) return false;\n		}\n		return true;\n	}\n	function isToken(value) {\n		return ![\n			127,\n			32,\n			\"(\",\n			\")\",\n			\"<\",\n			\">\",\n			\"@\",\n			\",\",\n			\";\",\n			\":\",\n			\"\\\\\",\n			\"\\\"\",\n			\"/\",\n			\"[\",\n			\"]\",\n			\"?\",\n			\"=\",\n			\"{\",\n			\"}\"\n		].includes(value);\n	}\n	/**\n	* Validate the given header value.\n	* @see https://fetch.spec.whatwg.org/#header-value\n	*/\n	function isValidHeaderValue(value) {\n		if (typeof value !== \"string\") return false;\n		if (value.trim() !== value) return false;\n		for (let i = 0; i < value.length; i++) {\n			const character = value.charCodeAt(i);\n			if (character === 0 || character === 10 || character === 13) return false;\n		}\n		return true;\n	}\n	let _Symbol$toStringTag;\n	const NORMALIZED_HEADERS = Symbol(\"normalizedHeaders\");\n	const RAW_HEADER_NAMES = Symbol(\"rawHeaderNames\");\n	const HEADER_VALUE_DELIMITER = \", \";\n	var Headers = class Headers {\n		constructor(init) {\n			this[NORMALIZED_HEADERS] = {};\n			this[RAW_HEADER_NAMES] = /* @__PURE__ */ new Map();\n			this[_Symbol$toStringTag] = \"Headers\";\n			/**\n			* @note Cannot necessarily check if the `init` is an instance of the\n			* `Headers` because that class may not be defined in Node or jsdom.\n			*/\n			if ([\"Headers\", \"HeadersPolyfill\"].includes(init?.constructor?.name) || init instanceof Headers || typeof globalThis.Headers !== \"undefined\" && init instanceof globalThis.Headers) init.forEach((value, name) => {\n				this.append(name, value);\n			}, this);\n			else if (Array.isArray(init)) init.forEach(([name, value]) => {\n				this.append(name, Array.isArray(value) ? value.join(HEADER_VALUE_DELIMITER) : value);\n			});\n			else if (init) Object.getOwnPropertyNames(init).forEach((name) => {\n				const value = init[name];\n				this.append(name, Array.isArray(value) ? value.join(HEADER_VALUE_DELIMITER) : value);\n			});\n		}\n		[(_Symbol$toStringTag = Symbol.toStringTag, Symbol.iterator)]() {\n			return this.entries();\n		}\n		*keys() {\n			for (const [name] of this.entries()) yield name;\n		}\n		*values() {\n			for (const [, value] of this.entries()) yield value;\n		}\n		*entries() {\n			let sortedKeys = Object.keys(this[NORMALIZED_HEADERS]).sort((a, b) => a.localeCompare(b));\n			for (const name of sortedKeys) if (name === \"set-cookie\") for (const value of this.getSetCookie()) yield [name, value];\n			else yield [name, this.get(name)];\n		}\n		/**\n		* Returns a boolean stating whether a `Headers` object contains a certain header.\n		*/\n		has(name) {\n			if (!isValidHeaderName(name)) throw new TypeError(`Invalid header name \"${name}\"`);\n			return this[NORMALIZED_HEADERS].hasOwnProperty(normalizeHeaderName(name));\n		}\n		/**\n		* Returns a `ByteString` sequence of all the values of a header with a given name.\n		*/\n		get(name) {\n			if (!isValidHeaderName(name)) throw TypeError(`Invalid header name \"${name}\"`);\n			return this[NORMALIZED_HEADERS][normalizeHeaderName(name)] ?? null;\n		}\n		/**\n		* Sets a new value for an existing header inside a `Headers` object, or adds the header if it does not already exist.\n		*/\n		set(name, value) {\n			if (!isValidHeaderName(name) || !isValidHeaderValue(value)) return;\n			const normalizedName = normalizeHeaderName(name);\n			const normalizedValue = normalizeHeaderValue(value);\n			this[NORMALIZED_HEADERS][normalizedName] = normalizeHeaderValue(normalizedValue);\n			this[RAW_HEADER_NAMES].set(normalizedName, name);\n		}\n		/**\n		* Appends a new value onto an existing header inside a `Headers` object, or adds the header if it does not already exist.\n		*/\n		append(name, value) {\n			if (!isValidHeaderName(name) || !isValidHeaderValue(value)) return;\n			const normalizedName = normalizeHeaderName(name);\n			const normalizedValue = normalizeHeaderValue(value);\n			let resolvedValue = this.has(normalizedName) ? `${this.get(normalizedName)}, ${normalizedValue}` : normalizedValue;\n			this.set(name, resolvedValue);\n		}\n		/**\n		* Deletes a header from the `Headers` object.\n		*/\n		delete(name) {\n			if (!isValidHeaderName(name)) return;\n			if (!this.has(name)) return;\n			const normalizedName = normalizeHeaderName(name);\n			delete this[NORMALIZED_HEADERS][normalizedName];\n			this[RAW_HEADER_NAMES].delete(normalizedName);\n		}\n		/**\n		* Traverses the `Headers` object,\n		* calling the given callback for each header.\n		*/\n		forEach(callback, thisArg) {\n			for (const [name, value] of this.entries()) callback.call(thisArg, value, name, this);\n		}\n		/**\n		* Returns an array containing the values\n		* of all Set-Cookie headers associated\n		* with a response\n		*/\n		getSetCookie() {\n			const setCookieHeader = this.get(\"set-cookie\");\n			if (setCookieHeader === null) return [];\n			if (setCookieHeader === \"\") return [\"\"];\n			return splitCookiesString(setCookieHeader);\n		}\n	};\n	//#endregion\n	//#region packages/core/src/code-mode/platform-entry.ts\n	const platformBridgeGlobalThis = globalThis;\n	const capletsPlatformHost = {\n		randomUUID: platformBridgeGlobalThis.__caplets_platform_random_uuid,\n		randomValues: platformBridgeGlobalThis.__caplets_platform_random_values,\n		sleep: platformBridgeGlobalThis.__caplets_platform_sleep,\n		clearTimer: platformBridgeGlobalThis.__caplets_platform_clear_timer\n	};\n	delete platformBridgeGlobalThis.__caplets_platform_random_uuid;\n	delete platformBridgeGlobalThis.__caplets_platform_random_values;\n	delete platformBridgeGlobalThis.__caplets_platform_sleep;\n	delete platformBridgeGlobalThis.__caplets_platform_clear_timer;\n	const DISABLED_FETCH_MESSAGE = \"Direct fetch is not available in Code Mode; use a Caplet instead.\";\n	const BASE64_ALPHABET = \"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/\";\n	const base64Lookup = new Map(BASE64_ALPHABET.split(\"\").map((char, index) => [char, index]));\n	function utf8Encode(input) {\n		const encoded = encodeURIComponent(input);\n		const bytes = [];\n		for (let index = 0; index < encoded.length; index += 1) {\n			if (encoded[index] === \"%\") {\n				bytes.push(Number.parseInt(encoded.slice(index + 1, index + 3), 16));\n				index += 2;\n				continue;\n			}\n			bytes.push(encoded.charCodeAt(index));\n		}\n		return Uint8Array.from(bytes);\n	}\n	function utf8Decode(input) {\n		let output = \"\";\n		for (let index = 0; index < input.length; index += 1) {\n			const first = input[index] ?? 0;\n			if (first < 128) {\n				output += String.fromCharCode(first);\n				continue;\n			}\n			if (first >= 194 && first <= 223) {\n				const second = input[index + 1];\n				if (isUtf8Continuation(second)) {\n					output += String.fromCodePoint((first & 31) << 6 | second & 63);\n					index += 1;\n					continue;\n				}\n				output += \"�\";\n				continue;\n			}\n			if (first >= 224 && first <= 239) {\n				const second = input[index + 1];\n				const third = input[index + 2];\n				if (isValidUtf8SecondForThreeByte(first, second) && isUtf8Continuation(third)) {\n					output += String.fromCodePoint((first & 15) << 12 | (second & 63) << 6 | third & 63);\n					index += 2;\n					continue;\n				}\n				output += \"�\";\n				if (isValidUtf8SecondForThreeByte(first, second)) index += 1;\n				continue;\n			}\n			if (first >= 240 && first <= 244) {\n				const second = input[index + 1];\n				const third = input[index + 2];\n				const fourth = input[index + 3];\n				if (isValidUtf8SecondForFourByte(first, second) && isUtf8Continuation(third) && isUtf8Continuation(fourth)) {\n					output += String.fromCodePoint((first & 7) << 18 | (second & 63) << 12 | (third & 63) << 6 | fourth & 63);\n					index += 3;\n					continue;\n				}\n				output += \"�\";\n				if (isValidUtf8SecondForFourByte(first, second)) index += isUtf8Continuation(third) ? 2 : 1;\n				continue;\n			}\n			output += \"�\";\n		}\n		return output;\n	}\n	function isUtf8Continuation(value) {\n		return value !== void 0 && value >= 128 && value <= 191;\n	}\n	function isValidUtf8SecondForThreeByte(first, second) {\n		if (second === void 0) return false;\n		if (first === 224) return second >= 160 && second <= 191;\n		if (first === 237) return second >= 128 && second <= 159;\n		return second >= 128 && second <= 191;\n	}\n	function isValidUtf8SecondForFourByte(first, second) {\n		if (second === void 0) return false;\n		if (first === 240) return second >= 144 && second <= 191;\n		if (first === 244) return second >= 128 && second <= 143;\n		return second >= 128 && second <= 191;\n	}\n	var TextEncoderShim = class {\n		encoding = \"utf-8\";\n		encode(input = \"\") {\n			return utf8Encode(String(input));\n		}\n	};\n	var TextDecoderShim = class {\n		encoding;\n		constructor(label = \"utf-8\") {\n			const normalized = label.toLowerCase();\n			if (![\n				\"utf-8\",\n				\"utf8\",\n				\"unicode-1-1-utf-8\"\n			].includes(normalized)) throw new TypeError(`Unsupported encoding: ${label}`);\n			this.encoding = \"utf-8\";\n		}\n		decode(input) {\n			if (input === void 0) return \"\";\n			return utf8Decode(copyBytes(input));\n		}\n	};\n	const textEncoder = new TextEncoderShim();\n	const textDecoder = new TextDecoderShim();\n	var URLSearchParamsShim = class URLSearchParamsShim {\n		#entries = [];\n		#onChange;\n		constructor(init = \"\", onChange) {\n			this.#onChange = onChange;\n			if (typeof init === \"string\") {\n				const source = init.startsWith(\"?\") ? init.slice(1) : init;\n				if (!source) return;\n				for (const pair of source.split(\"&\")) {\n					if (!pair) continue;\n					const separatorIndex = pair.indexOf(\"=\");\n					const key = separatorIndex >= 0 ? pair.slice(0, separatorIndex) : pair;\n					const value = separatorIndex >= 0 ? pair.slice(separatorIndex + 1) : \"\";\n					this.#entries.push([decodeUrlParam(key), decodeUrlParam(value)]);\n				}\n				return;\n			}\n			if (init instanceof URLSearchParamsShim) {\n				this.#entries = [...init.#entries];\n				return;\n			}\n			if (Array.isArray(init)) {\n				this.#entries = init.map(([key, value]) => [String(key), String(value)]);\n				return;\n			}\n			this.#entries = Object.entries(init).map(([key, value]) => [key, String(value)]);\n		}\n		append(name, value) {\n			this.#entries.push([String(name), String(value)]);\n			this.#onChange?.();\n		}\n		delete(name) {\n			const normalized = String(name);\n			this.#entries = this.#entries.filter(([key]) => key !== normalized);\n			this.#onChange?.();\n		}\n		entries() {\n			return this.#entries[Symbol.iterator]();\n		}\n		forEach(callback) {\n			for (const [key, value] of this.#entries) callback(value, key, this);\n		}\n		get(name) {\n			return this.#entries.find(([key]) => key === String(name))?.[1] ?? null;\n		}\n		getAll(name) {\n			return this.#entries.filter(([key]) => key === String(name)).map(([, value]) => value);\n		}\n		has(name) {\n			return this.#entries.some(([key]) => key === String(name));\n		}\n		keys() {\n			return this.#entries.map(([key]) => key)[Symbol.iterator]();\n		}\n		set(name, value) {\n			const normalizedName = String(name);\n			const normalizedValue = String(value);\n			const next = [];\n			let replaced = false;\n			for (const entry of this.#entries) {\n				if (entry[0] !== normalizedName) {\n					next.push(entry);\n					continue;\n				}\n				if (!replaced) {\n					next.push([normalizedName, normalizedValue]);\n					replaced = true;\n				}\n			}\n			if (!replaced) next.push([normalizedName, normalizedValue]);\n			this.#entries = next;\n			this.#onChange?.();\n		}\n		toString() {\n			return this.#entries.map(([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(value)}`).join(\"&\");\n		}\n		values() {\n			return this.#entries.map(([, value]) => value)[Symbol.iterator]();\n		}\n		[Symbol.iterator]() {\n			return this.entries();\n		}\n	};\n	function decodeUrlParam(value) {\n		return decodeURIComponent(value.replace(/\\+/gu, \" \"));\n	}\n	function parseAbsoluteUrl(input) {\n		const match = /^(?<protocol>[a-zA-Z][a-zA-Z\\d+.-]*:)\\/\\/(?<host>[^/?#]*)(?<pathname>[^?#]*)?(?<search>\\?[^#]*)?(?<hash>#.*)?$/u.exec(input);\n		if (!match?.groups?.protocol || !match.groups.host) return;\n		return {\n			protocol: match.groups.protocol,\n			host: match.groups.host,\n			pathname: match.groups.pathname || \"/\",\n			search: match.groups.search || \"\",\n			hash: match.groups.hash || \"\"\n		};\n	}\n	function normalizePathname(pathname) {\n		const segments = [];\n		for (const part of pathname.split(\"/\")) {\n			if (!part || part === \".\") continue;\n			if (part === \"..\") {\n				segments.pop();\n				continue;\n			}\n			segments.push(part);\n		}\n		return `/${segments.join(\"/\")}`;\n	}\n	function resolveUrl(input, base) {\n		const absolute = parseAbsoluteUrl(input);\n		if (absolute) return absolute;\n		if (base === void 0) throw new TypeError(`Invalid URL: ${input}`);\n		const baseUrl = base instanceof URLShim ? base : new URLShim(String(base));\n		const basePath = baseUrl.pathname.endsWith(\"/\") ? baseUrl.pathname : baseUrl.pathname.slice(0, baseUrl.pathname.lastIndexOf(\"/\") + 1);\n		const [beforeHash, rawHash = \"\"] = input.split(\"#\");\n		const hasExplicitSearch = beforeHash?.includes(\"?\") ?? false;\n		const [rawPath, rawSearch = \"\"] = (beforeHash ?? \"\").split(\"?\");\n		const pathname = rawPath === \"\" && (input === \"\" || input.startsWith(\"?\") || input.startsWith(\"#\")) ? baseUrl.pathname : rawPath?.startsWith(\"/\") ? rawPath : `${basePath}${rawPath || \"\"}`;\n		return {\n			protocol: baseUrl.protocol,\n			host: baseUrl.host,\n			pathname: normalizePathname(pathname),\n			search: hasExplicitSearch ? `?${rawSearch}` : rawPath === \"\" && (input === \"\" || input.startsWith(\"#\")) ? baseUrl.search : \"\",\n			hash: rawHash ? `#${rawHash}` : \"\"\n		};\n	}\n	var URLShim = class {\n		host;\n		hostname;\n		origin;\n		password = \"\";\n		port;\n		protocol;\n		searchParams;\n		username = \"\";\n		hash;\n		pathname;\n		#search;\n		constructor(input, base) {\n			const parsed = resolveUrl(String(input), base);\n			this.protocol = parsed.protocol;\n			this.host = parsed.host;\n			const portIndex = this.host.lastIndexOf(\":\");\n			this.hostname = portIndex >= 0 ? this.host.slice(0, portIndex) : this.host;\n			this.port = portIndex >= 0 ? this.host.slice(portIndex + 1) : \"\";\n			this.pathname = parsed.pathname;\n			this.#search = parsed.search;\n			this.hash = parsed.hash;\n			this.origin = `${this.protocol}//${this.host}`;\n			this.searchParams = new URLSearchParamsShim(this.#search, () => {\n				const next = this.searchParams.toString();\n				this.#search = next ? `?${next}` : \"\";\n			});\n		}\n		get href() {\n			return `${this.origin}${this.pathname}${this.#search}${this.hash}`;\n		}\n		get search() {\n			return this.#search;\n		}\n		toString() {\n			return this.href;\n		}\n		toJSON() {\n			return this.href;\n		}\n	};\n	var ReadableStreamShim = class {\n		#queue = [];\n		#closed = false;\n		#pulling = false;\n		#source;\n		#controller;\n		#pending;\n		constructor(source = {}) {\n			this.#source = source;\n			this.#controller = {\n				enqueue: (value) => {\n					if (this.#pending) {\n						this.#pending.resolve({\n							done: false,\n							value\n						});\n						this.#pending = void 0;\n						return;\n					}\n					this.#queue.push(value);\n				},\n				close: () => {\n					this.#closed = true;\n					if (this.#pending) {\n						this.#pending.resolve({ done: true });\n						this.#pending = void 0;\n					}\n				}\n			};\n			source.start?.(this.#controller);\n		}\n		async #pull() {\n			if (this.#pulling || this.#closed || !this.#source.pull) return;\n			this.#pulling = true;\n			try {\n				await this.#source.pull(this.#controller);\n			} finally {\n				this.#pulling = false;\n			}\n		}\n		getReader() {\n			return { read: async () => {\n				if (this.#queue.length > 0) return {\n					done: false,\n					value: this.#queue.shift()\n				};\n				await this.#pull();\n				if (this.#queue.length > 0) return {\n					done: false,\n					value: this.#queue.shift()\n				};\n				if (this.#closed) return {\n					done: true,\n					value: void 0\n				};\n				return await new Promise((resolve) => {\n					this.#pending = { resolve };\n					this.#pull();\n				});\n			} };\n		}\n	};\n	var WritableStreamShim = class {\n		#sink;\n		constructor(sink = {}) {\n			this.#sink = sink;\n		}\n		getWriter() {\n			return {\n				write: async (chunk) => {\n					await this.#sink.write?.(chunk);\n				},\n				close: async () => {\n					await this.#sink.close?.();\n				}\n			};\n		}\n	};\n	var TransformStreamShim = class {\n		readable;\n		writable;\n		constructor(transformer = {}) {\n			const queue = [];\n			let closed = false;\n			let pending;\n			const controller = {\n				enqueue: (value) => {\n					if (pending) {\n						pending.resolve({\n							done: false,\n							value\n						});\n						pending = void 0;\n						return;\n					}\n					queue.push(value);\n				},\n				close: () => {\n					closed = true;\n					if (pending) {\n						pending.resolve({ done: true });\n						pending = void 0;\n					}\n				}\n			};\n			this.readable = { getReader() {\n				return { read: async () => {\n					if (queue.length > 0) return {\n						done: false,\n						value: queue.shift()\n					};\n					if (closed) return {\n						done: true,\n						value: void 0\n					};\n					return await new Promise((resolve) => {\n						pending = { resolve };\n					});\n				} };\n			} };\n			this.writable = new WritableStreamShim({\n				write: async (chunk) => {\n					transformer.transform?.(chunk, controller);\n				},\n				close: async () => {\n					transformer.flush?.(controller);\n					controller.close();\n				}\n			});\n		}\n	};\n	function definePlatformGlobal(name, value, options = {}) {\n		if (!options.overwrite && name in globalThis) return;\n		Object.defineProperty(globalThis, name, {\n			value,\n			writable: true,\n			configurable: true\n		});\n	}\n	function formatLogArg(value) {\n		if (typeof value === \"string\") return value;\n		try {\n			return JSON.stringify(value);\n		} catch {\n			return String(value);\n		}\n	}\n	function formatLogLine(args) {\n		return args.map(formatLogArg).join(\" \");\n	}\n	const platformConsole = {\n		log: (...args) => __caplets_log(\"log\", formatLogLine(args)),\n		info: (...args) => __caplets_log(\"info\", formatLogLine(args)),\n		warn: (...args) => __caplets_log(\"warn\", formatLogLine(args)),\n		error: (...args) => __caplets_log(\"error\", formatLogLine(args)),\n		debug: (...args) => __caplets_log(\"debug\", formatLogLine(args))\n	};\n	function normalizeEncoding(encoding) {\n		const normalized = (encoding ?? \"utf8\").toLowerCase();\n		switch (normalized) {\n			case \"utf8\":\n			case \"utf-8\":\n			case \"base64\":\n			case \"base64url\":\n			case \"hex\": return normalized;\n			default: throw new TypeError(`Unsupported Buffer encoding: ${encoding}`);\n		}\n	}\n	function hexToBytes(value) {\n		if (value.length % 2 !== 0) throw new TypeError(\"Invalid hex string length\");\n		const bytes = new Uint8Array(value.length / 2);\n		for (let index = 0; index < value.length; index += 2) {\n			const parsed = Number.parseInt(value.slice(index, index + 2), 16);\n			if (Number.isNaN(parsed)) throw new TypeError(\"Invalid hex string\");\n			bytes[index / 2] = parsed;\n		}\n		return bytes;\n	}\n	function bytesToHex(bytes) {\n		return Array.from(bytes, (value) => value.toString(16).padStart(2, \"0\")).join(\"\");\n	}\n	function base64ToBytes(value, encoding) {\n		let normalized = value.replace(/\\s+/gu, \"\");\n		if (encoding === \"base64url\") normalized = normalized.replace(/-/gu, \"+\").replace(/_/gu, \"/\");\n		const padding = normalized.length % 4;\n		if (padding === 1) throw new TypeError(\"Invalid base64 string\");\n		if (padding > 0) normalized = normalized.padEnd(normalized.length + (4 - padding), \"=\");\n		const output = [];\n		for (let index = 0; index < normalized.length; index += 4) {\n			const values = normalized.slice(index, index + 4).split(\"\").map((char) => char === \"=\" ? 64 : base64Lookup.get(char) ?? NaN);\n			if (values.some((entry) => Number.isNaN(entry))) throw new TypeError(\"Invalid base64 string\");\n			const [a = 0, b = 0, c = 64, d = 64] = values;\n			const triple = a << 18 | b << 12 | (c & 63) << 6 | d & 63;\n			output.push(triple >> 16 & 255);\n			if (c !== 64) output.push(triple >> 8 & 255);\n			if (d !== 64) output.push(triple & 255);\n		}\n		return Uint8Array.from(output);\n	}\n	function bytesToBase64(bytes, encoding) {\n		let output = \"\";\n		for (let index = 0; index < bytes.length; index += 3) {\n			const a = bytes[index] ?? 0;\n			const b = bytes[index + 1] ?? 0;\n			const c = bytes[index + 2] ?? 0;\n			const triple = a << 16 | b << 8 | c;\n			output += BASE64_ALPHABET[triple >> 18 & 63];\n			output += BASE64_ALPHABET[triple >> 12 & 63];\n			output += index + 1 < bytes.length ? BASE64_ALPHABET[triple >> 6 & 63] : \"=\";\n			output += index + 2 < bytes.length ? BASE64_ALPHABET[triple & 63] : \"=\";\n		}\n		if (encoding === \"base64url\") return output.replace(/\\+/gu, \"-\").replace(/\\//gu, \"_\").replace(/=+$/gu, \"\");\n		return output;\n	}\n	function copyBytes(input) {\n		if (input instanceof ArrayBuffer) return new Uint8Array(input.slice(0));\n		return new Uint8Array(input.buffer.slice(input.byteOffset, input.byteOffset + input.byteLength));\n	}\n	function toBytes(input, encoding) {\n		if (input instanceof BufferShim) return input.toUint8Array();\n		if (typeof input === \"string\") switch (normalizeEncoding(encoding)) {\n			case \"utf8\":\n			case \"utf-8\": return textEncoder.encode(input);\n			case \"base64\":\n			case \"base64url\": return base64ToBytes(input, normalizeEncoding(encoding));\n			case \"hex\": return hexToBytes(input);\n		}\n		if (input instanceof ArrayBuffer || ArrayBuffer.isView(input)) return copyBytes(input);\n		if (Array.isArray(input)) return Uint8Array.from(input);\n		throw new TypeError(\"Buffer.from only supports strings, arrays, ArrayBuffers, and typed arrays\");\n	}\n	var BufferShim = class BufferShim {\n		#bytes;\n		byteLength;\n		length;\n		constructor(bytes) {\n			this.#bytes = bytes;\n			this.byteLength = bytes.byteLength;\n			this.length = bytes.length;\n		}\n		static from(input, encoding) {\n			return new BufferShim(toBytes(input, encoding));\n		}\n		static isBuffer(value) {\n			return value instanceof BufferShim;\n		}\n		static byteLength(input, encoding) {\n			return toBytes(input, encoding).byteLength;\n		}\n		toUint8Array() {\n			return new Uint8Array(this.#bytes);\n		}\n		toString(encoding) {\n			switch (normalizeEncoding(encoding)) {\n				case \"utf8\":\n				case \"utf-8\": return textDecoder.decode(this.#bytes);\n				case \"base64\":\n				case \"base64url\": return bytesToBase64(this.#bytes, normalizeEncoding(encoding));\n				case \"hex\": return bytesToHex(this.#bytes);\n			}\n		}\n	};\n	function atobShim(input) {\n		return Array.from(base64ToBytes(String(input), \"base64\"), (value) => String.fromCharCode(value)).join(\"\");\n	}\n	function btoaShim(input) {\n		const bytes = new Uint8Array(input.length);\n		for (let index = 0; index < input.length; index += 1) {\n			const codePoint = input.charCodeAt(index);\n			if (codePoint > 255) throw new TypeError(\"The string to be encoded contains characters outside of Latin1\");\n			bytes[index] = codePoint;\n		}\n		return bytesToBase64(bytes, \"base64\");\n	}\n	function queueMicrotaskShim(callback) {\n		Promise.resolve().then(callback);\n	}\n	var AbortSignalShim = class AbortSignalShim {\n		aborted = false;\n		reason;\n		onabort = null;\n		#listeners = /* @__PURE__ */ new Set();\n		addEventListener(type, listener) {\n			if (type === \"abort\" && listener) this.#listeners.add(listener);\n		}\n		removeEventListener(type, listener) {\n			if (type === \"abort\" && listener) this.#listeners.delete(listener);\n		}\n		dispatchEvent(event) {\n			if (event.type !== \"abort\") return true;\n			this.onabort?.(event);\n			for (const listener of this.#listeners) listener(event);\n			return true;\n		}\n		throwIfAborted() {\n			if (this.aborted) throw this.reason ?? /* @__PURE__ */ new Error(\"Operation was aborted\");\n		}\n		static abort(reason) {\n			const signal = new AbortSignalShim();\n			signal.abort(reason);\n			return signal;\n		}\n		abort(reason) {\n			if (this.aborted) return;\n			this.aborted = true;\n			this.reason = reason;\n			this.dispatchEvent({\n				type: \"abort\",\n				target: this\n			});\n		}\n	};\n	var AbortControllerShim = class {\n		signal = new AbortSignalShim();\n		abort(reason) {\n			this.signal.abort(reason);\n		}\n	};\n	function cloneFormData(input) {\n		const clone = new FormData();\n		for (const [name, value] of input.entries()) {\n			if (value instanceof File) {\n				clone.append(name, new File([value], value.name, { type: value.type }), value.name);\n				continue;\n			}\n			clone.append(name, value);\n		}\n		return clone;\n	}\n	function cloneBodyValue(input) {\n		if (input === null || input === void 0 || typeof input === \"string\") return input;\n		if (input instanceof FormData) return cloneFormData(input);\n		if (input instanceof Blob) return input.slice(0, input.size, input.type);\n		if (input instanceof ArrayBuffer || ArrayBuffer.isView(input)) return copyBytes(input);\n		return input;\n	}\n	function blobFromBody(input) {\n		if (input instanceof Blob) return input;\n		if (typeof input === \"string\") return new Blob([input], { type: \"text/plain;charset=utf-8\" });\n		if (input instanceof FormData) throw new TypeError(\"FormData body reading is not supported in Code Mode\");\n		if (input instanceof ArrayBuffer || ArrayBuffer.isView(input)) return new Blob([copyBytes(input)]);\n		return new Blob([]);\n	}\n	var BodyMixin = class {\n		_bodyInit;\n		bodyUsed = false;\n		body = null;\n		constructor(body) {\n			this._bodyInit = cloneBodyValue(body);\n		}\n		async arrayBuffer() {\n			this.bodyUsed = true;\n			return await blobFromBody(this._bodyInit).arrayBuffer();\n		}\n		async blob() {\n			this.bodyUsed = true;\n			return blobFromBody(this._bodyInit);\n		}\n		async formData() {\n			this.bodyUsed = true;\n			if (this._bodyInit instanceof FormData) return cloneFormData(this._bodyInit);\n			throw new TypeError(\"Body does not contain FormData\");\n		}\n		async json() {\n			return JSON.parse(await this.text());\n		}\n		async text() {\n			this.bodyUsed = true;\n			return await blobFromBody(this._bodyInit).text();\n		}\n	};\n	function toHeaders(init) {\n		return init instanceof Headers ? new Headers(init) : new Headers(init ?? {});\n	}\n	function normalizeMethod(method) {\n		return String(method ?? \"GET\").toUpperCase();\n	}\n	var RequestShim = class RequestShim extends BodyMixin {\n		headers;\n		method;\n		signal;\n		url;\n		constructor(input, init = {}) {\n			const sourceBody = input instanceof RequestShim ? input._bodyInit : void 0;\n			super(init.body ?? sourceBody);\n			if (input instanceof RequestShim) this.url = input.url;\n			else this.url = input instanceof URLShim ? input.href : new URLShim(String(input)).href;\n			this.method = normalizeMethod(init.method ?? (input instanceof RequestShim ? input.method : \"GET\"));\n			this.headers = toHeaders(init.headers ?? (input instanceof RequestShim ? input.headers : void 0));\n			this.signal = init.signal ?? (input instanceof RequestShim ? input.signal : new AbortControllerShim().signal);\n		}\n		clone() {\n			return new RequestShim(this, {\n				method: this.method,\n				headers: this.headers,\n				body: this._bodyInit,\n				signal: this.signal\n			});\n		}\n	};\n	var ResponseShim = class ResponseShim extends BodyMixin {\n		headers;\n		ok;\n		redirected = false;\n		status;\n		statusText;\n		type = \"default\";\n		url = \"\";\n		constructor(body, init = {}) {\n			super(body);\n			this.status = init.status ?? 200;\n			this.statusText = init.statusText ?? \"\";\n			this.headers = toHeaders(init.headers);\n			this.ok = this.status >= 200 && this.status <= 299;\n		}\n		clone() {\n			return new ResponseShim(this._bodyInit, {\n				headers: this.headers,\n				status: this.status,\n				statusText: this.statusText\n			});\n		}\n		static json(data, init) {\n			const headers = toHeaders(init?.headers);\n			if (!headers.has(\"content-type\")) headers.set(\"content-type\", \"application/json\");\n			const responseInit = { headers };\n			if (init?.status !== void 0) responseInit.status = init.status;\n			if (init?.statusText !== void 0) responseInit.statusText = init.statusText;\n			return new ResponseShim(JSON.stringify(data), responseInit);\n		}\n	};\n	function disabledFetch() {\n		throw new Error(DISABLED_FETCH_MESSAGE);\n	}\n	const integerTypedArrayConstructors = new Set([\n		Int8Array,\n		Uint8Array,\n		Uint8ClampedArray,\n		Int16Array,\n		Uint16Array,\n		Int32Array,\n		Uint32Array,\n		typeof BigInt64Array === \"undefined\" ? void 0 : BigInt64Array,\n		typeof BigUint64Array === \"undefined\" ? void 0 : BigUint64Array\n	]);\n	var QuotaExceededErrorShim = class extends Error {\n		constructor(message) {\n			super(message);\n			this.name = \"QuotaExceededError\";\n		}\n	};\n	const platformCrypto = {\n		randomUUID() {\n			const randomUUID = capletsPlatformHost.randomUUID;\n			if (!randomUUID) throw new Error(\"Code Mode platform random UUID bridge is not installed\");\n			return randomUUID();\n		},\n		getRandomValues(typedArray) {\n			if (!ArrayBuffer.isView(typedArray) || typedArray instanceof DataView) throw new TypeError(\"crypto.getRandomValues requires an integer typed array\");\n			if (!integerTypedArrayConstructors.has(typedArray.constructor)) throw new TypeError(\"crypto.getRandomValues requires an integer typed array\");\n			if (typedArray.byteLength > 65536) throw new QuotaExceededErrorShim(\"crypto.getRandomValues cannot generate more than 65,536 bytes\");\n			const randomValues = capletsPlatformHost.randomValues;\n			if (!randomValues) throw new Error(\"Code Mode platform random values bridge is not installed\");\n			const bytes = randomValues(typedArray.byteLength);\n			new Uint8Array(typedArray.buffer, typedArray.byteOffset, typedArray.byteLength).set(bytes);\n			return typedArray;\n		}\n	};\n	let nextTimerId = 1;\n	const activeTimers = /* @__PURE__ */ new Set();\n	function normalizeTimerDelay(delay) {\n		const value = Number(delay ?? 0);\n		if (!Number.isFinite(value) || value <= 0) return 0;\n		return Math.trunc(value);\n	}\n	function setTimeoutShim(callback, delay, ...args) {\n		if (typeof callback !== \"function\") throw new TypeError(\"setTimeout callback must be a function\");\n		const timerId = nextTimerId++;\n		activeTimers.add(timerId);\n		const sleep = capletsPlatformHost.sleep;\n		if (!sleep) throw new Error(\"Code Mode platform sleep bridge is not installed\");\n		sleep(timerId, normalizeTimerDelay(delay)).then((fired) => {\n			activeTimers.delete(timerId);\n			if (fired) callback(...args);\n		});\n		return timerId;\n	}\n	function clearTimeoutShim(timerId) {\n		const id = Number(timerId);\n		activeTimers.delete(id);\n		capletsPlatformHost.clearTimer?.(id);\n	}\n	function setIntervalShim(callback, delay, ...args) {\n		if (typeof callback !== \"function\") throw new TypeError(\"setInterval callback must be a function\");\n		const timerId = nextTimerId++;\n		const intervalDelay = normalizeTimerDelay(delay);\n		activeTimers.add(timerId);\n		const tick = () => {\n			const sleep = capletsPlatformHost.sleep;\n			if (!sleep) throw new Error(\"Code Mode platform sleep bridge is not installed\");\n			sleep(timerId, intervalDelay).then((fired) => {\n				if (!fired || !activeTimers.has(timerId)) {\n					activeTimers.delete(timerId);\n					return;\n				}\n				callback(...args);\n				if (activeTimers.has(timerId)) tick();\n			});\n		};\n		tick();\n		return timerId;\n	}\n	function clearIntervalShim(timerId) {\n		clearTimeoutShim(timerId);\n	}\n	definePlatformGlobal(\"atob\", atobShim);\n	definePlatformGlobal(\"btoa\", btoaShim);\n	definePlatformGlobal(\"Buffer\", BufferShim);\n	definePlatformGlobal(\"TextEncoder\", TextEncoderShim);\n	definePlatformGlobal(\"TextDecoder\", TextDecoderShim);\n	definePlatformGlobal(\"URL\", URLShim);\n	definePlatformGlobal(\"URLSearchParams\", URLSearchParamsShim);\n	definePlatformGlobal(\"structuredClone\", esm_default);\n	definePlatformGlobal(\"Headers\", Headers);\n	definePlatformGlobal(\"Blob\", Blob);\n	definePlatformGlobal(\"File\", File);\n	definePlatformGlobal(\"FormData\", FormData);\n	definePlatformGlobal(\"ReadableStream\", ReadableStreamShim);\n	definePlatformGlobal(\"WritableStream\", WritableStreamShim);\n	definePlatformGlobal(\"TransformStream\", TransformStreamShim);\n	definePlatformGlobal(\"AbortController\", AbortControllerShim);\n	definePlatformGlobal(\"AbortSignal\", AbortSignalShim);\n	definePlatformGlobal(\"Request\", RequestShim);\n	definePlatformGlobal(\"Response\", ResponseShim);\n	definePlatformGlobal(\"crypto\", platformCrypto);\n	definePlatformGlobal(\"setTimeout\", setTimeoutShim);\n	definePlatformGlobal(\"clearTimeout\", clearTimeoutShim);\n	definePlatformGlobal(\"setInterval\", setIntervalShim);\n	definePlatformGlobal(\"clearInterval\", clearIntervalShim);\n	definePlatformGlobal(\"queueMicrotask\", queueMicrotaskShim);\n	definePlatformGlobal(\"console\", platformConsole);\n	definePlatformGlobal(\"fetch\", disabledFetch, { overwrite: true });\n	//#endregion\n})();";
 //#endregion
 //#region src/code-mode/sandbox.ts
+const CODE_MODE_SANDBOX_METHODS = new Set([
+	"inspect",
+	"check",
+	"tools",
+	"searchTools",
+	"describeTool",
+	"callTool",
+	"resources",
+	"searchResources",
+	"resourceTemplates",
+	"readResource",
+	"prompts",
+	"searchPrompts",
+	"getPrompt",
+	"complete",
+	"readLogs",
+	"readRecovery"
+]);
+const CODE_MODE_DEBUG_METHODS = new Set(["readLogs", "readRecovery"]);
 var QuickJsCodeModeSandbox = class {
 	async run(input) {
 		return await evaluateInQuickJs(input);
 	}
+	async createSession() {
+		return new QuickJsCodeModeReplSession((await getQuickJS()).newRuntime());
+	}
+};
+var QuickJsCodeModeReplSession = class {
+	#runtime;
+	#context;
+	#pendingDeferreds = /* @__PURE__ */ new Set();
+	#pendingInvokes = /* @__PURE__ */ new Set();
+	#platformHost;
+	#capletIds = /* @__PURE__ */ new Set();
+	#persistentNames = /* @__PURE__ */ new Set();
+	#invoke = async () => {
+		throw new Error("Code Mode invoke bridge is not initialized.");
+	};
+	#deadlineMs = 0;
+	#timeoutMs = 0;
+	#logs = [];
+	#disposed = false;
+	#running = false;
+	#disposeRequested = false;
+	#globalNameCheckpoint = /* @__PURE__ */ new Set();
+	#persistDescriptorCheckpoint = "";
+	#checkpointToken = randomUUID();
+	constructor(runtime) {
+		this.#runtime = runtime;
+		this.#runtime.setMemoryLimit(64 * 1024 * 1024);
+		this.#runtime.setMaxStackSize(1 * 1024 * 1024);
+		this.#context = runtime.newContext();
+		this.#installStableBridges();
+		this.#platformHost = installCodeModePlatformHost(this.#context, this.#pendingDeferreds, {});
+		this.#evalInitSource();
+	}
+	async run(input) {
+		if (this.#disposed) return {
+			ok: false,
+			error: "Code Mode session is disposed.",
+			logs: []
+		};
+		if (this.#disposeRequested) return {
+			ok: false,
+			error: "Code Mode session is disposed.",
+			logs: []
+		};
+		if (this.#running) return {
+			ok: false,
+			error: "Code Mode session is already running.",
+			logs: []
+		};
+		this.#running = true;
+		const timeoutMs = Math.max(100, input.timeoutMs);
+		const deadlineMs = Date.now() + timeoutMs;
+		this.#runtime.setInterruptHandler(shouldInterruptAfterDeadline(deadlineMs));
+		this.#logs = [];
+		let shouldDispose = false;
+		try {
+			this.#refreshInvokeBridge(input.invoke, deadlineMs, timeoutMs);
+			const bridgeResult = this.#context.evalCode(buildBridgeRefreshSource(input.capletIds, [...this.#capletIds]));
+			if (bridgeResult.error) {
+				const error = this.#context.dump(bridgeResult.error);
+				bridgeResult.error.dispose();
+				const result = {
+					ok: false,
+					error: normalizeError(error, deadlineMs, timeoutMs),
+					logs: this.#logs,
+					...optionalStack(stackFromDump(error))
+				};
+				shouldDispose = isTimeoutMessage(result.error, timeoutMs);
+				return result;
+			}
+			bridgeResult.value.dispose();
+			this.#capletIds = new Set(input.capletIds);
+			const cell = buildSessionCellSource(input.code, input.capletIds, [...this.#persistentNames], this.#checkpointToken);
+			const resetResult = this.#context.evalCode(buildPlatformResetSource());
+			if (resetResult.error) {
+				const error = this.#context.dump(resetResult.error);
+				resetResult.error.dispose();
+				const result = {
+					ok: false,
+					error: `Code Mode session state is corrupted: ${normalizeError(error, deadlineMs, timeoutMs)}`,
+					logs: this.#logs,
+					...optionalStack(stackFromDump(error))
+				};
+				shouldDispose = true;
+				return result;
+			}
+			resetResult.value.dispose();
+			this.#snapshotGlobalNames();
+			this.#snapshotPersistDescriptors();
+			this.#snapshotPersistentNames([...this.#persistentNames]);
+			let pendingInvokePersistentValuesChanged = false;
+			const result = await evaluateCellInContext({
+				code: input.code,
+				compiledSource: cell.source,
+				context: this.#context,
+				runtime: this.#runtime,
+				pendingDeferreds: this.#pendingDeferreds,
+				pendingInvokes: this.#pendingInvokes,
+				deadlineMs,
+				timeoutMs,
+				logs: this.#logs,
+				session: true,
+				afterPendingInvokesDrained: () => {
+					pendingInvokePersistentValuesChanged = this.#persistentValuesDivergedFromPersist(cell.persistentNames);
+					this.#snapshotPersistentNames(cell.persistentNames);
+				}
+			});
+			if (result.ok) {
+				for (const name of cell.persistentNames) this.#persistentNames.add(name);
+				this.#snapshotPersistentNames(cell.persistentNames);
+			} else {
+				this.#restorePersistentNames([...this.#persistentNames]);
+				this.#rollbackNewPersistentNames(cell.newNames);
+			}
+			const platformRestored = result.ok ? this.#restorePlatformAfterRun() : true;
+			const persistenceDescriptorsOk = result.ok && platformRestored ? this.#persistentDescriptorsOk(cell.persistentNames) : true;
+			const persistentGlobalDescriptorsOk = this.#persistentGlobalDescriptorsOk(result.ok ? cell.persistentNames : [...this.#persistentNames]);
+			const hasGlobalNameAdditions = this.#hasGlobalNameAdditions(result.ok ? cell.persistentNames : []);
+			const directPersistAccess = this.#isPersistTainted();
+			const persistDescriptorsChanged = this.#persistDescriptorsChanged(result.ok ? cell.snapshotNames : []);
+			const hasObjectLikePersistentState = this.#hasObjectLikePersistentState();
+			shouldDispose = result.ok ? pendingInvokePersistentValuesChanged || this.#pendingDeferreds.size > 0 || hasGlobalNameAdditions || directPersistAccess || persistDescriptorsChanged || !this.#isGlobalExtensible() || !persistentGlobalDescriptorsOk || !persistenceDescriptorsOk || !platformRestored : isTimeoutMessage(result.error, timeoutMs) || this.#pendingDeferreds.size > 0 || cell.newNames.length > 0 || hasGlobalNameAdditions || directPersistAccess || persistDescriptorsChanged || hasObjectLikePersistentState || !persistentGlobalDescriptorsOk || !this.#isGlobalExtensible();
+			if (!shouldDispose) this.#clearPendingDeferreds();
+			return result;
+		} catch (error) {
+			const result = {
+				ok: false,
+				error: normalizeError(error, deadlineMs, timeoutMs),
+				logs: this.#logs,
+				...optionalStack(stackFromError(error))
+			};
+			shouldDispose = true;
+			return result;
+		} finally {
+			this.#running = false;
+			if (!this.#disposed) this.#runtime.setInterruptHandler(() => false);
+			if (shouldDispose) this.dispose();
+			if (this.#disposeRequested) this.#disposeNow();
+		}
+	}
+	dispose() {
+		if (this.#disposed) return;
+		if (this.#running) {
+			this.#disposeRequested = true;
+			return;
+		}
+		this.#disposeNow();
+	}
+	isDisposed() {
+		return this.#disposed;
+	}
+	#disposeNow() {
+		if (this.#disposed) return;
+		this.#disposeRequested = false;
+		this.#disposed = true;
+		this.#platformHost.dispose();
+		for (const deferred of this.#pendingDeferreds) if (deferred.alive) deferred.dispose();
+		this.#pendingDeferreds.clear();
+		this.#pendingInvokes.clear();
+		this.#context.dispose();
+		this.#runtime.dispose();
+	}
+	#installStableBridges() {
+		const logBridge = this.#context.newFunction("__caplets_log", (levelHandle, messageHandle) => {
+			this.#logs.push({
+				level: logLevel(this.#context.getString(levelHandle)),
+				message: this.#context.getString(messageHandle),
+				timestamp: (/* @__PURE__ */ new Date()).toISOString()
+			});
+			return this.#context.undefined;
+		});
+		this.#context.setProp(this.#context.global, "__caplets_log", logBridge);
+		logBridge.dispose();
+		const invokeBridge = createInvokeJsonBridge(this.#context, this.#pendingDeferreds, this.#pendingInvokes, () => this.#invoke, () => this.#deadlineMs, () => this.#timeoutMs, (capletId) => this.#capletIds.has(capletId));
+		this.#context.setProp(this.#context.global, "__caplets_invoke_json", invokeBridge);
+		invokeBridge.dispose();
+		const activeCapletBridge = this.#context.newFunction("__caplets_is_active_id", (capletIdHandle) => this.#capletIds.has(this.#context.getString(capletIdHandle)) ? this.#context.true : this.#context.false);
+		this.#context.setProp(this.#context.global, "__caplets_is_active_id", activeCapletBridge);
+		activeCapletBridge.dispose();
+		const protectInvokeBridge = this.#context.evalCode([
+			"Object.defineProperty(globalThis, '__caplets_log', { configurable: false, writable: false, value: globalThis.__caplets_log });",
+			"Object.defineProperty(globalThis, '__caplets_invoke_json', { configurable: false, writable: false, value: globalThis.__caplets_invoke_json });",
+			"Object.defineProperty(globalThis, '__caplets_is_active_id', { configurable: false, writable: false, value: globalThis.__caplets_is_active_id });"
+		].join("\n"));
+		if (protectInvokeBridge.error) {
+			const error = this.#context.dump(protectInvokeBridge.error);
+			protectInvokeBridge.error.dispose();
+			throw new Error(errorMessage$2(error));
+		}
+		protectInvokeBridge.value.dispose();
+	}
+	#evalInitSource() {
+		const result = this.#context.evalCode(buildSessionInitSource(this.#checkpointToken));
+		if (result.error) {
+			const error = this.#context.dump(result.error);
+			result.error.dispose();
+			throw new Error(errorMessage$2(error));
+		}
+		result.value.dispose();
+	}
+	#refreshInvokeBridge(invoke, deadlineMs, timeoutMs) {
+		this.#invoke = invoke;
+		this.#deadlineMs = deadlineMs;
+		this.#timeoutMs = timeoutMs;
+	}
+	#rollbackNewPersistentNames(names) {
+		if (names.length === 0 || this.#disposed) return;
+		const result = this.#context.evalCode(names.map((name) => `(0, eval)(${JSON.stringify(`${name} = undefined;`)});`).join("\n"));
+		if (result.error) {
+			result.error.dispose();
+			return;
+		}
+		result.value.dispose();
+	}
+	#clearPendingDeferreds() {
+		this.#platformHost.dispose();
+		for (const deferred of this.#pendingDeferreds) if (deferred.alive) deferred.dispose();
+		this.#pendingDeferreds.clear();
+	}
+	#snapshotGlobalNames() {
+		if (this.#disposed) return;
+		const result = this.#context.evalCode("__caplets_global_keys()");
+		if (result.error) {
+			result.error.dispose();
+			return;
+		}
+		const names = this.#context.dump(result.value);
+		this.#globalNameCheckpoint = new Set(names.filter((name) => !this.#isInternalGlobalName(name)));
+		result.value.dispose();
+	}
+	#snapshotPersistDescriptors() {
+		if (this.#disposed) return;
+		const result = this.#context.evalCode("__caplets_persist_descriptor_fingerprint()");
+		if (result.error) {
+			result.error.dispose();
+			this.#persistDescriptorCheckpoint = "";
+			return;
+		}
+		this.#persistDescriptorCheckpoint = String(this.#context.dump(result.value));
+		result.value.dispose();
+	}
+	#persistDescriptorsChanged(allowedNames = []) {
+		if (this.#disposed) return false;
+		const result = this.#context.evalCode(`__caplets_persist_descriptor_fingerprint(${JSON.stringify(allowedNames)})`);
+		if (result.error) {
+			result.error.dispose();
+			return true;
+		}
+		const fingerprint = String(this.#context.dump(result.value));
+		result.value.dispose();
+		return fingerprint !== filterPersistDescriptorFingerprint(this.#persistDescriptorCheckpoint, allowedNames);
+	}
+	#hasGlobalNameAdditions(allowedNames = []) {
+		if (this.#disposed) return false;
+		const result = this.#context.evalCode("__caplets_global_keys()");
+		if (result.error) {
+			result.error.dispose();
+			return true;
+		}
+		const names = this.#context.dump(result.value);
+		const allowedTokens = new Set(allowedNames.map((name) => `string:${name}`));
+		const hasAdditions = names.filter((name) => !this.#isInternalGlobalName(name)).filter((name) => !allowedTokens.has(name)).some((name) => !this.#globalNameCheckpoint.has(name));
+		result.value.dispose();
+		return hasAdditions;
+	}
+	#isGlobalExtensible() {
+		if (this.#disposed) return false;
+		const result = this.#context.evalCode("__caplets_is_global_extensible()");
+		if (result.error) {
+			result.error.dispose();
+			return false;
+		}
+		const isExtensible = this.#context.dump(result.value) === true;
+		result.value.dispose();
+		return isExtensible;
+	}
+	#restorePlatformAfterRun() {
+		if (this.#disposed) return false;
+		const result = this.#context.evalCode(buildPlatformResetSource());
+		if (result.error) {
+			result.error.dispose();
+			return false;
+		}
+		result.value.dispose();
+		return true;
+	}
+	#persistentDescriptorsOk(names) {
+		if (names.length === 0 || this.#disposed) return true;
+		const result = this.#context.evalCode(`__caplets_persist_descriptors_ok(${JSON.stringify(this.#checkpointToken)}, ${JSON.stringify(names)})`);
+		if (result.error) {
+			result.error.dispose();
+			return false;
+		}
+		const ok = this.#context.dump(result.value) === true;
+		result.value.dispose();
+		return ok;
+	}
+	#isPersistTainted() {
+		if (this.#disposed) return false;
+		const result = this.#context.evalCode(`__caplets_persist_is_tainted(${JSON.stringify(this.#checkpointToken)})`);
+		if (result.error) {
+			result.error.dispose();
+			return true;
+		}
+		const tainted = this.#context.dump(result.value) === true;
+		result.value.dispose();
+		return tainted;
+	}
+	#hasObjectLikePersistentState() {
+		if (this.#disposed || this.#persistentNames.size === 0) return false;
+		const result = this.#context.evalCode(`__caplets_persist_has_object_like_values(${JSON.stringify(this.#checkpointToken)}, ${JSON.stringify([...this.#persistentNames])})`);
+		if (result.error) {
+			result.error.dispose();
+			return true;
+		}
+		const hasObjectLike = this.#context.dump(result.value) === true;
+		result.value.dispose();
+		return hasObjectLike;
+	}
+	#persistentGlobalDescriptorsOk(names) {
+		if (names.length === 0 || this.#disposed) return true;
+		const result = this.#context.evalCode(`__caplets_persist_global_descriptors_ok(${JSON.stringify(this.#checkpointToken)}, ${JSON.stringify(names)})`);
+		if (result.error) {
+			result.error.dispose();
+			return false;
+		}
+		const ok = this.#context.dump(result.value) === true;
+		result.value.dispose();
+		return ok;
+	}
+	#isInternalGlobalName(name) {
+		return name === "string:__caplets_log" || name === "string:__caplets_invoke_json" || name === "string:__caplets_is_active_id" || name === "string:__caplets_restore_platform" || name === "string:__caplets_global_keys" || name === "string:__caplets_assert_active_id" || name === "string:__caplets_handle" || name === "string:__caplets_persist" || name === "string:__caplets_persist_descriptor_fingerprint" || name === "string:__caplets_persist_descriptors_ok" || name === "string:__caplets_persist_is_tainted" || name === "string:__caplets_persist_has_object_like_values" || name === "string:__caplets_persist_global_descriptors_ok" || name === "string:__caplets_get_persist" || name === "string:__caplets_set_persist" || name === "string:__caplets_snapshot_persist" || name === "string:__caplets_checkpoint_value" || name === "string:__caplets_observe_promise" || name === "string:__caplets_json_parse";
+	}
+	#snapshotPersistentNames(names) {
+		if (names.length === 0 || this.#disposed) return;
+		const result = this.#context.evalCode(`globalThis.__caplets_snapshot_persist(${JSON.stringify(this.#checkpointToken)}, ${JSON.stringify(names)});`);
+		if (result.error) {
+			result.error.dispose();
+			return;
+		}
+		result.value.dispose();
+	}
+	#persistentValuesDivergedFromPersist(names) {
+		if (this.#disposed || names.length === 0) return false;
+		const result = this.#context.evalCode(`(${JSON.stringify(names)}).some((name) => !Object.is((0, eval)(name), globalThis.__caplets_get_persist(${JSON.stringify(this.#checkpointToken)}, name)))`);
+		if (result.error) {
+			result.error.dispose();
+			return true;
+		}
+		try {
+			return this.#context.dump(result.value) === true;
+		} finally {
+			result.value.dispose();
+		}
+	}
+	#restorePersistentNames(names) {
+		if (names.length === 0 || this.#disposed) return;
+		const result = this.#context.evalCode(names.map((name) => [`globalThis.__caplets_set_persist(${JSON.stringify(this.#checkpointToken)}, ${JSON.stringify(name)}, globalThis.__caplets_checkpoint_value(${JSON.stringify(this.#checkpointToken)}, ${JSON.stringify(name)}));`, `(0, eval)(${JSON.stringify(`${name} = globalThis.__caplets_checkpoint_value(${JSON.stringify(this.#checkpointToken)}, ${JSON.stringify(name)});`)});`].join("\n")).join("\n"));
+		if (result.error) {
+			result.error.dispose();
+			return;
+		}
+		result.value.dispose();
+	}
 };
 async function evaluateInQuickJs(input) {
 	const timeoutMs = Math.max(100, input.timeoutMs);
@@ -77223,62 +78209,20 @@ async function evaluateInQuickJs(input) {
 			const invokeBridge = createInvokeBridge(context, pendingDeferreds, input.invoke, deadlineMs, timeoutMs);
 			context.setProp(context.global, "__caplets_invoke", invokeBridge);
 			invokeBridge.dispose();
-			const evaluated = context.evalCode(buildExecutionSource(input.code, input.capletIds));
-			if (evaluated.error) {
-				const error = context.dump(evaluated.error);
-				evaluated.error.dispose();
-				return {
-					ok: false,
-					error: normalizeError(error, deadlineMs, timeoutMs),
-					logs,
-					...optionalStack(stackFromDump(error))
-				};
-			}
-			context.setProp(context.global, "__caplets_result", evaluated.value);
-			evaluated.value.dispose();
-			const stateResult = context.evalCode([
-				"(function(p) {",
-				"  var s = { settled: false, value: void 0, error: void 0 };",
-				"  var formatError = function(e) {",
-				"    if (e && typeof e === 'object' && typeof e.message === 'string') return e.message;",
-				"    return String(e);",
-				"  };",
-				"  p.then(function(value) { s.value = value; s.settled = true; },",
-				"         function(error) { s.error = formatError(error); s.settled = true; });",
-				"  return s;",
-				"})(__caplets_result)"
-			].join("\n"));
-			if (stateResult.error) {
-				const error = context.dump(stateResult.error);
-				stateResult.error.dispose();
-				return {
-					ok: false,
-					error: normalizeError(error, deadlineMs, timeoutMs),
-					logs,
-					...optionalStack(stackFromDump(error))
-				};
-			}
-			const stateHandle = stateResult.value;
 			try {
-				await drainAsync(context, runtime, pendingDeferreds, deadlineMs, timeoutMs);
-				if (!(readProp(context, stateHandle, "settled") === true)) return {
-					ok: false,
-					error: timeoutMessage(timeoutMs),
-					logs
-				};
-				const error = readProp(context, stateHandle, "error");
-				if (typeof error !== "undefined") return {
-					ok: false,
-					error: normalizeError(error, deadlineMs, timeoutMs),
-					logs
-				};
-				return {
-					ok: true,
-					value: readProp(context, stateHandle, "value"),
-					logs
-				};
+				return await evaluateCellInContext({
+					code: input.code,
+					capletIds: input.capletIds,
+					context,
+					runtime,
+					pendingDeferreds,
+					pendingInvokes: pendingDeferreds,
+					deadlineMs,
+					timeoutMs,
+					logs,
+					session: false
+				});
 			} finally {
-				stateHandle.dispose();
 				platformHost.dispose();
 			}
 		} finally {
@@ -77297,6 +78241,96 @@ async function evaluateInQuickJs(input) {
 		runtime.dispose();
 	}
 }
+async function evaluateCellInContext(input) {
+	const observerResult = input.context.evalCode(buildPromiseObserverSource());
+	if (observerResult.error) {
+		const error = input.context.dump(observerResult.error);
+		observerResult.error.dispose();
+		return {
+			ok: false,
+			error: normalizeError(error, input.deadlineMs, input.timeoutMs),
+			logs: input.logs,
+			...optionalStack(stackFromDump(error))
+		};
+	}
+	observerResult.value.dispose();
+	const evaluated = input.context.evalCode(input.compiledSource ?? (input.session ? buildSessionCellSource(input.code, input.capletIds ?? []).source : buildExecutionSource(input.code, input.capletIds ?? [])));
+	if (evaluated.error) {
+		const error = input.context.dump(evaluated.error);
+		evaluated.error.dispose();
+		return {
+			ok: false,
+			error: normalizeError(error, input.deadlineMs, input.timeoutMs),
+			logs: input.logs,
+			...optionalStack(stackFromDump(error))
+		};
+	}
+	const resultName = `__caplets_result_${randomUUID().replace(/-/gu, "_")}`;
+	input.context.setProp(input.context.global, resultName, evaluated.value);
+	evaluated.value.dispose();
+	const stateResult = input.context.evalCode(buildPromiseStateSource(JSON.stringify(resultName)));
+	cleanupTemporaryGlobals(input.context, JSON.stringify(resultName));
+	if (stateResult.error) {
+		const error = input.context.dump(stateResult.error);
+		stateResult.error.dispose();
+		return {
+			ok: false,
+			error: normalizeError(error, input.deadlineMs, input.timeoutMs),
+			logs: input.logs,
+			...optionalStack(stackFromDump(error))
+		};
+	}
+	const stateHandle = stateResult.value;
+	try {
+		if (input.session) {
+			if (input.pendingInvokes.size > 0) {
+				await drainAsync(input.context, input.runtime, input.pendingInvokes, input.deadlineMs, input.timeoutMs);
+				await drainAsync(input.context, input.runtime, input.pendingDeferreds, input.deadlineMs, input.timeoutMs);
+				await Promise.resolve();
+				drainJobs(input.context, input.runtime, input.deadlineMs, input.timeoutMs);
+				input.afterPendingInvokesDrained?.();
+			} else drainJobs(input.context, input.runtime, input.deadlineMs, input.timeoutMs);
+			const earlyResult = readSettledPromiseState(input.context, stateHandle, input.logs);
+			if (earlyResult) return earlyResult;
+		}
+		await drainAsync(input.context, input.runtime, input.pendingDeferreds, input.deadlineMs, input.timeoutMs);
+		if (!(readProp(input.context, stateHandle, "settled") === true)) return {
+			ok: false,
+			error: timeoutMessage(input.timeoutMs),
+			logs: input.logs
+		};
+		return readSettledPromiseState(input.context, stateHandle, input.logs) ?? {
+			ok: false,
+			error: timeoutMessage(input.timeoutMs),
+			logs: input.logs
+		};
+	} finally {
+		stateHandle.dispose();
+	}
+}
+function cleanupTemporaryGlobals(context, ...names) {
+	if (names.length === 0) return;
+	const result = context.evalCode(names.map((name) => `delete globalThis[${name}];`).join("\n"));
+	if (result.error) {
+		result.error.dispose();
+		return;
+	}
+	result.value.dispose();
+}
+function readSettledPromiseState(context, stateHandle, logs) {
+	if (!(readProp(context, stateHandle, "settled") === true)) return;
+	const error = readProp(context, stateHandle, "error");
+	if (typeof error !== "undefined") return {
+		ok: false,
+		error: errorMessage$2(error),
+		logs
+	};
+	return {
+		ok: true,
+		value: readProp(context, stateHandle, "value"),
+		logs
+	};
+}
 function createInvokeBridge(context, pendingDeferreds, invoke, deadlineMs, timeoutMs) {
 	return context.newFunction("__caplets_invoke", (capletHandle, methodHandle, argsHandle) => {
 		const capletId = context.getString(capletHandle);
@@ -77304,7 +78338,10 @@ function createInvokeBridge(context, pendingDeferreds, invoke, deadlineMs, timeo
 		const args = context.dump(argsHandle);
 		const deferred = context.newPromise();
 		pendingDeferreds.add(deferred);
-		deferred.settled.finally(() => pendingDeferreds.delete(deferred));
+		deferred.settled.finally(() => {
+			pendingDeferreds.delete(deferred);
+			if (deferred.alive) deferred.dispose();
+		});
 		invoke({
 			capletId,
 			method,
@@ -77331,6 +78368,78 @@ function createInvokeBridge(context, pendingDeferreds, invoke, deadlineMs, timeo
 		return deferred.handle;
 	});
 }
+function createInvokeJsonBridge(context, pendingDeferreds, pendingInvokes, invoke, deadlineMs, timeoutMs, isCapletActive) {
+	return context.newFunction("__caplets_invoke_json", (capletHandle, methodHandle, argsHandle) => {
+		const capletId = context.getString(capletHandle);
+		const method = context.getString(methodHandle);
+		const args = context.dump(argsHandle);
+		const deferred = context.newPromise();
+		pendingDeferreds.add(deferred);
+		pendingInvokes.add(deferred);
+		deferred.settled.finally(() => {
+			pendingDeferreds.delete(deferred);
+			pendingInvokes.delete(deferred);
+			if (deferred.alive) deferred.dispose();
+		});
+		const debugMethod = CODE_MODE_DEBUG_METHODS.has(method);
+		const debugCapletActive = capletId === "debug" && isCapletActive("debug");
+		if (!isCodeModeSandboxMethod(method) || capletId === "debug" && !debugMethod && !debugCapletActive || capletId !== "debug" && debugMethod) {
+			const errorHandle = context.newError(`Method ${method} is not available in this Code Mode session cell.`);
+			deferred.reject(errorHandle);
+			errorHandle.dispose();
+			return deferred.handle;
+		}
+		if (!(capletId === "debug" && debugMethod) && !isCapletActive(capletId)) {
+			const errorHandle = context.newError(`Caplet ${capletId} is not available in this Code Mode session cell.`);
+			deferred.reject(errorHandle);
+			errorHandle.dispose();
+			return deferred.handle;
+		}
+		invoke()({
+			capletId,
+			method,
+			args
+		}).then((value) => {
+			if (!deferred.alive) return;
+			let valueHandle;
+			try {
+				const serialized = JSON.stringify(value);
+				const parsed = context.evalCode(`globalThis.__caplets_json_parse(${JSON.stringify(serialized ?? "null")})`);
+				if (parsed.error) {
+					const error = context.dump(parsed.error);
+					parsed.error.dispose();
+					throw new Error(errorMessage$2(error));
+				}
+				valueHandle = parsed.value;
+				deferred.resolve(valueHandle);
+			} catch (error) {
+				const errorHandle = context.newError(errorMessage$2(error));
+				deferred.reject(errorHandle);
+				errorHandle.dispose();
+			} finally {
+				valueHandle?.dispose();
+			}
+		}, (error) => {
+			if (!deferred.alive) return;
+			const message = Date.now() >= deadlineMs() ? timeoutMessage(timeoutMs()) : errorMessage$2(error);
+			const errorHandle = context.newError(message);
+			deferred.reject(errorHandle);
+			errorHandle.dispose();
+		});
+		return deferred.handle;
+	});
+}
+function isCodeModeSandboxMethod(method) {
+	return CODE_MODE_SANDBOX_METHODS.has(method);
+}
+function filterPersistDescriptorFingerprint(fingerprint, allowedNames) {
+	if (!fingerprint || allowedNames.length === 0) return fingerprint;
+	const allowedTokens = new Set(allowedNames.map((name) => `string:${name}`));
+	return fingerprint.split("|").filter((entry) => {
+		const token = entry.startsWith("string:") ? entry.slice(0, entry.indexOf(":", 7)) : entry.startsWith("symbol:") ? entry.slice(0, entry.indexOf(":", 7)) : entry;
+		return !allowedTokens.has(token);
+	}).join("|");
+}
 function buildExecutionSource(code, capletIds) {
 	const javascript = ts.transpileModule(code, { compilerOptions: {
 		target: ts.ScriptTarget.ES2022,
@@ -77362,11 +78471,546 @@ function buildExecutionSource(code, capletIds) {
 		...capletIds.map((capletId) => `caplets[${JSON.stringify(capletId)}] = __handle(${JSON.stringify(capletId)});`),
 		"caplets.debug = caplets.debug || {};",
 		"caplets.debug.readLogs = (input) => __invoke('debug', 'readLogs', [input]);",
+		"caplets.debug.readRecovery = (input) => __invoke('debug', 'readRecovery', [input]);",
 		"(async () => {",
 		javascript,
 		"})()"
 	].join("\n");
 }
+function buildSessionInitSource(checkpointToken) {
+	return [
+		CODE_MODE_PLATFORM_RUNTIME_SOURCE,
+		"const __caplets_restore_platform = (() => {",
+		"  const defineProperty = Object.defineProperty.bind(Object);",
+		"  const defineProperties = Object.defineProperties.bind(Object);",
+		"  const getOwnPropertyDescriptors = Object.getOwnPropertyDescriptors.bind(Object);",
+		"  const getPrototypeOf = Object.getPrototypeOf.bind(Object);",
+		"  const setPrototypeOf = Object.setPrototypeOf.bind(Object);",
+		"  const isExtensible = Object.isExtensible.bind(Object);",
+		"  const ownKeys = Reflect.ownKeys.bind(Reflect);",
+		"  const hasOwn = Function.prototype.call.bind(Object.prototype.hasOwnProperty);",
+		"  const arrayPush = Function.prototype.call.bind(Array.prototype.push);",
+		"  const globalSymbolIds = new Map();",
+		"  let nextGlobalSymbolId = 1;",
+		"  const keyToken = (key) => {",
+		"    if (typeof key !== 'symbol') return `string:${key}`;",
+		"    if (!globalSymbolIds.has(key)) globalSymbolIds.set(key, nextGlobalSymbolId++);",
+		"    return `symbol:${globalSymbolIds.get(key)}`;",
+		"  };",
+		"  const platformGlobals = [];",
+		"  const globalPrototypeSnapshot = getPrototypeOf(globalThis);",
+		"  const platformExtraObjects = [",
+		"    ['AsyncFunction.prototype', getPrototypeOf(async function() {})],",
+		"    ['AsyncFunctionConstructor', getPrototypeOf(async function() {}).constructor],",
+		"    ['GeneratorFunction.prototype', getPrototypeOf(function*() {})],",
+		"    ['GeneratorFunctionConstructor', getPrototypeOf(function*() {}).constructor],",
+		"    ['AsyncGeneratorFunction.prototype', getPrototypeOf(async function*() {})],",
+		"    ['AsyncGeneratorFunctionConstructor', getPrototypeOf(async function*() {}).constructor],",
+		"    ['GeneratorObjectPrototype', getPrototypeOf((function*() {})())],",
+		"    ['GeneratorObjectPrototypeParent', getPrototypeOf(getPrototypeOf((function*() {})()))],",
+		"    ['AsyncGeneratorObjectPrototype', getPrototypeOf((async function*() {})())],",
+		"    ['AsyncGeneratorObjectPrototypeParent', getPrototypeOf(getPrototypeOf((async function*() {})()))],",
+		"    ['ArrayIteratorPrototype', getPrototypeOf([][Symbol.iterator]())],",
+		"    ['IteratorPrototype', getPrototypeOf(getPrototypeOf([][Symbol.iterator]()))],",
+		"    ['StringIteratorPrototype', getPrototypeOf(''[Symbol.iterator]())],",
+		"    ['RegExpStringIteratorPrototype', getPrototypeOf(''.matchAll(/(?:)/g))],",
+		"    ['RegExpStringIteratorPrototypeParent', getPrototypeOf(getPrototypeOf(''.matchAll(/(?:)/g)))],",
+		"    ['MapIteratorPrototype', getPrototypeOf(new Map()[Symbol.iterator]())],",
+		"    ['SetIteratorPrototype', getPrototypeOf(new Set()[Symbol.iterator]())],",
+		"    ['TypedArrayConstructor', getPrototypeOf(Int8Array)],",
+		"    ['TypedArrayPrototype', getPrototypeOf(Int8Array.prototype)],",
+		"    ['AsyncFunctionPrototypeParent', getPrototypeOf(getPrototypeOf(async function() {}))],",
+		"    ['GeneratorFunctionPrototypeParent', getPrototypeOf(getPrototypeOf(function*() {}))],",
+		"    ['AsyncGeneratorFunctionPrototypeParent', getPrototypeOf(getPrototypeOf(async function*() {}))],",
+		"  ];",
+		"  const platformExtraSnapshot = Object.create(null);",
+		"  const platformExtraPrototypeSnapshot = Object.create(null);",
+		"  const platformExtraExtensibleSnapshot = Object.create(null);",
+		"  const platformGlobalNames = ownKeys(globalThis);",
+		"  for (const name of platformGlobalNames) {",
+		"    const record = {",
+		"      name,",
+		"      descriptor: Object.getOwnPropertyDescriptor(globalThis, name),",
+		"      value: globalThis[name],",
+		"      objectPrototype: undefined,",
+		"      properties: undefined,",
+		"      prototypeProperties: undefined,",
+		"      prototypeChain: undefined,",
+		"      extensible: undefined,",
+		"      prototypeExtensible: undefined,",
+		"    };",
+		"    const value = globalThis[name];",
+		"    if (value !== globalThis && ((typeof value === 'object' && value !== null) || typeof value === 'function')) {",
+		"      record.objectPrototype = getPrototypeOf(value);",
+		"      record.properties = getOwnPropertyDescriptors(value);",
+		"      record.extensible = isExtensible(value);",
+		"      const prototype = value.prototype;",
+		"      if ((typeof prototype === 'object' && prototype !== null) || typeof prototype === 'function') {",
+		"        record.prototypeChain = getPrototypeOf(prototype);",
+		"        record.prototypeProperties = getOwnPropertyDescriptors(prototype);",
+		"        record.prototypeExtensible = isExtensible(prototype);",
+		"      }",
+		"    }",
+		"    arrayPush(platformGlobals, record);",
+		"  }",
+		"  for (const [name, value] of platformExtraObjects) {",
+		"    if ((typeof value === 'object' && value !== null) || typeof value === 'function') {",
+		"      platformExtraSnapshot[name] = getOwnPropertyDescriptors(value);",
+		"      platformExtraPrototypeSnapshot[name] = getPrototypeOf(value);",
+		"      platformExtraExtensibleSnapshot[name] = isExtensible(value);",
+		"    }",
+		"  }",
+		"  const globalKeys = () => {",
+		"    const keys = ownKeys(globalThis);",
+		"    const tokens = [];",
+		"    for (let index = 0; index < keys.length; index += 1) {",
+		"      const key = keys[index];",
+		"      arrayPush(tokens, keyToken(key));",
+		"    }",
+		"    return tokens;",
+		"  };",
+		"  const restore = () => {",
+		"    if (getPrototypeOf(globalThis) !== globalPrototypeSnapshot) {",
+		"      try { setPrototypeOf(globalThis, globalPrototypeSnapshot); } catch { throw new Error('Code Mode global prototype chain is not restorable'); }",
+		"    }",
+		"    for (const record of platformGlobals) {",
+		"      const name = record.name;",
+		"      try {",
+		"      defineProperty(globalThis, name, record.descriptor);",
+		"      const descriptors = record.properties;",
+		"      const value = globalThis[name];",
+		"      if (descriptors && ((typeof value === 'object' && value !== null) || typeof value === 'function')) {",
+		"        if (record.extensible && !isExtensible(value)) throw new Error(`Code Mode platform global ${String(name)} is non-extensible`);",
+		"        if (getPrototypeOf(value) !== record.objectPrototype) {",
+		"          try { setPrototypeOf(value, record.objectPrototype); } catch { throw new Error(`Code Mode platform global ${String(name)} prototype chain is not restorable`); }",
+		"        }",
+		"        for (const key of ownKeys(value)) {",
+		"          if (!hasOwn(descriptors, key)) {",
+		"            try { delete value[key]; } catch {}",
+		"            if (hasOwn(value, key)) throw new Error(`Code Mode platform global ${String(name)} has non-restorable property ${String(key)}`);",
+		"          }",
+		"        }",
+		"        defineProperties(value, descriptors);",
+		"        const prototypeDescriptors = record.prototypeProperties;",
+		"        const prototype = value.prototype;",
+		"        if (prototypeDescriptors && ((typeof prototype === 'object' && prototype !== null) || typeof prototype === 'function')) {",
+		"          if (record.prototypeExtensible && !isExtensible(prototype)) throw new Error(`Code Mode platform prototype ${String(name)}.prototype is non-extensible`);",
+		"          if (getPrototypeOf(prototype) !== record.prototypeChain) {",
+		"            try { setPrototypeOf(prototype, record.prototypeChain); } catch { throw new Error(`Code Mode platform prototype ${String(name)}.prototype chain is not restorable`); }",
+		"          }",
+		"          for (const key of ownKeys(prototype)) {",
+		"            if (!hasOwn(prototypeDescriptors, key)) {",
+		"              try { delete prototype[key]; } catch {}",
+		"              if (hasOwn(prototype, key)) throw new Error(`Code Mode platform prototype ${String(name)}.prototype has non-restorable property ${String(key)}`);",
+		"            }",
+		"          }",
+		"          defineProperties(prototype, prototypeDescriptors);",
+		"        }",
+		"      }",
+		"      } catch (error) {",
+		"        throw new Error(`Code Mode platform global ${String(name)} is not restorable: ${String(error && error.message ? error.message : error)}`);",
+		"      }",
+		"    }",
+		"    for (const [name, value] of platformExtraObjects) {",
+		"      const descriptors = platformExtraSnapshot[name];",
+		"      if (!descriptors || !((typeof value === 'object' && value !== null) || typeof value === 'function')) continue;",
+		"      if (platformExtraExtensibleSnapshot[name] && !isExtensible(value)) throw new Error(`Code Mode platform intrinsic ${name} is non-extensible`);",
+		"      if (getPrototypeOf(value) !== platformExtraPrototypeSnapshot[name]) {",
+		"        try { setPrototypeOf(value, platformExtraPrototypeSnapshot[name]); } catch { throw new Error(`Code Mode platform intrinsic ${name} prototype chain is not restorable`); }",
+		"      }",
+		"      for (const key of ownKeys(value)) {",
+		"        if (!hasOwn(descriptors, key)) {",
+		"          try { delete value[key]; } catch {}",
+		"          if (hasOwn(value, key)) throw new Error(`Code Mode platform intrinsic ${name} has non-restorable property ${String(key)}`);",
+		"        }",
+		"      }",
+		"      defineProperties(value, descriptors);",
+		"    }",
+		"  };",
+		"  return { restore, globalKeys, isGlobalExtensible: () => isExtensible(globalThis) };",
+		"})();",
+		"Object.defineProperty(globalThis, '__caplets_restore_platform', { configurable: false, writable: false, value: __caplets_restore_platform.restore });",
+		"Object.defineProperty(globalThis, '__caplets_global_keys', { configurable: false, writable: false, value: __caplets_restore_platform.globalKeys });",
+		"Object.defineProperty(globalThis, '__caplets_is_global_extensible', { configurable: false, writable: false, value: __caplets_restore_platform.isGlobalExtensible });",
+		"Object.defineProperty(globalThis, '__caplets_assert_active_id', { configurable: false, writable: false, value: (capletId) => {",
+		"  if (capletId === 'debug' && !__caplets_is_active_id(capletId)) return;",
+		"  if (!__caplets_is_active_id(capletId)) throw new Error(`Caplet ${capletId} is not available in this Code Mode session cell.`);",
+		"} });",
+		"Object.defineProperty(globalThis, '__caplets_handle', { configurable: false, writable: false, value: (capletId) => ({",
+		"  id: capletId,",
+		"  inspect: () => (__caplets_assert_active_id(capletId), __caplets_invoke_json(capletId, 'inspect', [])),",
+		"  check: () => (__caplets_assert_active_id(capletId), __caplets_invoke_json(capletId, 'check', [])),",
+		"  tools: (input) => (__caplets_assert_active_id(capletId), __caplets_invoke_json(capletId, 'tools', [input])),",
+		"  searchTools: (query, input) => (__caplets_assert_active_id(capletId), __caplets_invoke_json(capletId, 'searchTools', [query, input])),",
+		"  describeTool: (name) => (__caplets_assert_active_id(capletId), __caplets_invoke_json(capletId, 'describeTool', [name])),",
+		"  callTool: (name, args) => (__caplets_assert_active_id(capletId), __caplets_invoke_json(capletId, 'callTool', [name, args])),",
+		"  resources: (input) => (__caplets_assert_active_id(capletId), __caplets_invoke_json(capletId, 'resources', [input])),",
+		"  searchResources: (query, input) => (__caplets_assert_active_id(capletId), __caplets_invoke_json(capletId, 'searchResources', [query, input])),",
+		"  resourceTemplates: (input) => (__caplets_assert_active_id(capletId), __caplets_invoke_json(capletId, 'resourceTemplates', [input])),",
+		"  readResource: (uri) => (__caplets_assert_active_id(capletId), __caplets_invoke_json(capletId, 'readResource', [uri])),",
+		"  prompts: (input) => (__caplets_assert_active_id(capletId), __caplets_invoke_json(capletId, 'prompts', [input])),",
+		"  searchPrompts: (query, input) => (__caplets_assert_active_id(capletId), __caplets_invoke_json(capletId, 'searchPrompts', [query, input])),",
+		"  getPrompt: (name, args) => (__caplets_assert_active_id(capletId), __caplets_invoke_json(capletId, 'getPrompt', [name, args])),",
+		"  complete: (input) => (__caplets_assert_active_id(capletId), __caplets_invoke_json(capletId, 'complete', [input])),",
+		"}) });",
+		"(() => {",
+		`  const checkpointToken = ${JSON.stringify(checkpointToken)};`,
+		"  const persistBacking = Object.create(null);",
+		"  let persistTainted = false;",
+		"  const checkpointState = { current: Object.create(null) };",
+		"  const ownKeys = Reflect.ownKeys.bind(Reflect);",
+		"  const getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor.bind(Object);",
+		"  const defineProperty = Object.defineProperty.bind(Object);",
+		"  const getPrototypeOf = Object.getPrototypeOf.bind(Object);",
+		"  const reflectGet = Reflect.get.bind(Reflect);",
+		"  const reflectSet = Reflect.set.bind(Reflect);",
+		"  const reflectDefineProperty = Reflect.defineProperty.bind(Reflect);",
+		"  const reflectDeleteProperty = Reflect.deleteProperty.bind(Reflect);",
+		"  const reflectSetPrototypeOf = Reflect.setPrototypeOf.bind(Reflect);",
+		"  const reflectPreventExtensions = Reflect.preventExtensions.bind(Reflect);",
+		"  const reflectGetOwnPropertyDescriptor = Reflect.getOwnPropertyDescriptor.bind(Reflect);",
+		"  const reflectOwnKeys = Reflect.ownKeys.bind(Reflect);",
+		"  const hasOwn = Function.prototype.call.bind(Object.prototype.hasOwnProperty);",
+		"  const objectIds = new WeakMap();",
+		"  let nextObjectId = 1;",
+		"  const keyToken = (key) => typeof key === 'symbol' ? `symbol:${String(key)}` : `string:${key}`;",
+		"  const valueToken = (value) => {",
+		"    const type = typeof value;",
+		"    if ((type === 'object' && value !== null) || type === 'function') {",
+		"      if (!objectIds.has(value)) objectIds.set(value, nextObjectId++);",
+		"      return `${type}:${objectIds.get(value)}`;",
+		"    }",
+		"    return `${type}:${String(value)}`;",
+		"  };",
+		"  const descriptorToken = (descriptor) => {",
+		"    if (!descriptor) return 'missing';",
+		"    return [",
+		"      hasOwn(descriptor, 'value') ? 'data' : 'accessor',",
+		"      descriptor.writable === true ? 'w' : 'nw',",
+		"      descriptor.configurable === true ? 'c' : 'nc',",
+		"      descriptor.enumerable === true ? 'e' : 'ne',",
+		"      typeof descriptor.get,",
+		"      typeof descriptor.set,",
+		"    ].join(':');",
+		"  };",
+		"  const assertToken = (token) => {",
+		"    if (token !== checkpointToken) throw new Error('Code Mode persistence checkpoint token is invalid.');",
+		"  };",
+		"  const persistProxy = new Proxy(persistBacking, {",
+		"    get(target, key, receiver) { persistTainted = true; return reflectGet(target, key, receiver); },",
+		"    set(target, key, value, receiver) { persistTainted = true; return reflectSet(target, key, value, receiver); },",
+		"    defineProperty(target, key, descriptor) { persistTainted = true; return reflectDefineProperty(target, key, descriptor); },",
+		"    deleteProperty(target, key) { persistTainted = true; return reflectDeleteProperty(target, key); },",
+		"    setPrototypeOf(target, prototype) { persistTainted = true; return reflectSetPrototypeOf(target, prototype); },",
+		"    preventExtensions(target) { persistTainted = true; return reflectPreventExtensions(target); },",
+		"    getOwnPropertyDescriptor(target, key) { persistTainted = true; return reflectGetOwnPropertyDescriptor(target, key); },",
+		"    ownKeys(target) { persistTainted = true; return reflectOwnKeys(target); },",
+		"    getPrototypeOf(target) { persistTainted = true; return getPrototypeOf(target); },",
+		"  });",
+		"  Object.defineProperty(globalThis, '__caplets_persist', { configurable: false, writable: false, value: persistProxy });",
+		"  Object.defineProperty(globalThis, '__caplets_get_persist', { configurable: false, writable: false, value: (token, name) => {",
+		"    assertToken(token);",
+		"    return hasOwn(persistBacking, name) ? persistBacking[name] : undefined;",
+		"  } });",
+		"  Object.defineProperty(globalThis, '__caplets_set_persist', { configurable: false, writable: false, value: (token, name, value) => {",
+		"    assertToken(token);",
+		"    defineProperty(persistBacking, name, { value, writable: true, configurable: true, enumerable: true });",
+		"    return value;",
+		"  } });",
+		"  Object.defineProperty(globalThis, '__caplets_persist_is_tainted', { configurable: false, writable: false, value: (token) => {",
+		"    assertToken(token);",
+		"    return persistTainted;",
+		"  } });",
+		"  Object.defineProperty(globalThis, '__caplets_persist_has_object_like_values', { configurable: false, writable: false, value: (token, names) => {",
+		"    assertToken(token);",
+		"    for (const name of names) {",
+		"      if (!hasOwn(persistBacking, name)) continue;",
+		"      const value = persistBacking[name];",
+		"      if ((typeof value === 'object' && value !== null) || typeof value === 'function') return true;",
+		"    }",
+		"    return false;",
+		"  } });",
+		"  Object.defineProperty(globalThis, '__caplets_persist_global_descriptors_ok', { configurable: false, writable: false, value: (token, names) => {",
+		"    assertToken(token);",
+		"    for (const name of names) {",
+		"      const descriptor = getOwnPropertyDescriptor(globalThis, name);",
+		"      if (!descriptor || !hasOwn(descriptor, 'value') || descriptor.writable !== true) return false;",
+		"    }",
+		"    return true;",
+		"  } });",
+		"  Object.defineProperty(globalThis, '__caplets_persist_descriptor_fingerprint', { configurable: false, writable: false, value: (allowedNames = []) => {",
+		"    const allowed = new Set(allowedNames.map((name) => `string:${name}`));",
+		"    const prototype = getPrototypeOf(persistBacking);",
+		"    const keys = ownKeys(persistBacking).map((key) => keyToken(key)).filter((token) => !allowed.has(token)).sort();",
+		"    return keys.map((token) => {",
+		"      const key = token.startsWith('symbol:') ? ownKeys(persistBacking).find((candidate) => keyToken(candidate) === token) : token.slice('string:'.length);",
+		"      const descriptor = getOwnPropertyDescriptor(persistBacking, key);",
+		"      const value = descriptor && hasOwn(descriptor, 'value') ? valueToken(descriptor.value) : 'accessor';",
+		"      return `${token}:${descriptorToken(descriptor)}:${value}`;",
+		"    }).concat(`[[Prototype]]:${valueToken(prototype)}`).join('|');",
+		"  } });",
+		"  Object.defineProperty(globalThis, '__caplets_persist_descriptors_ok', { configurable: false, writable: false, value: (token, names) => {",
+		"    assertToken(token);",
+		"    if (getPrototypeOf(persistBacking) !== null) return false;",
+		"    for (const name of names) {",
+		"      const descriptor = getOwnPropertyDescriptor(persistBacking, name);",
+		"      if (!descriptor || !hasOwn(descriptor, 'value')) return false;",
+		"      if (descriptor.get || descriptor.set || descriptor.writable !== true || descriptor.configurable !== true) return false;",
+		"    }",
+		"    return true;",
+		"  } });",
+		"  Object.defineProperty(globalThis, '__caplets_snapshot_persist', { configurable: false, writable: false, value: (token, names) => {",
+		"    assertToken(token);",
+		"    const next = Object.create(null);",
+		"    for (const name of names) {",
+		"      try { next[name] = (0, eval)(name); }",
+		"      catch { next[name] = hasOwn(globalThis, name) ? globalThis[name] : hasOwn(persistBacking, name) ? persistBacking[name] : undefined; }",
+		"    }",
+		"    checkpointState.current = next;",
+		"  } });",
+		"  Object.defineProperty(globalThis, '__caplets_checkpoint_value', { configurable: false, writable: false, value: (token, name) => {",
+		"    assertToken(token);",
+		"    return checkpointState.current[name];",
+		"  } });",
+		"})();",
+		"Object.defineProperty(globalThis, '__caplets_json_parse', { configurable: false, writable: false, value: JSON.parse.bind(JSON) });"
+	].join("\n");
+}
+function buildBridgeRefreshSource(_capletIds, _previousCapletIds = []) {
+	return "";
+}
+function buildSessionCellSource(code, capletIds, existingNames = [], checkpointToken = "") {
+	const javascript = ts.transpileModule(code, { compilerOptions: {
+		target: ts.ScriptTarget.ES2022,
+		module: ts.ModuleKind.ESNext,
+		importsNotUsedAsValues: ts.ImportsNotUsedAsValues.Remove
+	} }).outputText;
+	const split = splitPersistentPrelude(javascript, existingNames, checkpointToken);
+	return {
+		source: [
+			split.prelude,
+			"(async () => {",
+			"\"use strict\";",
+			buildPlatformResetSource(),
+			buildPlatformShadowRestoreSource(existingNames, checkpointToken),
+			buildCellCapletsSource(capletIds),
+			split.body,
+			split.postlude,
+			"})()"
+		].join("\n"),
+		persistentNames: split.persistentNames,
+		newNames: split.newNames,
+		snapshotNames: split.snapshotNames
+	};
+}
+function buildPlatformResetSource() {
+	return "globalThis.__caplets_restore_platform();";
+}
+function buildPlatformShadowRestoreSource(existingNames, checkpointToken) {
+	return existingNames.map((name) => `(0, eval)(${JSON.stringify(`${name} = globalThis.__caplets_get_persist(${JSON.stringify(checkpointToken)}, ${JSON.stringify(name)});`)});`).join("\n");
+}
+function buildCellCapletsSource(capletIds) {
+	return [
+		"const caplets = {};",
+		...capletIds.map((capletId) => `caplets[${JSON.stringify(capletId)}] = __caplets_handle(${JSON.stringify(capletId)});`),
+		"caplets.debug = caplets.debug ?? {};",
+		"caplets.debug.readLogs = (input) => __caplets_invoke_json('debug', 'readLogs', [input]);",
+		"caplets.debug.readRecovery = (input) => __caplets_invoke_json('debug', 'readRecovery', [input]);"
+	].join("\n");
+}
+function splitPersistentPrelude(javascript, existingNames = [], checkpointToken = "") {
+	const source = ts.createSourceFile("/caplets-code-mode/session-cell.js", javascript, ts.ScriptTarget.ES2022, true);
+	const ranges = [];
+	const names = collectPersistentBindingNames(source);
+	const lexicalNames = collectTopLevelLexicalBindingNames(source);
+	const allNames = [...new Set([...existingNames, ...names])];
+	const snapshotNames = allNames.filter((name) => !lexicalNames.has(name));
+	const returnTempName = uniqueInternalName("__caplets_return", allNames);
+	const postlude = snapshotNames.map((name) => persistentBindingPostlude(name, checkpointToken)).join("\n");
+	for (const statement of source.statements) {
+		collectPersistentVarRewriteRanges(statement, source, lexicalNames, ranges);
+		collectPersistentReturnRanges(statement, source, snapshotNames, ranges, returnTempName, checkpointToken);
+		collectPersistentFinallyRanges(statement, snapshotNames, ranges, checkpointToken);
+	}
+	ranges.sort((left, right) => left.start - right.start);
+	const prelude = [...allNames.map((name) => `var ${name} = globalThis.__caplets_get_persist(${JSON.stringify(checkpointToken)}, ${JSON.stringify(name)});`), ...ranges.map((range) => range.prelude)].filter(Boolean).join("\n");
+	let body = "";
+	let cursor = 0;
+	for (const range of ranges) {
+		body += javascript.slice(cursor, range.start);
+		body += range.body;
+		cursor = range.end;
+	}
+	body += javascript.slice(cursor);
+	if (postlude) body += `\n${postlude}`;
+	return {
+		prelude,
+		body,
+		postlude,
+		persistentNames: allNames,
+		newNames: names.filter((name) => !existingNames.includes(name)),
+		snapshotNames
+	};
+}
+function collectPersistentReturnRanges(node, source, snapshotNames, ranges, returnTempName, checkpointToken, shadowedNames = /* @__PURE__ */ new Set()) {
+	if (snapshotNames.length === 0) return;
+	if (ts.isFunctionLike(node) || ts.isClassLike(node)) return;
+	const declared = lexicalNamesDeclaredByNode(node);
+	const activeShadowedNames = declared.size === 0 ? shadowedNames : new Set([...shadowedNames, ...declared]);
+	if (ts.isReturnStatement(node)) {
+		const expression = node.expression?.getText(source);
+		const postludeExpression = snapshotNames.filter((name) => !activeShadowedNames.has(name)).map((name) => persistentBindingExpression(name, checkpointToken)).join(", ");
+		ranges.push({
+			start: node.getFullStart(),
+			end: node.end,
+			prelude: "",
+			body: returnWithPersistenceExpression(expression, postludeExpression, returnTempName)
+		});
+		return;
+	}
+	ts.forEachChild(node, (child) => collectPersistentReturnRanges(child, source, snapshotNames, ranges, returnTempName, checkpointToken, activeShadowedNames));
+}
+function lexicalNamesDeclaredByNode(node) {
+	const names = /* @__PURE__ */ new Set();
+	if (ts.isBlock(node) || ts.isCaseClause(node) || ts.isDefaultClause(node)) for (const statement of node.statements) {
+		if (ts.isVariableStatement(statement) && !isVarDeclarationList(statement.declarationList)) for (const name of declarationListBindingNames(statement.declarationList)) names.add(name);
+		if ((ts.isClassDeclaration(statement) || ts.isEnumDeclaration(statement)) && statement.name) names.add(statement.name.text);
+		if (ts.isFunctionDeclaration(statement) && statement.name) names.add(statement.name.text);
+	}
+	if (ts.isSwitchStatement(node)) for (const clause of node.caseBlock.clauses) for (const statement of clause.statements) {
+		if (ts.isVariableStatement(statement) && !isVarDeclarationList(statement.declarationList)) for (const name of declarationListBindingNames(statement.declarationList)) names.add(name);
+		if ((ts.isClassDeclaration(statement) || ts.isEnumDeclaration(statement)) && statement.name) names.add(statement.name.text);
+		if (ts.isFunctionDeclaration(statement) && statement.name) names.add(statement.name.text);
+	}
+	if (ts.isCatchClause(node) && node.variableDeclaration) for (const name of bindingNames(node.variableDeclaration.name)) names.add(name);
+	if ((ts.isForStatement(node) || ts.isForInStatement(node) || ts.isForOfStatement(node)) && node.initializer && ts.isVariableDeclarationList(node.initializer) && !isVarDeclarationList(node.initializer)) for (const name of declarationListBindingNames(node.initializer)) names.add(name);
+	return names;
+}
+function returnWithPersistenceExpression(expression, postludeExpression, returnTempName) {
+	if (!postludeExpression) return expression ? `return ${expression};` : "return;";
+	return expression ? `return (async (${returnTempName}) => { await Promise.resolve(); ${postludeExpression}; return ${returnTempName}; })((${expression}));` : `await Promise.resolve();\nreturn void (${postludeExpression});`;
+}
+function uniqueInternalName(baseName, unavailableNames) {
+	const unavailable = new Set(unavailableNames);
+	let name = baseName;
+	while (unavailable.has(name)) name = `_${name}`;
+	return name;
+}
+function collectPersistentVarRewriteRanges(node, source, lexicalNames, ranges) {
+	if (ts.isFunctionLike(node) || ts.isClassLike(node)) return;
+	if (ts.isVariableStatement(node) && isVarDeclarationList(node.declarationList)) {
+		if (!declarationListBindingNames(node.declarationList).some((name) => lexicalNames.has(name))) ranges.push({
+			start: node.getFullStart(),
+			end: node.end,
+			prelude: "",
+			body: varStatementAssignments(node.declarationList, source)
+		});
+		return;
+	}
+	if ((ts.isForStatement(node) || ts.isForInStatement(node) || ts.isForOfStatement(node)) && node.initializer && ts.isVariableDeclarationList(node.initializer) && isVarDeclarationList(node.initializer)) {
+		if (!declarationListBindingNames(node.initializer).some((name) => lexicalNames.has(name))) ranges.push({
+			start: node.initializer.getStart(source),
+			end: node.initializer.end,
+			prelude: "",
+			body: forInitializerAssignment(node.initializer, source)
+		});
+	}
+	ts.forEachChild(node, (child) => collectPersistentVarRewriteRanges(child, source, lexicalNames, ranges));
+}
+function collectPersistentFinallyRanges(node, snapshotNames, ranges, checkpointToken, shadowedNames = /* @__PURE__ */ new Set()) {
+	if (snapshotNames.length === 0) return;
+	if (ts.isFunctionLike(node) || ts.isClassLike(node)) return;
+	const declared = lexicalNamesDeclaredByNode(node);
+	const activeShadowedNames = declared.size === 0 ? shadowedNames : new Set([...shadowedNames, ...declared]);
+	if (ts.isTryStatement(node) && node.finallyBlock) {
+		const finallyDeclared = lexicalNamesDeclaredByNode(node.finallyBlock);
+		const finallyShadowedNames = finallyDeclared.size === 0 ? activeShadowedNames : new Set([...activeShadowedNames, ...finallyDeclared]);
+		const postlude = snapshotNames.filter((name) => !finallyShadowedNames.has(name)).map((name) => persistentBindingPostlude(name, checkpointToken)).join("\n");
+		if (postlude) ranges.push({
+			start: node.finallyBlock.end - 1,
+			end: node.finallyBlock.end - 1,
+			prelude: "",
+			body: `\n${postlude}\n`
+		});
+	}
+	ts.forEachChild(node, (child) => collectPersistentFinallyRanges(child, snapshotNames, ranges, checkpointToken, activeShadowedNames));
+}
+function collectPersistentBindingNames(source) {
+	const names = /* @__PURE__ */ new Set();
+	const visit = (node) => {
+		if (ts.isFunctionDeclaration(node) && node.name && node.parent === source) names.add(node.name.text);
+		if (node !== source && (ts.isFunctionLike(node) || ts.isClassLike(node))) return;
+		if (ts.isVariableStatement(node)) collectVarDeclarationListNames(node.declarationList, names);
+		if ((ts.isForStatement(node) || ts.isForInStatement(node) || ts.isForOfStatement(node)) && node.initializer && ts.isVariableDeclarationList(node.initializer)) collectVarDeclarationListNames(node.initializer, names);
+		ts.forEachChild(node, visit);
+	};
+	visit(source);
+	return [...names];
+}
+function collectTopLevelLexicalBindingNames(source) {
+	const names = /* @__PURE__ */ new Set();
+	for (const statement of source.statements) {
+		if (ts.isVariableStatement(statement) && !isVarDeclarationList(statement.declarationList)) for (const name of declarationListBindingNames(statement.declarationList)) names.add(name);
+		if ((ts.isClassDeclaration(statement) || ts.isEnumDeclaration(statement)) && statement.name) names.add(statement.name.text);
+	}
+	return names;
+}
+function collectVarDeclarationListNames(declarationList, names) {
+	if (!((ts.getCombinedNodeFlags(declarationList) & ts.NodeFlags.BlockScoped) === 0)) return;
+	for (const declaration of declarationList.declarations) for (const name of bindingNames(declaration.name)) names.add(name);
+}
+function isVarDeclarationList(declarationList) {
+	return (ts.getCombinedNodeFlags(declarationList) & ts.NodeFlags.BlockScoped) === 0;
+}
+function declarationListBindingNames(declarationList) {
+	return declarationList.declarations.flatMap((declaration) => bindingNames(declaration.name));
+}
+function varStatementAssignments(declarationList, source) {
+	return declarationList.declarations.map((declaration) => declaration.initializer ? assignmentStatement(declaration.name, declaration.initializer, source) : "").filter(Boolean).join("\n");
+}
+function forInitializerAssignment(declarationList, source) {
+	return declarationList.declarations.map((declaration) => declaration.initializer ? assignmentExpression(declaration.name, declaration.initializer, source) : declaration.name.getText(source)).join(", ");
+}
+function persistentBindingPostlude(name, checkpointToken) {
+	return [`globalThis.__caplets_set_persist(${JSON.stringify(checkpointToken)}, ${JSON.stringify(name)}, ${name});`, `(0, eval)(${JSON.stringify(`${name} = globalThis.__caplets_get_persist(${JSON.stringify(checkpointToken)}, ${JSON.stringify(name)});`)});`].join("\n");
+}
+function persistentBindingExpression(name, checkpointToken) {
+	return [`globalThis.__caplets_set_persist(${JSON.stringify(checkpointToken)}, ${JSON.stringify(name)}, ${name})`, `(0, eval)(${JSON.stringify(`${name} = globalThis.__caplets_get_persist(${JSON.stringify(checkpointToken)}, ${JSON.stringify(name)});`)})`].join(", ");
+}
+function bindingNames(name) {
+	if (ts.isIdentifier(name)) return [name.text];
+	return name.elements.flatMap((element) => {
+		if (ts.isOmittedExpression(element)) return [];
+		return bindingNames(element.name);
+	});
+}
+function assignmentStatement(name, initializer, source) {
+	const expression = assignmentExpression(name, initializer, source);
+	return ts.isObjectBindingPattern(name) ? `(${expression});` : `${expression};`;
+}
+function assignmentExpression(name, initializer, source) {
+	return `${name.getText(source)} = ${initializer.getText(source)}`;
+}
+function buildPromiseObserverSource() {
+	return [
+		"(() => {",
+		"  const then = Promise.prototype.then;",
+		"  const formatError = function(e) {",
+		"    if (e && typeof e === 'object' && typeof e.message === 'string') return e.message;",
+		"    return String(e);",
+		"  };",
+		"  try { Object.defineProperty(globalThis, '__caplets_observe_promise', { configurable: false, writable: false, value: function(p) {",
+		"    var s = { settled: false, value: void 0, error: void 0 };",
+		"    then.call(p, function(value) { s.value = value; s.settled = true; },",
+		"                function(error) { s.error = formatError(error); s.settled = true; });",
+		"    return s;",
+		"  } }); } catch {}",
+		"})()"
+	].join("\n");
+}
+function buildPromiseStateSource(resultName) {
+	return [`globalThis.__caplets_observe_promise(globalThis[${resultName}])`].join("\n");
+}
 async function drainAsync(context, runtime, pendingDeferreds, deadlineMs, timeoutMs) {
 	drainJobs(context, runtime, deadlineMs, timeoutMs);
 	while (pendingDeferreds.size > 0) {
@@ -77409,6 +79053,9 @@ function readProp(context, handle, key) {
 function timeoutMessage(timeoutMs) {
 	return `Code Mode execution timed out after ${timeoutMs}ms`;
 }
+function isTimeoutMessage(message, timeoutMs) {
+	return message === timeoutMessage(timeoutMs);
+}
 function normalizeError(error, deadlineMs, timeoutMs) {
 	const message = errorMessage$2(error);
 	return Date.now() >= deadlineMs && /\binterrupted\b/iu.test(message) ? timeoutMessage(timeoutMs) : message;
@@ -77431,6 +79078,181 @@ function optionalStack(stack) {
 function logLevel(value) {
 	return value === "info" || value === "warn" || value === "error" || value === "debug" || value === "log" ? value : "log";
 }
+var CodeModeSessionManager = class {
+	ttlMs;
+	maxSessions;
+	#sessions = /* @__PURE__ */ new Map();
+	#idGenerator;
+	#now;
+	#sandboxFactory;
+	#closed = false;
+	constructor(options = {}) {
+		this.ttlMs = options.ttlMs ?? 18e5;
+		this.maxSessions = options.maxSessions ?? 32;
+		this.#idGenerator = options.idGenerator ?? randomUUID;
+		this.#now = options.now ?? Date.now;
+		this.#sandboxFactory = options.sandboxFactory ?? (() => new QuickJsCodeModeSandbox());
+	}
+	async run(input) {
+		if (this.#closed) return {
+			ok: false,
+			sessionId: input.sessionId ?? "",
+			sessionStatus: null,
+			error: "closed"
+		};
+		this.#evictExpired();
+		const compatibilityKey = compatibilityKeyFor(input.compatibility);
+		const requestedSessionId = input.sessionId;
+		let record;
+		let sessionStatus;
+		if (requestedSessionId) {
+			record = this.#sessions.get(requestedSessionId);
+			if (!record) return {
+				ok: false,
+				sessionId: requestedSessionId,
+				sessionStatus: null,
+				error: "not_found"
+			};
+			if (record.busy) return {
+				ok: false,
+				sessionId: requestedSessionId,
+				sessionStatus: null,
+				error: "busy"
+			};
+			if (record.compatibilityKey !== compatibilityKey) {
+				this.#disposeRecord(record.id);
+				return {
+					ok: false,
+					sessionId: requestedSessionId,
+					sessionStatus: null,
+					error: "not_found"
+				};
+			} else sessionStatus = "reused";
+		} else {
+			const sessionId = this.#nextSessionId();
+			record = await this.#createRecord(sessionId, compatibilityKey);
+			if (!record) return this.#closedResult(sessionId);
+			sessionStatus = "created";
+		}
+		this.#evictToLimit(record.id);
+		record.busy = true;
+		try {
+			const result = await record.session.run({
+				...input,
+				invoke: async (invokeInput) => {
+					if (this.#closed) throw new Error("Code Mode session manager is closed.");
+					return await input.invoke(invokeInput);
+				}
+			});
+			record.lastUsedAt = this.#now();
+			const sessionDisposedAfterRun = record.session.isDisposed();
+			if (sessionDisposedAfterRun) this.#sessions.delete(record.id);
+			else if (result.ok) input.onSuccessfulCell?.(record.id, input.code);
+			return {
+				ok: true,
+				sessionId: record.id,
+				sessionStatus,
+				sessionDisposedAfterRun,
+				compatibilityKey: record.compatibilityKey,
+				result
+			};
+		} finally {
+			record.busy = false;
+			this.#evictToLimit(record.id);
+		}
+	}
+	close() {
+		this.#closed = true;
+		for (const record of this.#sessions.values()) record.session.dispose();
+		this.#sessions.clear();
+	}
+	has(sessionId) {
+		this.#evictExpired();
+		return this.#sessions.has(sessionId);
+	}
+	compatibilityKey(sessionId) {
+		this.#evictExpired();
+		return this.#sessions.get(sessionId)?.compatibilityKey;
+	}
+	diagnosticsSession(sessionId, compatibility) {
+		this.#evictExpired();
+		const record = this.#sessions.get(sessionId);
+		if (!record) return void 0;
+		const compatibilityKey = compatibilityKeyFor(compatibility);
+		if (record.compatibilityKey !== compatibilityKey) {
+			this.#disposeRecord(sessionId);
+			return;
+		}
+		return record.diagnosticsSession;
+	}
+	isBusy(sessionId, compatibility) {
+		this.#evictExpired();
+		const record = this.#sessions.get(sessionId);
+		if (!record) return false;
+		const compatibilityKey = compatibilityKeyFor(compatibility);
+		if (record.compatibilityKey !== compatibilityKey) return false;
+		return record.busy;
+	}
+	recordSuccessfulCell(sessionId, code, declaration = "") {
+		this.#sessions.get(sessionId)?.diagnosticsSession.recordSuccessfulCell(code, declaration);
+	}
+	async #createRecord(id, compatibilityKey) {
+		if (this.#closed) return;
+		const session = await this.#sandboxFactory().createSession();
+		if (this.#closed) {
+			session.dispose();
+			return;
+		}
+		const record = {
+			id,
+			session,
+			diagnosticsSession: new CodeModeDiagnosticsSession(),
+			compatibilityKey,
+			lastUsedAt: this.#now(),
+			busy: false
+		};
+		this.#sessions.set(id, record);
+		return record;
+	}
+	#nextSessionId() {
+		let id = this.#idGenerator();
+		while (this.#sessions.has(id)) id = this.#idGenerator();
+		return id;
+	}
+	#evictExpired() {
+		const now = this.#now();
+		for (const record of this.#sessions.values()) if (!record.busy && now - record.lastUsedAt > this.ttlMs) this.#disposeRecord(record.id);
+	}
+	#evictToLimit(protectedId) {
+		while (this.#sessions.size > this.maxSessions) {
+			const candidate = [...this.#sessions.values()].filter((record) => !record.busy && record.id !== protectedId).sort((left, right) => left.lastUsedAt - right.lastUsedAt)[0];
+			if (!candidate) return;
+			this.#disposeRecord(candidate.id);
+		}
+	}
+	#disposeRecord(id) {
+		const record = this.#sessions.get(id);
+		if (!record) return;
+		record.session.dispose();
+		this.#sessions.delete(id);
+	}
+	#closedResult(sessionId) {
+		return {
+			ok: false,
+			sessionId,
+			sessionStatus: null,
+			error: "closed"
+		};
+	}
+};
+function compatibilityKeyFor(input) {
+	return JSON.stringify({
+		declarationHash: input.declarationHash,
+		platformRuntimeHash: input.platformRuntimeHash,
+		runtimeScope: input.runtimeScope,
+		version: input.version ?? 1
+	});
+}
 //#endregion
 //#region src/code-mode/runner.ts
 const DEFAULT_TIMEOUT_MS = 1e4;
@@ -77443,45 +79265,126 @@ async function runCodeMode(input) {
 	const callable = listCodeModeCallableCaplets(input.service);
 	const declaration = generateCodeModeDeclarations({ caplets: callable });
 	const declarationHash = codeModeDeclarationHash(declaration);
+	const sessionCompatibility = {
+		declarationHash,
+		platformRuntimeHash: codeModeDeclarationHash(CODE_MODE_PLATFORM_RUNTIME_SOURCE),
+		runtimeScope: input.runtimeScope ?? "",
+		version: 1
+	};
+	const diagnosticsSession = input.sessionManager && input.sessionId ? input.sessionManager.diagnosticsSession(input.sessionId, sessionCompatibility) : void 0;
 	const metaBase = {
 		runId: randomUUID(),
 		traceId: randomUUID(),
 		declarationHash,
 		timeoutMs,
-		maxTimeoutMs
+		maxTimeoutMs,
+		sessionId: input.sessionManager ? null : input.sessionId ?? null,
+		sessionStatus: null,
+		recoveryRef: null
 	};
-	const diagnostics = timeoutMs > maxTimeoutMs ? [{
-		code: "TIMEOUT_POLICY_EXCEEDED",
-		severity: "error",
-		message: `timeoutMs must be <= ${maxTimeoutMs}.`
-	}] : diagnoseCodeModeTypeScript({
-		code: input.code,
-		declaration
+	const meta = () => ({
+		...metaBase,
+		durationMs: Date.now() - startedAt
 	});
-	if (diagnostics.some((diagnostic) => diagnostic.severity === "error")) return {
+	if (input.sessionId !== void 0 && !input.sessionManager) return {
 		ok: false,
 		error: {
-			code: "diagnostic_blocked",
-			message: "Code Mode diagnostics failed before execution."
+			code: "SESSION_NOT_FOUND",
+			message: "Code Mode session reuse is not available in this runtime. Omit sessionId to run one-shot."
 		},
-		diagnostics,
+		diagnostics: [],
+		logs: emptyLogs(),
+		meta: meta()
+	};
+	if (input.sessionManager && input.sessionId && input.sessionManager.isBusy(input.sessionId, sessionCompatibility)) return {
+		ok: false,
+		error: {
+			code: "SESSION_BUSY",
+			message: `Code Mode session ${input.sessionId} is already running.`
+		},
+		diagnostics: [],
 		logs: emptyLogs(),
 		meta: {
-			...metaBase,
-			durationMs: Date.now() - startedAt
+			...meta(),
+			sessionId: input.sessionId,
+			sessionStatus: null
 		}
 	};
+	const diagnostics = timeoutMs > maxTimeoutMs ? [{
+		code: "TIMEOUT_POLICY_EXCEEDED",
+		severity: "error",
+		message: `timeoutMs must be <= ${maxTimeoutMs}.`
+	}] : diagnoseCodeModeTypeScript({
+		code: input.code,
+		declaration,
+		...diagnosticsSession === void 0 ? {} : { session: diagnosticsSession }
+	});
+	if (diagnostics.some((diagnostic) => diagnostic.severity === "error")) {
+		const diagnosticJournalScope = input.sessionManager && input.sessionId ? input.sessionManager.compatibilityKey(input.sessionId) : void 0;
+		if (input.sessionManager && input.sessionId && diagnosticJournalScope === void 0) {
+			const recoveryRef = await recoveryRefForSession(input, input.sessionId);
+			return {
+				ok: false,
+				error: {
+					code: "SESSION_NOT_FOUND",
+					message: `Code Mode session ${input.sessionId} was not found.`
+				},
+				diagnostics,
+				logs: emptyLogs(),
+				meta: {
+					...meta(),
+					sessionId: input.sessionId,
+					sessionStatus: null,
+					...recoveryMeta(recoveryRef)
+				}
+			};
+		}
+		const recoveryRef = await journalRun(input, {
+			sessionId: input.sessionId ?? null,
+			code: input.code,
+			declarationHash,
+			diagnostics,
+			logs: emptyLogs(),
+			outcome: {
+				ok: false,
+				code: "diagnostic_blocked",
+				message: "Code Mode diagnostics failed before execution."
+			},
+			invokedCaplet: false,
+			sessionDisposedAfterRun: false,
+			journalScope: diagnosticJournalScope
+		});
+		if (input.sessionManager && input.sessionId) {
+			metaBase.sessionId = input.sessionId;
+			metaBase.sessionStatus = "reused";
+		}
+		if (recoveryRef && !input.sessionManager) setRecoveryMeta(metaBase, recoveryRef);
+		return {
+			ok: false,
+			error: {
+				code: "diagnostic_blocked",
+				message: "Code Mode diagnostics failed before execution."
+			},
+			diagnostics,
+			logs: emptyLogs(),
+			meta: meta()
+		};
+	}
 	const capturedLogs = [];
+	let invokedCaplet = false;
 	const api = createCodeModeCapletsApi({
 		service: input.service,
-		readLogs: async (readInput) => input.logStore?.read(readInput) ?? { entries: [] }
+		readLogs: async (readInput) => input.logStore?.read(readInput) ?? { entries: [] },
+		readRecovery: async (readInput) => input.journalStore?.readRecovery(readInput) ?? { entries: [] }
 	});
-	const result = await (input.sandbox ?? new QuickJsCodeModeSandbox()).run({
+	const sandboxInput = {
 		code: input.code,
 		capletIds: callable.map((caplet) => caplet.id),
 		timeoutMs,
 		invoke: async ({ capletId, method, args }) => {
 			if (method === "readLogs") return await api.debug.readLogs(args[0]);
+			if (method === "readRecovery") return await api.debug.readRecovery(args[0]);
+			invokedCaplet = true;
 			const handle = api[capletId];
 			if (!handle || !("callTool" in handle)) throw new Error(`Caplet ${capletId} is not available.`);
 			if (method === "inspect") return await handle.inspect();
@@ -77500,19 +79403,66 @@ async function runCodeMode(input) {
 			if (method === "complete") return await handle.complete(args[0]);
 			throw new Error(`Unknown Code Mode CapletHandle method: ${method}.`);
 		}
-	});
+	};
+	const sessionRun = input.sessionManager ? await input.sessionManager.run({
+		...sandboxInput,
+		...input.sessionId === void 0 ? {} : { sessionId: input.sessionId },
+		compatibility: sessionCompatibility,
+		onSuccessfulCell: (sessionId, code) => {
+			input.sessionManager?.recordSuccessfulCell(sessionId, code, declaration);
+		}
+	}) : void 0;
+	if (sessionRun && !sessionRun.ok) {
+		const recoveryRef = sessionRun.error === "not_found" ? await recoveryRefForSession(input, sessionRun.sessionId) : void 0;
+		return {
+			ok: false,
+			error: {
+				code: sessionRun.error === "not_found" ? "SESSION_NOT_FOUND" : sessionRun.error === "closed" ? "SESSION_CLOSED" : "SESSION_BUSY",
+				message: sessionRun.error === "not_found" ? `Code Mode session ${sessionRun.sessionId} was not found.` : sessionRun.error === "closed" ? "Code Mode session manager is closed." : `Code Mode session ${sessionRun.sessionId} is already running.`
+			},
+			diagnostics,
+			logs: emptyLogs(),
+			meta: {
+				...meta(),
+				sessionId: sessionRun.sessionId,
+				sessionStatus: null,
+				...recoveryMeta(recoveryRef)
+			}
+		};
+	}
+	const result = sessionRun?.result ?? await (input.sandbox ?? new QuickJsCodeModeSandbox()).run(sandboxInput);
+	const sessionId = sessionRun?.sessionId ?? metaBase.sessionId ?? null;
+	const sessionStatus = sessionRun?.sessionStatus ?? metaBase.sessionStatus ?? null;
+	const exposeRecoveryRef = !input.sessionManager || sessionStatus === "created";
+	metaBase.sessionId = sessionRun?.sessionDisposedAfterRun ? null : sessionId;
+	metaBase.sessionStatus = sessionRun?.sessionDisposedAfterRun ? null : sessionStatus;
 	capturedLogs.push(...result.logs.map(redactLogEntry));
 	const logs = await buildLogs(capturedLogs, input.logStore, input.returnedLogBytes);
-	if (!result.ok) return {
-		ok: false,
-		error: codeModeRuntimeError(result.error, result.stack),
-		diagnostics,
-		logs,
-		meta: {
-			...metaBase,
-			durationMs: Date.now() - startedAt
-		}
-	};
+	if (!result.ok) {
+		const recoveryRef = await journalRun(input, {
+			sessionId,
+			code: input.code,
+			declarationHash,
+			diagnostics,
+			logs,
+			outcome: {
+				ok: false,
+				code: runtimeErrorCode(result.error),
+				message: result.error
+			},
+			invokedCaplet,
+			sessionDisposedAfterRun: sessionRun?.sessionDisposedAfterRun ?? false,
+			journalScope: sessionRun?.compatibilityKey
+		});
+		if (recoveryRef && exposeRecoveryRef) setRecoveryMeta(metaBase, recoveryRef);
+		return {
+			ok: false,
+			error: codeModeRuntimeError(result.error, result.stack),
+			diagnostics,
+			logs,
+			meta: meta()
+		};
+	}
 	const serialized = serializeJsonValue(result.value);
 	if (!serialized.ok) {
 		const serializationDiagnostic = {
@@ -77520,6 +79470,22 @@ async function runCodeMode(input) {
 			severity: "error",
 			message: serialized.message
 		};
+		const recoveryRef = await journalRun(input, {
+			sessionId,
+			code: input.code,
+			declarationHash,
+			diagnostics: [...diagnostics, serializationDiagnostic],
+			logs,
+			outcome: {
+				ok: false,
+				code: "SERIALIZATION_ERROR",
+				message: serialized.message
+			},
+			invokedCaplet,
+			sessionDisposedAfterRun: sessionRun?.sessionDisposedAfterRun ?? false,
+			journalScope: sessionRun?.compatibilityKey
+		});
+		if (recoveryRef && exposeRecoveryRef) setRecoveryMeta(metaBase, recoveryRef);
 		return {
 			ok: false,
 			error: {
@@ -77528,23 +79494,60 @@ async function runCodeMode(input) {
 			},
 			diagnostics: [...diagnostics, serializationDiagnostic],
 			logs,
-			meta: {
-				...metaBase,
-				durationMs: Date.now() - startedAt
-			}
+			meta: meta()
 		};
 	}
+	const recoveryRef = await journalRun(input, {
+		sessionId,
+		code: input.code,
+		declarationHash,
+		diagnostics,
+		logs,
+		outcome: { ok: true },
+		invokedCaplet,
+		sessionDisposedAfterRun: sessionRun?.sessionDisposedAfterRun ?? false,
+		journalScope: sessionRun?.compatibilityKey
+	});
+	if (recoveryRef && exposeRecoveryRef) setRecoveryMeta(metaBase, recoveryRef);
 	return {
 		ok: true,
 		value: serialized.value,
 		diagnostics,
 		logs,
-		meta: {
-			...metaBase,
-			durationMs: Date.now() - startedAt
-		}
+		meta: meta()
 	};
 }
+async function journalRun(input, run) {
+	if (!input.journalStore || !run.sessionId) return void 0;
+	try {
+		return (await input.journalStore.store({
+			sessionId: run.sessionId,
+			...run.journalScope === void 0 ? {} : { journalScope: run.journalScope },
+			code: run.code,
+			declarationHash: run.declarationHash,
+			outcome: run.outcome,
+			diagnostics: run.diagnostics,
+			recoveryClassification: classifyCodeModeRecovery({
+				code: run.code,
+				invokedCaplet: run.invokedCaplet,
+				sessionDisposedAfterRun: run.sessionDisposedAfterRun
+			}),
+			...run.logs.logRef ? { logRef: run.logs.logRef } : {}
+		})).recoveryRef;
+	} catch {
+		return;
+	}
+}
+function setRecoveryMeta(metaBase, recoveryRef) {
+	metaBase.recoveryRef = recoveryRef;
+}
+async function recoveryRefForSession(input, sessionId) {
+	return (await input.journalStore?.lookupSession(sessionId))?.recoveryRef;
+}
+function recoveryMeta(recoveryRef) {
+	if (!recoveryRef) return { recoveryRef: null };
+	return { recoveryRef };
+}
 function codeModeRuntimeError(message, stack) {
 	const location = userCodeLocation(stack);
 	const stackPreview = location === void 0 ? void 0 : [`at user code line ${location.line} column ${location.column}`];
@@ -77636,9 +79639,11 @@ function redactLogEntry(entry) {
 }
 //#endregion
 //#region src/code-mode/tool.ts
+const CODE_MODE_SESSION_ID_DESCRIPTION = "Optional Code Mode session identifier. Omit to create a fresh reusable session; pass a known live session ID from meta.sessionId to reuse existing REPL state. Unknown or unavailable session IDs fail before code execution instead of starting an empty context.";
 const codeModeRunInputSchema = object$1({
 	code: string().describe("TypeScript Code Mode source to execute."),
-	timeoutMs: number$1().int().positive().optional().describe("Optional execution timeout in milliseconds.")
+	timeoutMs: number$1().int().positive().optional().describe("Optional execution timeout in milliseconds."),
+	sessionId: string().min(1).optional().describe(CODE_MODE_SESSION_ID_DESCRIPTION)
 });
 const codeModeRunParamsSchema = codeModeRunInputSchema.shape;
 function codeModeRunInputJsonSchema() {
@@ -77653,12 +79658,30 @@ function codeModeRunInputJsonSchema() {
 				type: "integer",
 				minimum: 1,
 				description: "Optional execution timeout in milliseconds."
+			},
+			sessionId: {
+				type: "string",
+				minLength: 1,
+				description: CODE_MODE_SESSION_ID_DESCRIPTION
 			}
 		},
 		required: ["code"],
 		additionalProperties: false
 	};
 }
+function emptyCodeModeRunMeta() {
+	return {
+		runId: "",
+		traceId: "",
+		declarationHash: "",
+		durationMs: 0,
+		timeoutMs: 0,
+		maxTimeoutMs: 0,
+		sessionId: null,
+		sessionStatus: null,
+		recoveryRef: null
+	};
+}
 //#endregion
 //#region src/native/tools.ts
 const nativeCodeModeToolId = "code_mode";
@@ -77676,12 +79699,23 @@ function nativeCapletsSystemGuidance(toolNames) {
 		toolNames.length > 0 ? toolNames.map((tool) => `- ${tool}`).join("\n") : "- none",
 		"",
 		`${nativeCodeModeToolName} executes Caplets Code Mode: TypeScript with generated caplets.<id> handles for multi-step discovery, tool calls, filtering, and compact synthesis in one native call.`,
+		...nativeCodeModePromptGuidance(),
 		"Flow: inspect when the domain is unfamiliar; use tools/search_tools for downstream names, arg hints, and callTemplate; call_tool directly from callTemplate/argsTemplate for simple calls; reserve describe_tool for complex schemas, nested args, fields, or uncertainty.",
 		"Do not guess downstream tool names, resource URIs, prompt names, input args, output fields, or schemas. Do not infer input/output schemas from memory.",
 		"Prefer list/read/search operations for triage and avoid broad provider searches that can return huge payloads or hit rate limits.",
 		"When output shaping matters, inspect one tool with describe_tool and follow its fieldSelection hint."
 	].join("\n");
 }
+function nativeCodeModePromptGuidance() {
+	return [
+		`Use ${nativeCodeModeToolName} to run Caplets Code Mode TypeScript with generated caplets.<id> handles.`,
+		"Prefer Code Mode for multi-step Caplet discovery, tool calls, filtering, joins, and compact synthesis.",
+		"For REPL reuse, omit sessionId to start fresh, then pass the returned meta.sessionId on later calls that should reuse live state.",
+		"Reused sessions preserve successful top-level var bindings, function declarations, and runtime state only while the live session remains available and compatible.",
+		"Unknown or unavailable sessionId values fail before code execution; use meta.recoveryRef with caplets.debug.readRecovery({ recoveryRef }) for audit and manual reconstruction, not automatic replay.",
+		"Return decision-ready JSON from Code Mode rather than raw bulky provider payloads."
+	];
+}
 function nativeCapletPromptGuidance(toolName, caplet) {
 	const descriptorFirst = "Use tools/search_tools callTemplate/arg hints for simple calls; reserve describe_tool for exact schemas, nested args, fields, or uncertainty. call_tool.args must match inputSchema exactly. Do not guess tool names or schemas.";
 	return caplet.backend === "mcp" ? [
@@ -77702,16 +79736,6 @@ function nativeCapletToolDescription(toolName, caplet) {
 //#endregion
 //#region src/server/options.ts
 const DEFAULT_SERVER_USER = "caplets";
-function resolveCapletsMode(input = {}, env = process.env) {
-	const mode = parseCapletsMode$1(input.mode ?? env.CAPLETS_MODE ?? "auto");
-	if (mode === "local") return { mode: "local" };
-	const rawUrl = nonEmpty$1(input.serverUrl, "serverUrl") ?? nonEmpty$1(env.CAPLETS_SERVER_URL, "CAPLETS_SERVER_URL");
-	if (mode === "remote") {
-		if (rawUrl === void 0) throw new CapletsError("REQUEST_INVALID", "CAPLETS_MODE=remote requires CAPLETS_SERVER_URL or serverUrl.");
-		return { mode: "remote" };
-	}
-	return rawUrl === void 0 ? { mode: "local" } : { mode: "remote" };
-}
 function resolveCapletsServer(input = {}, env = process.env) {
 	const rawUrl = nonEmpty$1(input.url, "url") ?? nonEmpty$1(env.CAPLETS_SERVER_URL, "CAPLETS_SERVER_URL");
 	if (rawUrl === void 0) throw new CapletsError("REQUEST_INVALID", "CAPLETS_SERVER_URL or url is required.");
@@ -77773,10 +79797,6 @@ function isLoopbackHost(host) {
 	const normalized = host.toLocaleLowerCase();
 	return normalized === "localhost" || normalized === "127.0.0.1" || normalized === "::1" || normalized === "[::1]";
 }
-function parseCapletsMode$1(value) {
-	if (value === "auto" || value === "local" || value === "remote") return value;
-	throw new CapletsError("REQUEST_INVALID", `Expected CAPLETS_MODE to be auto, local, or remote, got ${value}`);
-}
 function basicAuthHeader$1(user, password) {
 	return `Basic ${Buffer$1.from(`${user}:${password}`).toString("base64")}`;
 }
@@ -77936,15 +79956,11 @@ const DEFAULT_PRESENCE_HEARTBEAT_INTERVAL_MS = 3e4;
 function resolveNativeCapletsServiceOptions(input = {}, env = process.env) {
 	const mode = resolveRemoteMode({
 		...input.mode ? { mode: input.mode } : {},
-		...input.server?.url ? { remoteUrl: input.server.url } : {}
+		...input.remote?.url ? { remoteUrl: input.remote.url } : {}
 	}, env);
 	if (mode.mode === "local") return { mode: "local" };
-	const serverFetch = input.remote?.fetch ?? input.server?.fetch;
-	const serverInput = {
-		...input.server,
-		...serverFetch ? { fetch: serverFetch } : {}
-	};
-	const server = mode.mode === "cloud" ? resolveNativeHostedCloudRemote(input.server?.url ?? env.CAPLETS_REMOTE_URL ?? "", optionalWorkspace(input, env).workspace, serverFetch) : resolveCapletsRemote(serverInput, env);
+	const remoteFetch = input.remote?.fetch;
+	const server = mode.mode === "cloud" ? resolveNativeHostedCloudRemote(input.remote?.url ?? env.CAPLETS_REMOTE_URL ?? "", optionalWorkspace(input, env).workspace, remoteFetch) : resolveCapletsRemote(input.remote, env);
 	const cloud = resolveNativeCloudPresence(input.remote?.cloud, env);
 	return {
 		mode: mode.mode,
@@ -77966,7 +79982,7 @@ function resolveNativeHostedCloudRemote(url, workspace, fetch) {
 	});
 }
 function optionalWorkspace(input, env) {
-	const workspace = input.remote?.cloud?.workspaceId ?? env.CAPLETS_REMOTE_WORKSPACE ?? env.CAPLETS_CLOUD_WORKSPACE_ID;
+	const workspace = input.remote?.cloud?.workspaceId ?? input.remote?.workspace ?? env.CAPLETS_REMOTE_WORKSPACE ?? env.CAPLETS_CLOUD_WORKSPACE_ID;
 	return workspace ? { workspace } : {};
 }
 function nativeAuthFromRemoteAuth$1(auth) {
@@ -78394,6 +80410,7 @@ var RemoteNativeCapletsService = class {
 	client;
 	unsubscribeRemote;
 	pollTimer;
+	codeModeSessions = new CodeModeSessionManager();
 	closed = false;
 	resetInFlight;
 	constructor(options) {
@@ -78410,7 +80427,7 @@ var RemoteNativeCapletsService = class {
 		return [...this.tools];
 	}
 	async execute(capletId, request) {
-		if (capletId === "code_mode") return await executeCodeModeRunRemote(this, request);
+		if (capletId === "code_mode") return await executeCodeModeRunRemote(this, request, this.codeModeSessions);
 		const remoteToolId = this.toolRoutes.get(capletId) ?? capletId;
 		try {
 			return await this.client.callTool(remoteToolId, request);
@@ -78428,6 +80445,16 @@ var RemoteNativeCapletsService = class {
 			throw error;
 		}
 	}
+	codeModeService() {
+		return {
+			listTools: () => remoteCodeModeCallableNativeTools$1(this.listTools()),
+			execute: async (capletId, request) => await this.execute(capletId, request),
+			codeModeService: () => this.codeModeService(),
+			reload: async () => await this.reload(),
+			onToolsChanged: () => () => void 0,
+			close: async () => void 0
+		};
+	}
 	async reload() {
 		if (this.closed) return false;
 		try {
@@ -78454,6 +80481,7 @@ var RemoteNativeCapletsService = class {
 		if (this.closed) return;
 		this.closed = true;
 		clearInterval(this.pollTimer);
+		this.codeModeSessions.close();
 		this.unsubscribeRemote();
 		this.listeners.clear();
 		await this.client.close();
@@ -78508,6 +80536,7 @@ function remoteToolToNativeTool(tool) {
 	const toolName = tool.codeModeRun ? nativeCodeModeToolName : nativeCapletToolName(capletId);
 	const inputSchema = isPlainObject(tool.inputSchema) ? tool.inputSchema : generatedToolInputJsonSchemaForCaplet({ backend: "tool" });
 	const operationNames = tool.sourceCapletId === void 0 && !tool.codeModeRun ? operationNamesFromSchema(inputSchema) : void 0;
+	const description = tool.codeModeRun ? remoteCodeModeToolDescription(tool) : tool.description;
 	return {
 		caplet: capletId,
 		...sourceCaplet && sourceCaplet !== capletId ? { sourceCaplet } : {},
@@ -78515,12 +80544,12 @@ function remoteToolToNativeTool(tool) {
 		toolName,
 		title: tool.title ?? capletId,
 		description: [
-			tool.description ?? "Remote Caplets tool.",
+			description ?? "Remote Caplets tool.",
 			"",
 			`Native tool name: ${toolName}`,
 			`Remote Caplet ID: ${capletId}`
 		].join("\n"),
-		promptGuidance: [`Use ${toolName} through the remote Caplets service.`],
+		promptGuidance: tool.codeModeRun ? nativeCodeModePromptGuidance() : [`Use ${toolName} through the remote Caplets service.`],
 		...tool.codeModeRun || capletId === "code_mode" ? { codeModeRun: true } : {},
 		...tool.codeModeCaplets ? { codeModeCaplets: tool.codeModeCaplets.map((caplet) => ({
 			id: caplet.capletId,
@@ -78534,6 +80563,34 @@ function remoteToolToNativeTool(tool) {
 		...operationNames ? { operationNames } : {}
 	};
 }
+function remoteCodeModeToolDescription(tool) {
+	if (!tool.codeModeCaplets || tool.codeModeCaplets.length === 0) return tool.description;
+	return generateCodeModeRunToolDescription(generateCodeModeDeclarations({ caplets: tool.codeModeCaplets.map((caplet) => ({
+		id: caplet.capletId,
+		name: caplet.name,
+		description: caplet.description ?? "",
+		shadowing: caplet.shadowing
+	})) }));
+}
+function remoteCodeModeCallableNativeTools$1(tools) {
+	const codeModeCaplets = tools.flatMap((tool) => tool.codeModeCaplets ?? []);
+	const hasExplicitCodeModeManifest = tools.some((tool) => tool.codeModeCaplets !== void 0);
+	if (codeModeCaplets.length === 0) return hasExplicitCodeModeManifest ? [] : tools.filter((tool) => tool.codeModeRun !== true);
+	const byId = new Map(tools.map((tool) => [tool.caplet, tool]));
+	return codeModeCaplets.map((caplet) => {
+		const tool = byId.get(caplet.id);
+		return {
+			caplet: caplet.id,
+			toolName: tool?.toolName ?? nativeCapletToolName(caplet.id),
+			title: caplet.name,
+			description: caplet.description,
+			...caplet.shadowing ? { shadowing: caplet.shadowing } : {},
+			...caplet.useWhen ? { useWhen: caplet.useWhen } : {},
+			...caplet.avoidWhen ? { avoidWhen: caplet.avoidWhen } : {},
+			promptGuidance: tool?.promptGuidance ?? []
+		};
+	});
+}
 function nativeToolRouteId(tool) {
 	return tool.codeModeRun ? nativeCodeModeToolId : tool.name;
 }
@@ -78659,8 +80716,9 @@ function primitiveInvokeInput(capletId, operation, input) {
 	return input;
 }
 function toolsFromManifest(manifest) {
-	const codeModeMarker = attachCodeModeMarker(manifest);
-	const codeModeShadowing = manifest.codeModeCaplets.some((entry) => entry.shadowing === "forbid") ? "forbid" : "allow";
+	const codeModeCaplets = manifest.codeModeCaplets ?? [];
+	const codeModeMarker = attachCodeModeMarker(codeModeCaplets);
+	const codeModeShadowing = codeModeCaplets.some((entry) => entry.shadowing === "forbid") ? "forbid" : "allow";
 	return [
 		...manifest.caplets.map((entry) => ({
 			name: entry.capletId,
@@ -78684,20 +80742,20 @@ function toolsFromManifest(manifest) {
 			...codeModeMarker
 		})),
 		...primitiveToolsFromManifest(manifest, codeModeMarker),
-		...manifest.codeModeCaplets.length > 0 ? [{
+		...codeModeCaplets.length > 0 ? [{
 			name: nativeCodeModeToolId,
 			capletId: nativeCodeModeToolId,
 			title: "Code Mode",
 			description: "Remote Caplets available to locally-run attached Code Mode.",
 			codeModeRun: true,
-			codeModeCaplets: manifest.codeModeCaplets,
+			codeModeCaplets,
 			shadowing: codeModeShadowing,
 			inputSchema: codeModeRunInputJsonSchema()
 		}] : []
 	];
 }
-function attachCodeModeMarker(manifest) {
-	return manifest.codeModeCaplets.length === 0 ? { codeModeCaplets: [] } : {};
+function attachCodeModeMarker(codeModeCaplets = []) {
+	return codeModeCaplets.length === 0 ? { codeModeCaplets: [] } : {};
 }
 function primitiveToolsFromManifest(manifest, codeModeMarker) {
 	const directToolNames = new Set(manifest.tools.map((entry) => entry.name));
@@ -78806,7 +80864,7 @@ function exportMapFor(manifest) {
 		mapped.set(entry.name, entry);
 	}
 	for (const entry of manifest.tools) mapped.set(entry.name, entry);
-	for (const entry of manifest.codeModeCaplets) {
+	for (const entry of manifest.codeModeCaplets ?? []) {
 		setIfAbsent(entry.capletId, entry);
 		setIfAbsent(entry.name, entry);
 	}
@@ -78866,7 +80924,7 @@ function startAttachEvents(attachUrl, requestInit, fetchImpl, listeners, onClose
 	})();
 	return abort;
 }
-async function executeCodeModeRunRemote(service, request) {
+async function executeCodeModeRunRemote(service, request, sessionManager) {
 	const parsed = codeModeRunInputSchema.safeParse(request);
 	if (!parsed.success) return {
 		ok: false,
@@ -78881,20 +80939,16 @@ async function executeCodeModeRunRemote(service, request) {
 			truncated: false,
 			stored: false
 		},
-		meta: {
-			runId: "",
-			traceId: "",
-			declarationHash: "",
-			durationMs: 0,
-			timeoutMs: 0,
-			maxTimeoutMs: 0
-		}
+		meta: emptyCodeModeRunMeta()
 	};
 	return await runCodeMode({
 		code: parsed.data.code,
 		service,
 		...parsed.data.timeoutMs === void 0 ? {} : { timeoutMs: parsed.data.timeoutMs },
-		runtimeScope: process.env.CAPLETS_MODE?.trim() || "remote"
+		...parsed.data.sessionId === void 0 ? {} : { sessionId: parsed.data.sessionId },
+		runtimeScope: process.env.CAPLETS_MODE?.trim() || "remote",
+		journalStore: new CodeModeJournalStore(),
+		...sessionManager === void 0 ? {} : { sessionManager }
 	});
 }
 function compatibleExport(manifest, previous) {
@@ -78905,7 +80959,7 @@ function compatibleExport(manifest, previous) {
 		...manifest.resourceTemplates,
 		...manifest.prompts,
 		...manifest.completions,
-		...manifest.codeModeCaplets
+		...manifest.codeModeCaplets ?? []
 	].find((entry) => entry.stableId === previous.stableId);
 	if (!next) return void 0;
 	if (next.kind !== previous.kind) return void 0;
@@ -79346,6 +81400,7 @@ var DefaultNativeCapletsService = class {
 	toolListeners = /* @__PURE__ */ new Set();
 	directToolRoutes = /* @__PURE__ */ new Map();
 	exposureSnapshot;
+	codeModeSessions = new CodeModeSessionManager();
 	postReloadRefresh;
 	exposureRefreshGeneration = 0;
 	constructor(options) {
@@ -79383,7 +81438,7 @@ var DefaultNativeCapletsService = class {
 		];
 	}
 	async execute(capletId, request) {
-		if (capletId === "code_mode") return await executeCodeModeRunNative(this.codeModeDelegate(), request);
+		if (capletId === "code_mode") return await executeCodeModeRunNative(this.codeModeDelegate(), request, this.codeModeSessions);
 		const route = this.directToolRoutes.get(capletId);
 		if (route) {
 			if (isMcpPrimitiveRoute(route.operationName)) return await this.engine.execute(route.capletId, nativeMcpPrimitiveRequest(route.operationName, request));
@@ -79391,6 +81446,9 @@ var DefaultNativeCapletsService = class {
 		}
 		return await this.engine.execute(capletId, request);
 	}
+	codeModeService() {
+		return this.codeModeDelegate();
+	}
 	async reload() {
 		const reloaded = await this.engine.reload();
 		await this.postReloadRefresh;
@@ -79404,6 +81462,7 @@ var DefaultNativeCapletsService = class {
 	}
 	async close() {
 		this.unsubscribeEngineReload();
+		this.codeModeSessions.close();
 		this.toolListeners.clear();
 		await this.engine.close();
 	}
@@ -79630,11 +81689,7 @@ function codeModeRunNativeTool(capletTools) {
 		].join("\n"),
 		codeModeRun: true,
 		codeModeCaplets,
-		promptGuidance: [
-			`Use ${nativeCodeModeToolName} to run Caplets Code Mode TypeScript with generated caplets.<id> handles.`,
-			"Prefer Code Mode for multi-step Caplet discovery, tool calls, filtering, joins, and compact synthesis.",
-			"Return decision-ready JSON from Code Mode rather than raw bulky provider payloads."
-		],
+		promptGuidance: nativeCodeModePromptGuidance(),
 		inputSchema: codeModeRunInputJsonSchema()
 	};
 }
@@ -79657,7 +81712,7 @@ function codeModeCallableNativeTools(tools, options) {
 		};
 	});
 }
-async function executeCodeModeRunNative(service, request) {
+async function executeCodeModeRunNative(service, request, sessionManager) {
 	const parsed = codeModeRunInputSchema.safeParse(request);
 	if (!parsed.success) return {
 		ok: false,
@@ -79672,20 +81727,16 @@ async function executeCodeModeRunNative(service, request) {
 			truncated: false,
 			stored: false
 		},
-		meta: {
-			runId: "",
-			traceId: "",
-			declarationHash: "",
-			durationMs: 0,
-			timeoutMs: 0,
-			maxTimeoutMs: 0
-		}
+		meta: emptyCodeModeRunMeta()
 	};
 	return await runCodeMode({
 		code: parsed.data.code,
 		service,
 		...parsed.data.timeoutMs === void 0 ? {} : { timeoutMs: parsed.data.timeoutMs },
-		runtimeScope: process.env.CAPLETS_MODE?.trim() || "local"
+		...parsed.data.sessionId === void 0 ? {} : { sessionId: parsed.data.sessionId },
+		runtimeScope: process.env.CAPLETS_MODE?.trim() || "local",
+		journalStore: new CodeModeJournalStore(),
+		...sessionManager === void 0 ? {} : { sessionManager }
 	});
 }
 function createDefaultNativeCapletsService(options) {
@@ -79727,11 +81778,14 @@ var CloudNativeCapletsService = class {
 	async execute(capletId, request) {
 		return await (this.delegate ?? this.local).execute(capletId, request);
 	}
+	codeModeService() {
+		return (this.delegate ?? this.local).codeModeService?.() ?? this.delegate ?? this.local;
+	}
 	async reload() {
 		if (this.closed) return false;
 		if (!this.delegate) try {
-			const cloudFetch = this.options.remote?.fetch ?? this.options.server?.fetch;
-			const remoteUrl = this.options.server?.url ?? this.baseRemote.url.toString().replace(/\/mcp$/u, "");
+			const cloudFetch = this.options.remote?.fetch;
+			const remoteUrl = this.options.remote?.url ?? this.baseRemote.url.toString().replace(/\/mcp$/u, "");
 			const selection = await resolveRemoteSelection({
 				mode: "cloud",
 				remoteUrl,
@@ -79807,6 +81861,7 @@ var CompositeNativeCapletsService = class {
 	tools = [];
 	closed = false;
 	batchingReload = false;
+	codeModeSessions = new CodeModeSessionManager();
 	constructor(remote, local, options, presence) {
 		this.remote = remote;
 		this.local = local;
@@ -79822,10 +81877,20 @@ var CompositeNativeCapletsService = class {
 		return [...this.tools];
 	}
 	async execute(capletId, request) {
-		if (capletId === "code_mode") return await executeCodeModeRunNative(this, request);
+		if (capletId === "code_mode") return await executeCodeModeRunNative(this, request, this.codeModeSessions);
 		if (this.localCanExecute(capletId)) return await this.local.execute(capletId, request);
 		return await this.remote.execute(capletId, request);
 	}
+	codeModeService() {
+		return {
+			listTools: () => codeModeCallableNativeTools(this.listTools(), { fallbackToVisible: false }),
+			execute: async (capletId, request) => await this.execute(capletId, request),
+			codeModeService: () => this.codeModeService(),
+			reload: async () => await this.reload(),
+			onToolsChanged: () => () => void 0,
+			close: async () => void 0
+		};
+	}
 	async reload() {
 		if (this.closed) return false;
 		this.batchingReload = true;
@@ -79846,6 +81911,7 @@ var CompositeNativeCapletsService = class {
 		this.closed = true;
 		for (const unsubscribe of this.unsubscribers.splice(0)) unsubscribe();
 		this.listeners.clear();
+		this.codeModeSessions.close();
 		await Promise.all([
 			this.remote.close(),
 			this.local.close(),
@@ -79917,7 +81983,7 @@ function localExecutionKeys(tools, capletId) {
 function createProjectBindingSessionManager(cloud, local, options) {
 	if (!cloud) return;
 	const projectRoot = cloud.projectRoot ?? findProjectRoot();
-	const cloudFetch = options.remote?.fetch ?? options.server?.fetch;
+	const cloudFetch = options.remote?.fetch;
 	return new ProjectBindingSessionManager({
 		client: new CapletsCloudClient({
 			baseUrl: cloud.url,
@@ -79949,9 +82015,9 @@ function createLocalOverlayConfigLoader(options) {
 			return parseConfig({});
 		}
 		for (const warning of result.warnings) writeErr(options, `Caplets local overlay warning${typeof warning.path === "string" ? ` at ${warning.path}` : ""}: ${warning.message}\n`);
-		const warnings = new Set(result.warnings.map(warningKey));
-		if (hasLoaded && [...warnings].some((warning) => !previousWarnings.has(warning))) throw new CapletsError("CONFIG_INVALID", "Caplets local overlay reload produced new warnings; keeping last known-good config.");
-		previousWarnings = warnings;
+		const fatalWarnings = new Set(result.warnings.filter((warning) => !warning.recoverable).map(warningKey));
+		if (hasLoaded && [...fatalWarnings].some((warning) => !previousWarnings.has(warning))) throw new CapletsError("CONFIG_INVALID", "Caplets local overlay reload produced new warnings; keeping last known-good config.");
+		previousWarnings = fatalWarnings;
 		hasLoaded = true;
 		return result.config;
 	};
@@ -79971,4 +82037,4 @@ function errorMessage(error) {
 	return error instanceof Error ? error.message : String(error);
 }
 //#endregion
-export { loadConfigWithSources as $, ListResourcesRequestSchema as $t, codeModeRunParamsSchema as A, assertClientRequestTaskCapability as At, generateCodeModeRunToolDescription as B, CreateMessageResultWithToolsSchema as Bt, nativeCapletPromptGuidance as C, __exportAll as Cn, defaultStateBaseDir as Ct, nativeCodeModeToolId as D, resolveProjectConfigPath as Dt, nativeCapletsSystemGuidance as E, resolveProjectCapletsRoot as Et, listCodeModeCallableCaplets as F, toJsonSchemaCompat as Ft, directResourceUriMatchesTemplate as G, ErrorCode as Gt, CapletsEngine as H, DEFAULT_NEGOTIATED_PROTOCOL_VERSION as Ht, CodeModeLogStore as I, CallToolRequestSchema as It, handleServerTool as J, InitializedNotificationSchema as Jt, findProjectRoot as K, GetPromptRequestSchema as Kt, redactCodeModeLogText as L, CallToolResultSchema as Lt, QuickJsCodeModeSandbox as M, AjvJsonSchemaValidator as Mt, diagnoseCodeModeTypeScript as N, Protocol as Nt, nativeCodeModeToolName as O, ReadBuffer as Ot, createCodeModeCapletsApi as P, mergeCapabilities as Pt, loadConfig as Q, ListResourceTemplatesRequestSchema as Qt, codeModeDeclarationHash as R, CompleteRequestSchema as Rt, resolveCapletsServer as S, safeParseAsync as Sn, defaultConfigBaseDir as St, nativeCapletToolName as T, resolveConfigPath as Tt, resolveExposure as U, ElicitResultSchema as Ut, minifyCodeModeDeclarationText as V, CreateTaskResultSchema as Vt, decodeDirectResourceUri as W, EmptyResultSchema as Wt, capabilityDescription as X, LATEST_PROTOCOL_VERSION as Xt, ServerRegistry as Y, JSONRPCMessageSchema as Yt, GoogleDiscoveryManager as Z, ListPromptsRequestSchema as Zt, resolveHostedCloudRemote as _, isSchemaOptional as _n, readTokenBundle as _t, projectBindingError as a, SUPPORTED_PROTOCOL_VERSIONS as an, validateCapletFile as at, parseServerBaseUrl as b, objectFromShape as bn, DEFAULT_OBSERVED_OUTPUT_SHAPE_CACHE_DIR as bt, cloudAuthPath as c, assertCompleteRequestResourceTemplate as cn, markdownCallToolResultContent as ct, CloudAuthClient as d, isJSONRPCRequest as dn, runGenericOAuthFlow as dt, ListRootsResultSchema as en, loadGlobalConfig as et, RemoteNativeCapletsService as f, isJSONRPCResultResponse as fn, runOAuthFlow as ft, resolveCapletsRemote as g, getSchemaDescription as gn, isTokenBundleExpired as gt, resolveNativeCapletsServiceOptions as h, getParseErrorMessage as hn, deleteTokenBundle as ht, ProjectBindingError as i, ReadResourceRequestSchema as in, discoverCapletFiles as it, runCodeMode as j, assertToolsCallTaskCapability as jt, codeModeRunInputSchema as k, serializeMessage as kt, migrateCredentials as l, isInitializeRequest as ln, markdownStructuredContent as lt, buildProjectSyncManifest as m, getObjectShape as mn, startOAuthFlow as mt, resolveRemoteSelection as n, LoggingLevelSchema as nn, loadProjectConfig as nt, projectBindingRecovery as o, SetLevelRequestSchema as on, loadCapletFilesFromMap as ot, createSdkRemoteCapletsClient as p, getLiteralValue as pn, startGenericOAuthFlow as pt, fingerprintProjectRoot as q, InitializeRequestSchema as qt, PROJECT_BINDING_ERROR_CODES as r, McpError as rn, parseConfig as rt, CloudAuthStore as s, assertCompleteRequestPrompt as sn, hasRenderableStructuredContent as st, createNativeCapletsService as t, ListToolsRequestSchema as tn, loadLocalOverlayConfigWithSources as tt, redactedCloudAuthStatus as u, isJSONRPCErrorResponse as un, refreshOAuthTokenBundle as ut, resolveRemoteMode as v, isZ4Schema as vn, DEFAULT_AUTH_DIR as vt, nativeCapletToolDescription as w, resolveCapletsRoot as wt, resolveCapletsMode as x, safeParse as xn, defaultCacheBaseDir as xt, controlUrlForBase as y, normalizeObjectSchema as yn, DEFAULT_COMPLETION_CACHE_DIR as yt, generateCodeModeDeclarations as z, CreateMessageResultSchema as zt };
+export { GoogleDiscoveryManager as $, ListPromptsRequestSchema as $t, emptyCodeModeRunMeta as A, ReadBuffer as At, codeModeDeclarationHash as B, CompleteRequestSchema as Bt, nativeCapletToolDescription as C, safeParse as Cn, defaultCacheBaseDir as Ct, nativeCodeModeToolName as D, resolveConfigPath as Dt, nativeCodeModeToolId as E, resolveCapletsRoot as Et, createCodeModeCapletsApi as F, Protocol as Ft, resolveExposure as G, ElicitResultSchema as Gt, generateCodeModeRunToolDescription as H, CreateMessageResultWithToolsSchema as Ht, listCodeModeCallableCaplets as I, mergeCapabilities as It, findProjectRoot as J, GetPromptRequestSchema as Jt, decodeDirectResourceUri as K, EmptyResultSchema as Kt, CodeModeJournalStore as L, toJsonSchemaCompat as Lt, CodeModeSessionManager as M, assertClientRequestTaskCapability as Mt, QuickJsCodeModeSandbox as N, assertToolsCallTaskCapability as Nt, codeModeRunInputSchema as O, resolveProjectCapletsRoot as Ot, diagnoseCodeModeTypeScript as P, AjvJsonSchemaValidator as Pt, capabilityDescription as Q, LATEST_PROTOCOL_VERSION as Qt, CodeModeLogStore as R, CallToolRequestSchema as Rt, nativeCapletPromptGuidance as S, objectFromShape as Sn, DEFAULT_OBSERVED_OUTPUT_SHAPE_CACHE_DIR as St, nativeCapletsSystemGuidance as T, __exportAll as Tn, defaultStateBaseDir as Tt, minifyCodeModeDeclarationText as U, CreateTaskResultSchema as Ut, generateCodeModeDeclarations as V, CreateMessageResultSchema as Vt, CapletsEngine as W, DEFAULT_NEGOTIATED_PROTOCOL_VERSION as Wt, handleServerTool as X, InitializedNotificationSchema as Xt, fingerprintProjectRoot as Y, InitializeRequestSchema as Yt, ServerRegistry as Z, JSONRPCMessageSchema as Zt, resolveHostedCloudRemote as _, getParseErrorMessage as _n, deleteTokenBundle as _t, projectBindingError as a, McpError as an, parseConfig as at, parseServerBaseUrl as b, isZ4Schema as bn, DEFAULT_AUTH_DIR as bt, cloudAuthPath as c, SetLevelRequestSchema as cn, loadCapletFilesFromMap as ct, CloudAuthClient as d, isInitializeRequest as dn, markdownStructuredContent as dt, ListResourceTemplatesRequestSchema as en, loadConfig as et, RemoteNativeCapletsService as f, isJSONRPCErrorResponse as fn, refreshOAuthTokenBundle as ft, resolveCapletsRemote as g, getObjectShape as gn, startOAuthFlow as gt, resolveNativeCapletsServiceOptions as h, getLiteralValue as hn, startGenericOAuthFlow as ht, ProjectBindingError as i, LoggingLevelSchema as in, loadProjectConfig as it, runCodeMode as j, serializeMessage as jt, codeModeRunParamsSchema as k, resolveProjectConfigPath as kt, migrateCredentials as l, assertCompleteRequestPrompt as ln, hasRenderableStructuredContent as lt, buildProjectSyncManifest as m, isJSONRPCResultResponse as mn, runOAuthFlow as mt, resolveRemoteSelection as n, ListRootsResultSchema as nn, loadGlobalConfig as nt, projectBindingRecovery as o, ReadResourceRequestSchema as on, discoverCapletFiles as ot, createSdkRemoteCapletsClient as p, isJSONRPCRequest as pn, runGenericOAuthFlow as pt, directResourceUriMatchesTemplate as q, ErrorCode as qt, PROJECT_BINDING_ERROR_CODES as r, ListToolsRequestSchema as rn, loadLocalOverlayConfigWithSources as rt, CloudAuthStore as s, SUPPORTED_PROTOCOL_VERSIONS as sn, validateCapletFile as st, createNativeCapletsService as t, ListResourcesRequestSchema as tn, loadConfigWithSources as tt, redactedCloudAuthStatus as u, assertCompleteRequestResourceTemplate as un, markdownCallToolResultContent as ut, resolveRemoteMode as v, getSchemaDescription as vn, isTokenBundleExpired as vt, nativeCapletToolName as w, safeParseAsync as wn, defaultConfigBaseDir as wt, resolveCapletsServer as x, normalizeObjectSchema as xn, DEFAULT_COMPLETION_CACHE_DIR as xt, controlUrlForBase as y, isSchemaOptional as yn, readTokenBundle as yt, redactCodeModeLogText as z, CallToolResultSchema as zt };