@caelo-cms/shared 0.10.65 → 0.10.67

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.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;
@@ -384,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
@@ -605,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

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/version.ts

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