@caelo-cms/shared 0.10.64 → 0.10.66

package/src/nested-module-render.test.ts

@@ -53,6 +53,9 @@ const PARENT_CI_ID = "00000000-0000-0000-0000-00000000bbb1";
 const CHILD_CI_ID = "00000000-0000-0000-0000-00000000bbb2";
 const GRAND_CI_ID = "00000000-0000-0000-0000-00000000bbb3";
 
+/** The id stamp every nested module root carries (#1027). */
+const tag = (moduleId: string) => `data-caelo-module-id="${moduleId}"`;
+
 describe("renderModuleWithContent — primitive substitution", () => {
   it("replaces {{name}} with values[name] and tracks the touched module", () => {
     const resolver = buildResolver(
@@ -154,7 +157,9 @@ describe("renderModuleWithContent — nested module slots", () => {
       ],
     );
     const r = renderModuleWithContent(PARENT_MOD_ID, PARENT_CI_ID, resolver);
-    expect(r.html).toBe("<section><div><span>deep</span></div></section>");
+    expect(r.html).toBe(
+      `<section><div ${tag(CHILD_MOD_ID)}><span ${tag(GRAND_MOD_ID)}>deep</span></div></section>`,
+    );
     expect(r.missingSlots).toEqual([]);
     // All three modules touched — caller uses this set for CSS/JS dedup.
     expect(r.touchedModuleIds.has(PARENT_MOD_ID)).toBe(true);
@@ -201,7 +206,7 @@ describe("renderModuleWithContent — nested module slots", () => {
       ],
     );
     const r = renderModuleWithContent(PARENT_MOD_ID, PARENT_CI_ID, resolver);
-    expect(r.html).toBe("<ul><li>A</li><li>B</li></ul>");
+    expect(r.html).toBe(`<ul><li ${tag(CHILD_MOD_ID)}>A</li><li ${tag(CHILD_MOD_ID)}>B</li></ul>`);
     expect(r.missingSlots).toEqual([]);
   });
 });
@@ -697,7 +702,7 @@ describe("renderModuleWithContent — engine-routing parity (#71)", () => {
       ],
     );
     const r = renderModuleWithContent(PARENT_MOD_ID, PARENT_CI_ID, resolver);
-    expect(r.html).toContain("<article>OK</article>");
+    expect(r.html).toContain(`<article ${tag(CHILD_MOD_ID)}>OK</article>`);
     expect(r.html).toContain("<!-- caelo:missing reason=module-list-malformed cards[1] -->");
     expect(r.missingSlots).toContain("module-list-malformed:cards[1]");
   });
@@ -781,7 +786,9 @@ describe("renderPlacedModule — the composer's entry point", () => {
       resolver,
       {},
     );
-    expect(r.html).toBe("<section><div>Pro<a>Buy</a></div></section>");
+    expect(r.html).toBe(
+      `<section><div ${tag(CHILD_MOD_ID)}>Pro<a ${tag(GRAND_MOD_ID)}>Buy</a></div></section>`,
+    );
     expect(r.failures).toEqual([]);
     expect([...r.touchedModuleIds].sort()).toEqual([CHILD_MOD_ID, GRAND_MOD_ID].sort());
   });
@@ -848,7 +855,7 @@ describe("renderPlacedModule — only template-referenced nested fields render",
       resolver,
       {},
     );
-    expect(r.html).toBe("<section><article>Pro</article></section>");
+    expect(r.html).toBe(`<section><article ${tag(CHILD_MOD_ID)}>Pro</article></section>`);
     expect(r.failures).toEqual([]);
     expect(r.missingSlots).toEqual([]);
     expect([...r.touchedModuleIds]).toEqual([CHILD_MOD_ID]);
@@ -885,3 +892,89 @@ describe("renderPlacedModule — only template-referenced nested fields render",
     expect(r.failures).toEqual([{ field: "card", reason: `content-instance-missing:${GONE_CI}` }]);
   });
 });
