@intentic/sandbox-contract 1.326.0 → 1.328.0

package/src/state/workspace-state.ts

@@ -193,6 +193,22 @@ const STATE_FILES = [
         why: "Scheduler bookkeeping nothing in the browser renders: what a catch-up fire produces reaches the run ledger, which carries the automations key.",
         portability: "carry",
     },
+    // What each watch's check saw last (automations/automations-store.ts), so `fireOn: change` can say what moved and
+    // the list can show the last value. `carry`: a restored sandbox must not read every release it already saw as new.
+    {
+        path: ".intentic/records/automation-watch.json",
+        invalidates: [],
+        why: "Declared by the intentic.automations extension's contributes.files, `automations` is its query key, not core's.",
+        portability: "carry",
+    },
+    // One file per automation that a guard command may keep between runs ($AUTOMATION_STATE); the daemon only makes the
+    // directory and deletes an automation's file with it. `carry`: it is the guard's memory of what it already saw.
+    {
+        path: ".intentic/records/automation-state/",
+        invalidates: [],
+        why: "A guard's own scratch file; the daemon never reads it and nothing in the browser renders it.",
+        portability: "carry",
+    },
     {
         path: ".intentic/records/approvals/",
         invalidates: [],
@@ -312,6 +328,16 @@ const STATE_FILES = [
     // Owner's per-extension update posture (notify/agent/auto, advisory opt-out). `carry`: a decision about the
     // extension, not the machine.
     { path: ".intentic/config/extension-update-policy.json", invalidates: ["extensions"], portability: "carry", versioned: true },
+    // Which installed extensions run from a source checkout instead of their pinned clone (extensions/extension-dev.ts).
+    // Local and never versioned: it can name a conversation's worktree, a path that means nothing in a commit or on
+    // another machine. `extensions` because the row says where it runs from, and a rebuild reported here is what offers
+    // the reload.
+    {
+        path: ".intentic/local/extension-dev.json",
+        invalidates: ["extensions"],
+        portability: "derived",
+        note: "Extensions run their pinned versions on the target; point one at its source checkout again there if you were working on it.",
+    },
     // `carry`: evidence is about the extension, not the machine; dropping it would make every permission look unused
     // rather than simply unmeasured.
     {
@@ -320,14 +346,13 @@ const STATE_FILES = [
         why: "Which of the routes each extension DECLARED it has actually called, the evidence behind the permissions list on its row. The one entry here whose empty set is a RATE decision rather than an architectural one: every browser with the app open reports its batch on a timer, so wiring this to the `extensions` query would refetch the whole list every few seconds for a figure nobody is watching change. The tab reads it when it loads, which is when anyone is reading it.",
         portability: "carry",
     },
-    // Holds no credential but stays `identity`, not `carry`: it mirrors the platform's own invite records (the
-    // enforcer's copy, so a grant it never received is never honoured), and review already happens on the Access tab
-    // against the authoritative record. An access list that traveled would let a source sandbox hand itself the
-    // target's ownership.
+    // The roster's address before 2026-10-06 (now the history volume's `identity/members.json`). Holds no credential but
+    // stays `identity`, not `carry`: an access list that traveled would let a source sandbox hand itself the target's
+    // ownership, and a pre-move copy may still sit here.
     {
         path: ".intentic/identity/members.json",
         invalidates: [],
-        why: "Not this view's source at all: SandboxAccess renders the PLATFORM's invite records (apiClient.invite.list), and this file is the daemon's ENFORCED copy, written first so a grant the enforcer never got is never recorded, then never read back. A change here means the two disagreed, which the write order makes fail-closed rather than stale.",
+        why: "Where releases before 2026-10-06 kept the daemon's enforced roster; it now lives on the history volume (`identity/members.json`), off the workspace every turn writes, and nothing reads this copy. Kept declared, locked and never exported, since it may still hold a pre-move roster a rollback reads.",
         portability: "identity",
         note: "Re-invite collaborators from the Access tab, a grant is the platform's record, and the target enforces its own copy.",
     },
@@ -375,14 +400,15 @@ const STATE_FILES = [
         why: "Rebuildable indexes and caches, the iq index and its vector sidecar, the whisper model, fileq's derived/ markdown shadows of binary files; ignored by the watcher and recreated from carried workspace content.",
         portability: "derived",
     },
-    // Extension runtime scratch, one directory per extension via `extensionRuntimeDir` below (the only way an
-    // extension may name a home here). Resume watermarks and cached tokens; all of it expires or re-derives.
+    // Extension runtime scratch, one directory per extension via `extensionStateDir` below (the only way an extension
+    // may name a home here), plus the gateways' published control addresses. Resume watermarks and cached tokens; all
+    // of it expires or re-derives.
     {
         path: ".intentic/local/runtime/",
         invalidates: [],
         why: "Extension runtime scratch (watermarks, cached short-lived tokens); nothing renders it and gateways re-derive it.",
         portability: "derived",
-        outsideWriter: "extensions, through extensionRuntimeDir below",
+        outsideWriter: "extensions, through extensionStateDir below",
     },
     {
         path: ".intentic/local/tmp/",
@@ -447,7 +473,7 @@ const STATE_FILES = [
     {
         path: ".intentic/identity/control-tokens.json",
         invalidates: [],
-        why: "Hashed control tokens (the ACP editor bridge, and anything else driving this sandbox from outside), listed on demand by the owner.",
+        why: "Where releases before 2026-10-06 kept the hashed control tokens; they now live on the history volume (`identity/control-tokens.json`), and nothing reads this copy.",
         portability: "identity",
         backup: false,
         note: "Mint fresh control tokens, the old ones authenticate against the source sandbox.",
@@ -455,7 +481,7 @@ const STATE_FILES = [
     {
         path: ".intentic/identity/owner.json",
         invalidates: [],
-        why: "Bound once on first use; a change here means the sandbox was re-owned, which re-authenticates anyway.",
+        why: "Where releases before 2026-10-06 kept the bound owner; it now lives on the history volume (`identity/owner.json`), and nothing reads this copy.",
         portability: "identity",
     },
     {
@@ -464,13 +490,13 @@ const STATE_FILES = [
         why: "The workspace identity, read from the /events hello frame rather than as a file.",
         portability: "identity",
     },
-    // Public keys and the owner's require-a-passkey switch; the one credential-shaped thing in it, the recovery codes,
-    // is stored hashed. `identity` because a passkey admits its holder to THIS sandbox: a copy that traveled would let
-    // a source sandbox's passkeys open the target.
+    // The passkeys' address before the passkeys-off-workspace step (now the history volume's `identity/passkeys.json`):
+    // public keys, the owner's require-a-passkey switch and the hashes of their recovery codes. Stays `identity`, since
+    // a pre-move copy may still sit here and a passkey admits its holder to THIS sandbox.
     {
         path: ".intentic/identity/passkeys.json",
         invalidates: [],
-        why: "The passkeys registered with this sandbox, whether one is required to open it, and the hashes of the owner's recovery codes; the Access tab reads them through /system/passkeys, never off disk.",
+        why: "Where earlier releases kept the passkeys registered with this sandbox, whether one is required to open it, and the hashes of the owner's recovery codes; they now live on the history volume (`identity/passkeys.json`), off the workspace every turn writes, and nothing reads this copy.",
         portability: "identity",
         note: "Passkeys are bound to the sandbox they were registered with: add them again on the new one from its Access tab.",
     },
@@ -606,10 +632,28 @@ export const UNBACKED_STATE_PATHS: readonly string[] = WORKSPACE_STATE_FILES.fil
     (file) => file.path,
 );
 
-// The only way an extension may name a scratch home, workspace-relative and forward-slash so the browser bundle
-// can hold it too. Extension ids are already validated slugs; the character replace is defense in depth.
-export const extensionRuntimeDir = (extension: string): string =>
-    `${STATE_GROUP_DIR.local}/runtime/extensions/${extension.replaceAll(/[^a-zA-Z0-9._-]/g, "_")}`;
+// A name made safe as one path segment. Extension identities are already validated slugs joined by a dot; the replace
+// is defence in depth.
+const segmentOf = (name: string): string => name.replaceAll(/[^a-zA-Z0-9._-]/g, "_");
+
+// The only way an extension may name a home for its own state, workspace-relative and forward-slash so the browser
+// bundle can hold it too. Keyed by the extension's identity (`publisher.name`, extensionIdOf), like its settings and its
+// switch, so it survives an update, a re-install and dev mode. The daemon creates it and hands it to the extension's
+// code as `api.stateDir`; an agent-side CLI of the same extension names it by its own identity.
+export const extensionStateDir = (identity: string): string => `${STATE_GROUP_DIR.local}/runtime/extensions/${segmentOf(identity)}`;
+
+// Its counterpart for what can be fetched or built again (`api.cacheDir`), under the rebuildable cache the watcher
+// ignores and no backup carries.
+export const extensionCacheDir = (identity: string): string => `${STATE_GROUP_DIR.local}/cache/extensions/${segmentOf(identity)}`;
+
+// Where an extension kept its state before the directory was keyed by identity: its bare manifest name. Read only by
+// the daemon, which moves a first-party extension's directory from here to extensionStateDir once.
+export const legacyExtensionStateDir = (name: string): string => `${STATE_GROUP_DIR.local}/runtime/extensions/${segmentOf(name)}`;
+
+// Where a gateway publishes its loopback control address for the agent's CLI to read (`publishGatewayUrl`), keyed by
+// the listener provider the gateway serves. Beside the extensions' own directories rather than inside one, since the
+// provider is the rendezvous both sides know, and the CLI never learns which extension owns it.
+export const extensionGatewayUrlFile = (provider: string): string => `${STATE_GROUP_DIR.local}/runtime/gateways/${segmentOf(provider)}.url`;
 
 // Manifests the unreadable-manifest notice reports on: exactly the entries that declare `manifests` in
 // Report broken manifests only when a file change can refresh their notice.
@@ -619,8 +663,9 @@ export const REPORTED_MANIFEST_PATHS: readonly string[] = WORKSPACE_STATE_FILES.
 
 // Files on the daemon's own volume whose unreadable records are reported too, named by their absolute path there: the
 // conversation registry's rows, one of which this build could not read costs that conversation until a build that can
-// runs. Reported, never repaired from the card (no route edits them), and refreshed whenever the card is fetched.
-export const REPORTED_VOLUME_FILES: readonly string[] = [`${HISTORY_ROOT}/conversations.db`];
+// runs. Reported, never repaired from the card (no route edits them), and refreshed whenever the card is fetched. The
+// boot record (2026-10-05) is reported when a restart storm kept a boot from resuming the turns it cut.
+export const REPORTED_VOLUME_FILES: readonly string[] = [`${HISTORY_ROOT}/conversations.db`, `${HISTORY_ROOT}/boot-history.json`];
 
 // Accepts either separator; the daemon holds these as platform paths and normalizing at every call site is what
 // eventually gets forgotten.

package/src/text/embed.test.ts

@@ -1,6 +1,6 @@
 import { webcrypto } from "node:crypto";
 import { stubGlobal, unstubAllGlobals } from "@intentic/testing/bun";
-import { EmbedError, embedFailure, embedUrl, fetchEmbedJson, solveProofOfWork } from "./embed.js";
+import { DEFAULT_ACCENT, EmbedError, embedFailure, embedUrl, escapeHtml, fetchEmbedJson, onAccent, parseHex, solveProofOfWork } from "./embed.js";
 
 /* The wire every embed speaks before it speaks its own, against a fake fetch and the real WebCrypto. */
 
@@ -72,3 +72,23 @@ test("an http:// page is told the truth, in the embed's own words, instead of ha
     );
     Object.defineProperty(globalThis, "crypto", { value: webcrypto, configurable: true });
 });
+
+test("an accent is read as three channels from either hex spelling, and anything else is unreadable", () => {
+    expect(parseHex(DEFAULT_ACCENT)).toEqual([228, 113, 0]);
+    expect(parseHex(" #FA0 ")).toEqual([255, 170, 0]);
+    expect(parseHex("rebeccapurple")).toBeUndefined();
+    expect(parseHex("#12345")).toBeUndefined();
+});
+
+// The default orange is where a brightness threshold gets it wrong: it read as dark and put white on it, at 3.15:1.
+test("the label on an accent is whichever of the dark ink and white contrasts more, so the default orange gets dark text", () => {
+    expect(onAccent(DEFAULT_ACCENT, "#111827")).toBe("#111827");
+    expect(onAccent(DEFAULT_ACCENT, "#201c19")).toBe("#201c19");
+    expect(onAccent("#1a3d8f", "#111827")).toBe("#ffffff");
+    expect(onAccent("#fde047", "#111827")).toBe("#111827");
+});
+
+test("escaped text stays text both between tags and inside a quoted attribute", () => {
+    expect(escapeHtml(`<img src=x onerror="alert('hi')"> & more`)).toBe("&lt;img src=x onerror=&quot;alert(&#39;hi&#39;)&quot;&gt; &amp; more");
+    expect(escapeHtml("Report a problem")).toBe("Report a problem");
+});

package/src/text/embed.ts

@@ -1,6 +1,6 @@
-// The zod-free half of an embed's wire, shared by the two embeds (webchat-widget, issue-sdk) and the daemon's
-// public-door.ts. No imports, ever: this bundles into someone else's page, and the contract's barrel would drag in zod
-// (measured at 1.1 MB for two strings).
+// The zod-free half of an embed's wire and look, shared by the two embeds (webchat-widget, issue-sdk) and the daemon's
+// doors behind them. No imports, ever: this bundles into someone else's page, and the contract's barrel would drag in
+// zod (measured at 1.1 MB for two strings).
 
 // Where an embed talks to: the daemon it came from, and the automation it is the public face of.
 export interface EmbedEndpoint {
@@ -130,3 +130,50 @@ export const embedEndpointOf = (script: HTMLScriptElement): EmbedEndpoint | unde
     }
     return { automationId, base: (script.dataset["base"] ?? new URL(script.src, window.location.href).origin).replace(/\/$/, "") };
 };
+
+// The frames of a Visitor chat reply, streamed as server-sent events on the POST that sent the message: a chunk of the
+// answer, the notice that the owner reviews it first, the one failure sentence a visitor sees, and the end of the turn.
+export const WEBCHAT_EVENT = { delta: "delta", pending: "pending", error: "error", done: "done" } as const;
+
+// Intentic's brand orange (`--color-brand-600`): the accent of an embed nobody configured, so it still looks like the
+// product, and what an embed paints when it cannot read the configured one.
+export const DEFAULT_ACCENT = "#e47100";
+
+// The red, green and blue of a `#rgb` or `#rrggbb` colour, undefined for anything else. The embeds do their colour maths
+// here rather than in CSS: an unsupported color-mix() is invalid at computed-value time and would paint nothing.
+export const parseHex = (value: string): [number, number, number] | undefined => {
+    const digits = /^#([0-9a-f]{3}|[0-9a-f]{6})$/i.exec(value.trim())?.[1];
+    if (digits === undefined) {
+        return undefined;
+    }
+    const full = digits.length === 3 ? [...digits].map((char) => char + char).join("") : digits;
+    const channel = (at: number): number => Number.parseInt(full.slice(at, at + 2), 16);
+    return [channel(0), channel(2), channel(4)];
+};
+
+// One sRGB channel on WCAG's linear scale.
+const linear = (channel: number): number => {
+    const unit = channel / 255;
+    return unit <= 0.03928 ? unit / 12.92 : ((unit + 0.055) / 1.055) ** 2.4;
+};
+
+// WCAG relative luminance; an unreadable colour scores 0, which only ever picks a label and is never shown.
+const luminance = (color: string): number => {
+    const [r, g, b] = parseHex(color) ?? [0, 0, 0];
+    return 0.2126 * linear(r) + 0.7152 * linear(g) + 0.0722 * linear(b);
+};
+
+const contrast = (a: number, b: number): number => (Math.max(a, b) + 0.05) / (Math.min(a, b) + 0.05);
+
+// The label on a solid accent: the embed's own dark ink or white, whichever contrasts more. Measured, not assumed:
+// white on the default orange is 3.15:1, under AA, where either embed's dark ink clears 5:1, and comparing the two works
+// for any accent a customer picks.
+export const onAccent = (accent: string, dark: string): string => {
+    const field = luminance(accent);
+    return contrast(field, luminance(dark)) >= contrast(field, luminance("#ffffff")) ? dark : "#ffffff";
+};
+
+// Text for innerHTML, safe both between tags and inside a quoted attribute: neither an owner's config nor what a
+// visitor typed is trusted with markup.
+export const escapeHtml = (value: string): string =>
+    value.replace(/[&<>"']/g, (char) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" })[char] ?? char);

package/src/text/pages.test.ts

@@ -0,0 +1,161 @@
+import type { AgentEvent } from "../events/agent-events.js";
+import type { Page } from "../events/requests.js";
+import { settledRequests } from "../policy/request-status.js";
+import {
+    intoHead,
+    mcpAppDataScript,
+    PAGE_FALLBACK_THEMES,
+    PAGE_THEME_VARIABLES,
+    pageThemeCss,
+    publishedPage,
+    readMcpAppData,
+    sealedPage,
+    SEALED_PAGE_POLICY,
+    sizedFirst,
+    standalonePage,
+} from "./pages.js";
+import { foldTurn, userRow } from "./transcript-fold.js";
+
+// path-literals: content, a page's stored path as a transcript row carries it
+const PAGE: Page = { id: "a1b2c3d4e5", title: "Q3 revenue", path: ".intentic/records/artifacts/pages/c1/a1b2c3d4e5.r0.html" };
+
+describe("intoHead", () => {
+    it("puts markup first inside an existing head", () => {
+        expect(intoHead(`<!doctype html><html><head><title>x</title></head><body></body></html>`, `<i>`)).toBe(
+            `<!doctype html><html><head><i><title>x</title></head><body></body></html>`,
+        );
+    });
+
+    it("makes a head inside the html element when the page wrote none", () => {
+        expect(intoHead(`<html lang="en"><body>hi</body></html>`, `<i>`)).toBe(`<html lang="en"><head><i></head><body>hi</body></html>`);
+    });
+
+    it("makes one after a lone doctype, and for a bare fragment", () => {
+        expect(intoHead(`<!DOCTYPE html><p>hi</p>`, `<i>`)).toBe(`<!DOCTYPE html><head><i></head><p>hi</p>`);
+        expect(intoHead(`<p>hi</p>`, `<i>`)).toBe(`<!doctype html><head><i></head><p>hi</p>`);
+    });
+
+    it("never takes a head written inside a script or comment for the real one", () => {
+        const html = `<!-- <head> --><html><head><script>const s = "<head>";</script></head></html>`;
+        expect(intoHead(html, `<i>`)).toBe(`<!-- <head> --><html><head><i><script>const s = "<head>";</script></head></html>`);
+    });
+});
+
+describe("sealedPage", () => {
+    it("leads with the policy, then the theme and the bootstrap, before the page's own head", () => {
+        const sealed = sealedPage(`<html><head><style>body{color:red}</style></head><body></body></html>`, PAGE_FALLBACK_THEMES.dark);
+        const policy = sealed.indexOf(SEALED_PAGE_POLICY);
+        const theme = sealed.indexOf(`id="intentic-theme"`);
+        const own = sealed.indexOf(`body{color:red}`);
+        expect(policy).toBeGreaterThan(-1);
+        expect(policy).toBeLessThan(theme);
+        expect(theme).toBeLessThan(own);
+        expect(sealed).toContain(`window.intentic=`);
+    });
+
+    it("keeps the theme's values from ending the rule they sit in", () => {
+        const hostile = { ...PAGE_FALLBACK_THEMES.light, variables: { ...PAGE_FALLBACK_THEMES.light.variables, "--foreground": `red;}</style><script>x()` } };
+        expect(pageThemeCss(hostile)).not.toContain(`</style>`);
+        expect(pageThemeCss(hostile)).toContain(`--foreground:red/stylescriptx();`);
+    });
+
+    it("names every theme variable", () => {
+        const css = pageThemeCss(PAGE_FALLBACK_THEMES.dark);
+        for (const name of PAGE_THEME_VARIABLES) {
+            expect(css).toContain(`${name}:`);
+        }
+    });
+});
+
+describe("standalonePage", () => {
+    it("carries defaults at no specificity, so the chat's theme and the page's own rules win", () => {
+        const stored = standalonePage(`<html><head></head><body>x</body></html>`);
+        expect(stored).toContain(`:where(:root){`);
+        expect(stored).toContain(`@media (prefers-color-scheme: light)`);
+        expect(stored).not.toMatch(/(^|[^(]):root\{/);
+        expect(stored).toContain(`if(!window.intentic)`);
+    });
+});
+
+describe("pages in the fold", () => {
+    const fold = (events: readonly AgentEvent[]) => foldTurn([userRow("show me", 1, [])], events).slice(1);
+
+    it("draws a page on the bubble whose call showed it, and starts the next words below", () => {
+        const rows = fold([
+            { kind: "tool_call", id: "t1", name: "mcp__ui__show_page", category: "other", status: "in_progress" },
+            { kind: "page", page: PAGE },
+            { kind: "tool_call_update", id: "t1", status: "completed" },
+            { kind: "delta", text: "Revenue doubled." },
+        ]);
+        expect(rows).toHaveLength(2);
+        expect(rows[0]?.page).toEqual(PAGE);
+        expect(rows[0]?.tools?.[0]?.status).toBe("completed");
+        expect(rows[1]).toEqual({ role: "assistant", text: "Revenue doubled." });
+    });
+
+    it("folds an earlier drawing away when the page is redrawn", () => {
+        const redrawn: Page = { ...PAGE, path: PAGE.path.replace(".r0.", ".r1."), revision: 1 };
+        const rows = fold([
+            { kind: "page", page: PAGE },
+            { kind: "delta", text: "Here." },
+            { kind: "text_end" },
+            { kind: "page", page: redrawn },
+        ]);
+        expect(rows[0]?.page?.superseded).toBe(true);
+        expect(rows.at(-1)?.page).toEqual(redrawn);
+    });
+
+    it("parks a page asked on as a card, and settles it with what the page sent", () => {
+        const rows = fold([
+            { kind: "page_ask", requestId: "r1", page: PAGE },
+            { kind: "resolved", requestId: "r1", reply: { kind: "page_ask", requestId: "r1", value: `{"pick":"B"}` } },
+        ]);
+        expect(rows[0]?.pageAsk).toEqual({ requestId: "r1", page: PAGE, status: "answered", value: `{"pick":"B"}` });
+    });
+
+    it("draws nothing for a draft: it is live state, never transcript", () => {
+        expect(fold([{ kind: "page_draft", callId: "t1", at: 0, text: "<p>" }])).toEqual([]);
+    });
+
+    it("reads a dismissal, or a turn that died, as cancelled with no value", () => {
+        const card = { pageAsk: { requestId: "r1", page: PAGE, status: "pending" as const } };
+        expect(settledRequests(card, { kind: "page_ask", requestId: "r1", cancelled: true }).pageAsk).toEqual({ ...card.pageAsk, status: "cancelled" });
+        expect(settledRequests(card, undefined).pageAsk?.status).toBe("cancelled");
+    });
+});
+
+describe("an MCP app's call, kept inside its page", () => {
+    it("reads back exactly what was stored, markup in its values included", () => {
+        const data = { server: "maps", tool: "show_map", input: { q: "</script><b>" }, result: { content: [{ type: "text", text: "<i>3</i>" }] } };
+        const stored = standalonePage(intoHead(`<html><head></head><body></body></html>`, mcpAppDataScript(data)));
+        expect(stored).not.toContain("</script><b>");
+        expect(readMcpAppData(stored)).toEqual(data);
+        expect(readMcpAppData(`<html></html>`)).toBeUndefined();
+    });
+});
+
+describe("publishedPage", () => {
+    it("seals a stored page off the network and has it say its height to the page around it", () => {
+        const published = publishedPage(standalonePage(`<html><head></head><body>x</body></html>`));
+        expect(published.indexOf(SEALED_PAGE_POLICY)).toBeLessThan(published.indexOf(`intentic-page-defaults`));
+        expect(published).toContain(`ui/notifications/size-changed`);
+    });
+});
+
+describe("sizedFirst", () => {
+    const page = `<!DOCTYPE html><html><head><script>var a = "</script>";</script></head><body>x</body></html>`;
+    const shell = sizedFirst(page);
+
+    it("carries the page whole inside one script the page cannot close", () => {
+        expect(shell.startsWith(`<!DOCTYPE html><script>`)).toBe(true);
+        expect(shell.endsWith(`</script>`)).toBe(true);
+        // The only `</` left is the shell's own closing tag: the page's markup cannot end the script early.
+        expect(shell.split(`</`).length).toBe(2);
+    });
+
+    it("writes back exactly the page it was given", () => {
+        const literal = /var page=(".*?"),done=/.exec(shell)?.[1];
+        expect(literal).toBeDefined();
+        expect(JSON.parse(literal!)).toBe(page);
+    });
+});