@caelo-cms/shared 0.11.3 → 0.11.4

package/src/lists/resolve.ts

@@ -24,6 +24,7 @@
 
 import type { LinkResolver } from "../link-refs.js";
 import { parseLinkRef } from "../link-refs.js";
+import type { PageUrlStyle } from "../seo.js";
 import { SITE_TEXTS_LIST_TYPE } from "./default-types.js";
 import { type FieldDef, TERM_REF_RE, validateFieldValue } from "./fields.js";
 import type { ListItem } from "./items.js";
@@ -38,6 +39,16 @@ import {
   type SourceDef,
   type SystemSourceName,
 } from "./list-type.js";
+import {
+  type EffectivePagination,
+  effectivePagination,
+  type ListPaginationSettings,
+  listPaginationSchema,
+  type PaginationFollowUps,
+  pageCountOf,
+  pagedUrl,
+  splitPaginationValue,
+} from "./pagination.js";
 import { parseListRef } from "./refs.js";
 import type {
   ListPageRecord,
@@ -71,6 +82,9 @@ const LIST_MARKER_PREFIXES = [
   "list-source-unavailable:",
   "list-malformed:",
   "list-context-unavailable:",
+  // #1257 — a second paginated list on one page; a paginated page without a pager.
+  "list-pagination-conflict:",
+  "list-pager-missing:",
 ] as const;
 
 /** True for a list failure marker — the editor's missing-content surface shows these. */
@@ -86,6 +100,8 @@ export interface ListFieldSpec {
   readonly list?: string;
   readonly source?: SourceDef;
   readonly default?: unknown;
+  /** #1257 — the field lists every match across follow-up pages. */
+  readonly paginate?: ListPaginationSettings;
 }
 
 /** Result of resolving one list field for one page. */
@@ -116,6 +132,66 @@ export interface ListPageOptions {
   readonly linkResolver?: LinkResolver;
   /** Entries of every ACTIVE plugin list source for this page, keyed by source name. */
   readonly pluginSources?: Readonly<Record<string, readonly PluginSourceEntry[]>>;
+  /**
+   * #1257 — the target's URL style, for the pager's links to follow-up
+   * pages. Without it a rendered `pagination` source is
+   * `list-context-unavailable:pagination`.
+   */
+  readonly pageUrlStyle?: PageUrlStyle;
+  /**
+   * #1257 — which page of the paginated list this render is (1 = the
+   * page's own URL; default 1), and — once a first render found it —
+   * how many pages there are, so a pager rendered BEFORE the list knows.
+   */
+  readonly pagination?: { readonly page: number; readonly pageCount?: number };
+}
+
+/**
+ * #1257 — the page's paginated list as one render saw it
+ * ({@link ListPageContext.pagination}).
+ */
+export interface ListPaginationState {
+  /** The paginated module field. */
+  readonly field: string;
+  readonly perPage: number;
+  /** Every match of the query. */
+  readonly total: number;
+  readonly pageCount: number;
+  /** The page this render showed. */
+  readonly page: number;
+  readonly followUps: PaginationFollowUps;
+  /** A `pagination` source rendered on this page. */
+  readonly pagerShown: boolean;
+  /**
+   * The pager rendered before the list was resolved, so it did not know
+   * the page count yet: render the page again with
+   * `pagination: { page, pageCount }`.
+   */
+  readonly pagerEarly: boolean;
+}
+
+/**
+ * #1257 — a list cut at its limit: more pages match than it shows. Never
+ * silent: the Stage result and `preview_list_source` report it.
+ */
+export interface TruncatedList {
+  /** The module field (or source node's field) that rendered the list. */
+  readonly field: string;
+  readonly shown: number;
+  readonly total: number;
+  /** The limit that cut it (the query's `limit`; 50 for term_pages). */
+  readonly limit: number;
+}
+
+/**
+ * The markers a finished render's pagination asks for: a paginated page
+ * that shows no pager strands every entry after the first page
+ * (`list-pager-missing:<field>`). Exported so the preview and the
+ * generator apply one rule.
+ */
+export function paginationMarkers(state: ListPaginationState | null): string[] {
+  if (state === null || state.pageCount <= 1 || state.pagerShown) return [];
+  return [`list-pager-missing:${state.field}`];
 }
 
 /** The list view of ONE rendering page, handed to the template engine. */
@@ -149,6 +225,10 @@ export interface ListPageContext {
   deps(): ListRenderDeps;
   /** Overlay values this page's render refused (also the render-wide ones). */
   overlayIssues(): readonly ListOverlayIssue[];
+  /** #1257 — the paginated list this render resolved, or null. */
+  pagination(): ListPaginationState | null;
+  /** #1257 — lists this render cut at their limit (not paginated). */
+  truncatedLists(): readonly TruncatedList[];
 }
 
 /** Render-wide options of {@link createListRenderContext}. */
@@ -435,6 +515,14 @@ function createPageContext(
   let depTree = false;
   const depPages = new Set<string>();
   let trail: readonly string[] | null = null;
+  // #1257 — pagination and cut lists of this render.
+  const requestedPage = opts.pagination?.page ?? 1;
+  let paged:
+    | (Omit<ListPaginationState, "pagerShown" | "pagerEarly" | "page"> & { readonly key: string })
+    | null = null;
+  let pagerShown = false;
+  let pagerEarly = false;
+  const truncated = new Map<string, TruncatedList>();
   /** Entries of a page-shaped system source: their pages become deps. */
   const readPages = (pages: ListPageRecord[]): ListPageRecord[] => {
     for (const pg of pages) depPages.add(pg.id);
@@ -790,7 +878,8 @@ function createPageContext(
   const sameVariant = (p: ListPageRecord): boolean =>
     variant === null || data.pageVariants?.get(p.id)?.variant === variant;
 
-  const runQuery = (q: PageQuery): ScopeValue => {
+  /** Every page a query matches, in its order (deps recorded). */
+  const queryHits = (q: PageQuery): ListPageRecord[] => {
     const parent = q.parent
       ? ((parseLinkRef(q.parent) as { pageId: string } | null)?.pageId ?? null)
       : null;
@@ -814,7 +903,108 @@ function createPageContext(
             : terms.some((t) => p.terms.includes(t)))),
     );
     hits.sort(pageOrder(q.order, s.collator));
-    return listValue(pageEntries(hits.slice(0, q.limit)));
+    return hits;
+  };
+
+  /** The first `limit` hits; a cut is recorded, never silent (#1257). */
+  const cutAt = (hits: readonly ListPageRecord[], limit: number, field: string): ScopeValue => {
+    if (hits.length > limit) {
+      const key = `${field}:${limit}:${hits.length}`;
+      if (!truncated.has(key))
+        truncated.set(key, { field, shown: limit, total: hits.length, limit });
+    }
+    return listValue(pageEntries(hits.slice(0, limit)));
+  };
+
+  const runQuery = (q: PageQuery, field: string): ScopeValue => cutAt(queryHits(q), q.limit, field);
+
+  /**
+   * The slice of a paginated list this render shows. One paginated list
+   * per page: a second one (another query or page size) is refused.
+   */
+  const paginate = (
+    field: string,
+    key: string,
+    hits: readonly ListPageRecord[],
+    eff: EffectivePagination,
+  ): ScopeValue => {
+    const fullKey = JSON.stringify([key, eff.perPage, eff.followUps]);
+    if (paged !== null && paged.key !== fullKey) {
+      return { kind: "failed", marker: `list-pagination-conflict:${field}` };
+    }
+    paged = {
+      key: fullKey,
+      field,
+      perPage: eff.perPage,
+      total: hits.length,
+      pageCount: pageCountOf(hits.length, eff.perPage),
+      followUps: eff.followUps,
+    };
+    const from = (requestedPage - 1) * eff.perPage;
+    return listValue(pageEntries(hits.slice(from, from + eff.perPage)));
+  };
+
+  /** Hits of the term_pages source for `terms` (deps recorded). */
+  const termPageHits = (terms: readonly string[]): ListPageRecord[] => {
+    depTree = true;
+    if (terms.length === 0) return [];
+    const sorted = [...terms].sort();
+    const key = JSON.stringify([null, sorted, null]);
+    if (!depQueries.has(key)) depQueries.set(key, { pageType: null, terms: sorted, parent: null });
+    return s.pageList
+      .filter(
+        (p) =>
+          p.inBuild && sameVariant(p) && p.id !== pageId && terms.some((t) => p.terms.includes(t)),
+      )
+      .sort(byTitle);
+  };
+
+  /**
+   * The `pagination` source: one entry per page of the page's paginated
+   * list (`number`, `link`, `is_current`, `is_prev`, `is_next`); empty
+   * while everything fits on one page.
+   */
+  const pagerEntries = (): ScopeValue => {
+    pagerShown = true;
+    const known = opts.pagination?.pageCount ?? paged?.pageCount;
+    if (known === undefined) {
+      // The list renders later on this page: the caller renders again
+      // with the page count (ListPaginationState.pagerEarly).
+      pagerEarly = true;
+      return EMPTY_LIST;
+    }
+    if (known <= 1) return EMPTY_LIST;
+    const self = pageId === null ? null : parseLinkRef(`caelo:page/${pageId}`);
+    const r = self !== null && resolver ? resolver.resolve(self) : null;
+    const style = opts.pageUrlStyle;
+    if (
+      r === null ||
+      style === undefined ||
+      (r.status !== "resolved" && r.status !== "unpublished")
+    ) {
+      return { kind: "failed", marker: "list-context-unavailable:pagination" };
+    }
+    const entries: ScopeEntry[] = [];
+    for (let n = 1; n <= known; n += 1) {
+      const href = n === 1 ? r.url : pagedUrl(r.url, n, style);
+      const pos = { index: n - 1, count: known, depth: 1 };
+      const values: Record<string, ScopeValue> = {
+        number: text(String(n)),
+        link: linkValue({ href }, null),
+        is_current: bool(n === requestedPage),
+        is_prev: bool(n === requestedPage - 1),
+        is_next: bool(n === requestedPage + 1),
+        is_ancestor: bool(false),
+      };
+      entries.push({
+        id: `page-${n}`,
+        itemAttr: null,
+        childrenKey: null,
+        depth: 1,
+        get: (key) => values[key] ?? positionValue(key, pos),
+      });
+    }
+    return listValue(entries);
   };
 
   const byTitle = (a: ListPageRecord, b: ListPageRecord): number =>
@@ -877,24 +1067,10 @@ function createPageContext(
           field,
         );
       }
-      case "term_pages": {
-        depTree = true;
-        if (terms.length === 0) return EMPTY_LIST;
-        const sorted = [...terms].sort();
-        const key = JSON.stringify([null, sorted, null]);
-        if (!depQueries.has(key))
-          depQueries.set(key, { pageType: null, terms: sorted, parent: null });
-        const hits = s.pageList
-          .filter(
-            (p) =>
-              p.inBuild &&
-              sameVariant(p) &&
-              p.id !== pageId &&
-              terms.some((t) => p.terms.includes(t)),
-          )
-          .sort(byTitle);
-        return listValue(pageEntries(hits.slice(0, LIST_QUERY_MAX_LIMIT)));
-      }
+      case "term_pages":
+        return cutAt(termPageHits(terms), LIST_QUERY_MAX_LIMIT, field);
+      case "pagination":
+        return pagerEntries();
     }
   };
 
