@deepstrike/wasm 0.2.50 → 0.2.52

package/dist/runtime/execution-plane.d.ts

@@ -2,7 +2,6 @@ import type { ToolCall, ToolSchema, StreamEvent, PermissionRequestEvent, Permiss
 import type { RegisteredTool } from "../tools/index.js";
 import type { DreamStore, MemoryScope } from "../memory/index.js";
 import type { KnowledgeSource } from "../knowledge/index.js";
-import { LargeResultSpool } from "./large-result-spool.js";
 export interface ToolSuspendEvent {
     type: "tool_suspend";
     callId: string;
@@ -18,7 +17,6 @@ export interface RunContext {
     knowledgeSource?: KnowledgeSource;
     onToolSuspend?: (event: ToolSuspendEvent) => Promise<unknown> | unknown;
     onPermissionRequest?: (event: PermissionRequestEvent) => Promise<PermissionResponse | boolean> | PermissionResponse | boolean;
-    resultSpool?: LargeResultSpool;
     /** M3/G4: working directory a tool should run in. WASM has no filesystem, so this is carried for
      *  tool-ABI parity with Node/Python rather than consumed by a worktree plane. */
     cwd?: string;
@@ -35,6 +33,5 @@ export declare class LocalExecutionPlane implements ExecutionPlane {
     unregister(name: string): this;
     schemas(): ToolSchema[];
     executeAll(calls: ToolCall[], ctx: RunContext): AsyncIterable<StreamEvent>;
-    private tryReadSpooledArgument;
 }
 export declare function resolvePermissionRequest(request: PermissionRequestEvent, ctx: RunContext): Promise<PermissionResponse>;

package/dist/runtime/execution-plane.js

@@ -1,4 +1,3 @@
-import { LargeResultSpool } from "./large-result-spool.js";
 import { formatToolError } from "../tools/errors.js";
 function stripFrontmatter(content) {
     const s = content.trimStart();
@@ -62,11 +61,6 @@ export class LocalExecutionPlane {
             yield { type: "tool_result", callId: c.id, name: c.name, content, isError: false };
         }
         for (const call of regularCalls) {
-            const spooledContent = await this.tryReadSpooledArgument(call, ctx);
-            if (spooledContent !== null) {
-                yield { type: "tool_result", callId: call.id, name: call.name, content: spooledContent, isError: false };
-                continue;
-            }
             const registered = this.tools.get(call.name);
             if (!registered) {
                 yield { type: "tool_result", callId: call.id, name: call.name, content: `unknown tool: ${call.name}`, isError: true, isFatal: false, errorKind: "recoverable" };
@@ -111,25 +105,6 @@ export class LocalExecutionPlane {
             }
         }
     }
-    async tryReadSpooledArgument(call, ctx) {
-        const isReadTool = ["read", "read_file", "view_file", "read_spooled_result"].includes(call.name);
-        if (!isReadTool)
-            return null;
-        try {
-            const args = JSON.parse(call.arguments || "{}");
-            for (const val of Object.values(args)) {
-                if (typeof val === "string" && (val.startsWith(".spool/") || val.includes("/.spool/"))) {
-                    const spool = ctx.resultSpool ?? new LargeResultSpool();
-                    const content = await spool.readSpooledResult(val);
-                    return content;
-                }
-            }
-        }
-        catch {
-            // Ignore errors
-        }
-        return null;
-    }
 }
 function tryParseJson(s) {
     try {

package/dist/runtime/facade.js

@@ -38,6 +38,9 @@ export async function runFanout(opts) {
     if (opts.synthesisRole)
         spec.nodes[spec.nodes.length - 1].role = opts.synthesisRole;
     const outcome = await runner.runWorkflow(spec, opts.sessionId ? { sessionId: opts.sessionId } : undefined);
+    if (outcome.rejection) {
+        throw new Error(`workflow ${outcome.rejection.operation} rejected: ${outcome.rejection.reason}`);
+    }
     const synthesisId = `wf-node${opts.tasks.length}`;
     const completed = outcome.nodeOutcomes.filter(node => node.status === "completed" || node.status === "completed_partial");
     const lastCompleted = completed[completed.length - 1]?.nodeId;

package/dist/runtime/index.d.ts

@@ -1,16 +1,16 @@
-export type { KernelTransactionEntry, SessionEvent, SessionLog } from "./session-log.js";
+export type { SessionEvent, SessionLog } from "./session-log.js";
 export { InMemorySessionLog } from "./session-log.js";
-export * from "./kernel-transaction-log.js";
-export { rebuildKernelRuntime } from "./kernel-rebuild.js";
-export type { KernelRebuildResult } from "./kernel-rebuild.js";
+export { DriverKernelJournal, InMemoryJournalDriver, InMemoryKernelJournal, JournalCasConflictError, JournalIntegrityError, JournalIoError, } from "./kernel-journal.js";
+export type { CheckpointCandidate, InstalledCheckpoint, JournalAppendReceipt, JournalEntry, JournalHead, JournalPruneReceipt, JournalRecordInput, JournalStorageDriver, KernelJournal, } from "./kernel-journal.js";
 export * from "./context-policy.js";
 export type { RunContext, ExecutionPlane } from "./execution-plane.js";
 export { LocalExecutionPlane } from "./execution-plane.js";
 export type { MemoryPolicy, MemoryWriteRateLimit, OperationCancellationReason, PromptBudget, ResourceQuota, RuntimeOptions, SchedulerPolicy } from "./runner.js";
 export { RuntimeRunner, collectText } from "./runner.js";
-export { readKernelDiagnostics, restoreKernelRuntime, snapshotKernelRuntime } from "./kernel-step.js";
-export type { KernelDiagnostics } from "./kernel-step.js";
-export type { KernelSnapshot } from "./kernel-step.js";
+export { MemoryPayloadDriver, PayloadStore } from "./payload-store.js";
+export type { PayloadStorageDriver, PayloadStoreConfig } from "./payload-store.js";
+export { CanonicalKernelHost, CanonicalKernelRejectedError, CanonicalKernelRebuildRequiredError, CanonicalRunnerRuntime, canonicalActionFromPlannedStep, sha256, } from "./canonical-kernel-step.js";
+export type { CanonicalKernelInput, CanonicalPlannedStep, CanonicalRunnerRuntimeOptions, CanonicalTransition, CanonicalTransitionOptions, } from "./canonical-kernel-step.js";
 export { runAgent, runFanout } from "./facade.js";
 export type { RunAgentOptions, RunFanoutOptions } from "./facade.js";
 export { builtinReducers, resolveReducer } from "./reducers.js";

package/dist/runtime/index.js

@@ -1,10 +1,11 @@
 export { InMemorySessionLog } from "./session-log.js";
-export * from "./kernel-transaction-log.js";
-export { rebuildKernelRuntime } from "./kernel-rebuild.js";
+// Durable transaction capability (Canonical Kernel ABI §9.1)
+export { DriverKernelJournal, InMemoryJournalDriver, InMemoryKernelJournal, JournalCasConflictError, JournalIntegrityError, JournalIoError, } from "./kernel-journal.js";
 export * from "./context-policy.js";
 export { LocalExecutionPlane } from "./execution-plane.js";
 export { RuntimeRunner, collectText } from "./runner.js";
-export { readKernelDiagnostics, restoreKernelRuntime, snapshotKernelRuntime } from "./kernel-step.js";
+export { MemoryPayloadDriver, PayloadStore } from "./payload-store.js";
+export { CanonicalKernelHost, CanonicalKernelRejectedError, CanonicalKernelRebuildRequiredError, CanonicalRunnerRuntime, canonicalActionFromPlannedStep, sha256, } from "./canonical-kernel-step.js";
 export { runAgent, runFanout } from "./facade.js";
 export { builtinReducers, resolveReducer } from "./reducers.js";
 export { getKernel } from "./kernel.js";

package/dist/runtime/kernel-event-log.d.ts

@@ -12,7 +12,6 @@ export declare function kernelObservationToSessionEvent(obs: KernelObservation,
     archiveRef?: string;
     preservedRefs?: string[];
     compressionAction?: (action?: string) => CompressionAction;
-    spoolRef?: string;
 }): SessionEvent | null;
 export type KernelPrimitive = "syscall" | "sched" | "mm";
 export declare function primitiveForCategory(category: KernelEventCategory): KernelPrimitive;

package/dist/runtime/kernel-event-log.js

@@ -9,7 +9,6 @@ export function categoryForKind(kind) {
         case "page_in_requested":
         case "renewed":
         case "context_renewed":
-        case "large_result_spooled":
         case "memory_written":
         case "memory_queried":
         case "memory_validation_failed":
@@ -111,7 +110,7 @@ export function kernelObservationToSessionEvent(obs, turn, opts = {}) {
                 kind: "agent_process_changed",
                 turn: t,
                 agent_id: obs.agent_id ?? "",
-                parent_session_id: obs.parent_session_id ?? "",
+                parent_task_id: obs.parent_task_id ?? "",
                 role: obs.role ?? "",
                 isolation: obs.isolation ?? "",
                 context_inheritance: obs.context_inheritance ?? "",
@@ -182,16 +181,6 @@ export function kernelObservationToSessionEvent(obs, turn, opts = {}) {
             };
         case "page_in_requested":
             return null;
-        case "large_result_spooled":
-            return {
-                kind: "large_result_spooled",
-                turn: t,
-                call_id: obs.call_id ?? "",
-                tool: obs.tool ?? "",
-                original_size: obs.original_size ?? 0,
-                preview_size: obs.preview_size ?? 0,
-                spool_ref: obs.spool_ref,
-            };
         case "page_out_archived":
             return {
                 kind: "page_out",
@@ -247,7 +236,12 @@ export function kernelObservationToSessionEvent(obs, turn, opts = {}) {
             };
         }
         default:
-            return null;
+            return {
+                kind: "kernel_observation",
+                turn: t,
+                observation_kind: obs.kind,
+                raw: { ...obs },
+            };
     }
 }
 export function primitiveForCategory(category) {

package/dist/runtime/kernel-journal.d.ts

@@ -0,0 +1,332 @@
+/**
+ * `KernelJournal` — the durable transaction capability of the Canonical Kernel ABI (spec §9.1).
+ *
+ * The interface here is field-for-field the Node SDK's `node/src/runtime/kernel-journal.ts`, which is
+ * the authoritative shape for all four SDKs. Three rules give this file its shape:
+ *
+ * 1. **Records are opaque.** core owns canonical serialization and hashing
+ *    (`KernelRecord::record_bytes()` / `record_digest()` / `expected_head()`). The host stores the
+ *    bytes verbatim and indexes them by the digest core handed it. A journal that re-serializes a
+ *    record to recompute its hash would make "the host recomputed and disagreed" a reachable state;
+ *    it is not one here.
+ * 2. **CAS is a storage-layer primitive, not a read-compare-write sequence.** §9.1 requires a real
+ *    atomic operation (file lock / atomic-publish chained naming / conditional database update).
+ *    `InMemoryKernelJournal` is atomic only within one process and says so in its own type;
+ *    `DriverKernelJournal` is as atomic as the {@link JournalStorageDriver} the host injects.
+ * 3. **The journal's sequence space is `step_seq`** — the operation's record-chain position — and is
+ *    completely independent of `SessionLog`'s business event `seq`. Pruning a journal prefix can
+ *    never punch a hole in business event numbering (spec Task 8b, criterion 4).
+ *
+ * Failures are typed so a caller can tell "retry after rebuild" from "this storage is broken" from
+ * "someone handed me a corrupt chain" — a durable-step wrapper must never publish effects on any of
+ * them, and must never collapse them into one opaque `Error`.
+ *
+ * **Why this SDK has no file backend.** The WASM SDK targets browsers, Cloudflare Workers and Deno
+ * Deploy; it imports no host filesystem anywhere, so Node's `FileKernelJournal` (POSIX `link(2)` as
+ * the atomicity primitive) has nothing to stand on. The durable backend is therefore *injected*:
+ * the host supplies a {@link JournalStorageDriver} over whatever conditional-write primitive its
+ * platform actually has (R2/S3 `If-None-Match`, Durable Object storage, KV compare-and-set, OPFS),
+ * and {@link DriverKernelJournal} supplies the chain, checkpoint and prune protocol on top of it.
+ */
+/** Chain positions at or above this bound are rejected (parity with Node/Python/Rust). */
+export declare const MAX_CHAIN_POSITION = 1000000000000;
+/**
+ * The CAS precondition did not hold: the journal head (or checkpoint pointer) moved.
+ *
+ * Retryable — the protocol response is `abort(token)` → re-read head → rebuild → replay the input
+ * (spec §8.3, row "CAS conflict").
+ */
+export declare class JournalCasConflictError extends Error {
+    constructor(message: string);
+}
+/**
+ * The journal contents contradict themselves or the caller's claim: a broken digest chain, a
+ * `step_seq` that does not follow its predecessor, a checkpoint whose `covered_head` does not match
+ * the record at its `through_step_seq`. Never retryable — retrying replays the same contradiction.
+ */
+export declare class JournalIntegrityError extends Error {
+    constructor(message: string);
+}
+/**
+ * The storage layer failed (quota exceeded, network error, driver rejected the write). Distinct from
+ * both of the above: the journal state is *unknown*, not known-conflicting and not known-corrupt.
+ */
+export declare class JournalIoError extends Error {
+    constructor(message: string, options?: {
+        cause?: unknown;
+    });
+}
+/** What a host hands the journal: core's opaque bytes plus the identity core assigned them. */
+export interface JournalRecordInput {
+    /** Chain position. Genesis (`ConfigureOperation`) is 0; every later record is `head + 1`. */
+    step_seq: number;
+    /** core's `record_digest`. The journal indexes by it and never recomputes it. */
+    record_digest: string;
+    /** core's `record_bytes`, stored verbatim. */
+    record_bytes: Uint8Array;
+}
+/** A stored record. `previous_record_digest` is the CAS precondition it was appended under. */
+export interface JournalEntry extends JournalRecordInput {
+    /** Absent on the genesis record only (spec §8.1: the first append's expected head is empty). */
+    previous_record_digest?: string;
+}
+/** The journal head: the last record of an operation's chain. */
+export interface JournalHead {
+    step_seq: number;
+    record_digest: string;
+}
+export interface JournalAppendReceipt {
+    step_seq: number;
+    record_digest: string;
+}
+/** The host-persistable part of `kernel.checkpoint_candidate()` (spec §12.3). */
+export interface CheckpointCandidate {
+    /** Stable identity of this checkpoint; the CAS token a later install names as its predecessor. */
+    checkpoint_id: string;
+    /** The chain position this checkpoint's logical state covers. */
+    through_step_seq: number;
+    /** core's digest of the logical state. Opaque to the journal. */
+    state_digest: string;
+    /** The serialized checkpoint blob, stored verbatim. */
+    checkpoint_bytes: Uint8Array;
+}
+export interface InstalledCheckpoint extends CheckpointCandidate {
+    /** Monotonic install ordinal. `previous_checkpoint_id === undefined` installs ordinal 0. */
+    ordinal: number;
+    /** The record digest at `through_step_seq` — verified at install, not required to still be head. */
+    covered_head: string;
+    previous_checkpoint_id?: string;
+    /**
+     * Whether `ackCheckpoint` has run. Prefix reclamation is gated on this: a checkpoint that is
+     * installed but not acknowledged is recoverable-from but not prune-authorising (spec §12.3 rule 5/6).
+     */
+    acknowledged: boolean;
+}
+export interface JournalPruneReceipt {
+    /** Highest `step_seq` no longer retained. `-1` when nothing has ever been pruned. */
+    pruned_through_step_seq: number;
+    pruned_count: number;
+}
+/**
+ * The durable transaction capability (spec §9.1). Deliberately *not* part of `SessionLog`: a custom
+ * business-projection log must never be forced to masquerade as a transactional journal (§9.4).
+ * One class may implement both — `InMemorySessionLog` holds one rather than inheriting it — but the
+ * interfaces stay separate.
+ *
+ * Guarantees an implementation owes (spec §9.1):
+ * - strict ordering within an operation;
+ * - a failed CAS never overwrites;
+ * - record bytes preserved verbatim;
+ * - checkpoint pointer advances monotonically;
+ * - the checkpoint store verifies `covered_head` against `through_step_seq` but does **not** require
+ *   it to still be the current transaction head (§22.14);
+ * - checkpoint pointer and prefix pruning have an explicit acknowledgement boundary.
+ */
+export interface KernelJournal {
+    /**
+     * Atomically append `record` iff the operation's head is exactly `expectedHead`.
+     *
+     * @param expectedHead `undefined` starts the chain (genesis; `record.step_seq` must be 0).
+     * @throws {JournalCasConflictError} head moved, or a genesis already exists.
+     * @throws {JournalIntegrityError} `step_seq` does not follow the head.
+     * @throws {JournalIoError} storage failure.
+     */
+    compareAndAppend(operationId: string, expectedHead: string | undefined, record: JournalRecordInput): Promise<JournalAppendReceipt>;
+    /** The current head, or `undefined` when the operation has no records and no pruned anchor. */
+    head(operationId: string): Promise<JournalHead | undefined>;
+    /** Records with `step_seq >= fromStepSeq` (default: the whole retained chain), in chain order. */
+    readFrom(operationId: string, fromStepSeq?: number): Promise<JournalEntry[]>;
+    /**
+     * Records strictly after the record whose digest is `afterHead` — the digest-anchored cursor
+     * §9.1 names `records_after(operation_id, checkpoint_head)`. `undefined` returns everything retained.
+     *
+     * @throws {JournalIntegrityError} `afterHead` names no retained record and no pruned anchor.
+     */
+    recordsAfter(operationId: string, afterHead?: string): Promise<JournalEntry[]>;
+    /**
+     * Atomically install `checkpoint` iff the operation's checkpoint pointer is exactly
+     * `previousCheckpointId`, and `coveredHead` is the record digest at `checkpoint.through_step_seq`.
+     *
+     * Per §22.14 this deliberately does **not** require `coveredHead` to still be the current
+     * transaction head: transactions appended after the candidate was taken stay as tail.
+     *
+     * @param previousCheckpointId `undefined` installs the operation's first checkpoint.
+     * @throws {JournalCasConflictError} the checkpoint pointer moved.
+     * @throws {JournalIntegrityError} `coveredHead`/`through_step_seq` disagree with the chain, or
+     *   `through_step_seq` would move the pointer backwards.
+     */
+    compareAndInstallCheckpoint(operationId: string, previousCheckpointId: string | undefined, coveredHead: string, checkpoint: CheckpointCandidate): Promise<InstalledCheckpoint>;
+    /** The highest-ordinal installed checkpoint, acknowledged or not. */
+    latestCheckpoint(operationId: string): Promise<InstalledCheckpoint | undefined>;
+    /**
+     * Record the durable acknowledgement that opens the prefix-reclamation boundary. Idempotent.
+     *
+     * @throws {JournalIntegrityError} no checkpoint with that id is installed.
+     */
+    ackCheckpoint(operationId: string, checkpointId: string): Promise<InstalledCheckpoint>;
+    /**
+     * Reclaim the record prefix covered by the latest **acknowledged** checkpoint. A no-op while no
+     * checkpoint is acknowledged. The pruned boundary is retained as an anchor so `head()` and the
+     * next CAS still resolve on a fully-pruned chain.
+     */
+    pruneAckedPrefix(operationId: string): Promise<JournalPruneReceipt>;
+    /**
+     * Durably stage one outbound WireEnvelope JSON for `operationId` until the matching record is
+     * append-acked (or the attempt is abandoned). Overwrites any previous pending envelope.
+     *
+     * Required by Phase 6 host cutover (adjudication 5e.3): retries must replay byte-identical
+     * envelopes — reminting `observed_at_ms` after a crash produces `DuplicateInputConflict`.
+     */
+    stageOutboundEnvelope(operationId: string, envelopeJson: string): Promise<void>;
+    /** Read the staged outbound envelope, if any. */
+    readOutboundEnvelope(operationId: string): Promise<string | undefined>;
+    /** Clear the staged outbound envelope. Idempotent. */
+    clearOutboundEnvelope(operationId: string): Promise<void>;
+}
+/**
+ * **Single-process dev/test implementation.**
+ *
+ * CAS is genuinely atomic here — every check-then-mutate below runs to completion without an
+ * intervening `await`, so no other task can interleave on a single-threaded runtime — but that
+ * atomicity ends at the process boundary. Two workers/isolates sharing "the same" journal do not
+ * exist: each has its own `Map`. Production hosts must supply a `KernelJournal` whose CAS is a real
+ * storage-layer primitive (spec §9.1); {@link DriverKernelJournal} over a durable
+ * {@link JournalStorageDriver} is the reference for that.
+ */
+export declare class InMemoryKernelJournal implements KernelJournal {
+    private readonly operations;
+    private state;
+    private headOf;
+    compareAndAppend(operationId: string, expectedHead: string | undefined, record: JournalRecordInput): Promise<JournalAppendReceipt>;
+    head(operationId: string): Promise<JournalHead | undefined>;
+    readFrom(operationId: string, fromStepSeq?: number): Promise<JournalEntry[]>;
+    recordsAfter(operationId: string, afterHead?: string): Promise<JournalEntry[]>;
+    compareAndInstallCheckpoint(operationId: string, previousCheckpointId: string | undefined, coveredHead: string, checkpoint: CheckpointCandidate): Promise<InstalledCheckpoint>;
+    latestCheckpoint(operationId: string): Promise<InstalledCheckpoint | undefined>;
+    ackCheckpoint(operationId: string, checkpointId: string): Promise<InstalledCheckpoint>;
+    pruneAckedPrefix(operationId: string): Promise<JournalPruneReceipt>;
+    stageOutboundEnvelope(operationId: string, envelopeJson: string): Promise<void>;
+    readOutboundEnvelope(operationId: string): Promise<string | undefined>;
+    clearOutboundEnvelope(operationId: string): Promise<void>;
+}
+/**
+ * The storage primitive {@link DriverKernelJournal} needs from its host. This is the WASM SDK's
+ * substitute for Node's POSIX `link(2)`: this package runs where there is no filesystem, so the one
+ * operation that cannot be emulated in userspace — the atomic claim — is injected.
+ *
+ * **Driver contract.** Everything below is load-bearing; a driver that violates any of it turns
+ * §15.2 ("a CAS conflict never overwrites the journal") and §25.12 into unenforceable claims.
+ *
+ * 1. **`createIfAbsent` is THE atomic decision.** It must claim `key` and publish `bytes` in one
+ *    indivisible storage-layer operation — R2/S3 `If-None-Match: *`, a Durable Object transaction,
+ *    a KV compare-and-set, `INSERT ... ON CONFLICT DO NOTHING`, OPFS create-exclusive-then-rename.
+ *    A read-then-write pair in the driver only moves the race; it does not decide it. The journal
+ *    performs a *pre-check* before calling this, but that pre-check can only reject an append the
+ *    driver would have accepted — never accept one the driver would have rejected.
+ * 2. **Keys are the collision domain, and may contain only CAS-precondition-derived identity**
+ *    (spec Task 8b implementation correction (a)). {@link DriverKernelJournal} names records by
+ *    zero-padded `step_seq` and checkpoints by zero-padded ordinal, both of which two racing
+ *    writers *agree on* because both are derived from the predecessor they raced against. A driver
+ *    must never rewrite, salt, or namespace keys per-writer: if racers end up at different keys,
+ *    both writes succeed and the chain forks.
+ * 3. **Publication is all-or-nothing** (correction (b)). A partially written value must never
+ *    become readable at `key`; stage first, publish second. A crash mid-write may leave residue
+ *    under other keys, but never a half-value at a claimed key.
+ * 4. **`put` overwrites; use it only where the value is monotone.** The journal uses it solely for
+ *    the pruned anchor `{through_step_seq, covered_head}`, which only ever moves forward, so a
+ *    lost update is a stale-but-valid anchor rather than a corruption.
+ * 5. **`read` returns bytes verbatim**, and `undefined` (not a throw) for an absent key.
+ * 6. **`list(prefix)` returns every key beginning with `prefix`**, in any order. The journal
+ *    ignores keys that do not match its own naming rule, so unrelated residue is harmless.
+ * 7. **Failures throw.** Any thrown error is wrapped as {@link JournalIoError}: the journal state
+ *    is unknown, which is neither a conflict nor a corruption.
+ */
+export interface JournalStorageDriver {
+    /**
+     * Atomically publish `bytes` at `key` iff `key` is absent.
+     *
+     * @returns `false` when the key was already taken — i.e. a lost CAS race. An existing value must
+     *   be left byte-identical.
+     */
+    createIfAbsent(key: string, bytes: Uint8Array): Promise<boolean>;
+    /** The bytes at `key`, or `undefined` when absent. */
+    read(key: string): Promise<Uint8Array | undefined>;
+    /** Every key beginning with `prefix`, in any order. */
+    list(prefix: string): Promise<string[]>;
+    /** Atomically create-or-replace `key`. Only used for the monotone pruned anchor. */
+    put(key: string, bytes: Uint8Array): Promise<void>;
+    /** Remove `key`. Removing an absent key is not an error. */
+    remove(key: string): Promise<void>;
+}
+/**
+ * **Single-process reference driver.** Backed by one `Map`, so `createIfAbsent` is atomic in the
+ * only sense a single isolate can offer: the check and the insert run with no `await` between them,
+ * so no other task interleaves. It is a complete, spec-conformant driver *within one isolate* — use
+ * it for dev, tests, and ephemeral Workers; use a durable driver anywhere state must outlive the
+ * isolate or be shared with another one.
+ */
+export declare class InMemoryJournalDriver implements JournalStorageDriver {
+    private readonly entries;
+    createIfAbsent(key: string, bytes: Uint8Array): Promise<boolean>;
+    read(key: string): Promise<Uint8Array | undefined>;
+    list(prefix: string): Promise<string[]>;
+    put(key: string, bytes: Uint8Array): Promise<void>;
+    remove(key: string): Promise<void>;
+}
+/**
+ * **Durable reference implementation** of `KernelJournal` over a host-injected
+ * {@link JournalStorageDriver} (spec Task 8b) — the WASM SDK's counterpart to Node's
+ * `FileKernelJournal`.
+ *
+ * The atomicity primitive is `driver.createIfAbsent`. Content is published complete, under a name
+ * derived *only* from the CAS precondition, so a crash can never leave a half-written record and
+ * two racing writers can never land on different names.
+ *
+ * **Why a record's key is `<step_seq>.rec` and contains no digest.** The key *is* the collision
+ * domain. Two writers racing on the same head both compute the same next `step_seq`, so they
+ * contend for one key and exactly one wins. Folding a per-writer value (the new record's digest)
+ * into the key would give the racers *different* keys — both claims would succeed and the chain
+ * would fork. Only the predecessor-determined part of the identity may appear in the key.
+ *
+ * The pre-claim head check is not a TOCTOU hole: it can only *reject* an append the driver would
+ * have accepted (a stale `expectedHead` whose `step_seq` slot happens to be free), never accept one
+ * the driver would have rejected. Every acceptance is still decided by the atomic claim.
+ *
+ * Checkpoint installs use the same primitive on a separate ordinal space (`<ordinal>.ckpt`), so two
+ * writers installing on the same predecessor also contend for one key.
+ */
+export declare class DriverKernelJournal implements KernelJournal {
+    private readonly driver;
+    private readonly prefix;
+    constructor(driver: JournalStorageDriver, prefix?: string);
+    private operationPrefix;
+    private recordsPrefix;
+    private checkpointsPrefix;
+    private prunedKey;
+    private outboundKey;
+    /** Every driver call funnels through these three so a driver fault is always a `JournalIoError`. */
+    private claim;
+    private load;
+    private names;
+    /** Sorted `step_seq` values of the retained records. Anything not matching the rule is residue. */
+    private recordSeqs;
+    private readRecord;
+    private prunedAnchor;
+    head(operationId: string): Promise<JournalHead | undefined>;
+    compareAndAppend(operationId: string, expectedHead: string | undefined, record: JournalRecordInput): Promise<JournalAppendReceipt>;
+    readFrom(operationId: string, fromStepSeq?: number): Promise<JournalEntry[]>;
+    recordsAfter(operationId: string, afterHead?: string): Promise<JournalEntry[]>;
+    /** Sorted ordinals of installed checkpoints. */
+    private checkpointOrdinals;
+    private ackedOrdinals;
+    private readCheckpoint;
+    latestCheckpoint(operationId: string): Promise<InstalledCheckpoint | undefined>;
+    compareAndInstallCheckpoint(operationId: string, previousCheckpointId: string | undefined, coveredHead: string, checkpoint: CheckpointCandidate): Promise<InstalledCheckpoint>;
+    ackCheckpoint(operationId: string, checkpointId: string): Promise<InstalledCheckpoint>;
+    pruneAckedPrefix(operationId: string): Promise<JournalPruneReceipt>;
+    /** The anchor only ever moves forward, so an overwriting `put` is the right primitive. */
+    private writeAnchor;
+    stageOutboundEnvelope(operationId: string, envelopeJson: string): Promise<void>;
+    readOutboundEnvelope(operationId: string): Promise<string | undefined>;
+    clearOutboundEnvelope(operationId: string): Promise<void>;
+}