+
+describe("#1027 — nested module roots carry data-caelo-module-id", () => {
+  // The FAQ case from the searchVIU install: a module-list of FAQ items.
+  const faq: NestedModuleResource = {
+    moduleId: PARENT_MOD_ID,
+    slug: "faq",
+    html: '<div class="faq">{{#items}}{{/items}}{{>featured}}</div>',
+    css: "",
+    js: "",
+    fields: [
+      { name: "items", kind: "module-list" },
+      { name: "featured", kind: "module" },
+    ],
+  };
+  const item: NestedModuleResource = {
+    moduleId: CHILD_MOD_ID,
+    slug: "faq-entry",
+    html: "<details><summary>{{question}}</summary><p>{{answer}}</p></details>",
+    css: "",
+    js: "",
+    fields: [
+      { name: "question", kind: "text" },
+      { name: "answer", kind: "text" },
+    ],
+  };
+  const values = {
+    items: [
+      { moduleId: CHILD_MOD_ID, contentInstanceId: CHILD_CI_ID },
+      { moduleId: CHILD_MOD_ID, contentInstanceId: GRAND_CI_ID },
+    ],
+    featured: { moduleId: CHILD_MOD_ID, contentInstanceId: CHILD_CI_ID },
+  };
+  const resolver = buildResolver(
+    [faq, item],
+    [
+      { id: PARENT_CI_ID, moduleId: PARENT_MOD_ID, values, deletedAt: null },
+      {
+        id: CHILD_CI_ID,
+        moduleId: CHILD_MOD_ID,
+        values: { question: "Q1", answer: "A1" },
+        deletedAt: null,
+      },
+      {
+        id: GRAND_CI_ID,
+        moduleId: CHILD_MOD_ID,
+        values: { question: "Q2", answer: "A2" },
+        deletedAt: null,
+      },
+    ],
+  );
+  const expected =
+    `<div class="faq"><details ${tag(CHILD_MOD_ID)}><summary>Q1</summary><p>A1</p></details>` +
+    `<details ${tag(CHILD_MOD_ID)}><summary>Q2</summary><p>A2</p></details>` +
+    `<details ${tag(CHILD_MOD_ID)}><summary>Q1</summary><p>A1</p></details></div>`;
+
+  it("tags module and module-list roots in the editor preview path", () => {
+    const r = renderModuleWithContent(PARENT_MOD_ID, PARENT_CI_ID, resolver);
+    // The placed module's own root is left to the composer (tagModuleId).
+    expect(r.html).toBe(expected);
+    expect(r.failures).toEqual([]);
+  });
+
+  it("tags them identically in the composer / static build path", () => {
+    const r = renderPlacedModule({ html: faq.html, fields: faq.fields, values }, resolver, {});
+    expect(r.html).toBe(expected);
+  });
+
+  it("leaves a failure comment untagged (no element to carry the id)", () => {
+    const r = renderPlacedModule(
+      {
+        html: faq.html,
+        fields: faq.fields,
+        values: {
+          items: [{ moduleId: CHILD_MOD_ID, contentInstanceId: "missing" }],
+          featured: values.featured,
+        },
+      },
+      resolver,
+      {},
+    );
+    expect(r.html).toBe(
+      '<div class="faq"><!-- caelo:missing reason=content-instance-missing missing -->' +
+        `<details ${tag(CHILD_MOD_ID)}><summary>Q1</summary><p>A1</p></details></div>`,
+    );
+  });
+});

package/src/nested-module-render.ts

@@ -51,6 +51,10 @@
  *     comment + missingSlots entry. Same channel; the operator sees the
  *     gap in the preview, and the static generator refuses the build.
  *
