@code-yeongyu/senpi-codemode 2026.10.8 → 2026.10.10-10

package/src/kernels/js/context-manager.ts

@@ -1,19 +1,21 @@
 import type { HostToKernelMessage, KernelToHostMessage } from "../../bridge/protocol.ts";
-import { CHILD_LIFECYCLE_OP, INTERRUPT_ACK_OP } from "../../bridge/reserved.ts";
 import type { KernelInterruptHandle } from "../../tool/types.ts";
 import { KernelToolHostPump } from "../shared/kernel-tools-pump.ts";
 import { ActiveCellControl } from "./active-cell-control.ts";
-import { DEFAULT_INTERRUPT_BOUNDS, type WorkerRetirement } from "./interrupt-bounds.ts";
+import { dispatchCell } from "./cell-dispatch.ts";
+import { consumeControlFrame } from "./control-frames.ts";
+import { HostEntries } from "./host-entries.ts";
+import { DEFAULT_INTERRUPT_BOUNDS, JS_INTERRUPT_GRACE_MS, type WorkerRetirement } from "./interrupt-bounds.ts";
 import {
 	assertJavaScriptKernelOpen,
 	type JavaScriptKernelMode,
 	type JavaScriptRunInput,
 	type LifecycleState,
 	type ResultMessage,
-	resolveKernelToolNameSource,
 	type ToolCallMessage,
 } from "./kernel-contract.ts";
