@cortexkit/opencode-magic-context 0.49.8 → 0.49.9

package/dist/v2/{wrapup-orchestrator-5wxy1ggv.js → wrapup-orchestrator-wg8dmmm9.js}

@@ -19,7 +19,7 @@ import {
   registerActiveCompartmentRun,
   setRecompStarting2,
   setRecompTerminal2
-} from "./server-q360kdb8.js";
+} from "./server-c9w52qss.js";
 import"./server-s6jqh8bj.js";
 import"./server-988cqjme.js";
 import {
@@ -27,7 +27,7 @@ import {
 } from "./server-wafzvyhg.js";
 import"./server-63ha7f0f.js";
 import"./server-9a6bwc12.js";
-import"./server-j3dm74ey.js";
+import"./server-z0rjemg1.js";
 import {
   getWrapupInProgressState,
   acquireWrapupInProgress,
@@ -36,23 +36,23 @@ import {
   getHistorianFailureState,
   clearEmergencyRecovery,
   prepareRawSessionOrdinals2
-} from "./server-xj4mewze.js";
-import"./server-shme41gj.js";
-import"./server-08k4zkfk.js";
+} from "./server-gc8x2xdb.js";
+import"./server-89fcbe37.js";
+import"./server-23znwjqk.js";
 import"./server-1zx87sdm.js";
-import"./server-jjsf29aq.js";
+import"./server-kmapq3v0.js";
 import"./server-7e087rvk.js";
 import"./server-51779zs2.js";
 import"./server-bx59ezg6.js";
 import"./server-2ra6pwf3.js";
 import"./server-zrwaj29a.js";
-import"./server-adfte03x.js";
+import"./server-xqf2d2mg.js";
 import"./server-fr0wbhdn.js";
-import"./server-4gz0xkrc.js";
+import"./server-f27he3j1.js";
 import"./server-njnx39q2.js";
 import"./server-4easnf78.js";
 import"./server-fb3zxn06.js";
-import"./server-yak3sxya.js";
+import"./server-4zwx20yg.js";
 import {
   pushNotification2
 } from "./server-x8a7jmkh.js";

package/dist/{wrapup-orchestrator-gv08c6f9.js → wrapup-orchestrator-b1z99yg5.js}

@@ -1,11 +1,11 @@
 import {
   runManagedWrapup2
-} from "./index-pjgzdezw.js";
-import"./index-xf6k8szp.js";
-import"./index-hxrvx6cy.js";
+} from "./index-nenz4gpb.js";
+import"./index-21919gcq.js";
+import"./index-3403gbzj.js";
 import"./index-s178h9z8.js";
-import"./index-ydjgz36f.js";
-import"./index-b4gcb3rk.js";
+import"./index-16vwdyy5.js";
+import"./index-0x9cn9w1.js";
 import"./index-sd3egckz.js";
 import"./index-a43xq1pg.js";
 import"./index-n78avt2p.js";
@@ -19,22 +19,22 @@ import"./index-x8a7jmkh.js";
 import"./index-a4b0gbyg.js";
 import"./index-bmwfzz28.js";
 import"./index-kvw6xew3.js";
-import"./index-zf9nydbd.js";
-import"./index-qgp5vnt4.js";
+import"./index-swgpe402.js";
+import"./index-a865mj02.js";
 import"./index-fb3zxn06.js";
 import"./index-fr0wbhdn.js";
 import"./index-0jz47061.js";
 import"./index-mp2kghkv.js";
 import"./index-q28hsbpg.js";
-import"./index-9g1c4bt9.js";
-import"./index-xpn05jxq.js";
+import"./index-wpwpn7nj.js";
+import"./index-f8cn4xqa.js";
 import"./index-1zx87sdm.js";
 import"./index-q76br5zn.js";
 import"./index-angx1s0k.js";
 import"./index-v0p37hm2.js";
 import"./index-w28y7d0z.js";