@@ -955,7 +1131,7 @@ function createPageContext(
     switch (source.kind) {
       case "query": {
         const q = mergedQuery(source, item.query, field, `${item.id}.query`);
-        return "marker" in q ? { kind: "failed", marker: q.marker } : runQuery(q);
+        return "marker" in q ? { kind: "failed", marker: q.marker } : runQuery(q, field);
       }
       case "system": {
         const termFields = node.fields.filter((f) => f.type === "term");
@@ -980,19 +1156,61 @@ function createPageContext(
       ? { ok: false, marker: v.marker }
       : { ok: true, entries: v.kind === "list" ? v.entries : [] };
 
+  /**
+   * A paginated source field (#1257): a query, or the term_pages system
+   * source. The page size replaces the query's `limit`; the placement
+   * value may carry `paginate` overrides next to its knobs.
+   */
+  const resolvePaginated = (
+    field: ListFieldSpec,
+    settings: ListPaginationSettings,
+    value: unknown,
+  ): ListFieldResolution => {
+    const { paginate: overrides, rest } = splitPaginationValue(value);
+    const valid = listPaginationSchema.safeParse(settings);
+    const eff = valid.success ? effectivePagination(valid.data, overrides) : null;
+    if (eff === null) return { ok: false, marker: `list-malformed:${field.name}[paginate]` };
+    const source = field.source;
+    if (source?.kind === "query") {
+      const q = mergedQuery(
+        { ...source, defaults: { ...source.defaults, limit: eff.perPage } },
+        rest,
+        field.name,
+        "query",
+      );
+      if ("marker" in q) return { ok: false, marker: q.marker };
+      const key = JSON.stringify(["query", { ...q, limit: null }]);
+      return fromValue(paginate(field.name, key, queryHits(q), eff));
+    }
+    if (source?.kind === "system" && source.name === "term_pages") {
+      const terms = (rest as { terms?: unknown } | undefined)?.terms;
+      const list = Array.isArray(terms)
+        ? terms.filter((t): t is string => typeof t === "string")
+        : [];
+      const key = JSON.stringify(["term_pages", [...list].sort()]);
+      return fromValue(paginate(field.name, key, termPageHits(list), eff));
+    }
+    return { ok: false, marker: `list-malformed:${field.name}[paginate]` };
+  };
+
   const resolveField = (
     field: ListFieldSpec,
     value: unknown,
     holder: ListHolder,
   ): ListFieldResolution => {
     const bind = field.bind ?? "local";
+    if (bind === "source" && field.paginate !== undefined) {
+      return resolvePaginated(field, field.paginate, value);
+    }
     if (bind === "source") {
       const source = field.source;
       if (!source) return { ok: false, marker: `list-malformed:${field.name}[source]` };
       switch (source.kind) {
         case "query": {
           const q = mergedQuery(source, value, field.name, "query");
-          return "marker" in q ? { ok: false, marker: q.marker } : fromValue(runQuery(q));
+          return "marker" in q
+            ? { ok: false, marker: q.marker }
+            : fromValue(runQuery(q, field.name));
         }
         case "system": {
           const overrides = (value ?? {}) as { terms?: unknown };
@@ -1163,6 +1381,20 @@ function createPageContext(
       pages: [...depPages].sort(),
     }),
     overlayIssues: () => [...renderIssues, ...pageIssues],
+    pagination: () =>
+      paged === null
+        ? null
+        : {
+            field: paged.field,
+            perPage: paged.perPage,
+            total: paged.total,
+            pageCount: paged.pageCount,
+            page: requestedPage,
+            followUps: paged.followUps,
+            pagerShown,
+            pagerEarly,
+          },
+    truncatedLists: () => [...truncated.values()],
   };
 }
 

package/src/live-events.ts

@@ -92,6 +92,9 @@ const EXACT: Readonly<Record<string, readonly LiveTopic[]>> = {
   "quality_audits.ack_chat_notification": ["quality"],
   "quality_audits.release_chat_notification": ["quality"],
   "quality_audits.publish_anyway": ["quality"],
+  // #1225 — an approved quality decision's claim and record steps.
+  "quality_audits.begin_execute_proposal": ["pending", "quality"],
+  "quality_audits.end_execute_proposal": ["pending", "quality"],
   "imports.create_run": ["crawl"],
   "imports.update_run_status": ["crawl"],
   "imports.write_extracted_pages": ["crawl"],
@@ -100,11 +103,19 @@ const EXACT: Readonly<Record<string, readonly LiveTopic[]>> = {
   "deploy.start_trigger": ["deploys"],
   "deploy.fail_run": ["deploys"],
   "deploy.finish_trigger": ["deploys"],
-  "deploy.begin_run": ["deploys"],
   "deploy.update_progress": ["deploys"],
   "deploy.promote": ["deploys"],
+  // #1225 — Publish live's steps, and an approved card's claim and record.
+  "deploy.start_promote": ["deploys"],
+  "deploy.finish_promote": ["deploys"],
+  "deploy.begin_execute_proposal": ["pending", "deploys"],
+  "deploy.end_execute_proposal": ["pending", "deploys"],
   "deploy.rollback": ["deploys"],
+  "deploy.release_rollback": ["deploys"],
   "deploy.build_plugin_data": ["deploys"],
+  // #1220 — the plugin-data build's steps that start and record a run.
+  "deploy.begin_plugin_data_run": ["deploys"],
+  "deploy.finish_plugin_data_run": ["deploys"],
 };
 
 /**

package/src/markup-structure.test.ts

@@ -113,6 +113,33 @@ describe("templates and free regions", () => {
     expect(performance.now() - started).toBeLessThan(500);
   });
 
+  it("stripMustache markSections keeps sections between elements as markers (#1256)", () => {
+    const t =
+      '<ul class="x {{#on}}on{{/on}}">{{#links}}<li><a href="{{link}}">{{label}}</a></li>{{/links}}{{^links}}<p>none</p>{{/links}}</ul>';
+    expect(stripMustache(t, { markSections: true })).toBe(
+      '<ul class="x "><caelo-section class="s:links"><li><a href="\u001f"><caelo-partial class="v:label"></caelo-partial></a></li></caelo-section><caelo-section class="i:links"><p>none</p></caelo-section></ul>',
+    );
+    // Default output is unchanged.
+    expect(stripMustache(t)).toBe('<ul class="x "><li><a href=""></a></li><p>none</p></ul>');
+    expect(
+      stripMustache("<ul>{{ #links }}<li></li>{{ /links }}</ul>", { markSections: true }),
+    ).toBe('<ul><caelo-section class="s:links"><li></li></caelo-section></ul>');
+    expect(
+      stripMustache('<a class="card card--{{type}}" href="{{link}}">{{title}}</a>', {
+        markSections: true,
+      }),
+    ).toBe(
+      '<a class="card card--\u001f" href="\u001f"><caelo-partial class="v:title"></caelo-partial></a>',
+    );
+    expect(
+      stripMustache("<div>{{#g}}{{> props.teaser }}{{/g}}</div>", { markSections: true }),
+    ).toBe(
+      '<div><caelo-section class="s:g"><caelo-partial class="p:props.teaser"></caelo-partial></caelo-section></div>',
+    );
+    stripMustache(`{{#${" ".repeat(50_000)}`, { markSections: true });
+    stripMustache(`<a ${"{{".repeat(50_000)}`, { markSections: true });
+  });
+
   it("stripMustache keeps the markup a template renders", () => {
     expect(stripMustache("<p>{{a}}{{{b}}}</p>{{#s}}<i></i>{{/s}}{{>n}}")).toBe("<p></p><i></i>");
   });

package/src/markup-structure.ts

@@ -128,8 +128,36 @@ export interface StripMustacheOptions {
    * such a section is dropped, leaving the classes it ALWAYS renders.
    */
   readonly keepOptionalAttributeText?: boolean;
+  /**
+   * Issue #1256 — keep every section between elements as a marker element
+   * instead of dropping its tags: `{{#f}}…{{/f}}` becomes
+   * `<caelo-section class="s:f">…</caelo-section>`, an inverted
+   * `{{^f}}` the class `i:f`. The structure check reads from them which
+   * links a template renders per list entry. Ignored with
+   * `keepOptionalAttributeText` (in-tag sections must be dropped first).
+   */
+  readonly markSections?: boolean;
 }
 
+/** The marker element {@link stripMustache} `markSections` emits. */
+export const SECTION_MARKER_TAG = "caelo-section";
+
+/**
+ * The empty element `markSections` leaves where a placeholder between
+ * elements renders: a partial's nested module (`{{>teaser}}` →
+ * `<caelo-partial class="p:teaser">`) or a value that may hold markup
+ * (`{{body}}` → `class="v:body"`), so a reader knows which section the
+ * rendered content sits in.
+ */
+export const PARTIAL_MARKER_TAG = "caelo-partial";
+
+/**
+ * What a placeholder inside a tag becomes with `markSections`
+ * (`class="card card--{{type}}"` → `card--\u001f`): a class token holding
+ * it matches any rendered token with the same text around it.
+ */
+export const PLACEHOLDER_MARK = "\u001f";
+
 /**
  * Remove Mustache tags (`{{x}}`, `{{{x}}}`, `{{#s}}`, `{{/s}}`, `{{>p}}`)
  * from a module template so it parses as the markup it renders: a section
@@ -146,7 +174,74 @@ export interface StripMustacheOptions {
  */
 export function stripMustache(template: string, opts: StripMustacheOptions = {}): string {
   const base = opts.keepOptionalAttributeText ? template : dropInTagSections(template);
-  return stripDelimited(stripDelimited(base, 3), 2);
+  const marked =
+    opts.markSections && !opts.keepOptionalAttributeText
+      ? markSections(markTagPlaceholders(base))
+      : base;
+  return stripDelimited(stripDelimited(marked, 3), 2);
+}
+
+/**
+ * Replace every placeholder inside a tag (`{{x}}`, `{{{x}}}`) with
+ * {@link PLACEHOLDER_MARK}. One linear scan, tags tracked as in
+ * {@link dropInTagSections}; placeholders between elements are left for
+ * the strip.
+ */
+function markTagPlaceholders(text: string): string {
+  let out = "";
+  let i = 0;
+  let inTag = false;
+  let quote: string | null = null;
+  while (i < text.length) {
+    if (text.startsWith("{{", i)) {
+      const end = text.indexOf("}}", i + 2);
+      if (end < 0) break;
+      const close = text.startsWith("}}}", end) ? end + 3 : end + 2;
+      out += inTag ? PLACEHOLDER_MARK : text.slice(i, close);
+      i = close;
+      continue;
+    }
+    const ch = text[i] as string;
+    if (inTag) {
+      if (quote !== null) {
+        if (ch === quote) quote = null;
+      } else if (ch === '"' || ch === "'") {
+        quote = ch;
+      } else if (ch === ">") {
+        inTag = false;
+      }
+    } else if (ch === "<" && /[a-zA-Z]/.test(text[i + 1] ?? "")) {
+      inTag = true;
+      quote = null;
+    }
+    out += ch;
+    i++;
+  }
+  return out + text.slice(i);
+}
+
+/**
+ * Turn the section tags left after {@link dropInTagSections} (all between
+ * elements) into marker elements, and every partial and value placeholder
+ * into an empty {@link PARTIAL_MARKER_TAG}. Whitespace around the sigil and the name
+ * is allowed, as the template engine allows it (`{{ #guides }}`). `[^{}]*`
+ * before the closer keeps the match linear.
+ */
+function markSections(text: string): string {
+  return text.replace(/\{\{([^{}]*)\}\}/g, (tag: string, raw: string) => {
+    const body = raw.trim();
+    const sigil = body[0];
+    const name = body.slice(1).replace(/[\s"<>]/g, "");
+    if (sigil === ">") return `<${PARTIAL_MARKER_TAG} class="p:${name}"></${PARTIAL_MARKER_TAG}>`;
+    if (sigil !== "#" && sigil !== "^" && sigil !== "/") {
+      const value = body.replace(/[\s"<>{}]/g, "");
+      return value === ""
+        ? tag
+        : `<${PARTIAL_MARKER_TAG} class="v:${value}"></${PARTIAL_MARKER_TAG}>`;
+    }
+    if (sigil === "/") return `</${SECTION_MARKER_TAG}>`;
+    return `<${SECTION_MARKER_TAG} class="${sigil === "#" ? "s" : "i"}:${name}">`;
+  });
 }
 
 /**

package/src/media.ts

@@ -243,6 +243,49 @@ export function extractMediaRefs(html: string): MediaRef[] {
   return out;
 }
 
+/**
+ * Issue #1217 — every editor media URL in an HTML string as the browser
+ * will request it (`/_caelo/media/<slug>` or `/_caelo/media/<ref>/<variant>`),
+ * deduped, with the asset reference and variant the admin's media routes
+ * resolve it to. The capture job serves exactly these paths.
+ */
+export function extractMediaUrlPaths(
+  html: string,
+): { readonly path: string; readonly ref: string; readonly variant: string }[] {
+  const out = new Map<string, { path: string; ref: string; variant: string }>();
+  for (const m of html.matchAll(mediaUrlPattern)) {
+    const path = m[0];
+    if (!out.has(path)) out.set(path, { path, ref: m[1] as string, variant: m[2] ?? "orig" });
+  }
+  return [...out.values()];
+}
+
+/** The Content-Type the admin serves a stored media variant with, by its `format`. */
+export function mediaFormatContentType(format: string): string {
+  switch (format) {
+    case "jpeg":
+      return "image/jpeg";
+    case "png":
+      return "image/png";
+    case "webp":
+      return "image/webp";
+    case "avif":
+      return "image/avif";
+    case "gif":
+      return "image/gif";
+    case "svg":
+      return "image/svg+xml";
+    case "ico":
+      return "image/x-icon";
+    case "pdf":
+      return "application/pdf";
+    case "mp4":
+      return "video/mp4";
+    default:
+      return "application/octet-stream";
+  }
+}
+
 const mediaRefPattern =
   /caelo:media\/([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})(?:\/([a-z][a-z0-9-]{0,63}))?/g;
 

package/src/nested-module-render.ts

@@ -397,13 +397,37 @@ function nestedRefForPartial(
   const name = key.slice(0, sep);
   const list = fieldByName.get(name);
   if (list?.kind !== "module-list") return undefined;
-  const raw = Object.hasOwn(values, name) ? values[name] : list.default;
+  const raw = rendersFieldDefault(list, values) ? list.default : values[name];
   if (!Array.isArray(raw)) return undefined;
   const i = Number(index);
   const el = raw[i];
   return isNestedRef(el) ? { ref: el, field: name, step: `${name}[${i}]` } : undefined;
 }
 
+/**
+ * Whether a module rendered with `values` shows `field`'s DEFAULT instead
+ * of a stored value — the renderer's per-kind fallback, shared with the
+ * reach walk so a content instance's blast radius follows it (#627):
+ *
+ *   - `module-list`: the default when the values do not hold the field
+ *     (an explicit `[]` or `null` overrides it);
+ *   - a local `list`: the default when the value is absent or `null`
+ *     (`resolveListField`);
+ *   - `module` and the rest: the stored value only, never the default.
+ *     (A shared list's default names a list, which embeds nothing here.)
+ */
+export function rendersFieldDefault(
+  field: Pick<TemplateField, "name" | "kind" | "bind">,
+  values: Readonly<Record<string, unknown>>,
+): boolean {
+  if (field.kind === "module-list") return !Object.hasOwn(values, field.name);
+  if (field.kind === "list" && (field.bind ?? "local") === "local") {
+    const value = values[field.name];
+    return value === undefined || value === null;
+  }
+  return false;
+}
+
 /** Partial-key prefix of a list entry's embedded module (`template-sections.ts`). */
 const LIST_PARTIAL_PREFIX = "list:";