-import { type JavaScriptMemoryReading, KernelMemoryBridge } from "./kernel-memory-bridge.ts";
+import { JavaScriptKernelMemory } from "./kernel-memory.ts";
+import type { JavaScriptMemoryReading } from "./kernel-memory-bridge.ts";
 import { kernelToolError } from "./kernel-tools-errors.ts";
 import type {
 	KernelToolsDescribeResult,
@@ -21,10 +23,9 @@ import type {
 	KernelToolsInvokeRequest,
 } from "./kernel-tools-types.ts";
 import { type JavaScriptKernelOptions, LocalModuleLoader } from "./local-module-loader.ts";
-import { JavaScriptRunQueue } from "./run-queue.ts";
+import { JavaScriptRunQueue, type PendingJavaScriptRun } from "./run-queue.ts";
 import { ToolCallQueue } from "./tool-call-queue.ts";
 import { WorkerChildren } from "./worker-children.ts";
-import { crashedResult } from "./worker-host.ts";
 import { WorkerRecovery } from "./worker-recovery.ts";
 import { WorkerSlot } from "./worker-slot.ts";
 
@@ -34,6 +35,15 @@ export type { JavaScriptKernelOptions } from "./local-module-loader.ts";
 export { type JavaScriptWorkerEntryUrlOptions, resolveJsWorkerEntryUrl } from "./worker-startup.ts";
 
 export class JavaScriptKernel {
+	readonly #hostEntries = new HostEntries<PendingJavaScriptRun>({
+		emit: (run, message) => (run.input.onMessage ?? this.#options.onMessage)?.(message),
+		settle: (run, result) => {
+			if (!this.#runs.releaseActive(run)) return;
+			this.#runs.settle(run, result);
+			this.#startNext();
+		},
+		durationMs: (run) => this.#runs.durationMs(run, performance.now()),
+	});
 	readonly #options: JavaScriptKernelOptions;
 	readonly #moduleLoader: LocalModuleLoader;
 	readonly #slot: WorkerSlot;
@@ -47,7 +57,7 @@ export class JavaScriptKernel {
 	);
 	readonly #toolCalls = new ToolCallQueue();
 	readonly #children: WorkerChildren;
-	readonly #memory: KernelMemoryBridge;
+	readonly #memory: JavaScriptKernelMemory;
 	readonly #activeCell: ActiveCellControl;
 	readonly #recovery = new WorkerRecovery({
 		runs: this.#runs,
@@ -66,7 +76,7 @@ export class JavaScriptKernel {
 			recover: () => void this.#recovery.recover(() => Promise.resolve()),
 			clearToolCalls: () => this.#toolCalls.clear(),
 		});
-		this.#memory = new KernelMemoryBridge(options.memory, options.onMemoryCollected);
+		this.#memory = new JavaScriptKernelMemory(options, () => this.#slot.processPid);
 		this.#children = new WorkerChildren(options.collectOrphanedChildren);
 		this.#moduleLoader = new LocalModuleLoader(options);
 		this.#slot = new WorkerSlot(options, {
@@ -80,15 +90,20 @@ export class JavaScriptKernel {
 		return this.#slot.mode;
 	}
 
-	/** The last heap reading the worker sent (a result, an idle collection, a query); none before the first. */
+	/** The kernel process's pid in process mode; none in worker mode or before it starts. */
+	get processPid(): number | undefined {
+		return this.#slot.processPid;
+	}
+
+	/** The last memory reading (a result, an idle collection, a query); none before the first. */
 	get lastLiveBytes(): number | undefined {
 		return this.#memory.lastLiveBytes;
 	}
 
 	/** A heap reading taken between cells without running one; nothing when no worker is live to ask. */
 	async queryMemory(): Promise<JavaScriptMemoryReading | undefined> {
-		if (this.#lifecycle !== "open" || !this.#slot.present || this.#slot.startingUp) return undefined;
-		return await this.#memory.query((message) => this.#slot.postMessage(message));
+		const ready = this.#lifecycle === "open" && this.#slot.present && !this.#slot.startingUp;
+		return await this.#memory.query(ready ? (message) => this.#slot.postMessage(message) : undefined);
 	}
 
 	get kernelToolEvents(): EventTarget {
@@ -128,6 +143,7 @@ export class JavaScriptKernel {
 			const cancelled = this.cancelQueued(cellId, reason);
 			return { stateRetained: Promise.resolve(true), ...(cancelled ? {} : { note: "cell not found" }) };
 		}
+		if (active && this.#hostEntries.abort(active, reason)) return { stateRetained: Promise.resolve(true) };
 		if (!active) {
 			// A worker still stuck in startup is not a healthy idle worker: retiring it is the only recovery.
 			const wedgedInStartup = this.#slot.startingUp;
@@ -162,11 +178,14 @@ export class JavaScriptKernel {
 		if (this.#closePromise) return await this.#closePromise;
 		this.#slot.postMessage({ type: "close" });
 		this.#lifecycle = "closing";
+		const graceMs = this.#options.interruptBounds?.graceMs ?? JS_INTERRUPT_GRACE_MS;
+		const hostEntriesStopped = this.#hostEntries.stopAll("JS kernel closed", graceMs);
 		this.#runs.settleAll("JS kernel closed");
 		this.#kernelTools.rejectAll(kernelToolError("kernel_tool_stale", "JS kernel closed"));
 		this.#toolCalls.clear();
 		const recovery = this.#recovery.inFlight;
 		const closePromise = (async () => {
+			await hostEntriesStopped;
 			if (recovery) await recovery;
 			await this.#terminate();
 		})().finally(() => {
@@ -188,25 +207,26 @@ export class JavaScriptKernel {
 
 	async #ensureReady(): Promise<void> {
 		assertJavaScriptKernelOpen(this.#lifecycle, "run");
-		await this.#slot.ensureReady();
+		try {
+			await this.#slot.ensureReady();
+		} catch (error) {
+			if (this.#options.isolation !== "process") throw error;
+			// Process mode reports a failed start on the waiting cell, never as a rejection of run().
+			if (this.#lifecycle === "open") this.#runs.settleAll(error instanceof Error ? error.message : String(error));
+		}
 	}
 
 	#startNext(): void {
 		if (this.#lifecycle !== "open" || this.#runs.active || !this.#slot.present) return;
 		const next = this.#runs.startNext(performance.now());
 		if (!next) return;
+		const dispatch = dispatchCell(next.input, this.#moduleLoader, this.#options);
+		if (dispatch.kind === "host") {
+			this.#hostEntries.start(next, dispatch.host);
+			return;
+		}
 		this.#activeCell.arm(next);
-		this.#slot.postMessage({
-			type: "kernel-tools-names",
-			hostToolNames: resolveKernelToolNameSource(this.#options.hostToolNames),
-			foreignLanguageNames: resolveKernelToolNameSource(this.#options.foreignLanguageNames),
-		});
-		this.#slot.postMessage({
-			type: "run",
-			cellId: next.input.cellId,
-			code: this.#moduleLoader.prepareCell(next.input.code, next.input.kernelPreludes),
-			timeoutMs: next.input.timeoutMs,
-		});
+		for (const frame of dispatch.frames) this.#slot.postMessage(frame);
 	}
 
 	async #restartAfterStop(): Promise<void> {
@@ -215,15 +235,7 @@ export class JavaScriptKernel {
 
 	#handleMessage(message: KernelToHostMessage): void {
 		if (this.#kernelTools.consume(message) && message.type !== "tool-call") return;
-		if (this.#memory.consume(message)) return;
-		if (message.type === "status" && message.event.op === INTERRUPT_ACK_OP) {
-			this.#runs.acknowledgeInterrupt(message.event);
-			return;
-		}
-		if (message.type === "status" && message.event.op === CHILD_LIFECYCLE_OP) {
-			this.#children.track(message.event);
-			return;
-		}
+		if (consumeControlFrame(message, { memory: this.#memory, runs: this.#runs, children: this.#children })) return;
 		(this.#runs.active?.input.onMessage ?? this.#options.onMessage)?.(message);
 		if (message.type === "tool-call") {
 			this.#toolCalls.push(message);
@@ -246,13 +258,10 @@ export class JavaScriptKernel {
 		if (!active && this.#slot.startingUp) return;
 		this.#activeCell.disarm();
 		this.#kernelTools.rejectAll(kernelToolError("kernel_tool_stale", error.message));
-		this.#memory.workerLost(error);
-		if (active) {
-			this.#runs.releaseActive(active);
-			this.#runs.settle(
-				active,
-				crashedResult(active.input.cellId, error, this.#runs.durationMs(active, performance.now())),
-			);
+		this.#memory.crashed(error);
+		// A crash mid-install stops the install (process group killed, nothing published); it settles itself once stopped.
+		if (active && !this.#hostEntries.abort(active, `JavaScript worker crashed: ${error.message}`)) {
+			this.#runs.settleCrashed(active, error);
 		}
 		this.#toolCalls.clear();
 		void this.#restartAfterStop();

package/src/kernels/js/control-frames.ts

@@ -0,0 +1,24 @@
+import type { KernelToHostMessage } from "../../bridge/protocol.ts";
+import { CHILD_LIFECYCLE_OP, INTERRUPT_ACK_OP } from "../../bridge/reserved.ts";
+import type { JavaScriptKernelMemory } from "./kernel-memory.ts";
+import type { JavaScriptRunQueue } from "./run-queue.ts";
+import type { WorkerChildren } from "./worker-children.ts";
+
+export interface ControlFrameOwners {
+	readonly memory: Pick<JavaScriptKernelMemory, "consume">;
+	readonly runs: Pick<JavaScriptRunQueue, "acknowledgeInterrupt">;
+	readonly children: Pick<WorkerChildren, "track">;
+}
+
+/** Routes a worker's side-channel frames (memory readings, interrupt acks, child lifecycle) to their owners. */
+export function consumeControlFrame(message: KernelToHostMessage, owners: ControlFrameOwners): boolean {
+	if (owners.memory.consume(message)) return true;
+	if (message.type !== "status") return false;
+	if (message.event.op === INTERRUPT_ACK_OP) {
+		owners.runs.acknowledgeInterrupt(message.event);
+		return true;
+	}
+	if (message.event.op !== CHILD_LIFECYCLE_OP) return false;
+	owners.children.track(message.event);
+	return true;
+}

package/src/kernels/js/host-entries.ts

@@ -0,0 +1,62 @@
+import type { KernelToHostMessage } from "../../bridge/protocol.ts";
+import type { HostCellExecutor } from "../../tool/types.ts";
+import { runHostCell } from "../shared/host-cell.ts";
+import type { ResultMessage } from "./kernel-contract.ts";
+
+export interface HostEntryKernel<Run> {
+	emit(run: Run, message: KernelToHostMessage): void;
+	settle(run: Run, result: ResultMessage): void;
+	durationMs(run: Run): number;
+}
+
+/** The host entries (installs) a JavaScript kernel is running: started per queue slot, stopped by interrupt and close. */
+export class HostEntries<Run extends { readonly input: { readonly cellId: string } }> {
+	readonly #aborts = new Map<Run, AbortController>();
+	readonly #done = new Map<Run, Promise<unknown>>();
+	readonly #kernel: HostEntryKernel<Run>;
+
+	constructor(kernel: HostEntryKernel<Run>) {
+		this.#kernel = kernel;
+	}
+
+	/** Runs `host` for `run`'s queue slot; it holds the slot like a cell but never reaches the worker. */
+	start(run: Run, host: HostCellExecutor): void {
+		const entry = runHostCell(run.input.cellId, host, {
+			emit: (message) => this.#kernel.emit(run, message),
+			settle: (result) => {
+				this.#aborts.delete(run);
+				this.#kernel.settle(run, result);
+			},
+			durationMs: () => this.#kernel.durationMs(run),
+			settleAfterAbort: true,
+		});
+		this.#aborts.set(run, entry.abort);
+		this.#done.set(run, entry.done);
+		void entry.done.finally(() => this.#done.delete(run));
+	}
+
+	/** Aborts `run`'s host entry; false when `run` is not one. */
+	abort(run: Run, reason: string): boolean {
+		const abort = this.#aborts.get(run);
+		if (abort === undefined) return false;
+		abort.abort(new Error(reason));
+		return true;
+	}
+
+	/** Aborts every running entry and waits for them to stop, at most `ms`: a closed kernel leaves no install running. */
+	async stopAll(reason: string, ms: number): Promise<void> {
+		const running = [...this.#done.values()];
+		for (const abort of this.#aborts.values()) abort.abort(new Error(reason));
+		let timer: ReturnType<typeof setTimeout> | undefined;
+		await Promise.race([
+			Promise.allSettled(running),
+			new Promise<void>((resolve) => (timer = setTimeout(resolve, ms))),
+		]);
+		if (timer !== undefined) clearTimeout(timer);
+	}
+}
+
+/** A turn-time refusal (an unreadable `%load` file, a refused magic) settles in queue order as a failed host entry. */
+export function refusedEntry(message: string): HostCellExecutor {
+	return async () => ({ ok: false, error: { message } });
+}

package/src/kernels/js/kernel-contract.ts

@@ -7,7 +7,7 @@ import type { JavaScriptInterruptBounds } from "./interrupt-bounds.ts";
 export type ResultMessage = Extract<KernelToHostMessage, { type: "result" }>;
 export type ToolCallMessage = Extract<KernelToHostMessage, { type: "tool-call" }>;
 
-export type JavaScriptKernelMode = "worker" | "inline";
+export type JavaScriptKernelMode = "worker" | "inline" | "process";
 
 /** Snapshot or live provider consulted when the worker registry checks collisions. */
 export type KernelToolNameSource = readonly string[] | (() => readonly string[]);
@@ -30,8 +30,23 @@ export interface JavaScriptKernelOptions {
 	readonly workerEntryUrl?: URL;
 	/** Per-session PI_* values applied to the worker environment before the first cell runs. */
 	readonly sessionEnv?: SessionEnvironment;
+	/** Opt-in child-process kernel; absent keeps the worker-thread kernel. */
+	readonly isolation?: "process";
+	/** Resolution root for the process-mode runtime (bun, then node); `""` names a machine with none on PATH. */
+	readonly processCommandPath?: string;
+	/** The host's executable, which runs the child when it is bun or node; defaults to `process.execPath`. */
+	readonly processExecPath?: string;
+	/** How long a process-mode child gets to report ready; defaults to `PROCESS_STARTUP_DEADLINE_MS`. */
+	readonly processStartupDeadlineMs?: number;
+	/** Process-mode memory policy: the host reads the child's footprint instead of the in-heap worker reading. */
+	readonly processMemory?: {
+		readonly thresholds: KernelMemoryThresholds;
+		readonly readFootprint?: (pid: number) => { readonly bytes: number } | undefined;
+	};
 	/** Host tool names denied as JS kernel-tool identifiers (init protocol). */
 	readonly hostToolNames?: KernelToolNameSource;
+	/** `kernelTools.enabled`; false makes `tool(fn)` refuse with `tools_unavailable`. Unset keeps them on. */
+	readonly kernelToolsEnabled?: boolean;
 	/** Tool names registered in another kernel language, denied as JS kernel-tool identifiers. */
 	readonly foreignLanguageNames?: KernelToolNameSource;
 	/** Post-cell collection, notice, and ceiling thresholds; absent leaves the worker's memory unmanaged. */

package/src/kernels/js/kernel-memory-bridge.ts

@@ -6,7 +6,7 @@ import type { ResultMessage } from "./kernel-contract.ts";
 
 export interface JavaScriptMemoryReading {
 	readonly liveBytes: number;
-	readonly measure: "heap";
+	readonly measure: "heap" | "footprint";
 }
 
 /** A query waits at most this long: the worker answers between cells, never inside one. */

package/src/kernels/js/kernel-memory.ts

@@ -0,0 +1,79 @@
+import type { HostToKernelMessage, KernelToHostMessage } from "../../bridge/protocol.ts";
+import { restartNotice } from "../shared/kernel-death.ts";
+import type { ResultMessage } from "./kernel-contract.ts";
+import { type JavaScriptMemoryReading, KernelMemoryBridge } from "./kernel-memory-bridge.ts";
+import type { JavaScriptKernelOptions } from "./local-module-loader.ts";
+import { JavaScriptProcessMemoryHost } from "./process-memory-host.ts";
+
+/**
+ * The kernel's one view of memory: the worker's heap bridge, or in process mode the child process's footprint, plus
+ * the restart notice a crash leaves for the next result.
+ */
+export class JavaScriptKernelMemory {
+	readonly #bridge: KernelMemoryBridge;
+	readonly #process: JavaScriptProcessMemoryHost | null;
+	readonly #pid: () => number | undefined;
+	readonly #processMode: boolean;
+	#restartNotice: string | null = null;
+
+	constructor(options: JavaScriptKernelOptions, pid: () => number | undefined) {
+		const processMode = options.isolation === "process";
+		this.#bridge = new KernelMemoryBridge(processMode ? undefined : options.memory, options.onMemoryCollected);
+		this.#process =
+			processMode && options.processMemory !== undefined
+				? new JavaScriptProcessMemoryHost(options.processMemory.thresholds, options.processMemory.readFootprint)
+				: null;
+		this.#pid = pid;
+		this.#processMode = processMode;
+	}
+
+	get lastLiveBytes(): number | undefined {
+		return this.#process === null ? this.#bridge.lastLiveBytes : this.#process.lastLiveBytes(this.#pid);
+	}
+
+	/** A reading between cells. The worker is asked only through `post`, given when a worker is ready to answer. */
+	async query(
+		post: ((message: HostToKernelMessage) => void) | undefined,
+	): Promise<JavaScriptMemoryReading | undefined> {
+		if (this.#process !== null) return this.#process.query(this.#pid);
+		return post === undefined ? undefined : await this.#bridge.query(post);
+	}
+
+	consume(message: KernelToHostMessage): boolean {
+		return this.#bridge.consume(message);
+	}
+
+	settled(message: ResultMessage): ResultMessage {
+		if (this.#process !== null) return this.#process.settled(message, this.#pid);
+		const settled = this.#bridge.settled(message);
+		if (this.#restartNotice === null) return settled;
+		const notice = this.#restartNotice;
+		this.#restartNotice = null;
+		return { ...settled, notice, kernelState: "restarted" };
+	}
+
+	/** Whether the kernel should restart for memory now; only once nothing is running or queued (`idle`). */
+	claimRecycle(idle: boolean): boolean {
+		const worker = this.#bridge.claimRecycle(idle);
+		return this.#process?.claimRecycle(idle) === true || worker;
+	}
+
+	/** The worker was retired: pending readings fail. */
+	workerLost(error: Error): void {
+		this.#bridge.workerLost(error);
+	}
+
+	/**
+	 * The kernel crashed: pending readings fail. In process mode the next result also says the kernel restarted (a
+	 * crashed child loses every global); worker mode reports its crash as it always has, with no notice.
+	 */
+	crashed(error: Error): void {
+		this.#bridge.workerLost(error);
+		if (this.#process !== null) {
+			this.#process.workerLost();
+			this.#process.markRestarted(error);
+			return;
+		}
+		if (this.#processMode) this.#restartNotice = restartNotice("js", error.message);
+	}
+}

package/src/kernels/js/kernel-tools-registry.js

@@ -45,6 +45,7 @@ export function createKernelToolRegistry(options = {}) {
 			return generation;
 		},
 		define(fn, metadata) {
+			if (options.disabled === true) throw kernelToolError("tools_unavailable", "kernel tools are turned off for this project (kernelTools.enabled is false)");
 			assertJs();
 			const parsed = parseToolFunction(fn);
 			const resolved = resolveToolMetadata(metadata, parsed.params);

package/src/kernels/js/local-module-loader.ts

@@ -1,4 +1,4 @@
-import { join, resolve, sep } from "node:path";
+import { dirname, join, resolve, sep } from "node:path";
 import { pathToFileURL } from "node:url";
 import type { KernelPreludeContribution } from "@code-yeongyu/senpi";
 import type { BridgeConnectionConfig } from "../../bridge/protocol.ts";
@@ -98,7 +98,13 @@ function loaderPrelude(context: RuntimeModuleContext): string {
 		"    const urlModule = await import('node:url');",
 		"    target = urlModule.pathToFileURL(specifier).href;",
 		"  }",
-		"  return options === undefined ? import(target) : import(target, options);",
+		"  const load = (resolved) => (options === undefined ? import(resolved) : import(resolved, options));",
+		"  const resolvePackage = globalThis[Symbol.for('senpi.kernel.resolvePackage')];",
+		"  if (target === specifier && typeof resolvePackage === 'function') {",
+		"    const resolved = resolvePackage(specifier, [context.cwdUrl, context.packageRootUrl]);",
+		"    if (resolved !== undefined) return await load(resolved);",
+		"  }",
+		"  return await load(target);",
 		"};",
 	].join("\n");
 }
@@ -115,14 +121,24 @@ function contributionPrelude(plan: KernelPreludePlan): string {
 
 export class LocalModuleLoader {
 	readonly #prelude: string;
+	readonly #cwdUrl: string;
 	readonly #contributions = new KernelPreludeTracker();
 
 	constructor(options: LocalModuleLoaderOptions) {
 		this.#prelude = loaderPrelude(runtimeContext(options));
+		this.#cwdUrl = directoryUrl(options.cwd);
 	}
 
-	prepareCell(code: string, contributions: readonly KernelPreludeContribution[] = []): string {
-		const prelude = `${this.#prelude}\n${contributionPrelude(this.#contributions.plan(contributions))}`;
-		return `${PREPARED_CELL_PREFIX}${JSON.stringify({ prelude, code: rewriteImports(code) })}`;
+	prepareCell(
+		code: string,
+		contributions: readonly KernelPreludeContribution[] = [],
+		sourceFile?: string,
+		packageRoot?: string,
+	): string {
+		// A %load cell resolves its relative imports from its own file's directory for that cell only.
+		const cwdUrl = sourceFile === undefined ? this.#cwdUrl : directoryUrl(dirname(sourceFile));
+		const base = `\nglobalThis.__senpi_module_context__ = { ...globalThis.__senpi_module_context__, cwdUrl: ${JSON.stringify(cwdUrl)}, packageRootUrl: ${JSON.stringify(packageRoot === undefined ? null : directoryUrl(packageRoot))} };`;
+		const prelude = `${this.#prelude}${base}\n${contributionPrelude(this.#contributions.plan(contributions))}`;
+		return `${PREPARED_CELL_PREFIX}${JSON.stringify({ prelude, code: rewriteImports(code), ...(sourceFile === undefined ? {} : { sourceFile }) })}`;
 	}
 }

package/src/kernels/js/process-drain-scan.d.ts

@@ -0,0 +1,8 @@
+export type DrainPart = { readonly text: string } | { readonly key: string };
+
+export interface DrainScan {
+	readonly parts: DrainPart[];
+	readonly carry: string;
+}
+
+export function scanDrainText(carry: string, chunk: string, marker: string): DrainScan;

package/src/kernels/js/process-drain-scan.js

@@ -0,0 +1,28 @@
+/**
+ * Splits text read from the process kernel's fd 1 pipe into the output it carries and the result keys its drain
+ * markers name, in order. A read boundary can cut a marker, so a trailing prefix of one is handed back as `carry` for
+ * the next read rather than sent as output.
+ *
+ * Self-contained on purpose: its source also runs inside the pipe reader thread (process-entry.js `DRAINER`).
+ */
+export function scanDrainText(carry, chunk, marker) {
+	let text = carry + chunk;
+	const parts = [];
+	for (;;) {
+		const at = text.indexOf(marker);
+		if (at === -1) break;
+		const close = text.indexOf("\u0000", at + marker.length);
+		if (close === -1) break;
+		if (at > 0) parts.push({ text: text.slice(0, at) });
+		parts.push({ key: text.slice(at + marker.length, close) });
+		text = text.slice(close + 1);
+	}
+	let nextCarry = "";
+	const partial = text.lastIndexOf("\u0000");
+	if (partial !== -1 && marker.startsWith(text.slice(partial, partial + marker.length))) {
+		nextCarry = text.slice(partial);
+		text = text.slice(0, partial);
+	}
+	if (text.length > 0) parts.push({ text });
+	return { parts, carry: nextCarry };
+}