-import"./index-8kk7yh6m.js";
-import"./index-bd9cjab3.js";
+import"./index-9jvab89d.js";
+import"./index-g7jkrz0x.js";
 import"./index-58e3y90n.js";
 import"./index-150zz6fh.js";
 import"./index-gjvjh960.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cortexkit/opencode-magic-context",
-  "version": "0.49.8",
+  "version": "0.49.9",
   "type": "module",
   "description": "OpenCode plugin for Magic Context — cross-session memory and context management",
   "main": "dist/index.js",

package/src/agents/hidden-agent-registrations.ts

@@ -1,3 +1,4 @@
+import { isToolFreeHiddenAgent, ZEN_READ_AGENT_SUFFIX } from "../shared/hidden-zen-read";
 import { buildAllowOnlyPermission } from "./permissions";
 
 /**
@@ -77,8 +78,8 @@ export interface HiddenAgentRegistration {
  * Hoisted function declaration: returns the hidden-agent registrations with
  * INLINE id / allow-list / step-cap literals (see {@link HiddenAgentRegistration}
  * for why these must not come from module-level `var` consts). Prompts and
- * computed overrides are passed in by the caller. Historians transform only
- * the text supplied in their prompt and never receive tools.
+ * computed overrides are passed in by the caller. The separate Zen carriers
+ * advertise read for provider compatibility; execution is refused by session.
  */
 export function buildHiddenAgentRegistrations(args: {
     dreamerPrompt: string | undefined;
@@ -88,7 +89,7 @@ export function buildHiddenAgentRegistrations(args: {
     historianEditorPrompt: string | undefined;
     dreamerOverrides?: Record<string, unknown>;
     historianOverrides?: Record<string, unknown>;
-    /** Legacy config input retained for compatibility; historians always have zero tools. */
+    /** Legacy config input retained for compatibility; it cannot grant historian tools. */
     historianDisallowed: readonly string[];
 }): HiddenAgentRegistration[] {
     return [
@@ -278,6 +279,19 @@ export function buildHiddenAgentRegistrations(args: {
     ];
 }
 
+/** Alternate carriers preserve the original registrations for all other providers. */
+export function buildZenReadAgentRegistrations(
+    registrations: HiddenAgentRegistration[],
+): HiddenAgentRegistration[] {
+    return registrations
+        .filter((registration) => isToolFreeHiddenAgent(registration.id))
+        .map((registration) => ({
+            ...registration,
+            id: `${registration.id}${ZEN_READ_AGENT_SUFFIX}`,
+            allowedTools: ["read"],
+        }));
+}
+
 /**
  * Build a hidden-agent config with a deny-everything-by-default permission
  * baseline and a hard tool-iteration ceiling. User overrides may lower
@@ -333,7 +347,11 @@ export function buildHiddenAgentConfig(
     // The plugin appends named Task routing denies after the general wildcard.
     // Seed an explicit Task deny so that routing also re-emits a final wildcard
     // deny for Task itself; otherwise OpenCode exposes a callable-but-refused tool.
-    if (lockPermissions && agentLabel?.startsWith("historian") && allowedTools.length === 0) {
+    if (
+        lockPermissions &&
+        ((agentLabel?.startsWith("historian") && allowedTools.length === 0) ||
+            agentLabel?.endsWith(ZEN_READ_AGENT_SUFFIX))
+    ) {
         basePermission.task = "deny";
     }
     return {

package/src/shared/hidden-zen-read.test.ts

@@ -0,0 +1,99 @@
+import { expect, test } from "bun:test";
+import {
+    needsBlockedRead,
+    rememberV1HiddenRun,
+    shapeV1HiddenMessage,
+    withBlockedReadInstruction,
+} from "./hidden-zen-read";
+
+for (const [agent, task, sentence] of [
+    [
+        "historian",
+        "initial",
+        "Summarize only the supplied conversation and memory context. Do not call tools.",
+    ],
+    [
+        "historian-recomp",
+        "repair",
+        "Summarize only the supplied conversation and memory context. Do not call tools.",
+    ],
+    [
+        "historian-editor",
+        "fallback",
+        "Summarize only the supplied conversation and memory context. Do not call tools.",
+    ],
+    [
+        "dreamer-classifier",
+        "classify-memories",
+        "Classify only the supplied memory context. Do not call tools.",
+    ],
+    [
+        "dreamer-classifier",
+        "compress-cues",
+        "Compress only the supplied memory cues. Do not call tools.",
+    ],
+    [
+        "smart-note-compiler",
+        "compile",
+        "Compile only the supplied conditions and memory context. Do not call tools.",
+    ],
+    [
+        "dreamer-reviewer",
+        "review-user-memories",
+        "Review only the supplied observations and memory context. Do not call tools.",
+    ],
+]) {
+    test(`Zen compatibility is provider-scoped and prompt-guided for ${agent}/${task}`, () => {
+        expect(needsBlockedRead(agent!, "opencode")).toBe(true);
+        for (const provider of ["anthropic", "openai", "opencode-zen", undefined])
+            expect(needsBlockedRead(agent!, provider)).toBe(false);
+        expect(
+            withBlockedReadInstruction("original prompt\n", { agent: agent!, metadata: { task } }),
+        ).toBe(`original prompt\n\n\n${sentence}`);
+        expect(withBlockedReadInstruction(sentence!, { agent: agent!, metadata: { task } })).toBe(
+            sentence!,
+        );
+    });
+}
+
+test("genuine-tool agents and user agents never receive the compatibility read", () => {
+    for (const agent of [
+        "dreamer",
+        "dreamer-docs",
+        "dreamer-memory-mapper",
+        "dreamer-primer-investigator",
+        "dreamer-retrospective",
+        "build",
+        "custom",
+    ])
+        expect(needsBlockedRead(agent, "opencode")).toBe(false);
+});
+
+test("v1 uses the host-resolved default model only on a registered hidden session", () => {
+    const message = { agent: "historian", model: { providerID: "opencode" }, system: "original" };
+    shapeV1HiddenMessage("user", message);
+    expect(message).toEqual({
+        agent: "historian",
+        model: { providerID: "opencode" },
+        system: "original",
+    });
+    rememberV1HiddenRun("child", {
+        agent: "historian",
+        kind: "historian",
+        system: "original",
+        title: "test",
+        directory: "/project",
+        timeoutMs: 1000,
+    });
+    try {
+        shapeV1HiddenMessage("child", message);
+        expect(message.agent).toBe("historian-zen-blocked-read");
+        expect(message.system).toBe(
+            "original\n\nSummarize only the supplied conversation and memory context. Do not call tools.",
+        );
+        shapeV1HiddenMessage("child", message);
+        expect(message.system.match(/Do not call tools\./g)).toHaveLength(1);
+    } finally {
+        rememberV1HiddenRun("child", undefined);
+    }
+});

package/src/shared/hidden-zen-read.ts

@@ -0,0 +1,88 @@
+import type { HiddenRunIdentity } from "../hooks/magic-context/compartment-runner-types";
+
+/** These agents transform supplied text; agents that inspect code or memories keep their existing tools. */
+export function isToolFreeHiddenAgent(agent: string): boolean {
+    return [
+        "historian",
+        "historian-recomp",
+        "historian-editor",
+        "dreamer-classifier",
+        "dreamer-reviewer",
+        "smart-note-compiler",
+    ].includes(agent);
+}
+
+export const TOOL_USE_DISABLED = "tool use is disabled for this task";
+export const ZEN_READ_AGENT_SUFFIX = "-zen-blocked-read";
+
+export function needsBlockedRead(agent: string, providerID: string | undefined): boolean {
+    return providerID === "opencode" && isToolFreeHiddenAgent(agent);
+}
+
+export function blockedReadInstruction(run: Pick<HiddenRunIdentity, "agent" | "metadata">): string {
+    if (run.agent.startsWith("historian"))
+        return "Summarize only the supplied conversation and memory context. Do not call tools.";
+    if (run.metadata?.task === "compress-cues")
+        return "Compress only the supplied memory cues. Do not call tools.";
+    if (run.agent === "smart-note-compiler")
+        return "Compile only the supplied conditions and memory context. Do not call tools.";
+    if (run.agent === "dreamer-reviewer")
+        return "Review only the supplied observations and memory context. Do not call tools.";
+    return "Classify only the supplied memory context. Do not call tools.";
+}
+
+export function withBlockedReadInstruction(
+    system: string,
+    run: Parameters<typeof blockedReadInstruction>[0],
+): string {
+    const instruction = blockedReadInstruction(run);
+    return system.endsWith(instruction) ? system : `${system}${system ? "\n\n" : ""}${instruction}`;
+}
+
+// Only sessions opened by Magic Context's hidden executor can have tool calls
+// blocked in OpenCode 1. Agent names and user permissions never select user sessions.
+const blockedSessions = new Set<string>();
+const v1Runs = new Map<string, HiddenRunIdentity>();
+
+export function rememberV1HiddenRun(sessionID: string, run: HiddenRunIdentity | undefined): void {
+    if (run) v1Runs.set(sessionID, run);
+    else {
+        v1Runs.delete(sessionID);
+        setBlockedReadSession(sessionID, false);
+    }
+}
+
+/**
+ * OpenCode 1 calls chat.message after selecting the request's actual model.
+ * Select the read-bearing carrier there so agent defaults and fallback models
+ * cannot accidentally apply Zen's compatibility surface to another provider.
+ */
+export function shapeV1HiddenMessage(
+    sessionID: string,
+    message: {
+        agent?: string;
+        model?: { providerID: string };
+        system?: string;
+    },
+): void {
+    const run = v1Runs.get(sessionID);
+    if (!run) return;
+    const agent = message.agent ?? run.agent;
+    const base = agent.endsWith(ZEN_READ_AGENT_SUFFIX)
+        ? agent.slice(0, -ZEN_READ_AGENT_SUFFIX.length)
+        : agent;
+    const enabled = needsBlockedRead(base, message.model?.providerID);
+    setBlockedReadSession(sessionID, enabled);
+    if (!enabled) return;
+    message.agent = `${base}${ZEN_READ_AGENT_SUFFIX}`;
+    message.system = withBlockedReadInstruction(message.system ?? "", run);
+}
+
+export function setBlockedReadSession(sessionID: string, enabled: boolean): void {
+    if (enabled) blockedSessions.add(sessionID);
+    else blockedSessions.delete(sessionID);
+}
+
+export function blockedReadSessionRefusal(sessionID: string): string | undefined {
+    return blockedSessions.has(sessionID) ? TOOL_USE_DISABLED : undefined;
+}

package/src/shared/reclaim-distance.test.ts

@@ -0,0 +1,111 @@
+import { describe, expect, it } from "bun:test";
+import {
+    farBehindToolBookmark,
+    isReclaimUserTurn,
+    type ReclaimDistanceEntry,
+} from "./reclaim-distance";
+
+const output = (tag: number, tokens = 1000): ReclaimDistanceEntry => ({
+    toolOutputTag: tag,
+    tokens,
+});
+const turn = (): ReclaimDistanceEntry => ({ userTurn: true, tokens: 10 });
+
+describe("reclaim distance", () => {
+    it("repeated rebuilds cannot age the current task", () => {
+        const entries = [turn(), ...Array.from({ length: 28 }, (_, i) => output(i + 1))];
+        for (const count of [2, 3, 5]) {
+            let bookmark = 0;
+            for (let pass = 0; pass < count + 1; pass++) {
+                expect(bookmark).toBe(0);
+                bookmark = Math.max(bookmark, farBehindToolBookmark(entries, 200_000));
+            }
+        }
+    });
+
+    it("three newer user turns establish a bookmark, not two", () => {
+        const entries = [turn(), output(1), turn(), output(2), turn()];
+        expect(farBehindToolBookmark(entries, 200_000)).toBe(0);
+        expect(farBehindToolBookmark([...entries, turn()], 200_000)).toBe(1);
+    });
+
+    it("single-turn tool loop ages at exactly a quarter of the usable window", () => {
+        const entries = [turn(), output(1), output(2, 49_999)];
+        expect(farBehindToolBookmark(entries, 200_000)).toBe(0);
+        expect(farBehindToolBookmark([...entries, { tokens: 1 }], 200_000)).toBe(1);
+        expect(farBehindToolBookmark([turn(), output(1, 100_000)], 200_000)).toBe(0);
+    });
+
+    it("multipart outputs never age from their own trailing chunks", () => {
+        expect(farBehindToolBookmark([output(1), output(1, 60_000)], 200_000)).toBe(0);
+    });
+
+    it("unknown windows disable only token distance", () => {
+        expect(farBehindToolBookmark([output(1), output(2, 99_999)], 0)).toBe(0);
+        expect(farBehindToolBookmark([output(1), turn(), turn(), turn()], 0)).toBe(1);
+    });
+
+    it("excludes synthetic host wakes, MC reminders, heads and result carriers", () => {
+        expect(
+            isReclaimUserTurn({
+                role: "user",
+                parts: [
+                    {
+                        kind: "text",
+                        synthetic: true,
+                        text: "<system-reminder>Background task finished.</system-reminder>",
+                    },
+                ],
+            }),
+        ).toBe(false);
+        expect(
+            isReclaimUserTurn({
+                role: "user",
+                parts: [
+                    {
+                        kind: "text",
+                        text: "<system-reminder>Your next step: call ctx_reduce on the outputs you've already used (5).</system-reminder>",
+                    },
+                ],
+            }),
+        ).toBe(false);
+        expect(
+            isReclaimUserTurn({
+                role: "user",
+                syntheticHead: true,
+                parts: [{ kind: "text", text: "history" }],
+            }),
+        ).toBe(false);
+        expect(
+            isReclaimUserTurn({ role: "user", parts: [{ kind: "tool_result", text: "output" }] }),
+        ).toBe(false);
+        expect(
+            isReclaimUserTurn({
+                role: "user",
+                parts: [
+                    { kind: "tool_result", text: "output" },
+                    { kind: "text", text: "continue" },
+                ],
+            }),
+        ).toBe(true);
+    });
+
+    it("counts an authored part even after synthetic or ignored parts", () => {
+        for (const provenance of [{ synthetic: true }, { ignored: true }]) {
+            expect(
+                isReclaimUserTurn({ role: "user", parts: [{ kind: "image", ...provenance }] }),
+            ).toBe(false);
+            expect(
+                isReclaimUserTurn({
+                    role: "user",
+                    parts: [{ kind: "text", text: "notice", ...provenance }, { kind: "image" }],
+                }),
+            ).toBe(true);
+        }
+    });
+
+    it("a young lower-tag result holds back distant higher tags", () => {
+        expect(farBehindToolBookmark([output(2), output(3, 50_000), output(1)], 200_000)).toBe(0);
+        expect(farBehindToolBookmark([output(1), output(3, 50_000), output(2)], 200_000)).toBe(1);
+    });
+});

package/src/shared/reclaim-distance.ts

@@ -0,0 +1,91 @@
+export const RECLAIM_DISTANCE_USER_TURNS = 3;
+export const RECLAIM_DISTANCE_WINDOW_FRACTION = 0.25;
+
+export interface ReclaimDistanceEntry {
+    /** Local content tokens, excluding Magic Context's history and reduction/note reminders. */
+    tokens: number;
+    /** One event per authored user-role message, after any folded tool results. */
+    userTurn?: boolean;
+    /** Durable identifier of the tool invocation whose result ends at this entry. */
+    toolOutputTag?: number;
+}
+
+/** Only authored content starts a user turn; host control notices do not. */
+export function isReclaimUserTurn(args: {
+    role?: string;
+    syntheticHead?: boolean;
+    synthetic?: boolean;
+    ignored?: boolean;
+    parts: readonly { kind: string; text?: string; synthetic?: boolean; ignored?: boolean }[];
+}): boolean {
+    return (
+        args.role === "user" &&
+        !args.syntheticHead &&
+        !args.synthetic &&
+        !args.ignored &&
+        args.parts.some((part) => {
+            if (part.synthetic || part.ignored) return false;
+            if (part.kind !== "text" && part.kind !== "image" && part.kind !== "file") return false;
+            if (part.kind !== "text") return true;
+            return stripReclaimMcText(part.text ?? "").trim().length > 0;
+        })
+    );
+}
+
+/** Remove Magic Context's reduction/note reminders, not generic host wake notices. */
+export function stripReclaimMcText(text: string): string {
+    return text
+        .replace(/^§\d+§\s*/, "")
+        .replace(/<system-reminder>[\s\S]*?<\/system-reminder>/g, (reminder) =>
+            /^(?:Your next step: call ctx_reduce on the outputs you've already used|Still unstamped:|Housekeeping: .* are reclaimable\. Stamp each output with ctx_reduce|.* are reclaimable\. Make a ctx_reduce pass now|.* are still unstamped\. Call ctx_reduce now)/.test(
+                reminder.slice("<system-reminder>".length).trimStart(),
+            )
+                ? ""
+                : reminder,
+        )
+        .replace(/<instruction name="deferred_notes">[\s\S]*?<\/instruction>/g, "");
+}
+
+/**
+ * A free cache rebuild is not evidence that the model has moved on. An output
+ * is far behind only after three newer user turns or a quarter-window of newer
+ * content. Return a prefix of qualifying tags; callers drop against the PREVIOUS
+ * durable bookmark before advancing it, so distance must survive two rebuilds.
+ */
+export function farBehindToolBookmark(
+    entries: readonly ReclaimDistanceEntry[],
+    usableWindow: number,
+): number {
+    let newerTurns = 0;
+    let newerTokens = 0;
+    const farTags: number[] = [];
+    let firstYoungTag = Infinity;
+    const seenOutputs = new Set<number>();
+    const tokenDistance =
+        usableWindow > 0 && Number.isFinite(usableWindow)
+            ? usableWindow * RECLAIM_DISTANCE_WINDOW_FRACTION
+            : Infinity;
+    for (let index = entries.length - 1; index >= 0; index--) {
+        const entry = entries[index];
+        if (!entry) continue;
+        const tag = entry.toolOutputTag;
+        // Multi-part outputs are positioned at their last result, not their call
+        // or first chunk: an output must never count its own remaining payload.
+        if (tag !== undefined && !seenOutputs.has(tag)) {
+            seenOutputs.add(tag);
+            if (newerTurns >= RECLAIM_DISTANCE_USER_TURNS || newerTokens >= tokenDistance) {
+                farTags.push(tag);
+            } else {
+                firstYoungTag = Math.min(firstYoungTag, tag);
+            }
+        }
+        if (entry.userTurn) newerTurns++;
+        if (Number.isFinite(entry.tokens) && entry.tokens > 0) newerTokens += entry.tokens;
+    }
+    // Tags follow call order, not result arrival. A late lower-tag sibling must
+    // hold the prefix even when a higher-tag result is already distant.
+    return farTags.reduce(
+        (bookmark, tag) => (tag < firstYoungTag ? Math.max(bookmark, tag) : bookmark),
+        0,
+    );
+}

package/src/shared/stable-json.ts

@@ -22,33 +22,33 @@ export function stableStringify(value: unknown, seen = new WeakSet<object>()): s
     // value's text once per enclosing level, so a large value N levels deep cost
     // N copies of itself.
     const pieces: string[] = [];
-    writeStable(value, seen, pieces);
+    writeStable(value, seen, (piece) => pieces.push(piece));
     return pieces.join("");
 }
 
-function writeStable(value: unknown, seen: WeakSet<object>, pieces: string[]): void {
+function writeStable(value: unknown, seen: WeakSet<object>, write: (piece: string) => void): void {
     if (value === undefined) {
-        pieces.push("undefined");
+        write("undefined");
         return;
     }
     if (value === null || typeof value !== "object") {
-        pieces.push(JSON.stringify(value) ?? String(value));
+        write(JSON.stringify(value) ?? String(value));
         return;
     }
     // Any object met a second time, shared or cyclic, is written as "[Circular]".
     if (seen.has(value)) {
-        pieces.push('"[Circular]"');
+        write('"[Circular]"');
         return;
     }
     seen.add(value);
     if (Array.isArray(value)) {
-        pieces.push("[");
+        write("[");
         for (let index = 0; index < value.length; index += 1) {
-            if (index > 0) pieces.push(",");
+            if (index > 0) write(",");
             // A hole writes nothing between its commas, as joining a mapped array did.
-            if (index in value) writeStable(value[index], seen, pieces);
+            if (index in value) writeStable(value[index], seen, write);
         }
-        pieces.push("]");
+        write("]");
         return;
     }
     // Code-point sort (NOT localeCompare). Stable across runtimes/locales.
@@ -57,11 +57,53 @@ function writeStable(value: unknown, seen: WeakSet<object>, pieces: string[]): v
         if (a > b) return 1;
         return 0;
     });
-    pieces.push("{");
+    // Native JSON can emit a small scalar-only object in one operation. Larger
+    // containers still stream; undefined and integer keys need the writer's
+    // non-native spelling/order. Bound chunks so hashing never builds a large JSON string.
+    if (
+        entries.length > 0 &&
+        entries.length <= 16 &&
+        entries.every(
+            ([key, child]) =>
+                key.length <= 4096 &&
+                !/^(0|[1-9]\d*)$/.test(key) &&
+                (child === null ||
+                    typeof child === "number" ||
+                    typeof child === "boolean" ||
+                    (typeof child === "string" && child.length <= 4096)),
+        )
+    ) {
+        write(JSON.stringify(Object.fromEntries(entries)));
+        return;
+    }
+    write("{");
     entries.forEach(([key, child], index) => {
-        if (index > 0) pieces.push(",");
-        pieces.push(JSON.stringify(key), ":");
-        writeStable(child, seen, pieces);
+        if (index > 0) write(",");
+        write(JSON.stringify(key));
+        write(":");
+        writeStable(child, seen, write);
     });
-    pieces.push("}");
+    write("}");
+}
+
+/** The existing UTF-16 FNV fingerprint, without retaining the serialized JSON. */
+export function stableStringifyHash(value: unknown, prefix = ""): string {
+    const sink = jsonHashSink(prefix);
+    writeStable(value, new WeakSet(), sink.write);
+    return sink.digest();
+}
+
+/** Hash the same code units as the content memo, including lone surrogates. */
+export function jsonHashSink(prefix = ""): {
+    write: (piece: string) => void;
+    digest: () => string;
+} {
+    let hash = 0x811c9dc5;
+    const write = (piece: string): void => {
+        for (let index = 0; index < piece.length; index++) {
+            hash = Math.imul(hash ^ piece.charCodeAt(index), 0x01000193);
+        }
+    };
+    write(prefix);
+    return { write, digest: () => (hash >>> 0).toString(16).padStart(8, "0") };
 }