+ * Module ids: the root element of every nested module render carries
+ * `data-caelo-module-id` (#1027), the same stamp the composer puts on a
+ * page placement's root, in the preview and the static build alike.
+ *
  * CSS + JS dedup: every unique module touched during recursion
  * contributes its CSS + JS once. The caller collects the seen-set out
  * of band so the page's <head>/<style> + footer scripts are stable.
@@ -58,6 +62,7 @@
 
 import type { ModuleFieldKind } from "./content.js";
 import { isLinkFailureMarker, type LinkResolver } from "./link-refs.js";
+import { tagModuleId } from "./module-id-tag.js";
 import { caeloMissingComment, renderTemplate, type TemplateField } from "./template-engine.js";
 
 const MAX_RECURSION_DEPTH = 8;
@@ -343,7 +348,15 @@ function renderPartial(
 ): string | undefined {
   const hit = nestedRefForPartial(key, fieldByName, values);
   if (!hit) return undefined;
-  return renderInner(hit.ref.moduleId, hit.ref.contentInstanceId, descend(ctx, hit.step));
+  // #1027 — a nested module's root carries its own id, exactly like a
+  // page placement's (the composer tags those), so the live-edit overlay
+  // and the quality checks attribute its markup to the nested module
+  // instead of reading it as free HTML of the parent. A failure comment
+  // has no element and stays as it is.
+  return tagModuleId(
+    renderInner(hit.ref.moduleId, hit.ref.contentInstanceId, descend(ctx, hit.step)),
+    hit.ref.moduleId,
+  );
 }
 
 /**

package/src/preview-compose-nested.test.ts

@@ -30,6 +30,9 @@ const CARD_A = "00000000-0000-0000-0000-0000000ca001";
 const CARD_B = "00000000-0000-0000-0000-0000000ca002";
 const GONE = "00000000-0000-0000-0000-00000000dead";
 
+/** The id stamp every nested module root carries (#1027). */
+const tag = (moduleId: string) => `data-caelo-module-id="${moduleId}"`;
+
 const card: NestedModuleResource = {
   moduleId: CARD_MOD,
   slug: "card",
@@ -89,7 +92,9 @@ describe("composePageWithLayout — nested modules", () => {
 
   it("renders every module-list element with the nested resolver", () => {
     const out = compose(grid(refs), resolver([card], instances));
-    expect(out.html).toContain("<article>Starter</article><article>Pro</article>");
+    expect(out.html).toContain(
+      `<article ${tag(CARD_MOD)}>Starter</article><article ${tag(CARD_MOD)}>Pro</article>`,
+    );
     expect(out.html).not.toContain("needs recursive renderer");
     expect(out.moduleFailures).toEqual([]);
   });
@@ -104,7 +109,7 @@ describe("composePageWithLayout — nested modules", () => {
       grid([refs[0], { moduleId: CARD_MOD, contentInstanceId: GONE }, "not-a-ref"]),
       resolver([card], instances),
     );
-    expect(out.html).toContain("<article>Starter</article>");
+    expect(out.html).toContain(`<article ${tag(CARD_MOD)}>Starter</article>`);
     expect(out.moduleFailures).toEqual([
       {
         blockName: "content",

package/src/preview-compose.test.ts

@@ -818,4 +818,31 @@ describe("theme favicon in <head>", () => {
     expect(out.html).toContain('href="/x&quot;&gt;&lt;script&gt;"');
     expect(out.html).not.toContain('/x"><script>');
   });
+
+  it("base64-encodes the page-wide module script bundle when JS contains </script or <!--", () => {
+    const mod = {
+      ...blankModule,
+      html: "<p>x</p>",
+      js: 'const tpl = "</script><img src=x onerror=alert(1)>";',
+    };
+    const preview = composePagePreview({
+      templateHtml: `<html><head></head><body><caelo-slot name="content">_</caelo-slot></body></html>`,
+      templateCss: "",
+      blocks: [{ blockName: "content", modules: [mod] }],
+    });
+    expect(preview.html).not.toContain("<img src=x onerror=alert(1)>");
+    expect(preview.html).toContain('src="data:text/javascript;base64,');
+
+    const withLayout = composePageWithLayout({
+      templateHtml,
+      templateCss: "",
+      blocks: [{ blockName: "content", modules: [mod] }],
+      layoutHtml,
+      layoutCss: "",
+      layoutBlocks: [],
+      layoutSlug: "test",
+    });
+    expect(withLayout.html).not.toContain("<img src=x onerror=alert(1)>");
+    expect(withLayout.html).toContain('src="data:text/javascript;base64,');
+  });
 });

package/src/preview-compose.ts

@@ -29,6 +29,7 @@ import { BASE_TECHNICAL_CSS } from "./base-css.js";
 import type { ModuleFieldKind } from "./content.js";
 import { findInteractionIds, interactionAssets } from "./interactions.js";
 import { type LinkResolver, resolveLinkRefsInHtml } from "./link-refs.js";
+import { tagModuleId } from "./module-id-tag.js";
 import {
   type NestedModuleResource,
   type NestedRenderFailure,
@@ -47,6 +48,9 @@ import { renderTemplate, type TemplateField } from "./template-engine.js";
 import { renderThemeCss as renderThemeCssFromTokens } from "./theme-render.js";
 import type { ThemeDocument } from "./themes.js";
 
+// Re-exported so existing callers keep importing it from the composer.
+export { tagModuleId };
+
 export interface ComposeModule {
   readonly moduleId: string;
   readonly slug: string;
@@ -369,7 +373,10 @@ export function composePagePreview(input: ComposeInput): ComposeOutput {
     html = injectBefore(html, HEAD_CLOSE_RE, styleTag);
   }
   if (allJs.length > 0) {
-    const scriptTag = `<script defer data-source="modules">\n${allJs.join("\n")}\n</script>`;
+    const joinedJs = allJs.join("\n");
+    const scriptTag = scriptNeedsEncoding(joinedJs)
+      ? `<script defer data-source="modules" src="data:text/javascript;base64,${utf8ToBase64(joinedJs)}"></script>`
+      : `<script defer data-source="modules">\n${joinedJs}\n</script>`;
     html = injectBefore(html, BODY_CLOSE_RE, scriptTag);
   }
 
@@ -381,16 +388,6 @@ export function composePagePreview(input: ComposeInput): ComposeOutput {
   };
 }
 
-/**
- * Insert `data-caelo-module-id="<id>"` into the first opening tag of
- * the module's HTML. Idempotent — re-tagging an already-tagged module
- * is a no-op. Comments / DOCTYPE / leading whitespace before the first
- * tag are tolerated. Modules that have no opening tag (pure text)
- * return unchanged because there's nothing to attach to.
- *
- * Exported so callers (admin preview endpoint, static generator,
- * tests) can reuse the same logic.
- */
 /**
  * P6.7.5 — return the items for a `nav-menu/<slug>` set when a module's
  * slug starts with `nav-menu-`. Returns null when the module is not a
@@ -602,18 +599,6 @@ function recordFailures(
   }
 }
 
-export function tagModuleId(html: string, moduleId: string): string {
-  if (!html) return html;
-  const firstOpen = /<([a-zA-Z][a-zA-Z0-9-]*)\b([^>]*)>/;
-  const m = firstOpen.exec(html);
-  if (!m) return html;
-  // Already tagged?
-  const tagAttrs = m[2] ?? "";
-  if (/\sdata-caelo-module-id\s*=/.test(tagAttrs)) return html;
-  const replaced = `<${m[1]}${tagAttrs} data-caelo-module-id="${moduleId}">`;
-  return html.slice(0, m.index) + replaced + html.slice(m.index + m[0].length);
-}
-
 /**
  * P6.7.6 — layout-aware composer. Runs the template composer first,
  * extracts the resulting body content, then renders the layout HTML
@@ -958,11 +943,11 @@ export function composePageWithLayout(input: ComposeWithLayoutInput): ComposeOut
     );
   }
   if (jsParts.length > 0) {
-    html = injectBefore(
-      html,
-      BODY_CLOSE_RE,
-      `<script defer data-source="modules">\n${jsParts.join("\n")}\n</script>`,
-    );
+    const joinedJs = jsParts.join("\n");
+    const scriptTag = scriptNeedsEncoding(joinedJs)
+      ? `<script defer data-source="modules" src="data:text/javascript;base64,${utf8ToBase64(joinedJs)}"></script>`
+      : `<script defer data-source="modules">\n${joinedJs}\n</script>`;
+    html = injectBefore(html, BODY_CLOSE_RE, scriptTag);
   }
 
   // De-duplicate slot accounting across both passes — the template's

package/src/release-manifest.ts

@@ -40,6 +40,19 @@ export const ReleaseManifestSchema = z.object({
   version: z.string().regex(SEMVER, "expected a SemVer version without a leading v"),
   channel: z.enum(RELEASE_CHANNELS),
   digests: z.object({ admin: digest, gateway: digest, ops: digest }),
+  /**
+   * #1025 — the linux/amd64 platform manifest inside each image index of
+   * `digests`. The release images are OCI indexes (buildx adds an
+   * attestation manifest even to a single-platform build), and Cloud Run
+   * records the platform manifest it resolved — not the index a deploy
+   * pinned — in a revision's `spec.containers[0].image` and
+   * `status.imageDigest`. Signing this form too lets an upgrader tell
+   * which release serves without a registry round trip. Absent on
+   * releases from before the field: optional, so manifestVersion stays 1
+   * and older readers ignore it; readers then list the index itself
+   * (content-addressed, so it cannot be forged either).
+   */
+  platformDigests: z.object({ admin: digest, gateway: digest, ops: digest }).optional(),
   minFromVersion: z.string().regex(SEMVER),
   infraContractVersion: z.number().int().positive(),
   migrations: z.object({

package/src/screenshot-capture.ts

@@ -0,0 +1,46 @@
+// SPDX-License-Identifier: MPL-2.0
+
+/**
+ * The operator-browser `screenshot_page` capture (html2canvas in the chat
+ * panel) and the tool handler that receives its result agree on one failure
+ * kind: the capture target exists but has no rendered size.
+ *
+ * Why it needs its own kind: the browser capture renders the preview WITHOUT
+ * the page's scripts (#946 — the frame shares the admin origin, so scripts
+ * must not run with the operator's session). An element a script reveals —
+ * the consent banner is `display:none` until the consent runtime adds a class
+ * to `<html>` — is therefore 0×0 there, html2canvas paints a 0×0 canvas and
+ * `canvas.toBlob` answers null (e2e-livedit 2026-10, "canvas.toBlob returned
+ * null" on `[data-consent-banner]`). That is a limit of this backend, not of
+ * the page: the server-side renderer runs real Chromium with scripts and can
+ * capture the element, so the handler routes such a failure there.
+ */
+
+/** Prefix of a browser-capture failure whose target has no rendered size. */
+export const SCREENSHOT_TARGET_NOT_RENDERED = "capture target is not rendered";
+
+/** A rendered box, as `getBoundingClientRect()` / a canvas reports it. */
+export interface ScreenshotBox {
+  readonly width: number;
+  readonly height: number;
+}
+
+/**
+ * The failure message when the capture target (or the canvas painted from
+ * it) has no area, else null.
+ *
+ * @param target - what is being captured: the selector, or "page body".
+ */
+export function screenshotTargetNotRendered(target: string, box: ScreenshotBox): string | null {
+  if (box.width > 0 && box.height > 0) return null;
+  return (
+    `${SCREENSHOT_TARGET_NOT_RENDERED}: ${target} is ${Math.round(box.width)}×${Math.round(box.height)}px ` +
+    "in the operator-browser capture, which runs without the page's scripts — an element a script " +
+    "reveals (display:none until then) has no size there"
+  );
+}
+
+/** True when a browser-capture failure message is the not-rendered kind. */
+export function isScreenshotTargetNotRendered(message: string): boolean {
+  return message.includes(SCREENSHOT_TARGET_NOT_RENDERED);
+}

package/src/seo.test.ts

@@ -199,6 +199,15 @@ describe("injectSeoIntoHead", () => {
     const out = injectSeoIntoHead(html, headBlock);
     expect(out).toContain(headBlock);
   });
+
+  it("matches uppercase </HEAD> and preserves <svg><title> inside <body>", () => {
+    const html =
+      "<html><HEAD><title>LayoutTitle</title></HEAD><body><svg><title>IconTitle</title></svg></body></html>";
+    const out = injectSeoIntoHead(html, "<title>PageTitle</title>");
+    expect(out).not.toContain("LayoutTitle");
+    expect(out).toContain("<title>PageTitle</title>\n</HEAD>");
+    expect(out).toContain("<svg><title>IconTitle</title></svg>");
+  });
 });
 
 describe("schemas", () => {

package/src/seo.ts

@@ -340,12 +340,16 @@ export function renderSeoHead(input: SeoMetaInput): string {
  * the layout HTML.
  */
 export function injectSeoIntoHead(html: string, headBlock: string): string {
-  // Strip a layout-supplied <title> if present; we'll re-emit it in
-  // the headBlock at the right position.
-  const titleStripped = html.replace(/<title\b[^>]*>[\s\S]*?<\/title>/i, "");
-  if (titleStripped.includes("</head>")) {
-    return titleStripped.replace("</head>", () => `${headBlock}\n</head>`);
+  const headCloseMatch = /<\/head\s*>/i.exec(html);
+  if (headCloseMatch) {
+    const headEnd = headCloseMatch.index;
+    // Strip a layout-supplied <title> inside <head> only (never an SVG
+    // <title> in <body>); we re-emit the page title in headBlock.
+    const beforeClose = html.slice(0, headEnd).replace(/<title\b[^>]*>[\s\S]*?<\/title>/i, "");
+    const afterClose = html.slice(headEnd);
+    return `${beforeClose}${headBlock}\n${afterClose}`;
   }
   // No closing head tag — prepend the block to the document.
+  const titleStripped = html.replace(/<title\b[^>]*>[\s\S]*?<\/title>/i, "");
   return `${headBlock}\n${titleStripped}`;
 }

package/src/theme-importers/__tests__/proto-pollution.test.ts

@@ -9,7 +9,7 @@
 
 import { describe, expect, it } from "bun:test";
 import { isUnsafeKey } from "../../safe-keys.js";
-import { applyDtcgWrites } from "../../themes.js";
+import { applyDtcgWrites, removeDtcgPath } from "../../themes.js";
 import { importTailwind } from "../tailwind.js";
 
 describe("isUnsafeKey", () => {
@@ -51,4 +51,12 @@ describe("applyDtcgWrites / setLeafAtPath path guard (S5)", () => {
     const out = applyDtcgWrites({}, { "color.primary": "#fff" }, { "color.primary": "color" });
     expect(JSON.stringify(out)).toContain("primary");
   });
+
+  it("removeDtcgPath rejects __proto__/constructor/prototype and inherited keys", () => {
+    const doc = applyDtcgWrites({}, { "color.primary": "#fff" }, { "color.primary": "color" });
+    expect(removeDtcgPath(doc, "__proto__.toString").removed).toBe(false);
+    expect(removeDtcgPath(doc, "color.toString").removed).toBe(false);
+    expect(removeDtcgPath(doc, "constructor.prototype").removed).toBe(false);
+    expect(removeDtcgPath(doc, "color.primary").removed).toBe(true);
+  });
 });

package/src/theme-literal-binding.test.ts

@@ -62,9 +62,29 @@ describe("applyThemeLiteralBinding", () => {
     expect(r.suggestions).toEqual([{ literal: "6rem", varName: "--spacing-xl" }]);
   });
 
+  it("leaves a var() fallback literal as written (e2e-livedit: edit_content anchors missed)", () => {
+    // The AI authors `var(--x, #literal)`; rebinding the fallback stored
+    // CSS it never wrote and its next edit_content anchor did not match.
+    const css =
+      ".f{border-top:1px solid var(--color-foreground, #0f172a);background:var(--color-surface, #4f46e5);color:var( --color-x ,#0F172A)}";
+    const r = applyThemeLiteralBinding(css, TOKENS);
+    expect(r.css).toBe(css);
+    expect(r.rewrites).toEqual([]);
+  });
+
+  it("still binds a bare literal next to a var() reference", () => {
+    const r = applyThemeLiteralBinding(
+      ".f{color:var(--color-foreground);background:#4f46e5}",
+      TOKENS,
+    );
+    expect(r.css).toBe(".f{color:var(--color-foreground);background:var(--color-primary)}");
+  });
+
   it("formats a report and stays silent on no-ops", () => {
     const bound = applyThemeLiteralBinding(".a{color:#0F172A}", TOKENS);
     expect(formatBindingReport(bound)).toContain("#0F172A→var(--color-foreground)");
+    // The AI must know the stored css differs from what it sent.
+    expect(formatBindingReport(bound)).toContain("anchor later edit_content calls");
     const noop = applyThemeLiteralBinding(".a{color:#123456}", TOKENS);
     expect(formatBindingReport(noop)).toBeNull();
   });

package/src/theme-literal-binding.ts

@@ -26,6 +26,9 @@ import type { ThemeDocument } from "./themes.js";
 
 const COLOR_LITERAL_RE = /#[0-9a-fA-F]{3,8}\b|(?:oklch|rgba?|hsla?|lab|lch|hwb)\([^()]*\)/g;
 const DIMENSION_VALUE_RE = /^-?\d+(\.\d+)?(rem|em|px|%)$/;
+/** The text before a literal ends in an open `var(--name,` — the literal is
+ *  (the start of) that var's fallback. */
+const VAR_FALLBACK_BEFORE_RE = /var\(\s*--[\w-]+\s*,[^()]*$/i;
 
 export interface ThemeValueMap {
   /** normalized color value → var name (first-declared wins). */
@@ -107,11 +110,18 @@ export function applyThemeLiteralBinding(css: string, tokens: ThemeDocument): Li
   });
 
   out = out.replace(COLOR_LITERAL_RE, (literal, offset: number) => {
-    // Never rewrite inside an already-produced var(...) fallback or a
-    // remaining gradient (a gradient that did NOT match stays literal
-    // by decision — rebinding its stops would half-tokenise it).
+    // Never rewrite inside a remaining gradient (a gradient that did NOT
+    // match stays literal by decision — rebinding its stops would
+    // half-tokenise it) or a var() fallback. The author already referenced
+    // a var there; rebinding its fallback produced
+    // `var(--color-border, var(--color-border))` and
+    // `var(--color-surface, var(--color-primary-foreground))` — CSS the AI
+    // never wrote, so its next edit_content anchored on its own copy
+    // missed (5 "oldString not found" in e2e-livedit, 2026-10). An unknown
+    // var name in front of the fallback is reported by the unknown-var check.
     const before = out.slice(Math.max(0, offset - 64), offset);
     if (/gradient\([^()]*$/i.test(before)) return literal;
+    if (VAR_FALLBACK_BEFORE_RE.test(before)) return literal;
     const varName = map.colors.get(normalizeColor(literal));
     if (varName === undefined) return literal;
     const entry = counts.get(literal) ?? { to: varName, count: 0 };
@@ -145,7 +155,9 @@ export function formatBindingReport(result: LiteralBindingResult): string | null
     parts.push(
       `🔗 bound ${total} literal(s) to theme vars: ${result.rewrites
         .map((r) => `${r.from}→var(${r.to})${r.count > 1 ? `×${r.count}` : ""}`)
-        .join(", ")}`,
+        .join(
+          ", ",
+        )} — the STORED css has var(…) in place of those literals, so anchor later edit_content calls on that text, not on the css you sent`,
     );
   }
   if (result.suggestions.length > 0) {

package/src/theme-render-sanitize.test.ts

@@ -82,4 +82,13 @@ describe("renderThemeCss CSS-token sanitization (S6)", () => {
     } as unknown as ThemeDocument;
     expect(renderThemeCss(doc)).toContain("--color-grün:#0a0;");
   });
+
+  it("scrubs CSS declaration/block delimiters (; { }) from fontFamily and shadow strings", () => {
+    const css = renderThemeCss(
+      fontDoc("Inter; } body { background: url(https://evil.example/x) } :root { --x: 1"),
+    );
+    expect(css).toBe(
+      ":root{--font-body:Inter  body  background: url(https://evil.example/x)  :root  --x: 1;}",
+    );
+  });
 });

package/src/theme-render.ts

@@ -549,7 +549,8 @@ function sanitizeCssTokenValue(value: string): string {
     out = out
       .replace(/<\/style/gi, "")
       .replace(/<!--/g, "")
-      .replace(/--!?>/g, "");
+      .replace(/--!?>/g, "")
+      .replace(/[;{}]/g, "");
   } while (out !== prev);
   return out;
 }

package/src/themes.ts

@@ -882,19 +882,21 @@ export function removeDtcgPath(
   doc: ThemeDocument,
   path: string,
 ): { tokens: ThemeDocument; removed: boolean } {
-  const out: ThemeDocument = JSON.parse(JSON.stringify(doc));
   const parts = path.split(".");
+  if (parts.some(isUnsafeKey)) return { tokens: doc, removed: false };
+  const out: ThemeDocument = JSON.parse(JSON.stringify(doc));
   let cur: Record<string, unknown> = out;
   for (let i = 0; i < parts.length - 1; i++) {
     const k = parts[i];
     if (!k) continue;
+    if (!Object.hasOwn(cur, k)) return { tokens: doc, removed: false };
     const next = cur[k];
     if (!next || typeof next !== "object") return { tokens: doc, removed: false };
     cur = next as Record<string, unknown>;
   }
   const last = parts[parts.length - 1];
   if (!last) return { tokens: doc, removed: false };
-  if (!(last in cur)) return { tokens: doc, removed: false };
+  if (!Object.hasOwn(cur, last)) return { tokens: doc, removed: false };
   delete cur[last];
   return { tokens: out, removed: true };
 }

package/src/version.ts

@@ -22,7 +22,7 @@
  * follow standard SemVer.
  */
 
-export const CAELO_VERSION = "0.10.64";
+export const CAELO_VERSION = "0.10.66";
 
 /**
  * Deprecated alias for back-compat — early P17 work spelled this