@bettercms-ai/convert 0.10.0 → 0.12.0

package/dist/cli.js

@@ -4142,7 +4142,7 @@ function bindImages(ctx, targets) {
 
 // src/helper.ts
 import { createHash as createHash2 } from "crypto";
-var HELPER_VERSION = 6;
+var HELPER_VERSION = 7;
 var HEADER = "// @bettercms-ai/convert helper v";
 var HELPER_PATH = Object.fromEntries(
   Object.keys(DIALECT_RULES).map((d) => [d, DIALECT_RULES[d].helper])
@@ -4335,9 +4335,65 @@ export function bcmsSection(page: unknown, bind?: string, overrides?: unknown):
  * how the codemod ran: one component renders a Phase A placement on one page and a Phase B
  * instance on the next, and a repository does not have to be re-cut when its copy moves.
  */
+/** How a flat field family maps page paths to an instance's override keys. @see bcmsSectionPaths */
+export type BcmsPathMap = {
+  scalars?: Record<string, string>;
+  tables?: Record<string, { key: string; columns: Record<string, string> }>;
+};
+
+/**
+ * The snapshot for a section whose page fields are a FLAT family (\`wrap-h2-latest\`, not \`wrap.h2_latest\`).
+ *
+ * \`bcmsSection\` returns a group object read through a dotted path, which a flat family does not have: its
+ * copy lives in top-level keys of the page snapshot. So this answers in the page's own spelling \u2014 the
+ * markup reads \`bcms(snapshot, "wrap-h2-latest", \u2026)\` verbatim \u2014 with every mapped path set explicitly:
+ *
+ * - the instance's override for that key when it holds one (a table's rows re-spelled with the page's
+ *   column names, \`{ rows }\` unwrapped as in \`bcmsSection\`);
+ * - else, for a placement bound to a group, the page value at the path re-based onto that group;
+ * - else NOTHING \u2014 a placement that owns its copy never falls back to the page's stale copy, exactly as
+ *   \`bcmsSection\` synthesizes no group for it.
+ *
+ * Every other page key passes through, so reads outside the family (a shared link) keep working.
+ */
+export function bcmsSectionPaths(
+  page: unknown,
+  bind: string | undefined,
+  overrides: unknown,
+  prefix: string,
+  map: BcmsPathMap,
+): Record<string, unknown> {
+  const out: Record<string, unknown> = isRecord(page) ? { ...page } : {};
+  const own = isRecord(overrides) ? overrides : {};
+  const separator = prefix.slice(-1);
+  const fromPage = (path: string): unknown =>
+    bind ? readPath(page, bind + separator + path.slice(prefix.length)) : undefined;
+  for (const [path, key] of Object.entries(map.scalars ?? {})) {
+    const value = own[key];
+    out[path] = value !== undefined && value !== null ? value : fromPage(path);
+  }
+  for (const [path, table] of Object.entries(map.tables ?? {})) {
+    const held = own[table.key];
+    const rows = isRecord(held) && Array.isArray(held.rows) ? held.rows : held;
+    if (!Array.isArray(rows)) {
+      out[path] = fromPage(path);
+      continue;
+    }
+    const pageColumn = new Map(Object.entries(table.columns).map(([column, key]) => [key, column]));
+    out[path] = rows.map((row) => {
+      if (!isRecord(row)) return row;
+      const spelled: Record<string, unknown> = {};
+      for (const [key, value] of Object.entries(row)) spelled[pageColumn.get(key) ?? key] = value;
+      return spelled;
+    });
+  }
+  return out;
+}
+
 export function bcmsFields(
   placement: { blockId?: string; bind?: string; overrides?: unknown },
   pathPrefix: string,
+  map?: BcmsPathMap,
 ): (path: string) => string {
   const id = placement.blockId;
   const own = typeof id === "string" && id !== "" && !placement.bind && isRecord(placement.overrides);
@@ -4350,6 +4406,24 @@ export function bcmsFields(
    * so prepending one would invent an address rather than correct it.
    */
   const lane = own ? \`\${id}__overrides.\` : placement.bind && pathPrefix ? \`\${placement.bind}.\` : null;
+  if (map) {
+    /**
+     * A FLAT family: the address is not "prefix swapped". The instance lane names the override key the
+     * plan allocated (\`h2_latest\`, \`group_webgl[0].a_webgl\`); the bind lane keeps the page's own
+     * separator (\`landing-h2-latest\`, never \`landing.h2-latest\`).
+     */
+    const separator = pathPrefix.slice(-1);
+    return (path: string): string => {
+      if (!path.startsWith(pathPrefix) || !(own || placement.bind)) return path;
+      if (!own) return placement.bind + separator + path.slice(pathPrefix.length);
+      const scalar = map.scalars?.[path];
+      if (scalar !== undefined) return id + "__overrides." + scalar;
+      const row = /^([^[]+)\\[(\\d+)\\]\\.(.+)$/.exec(path);
+      const table = row ? map.tables?.[row[1]] : undefined;
+      const column = row && table ? table.columns[row[3]] : undefined;
+      return table && column !== undefined ? id + "__overrides." + table.key + "[" + row![2] + "]." + column : path;
+    };
+  }
   return (path: string): string => {
     // A path outside the group this section was cut from is not one this placement re-addresses:
     // it names a key the instance does not hold and a group this placement is not bound to.
@@ -4366,21 +4440,24 @@ var HISTORICAL = {
     2: "51e2ae65ddd86bf43d14e29b3865e3f16e45f72069692d1fea57e1f986a894f0",
     3: "d4305b2983adcb456ef782d35ea9d083a04465c2b68baa0d44a084dfa01a9227",
     4: "a5742f64dacb1b26ee6dd5e1469a54871487934c71bc8267df19e3a80e417595",
-    5: "0472fe3ffdcfa49e719c7b9da9cb63b6eba637cc22783bb00c3c2cadd3d800da"
+    5: "0472fe3ffdcfa49e719c7b9da9cb63b6eba637cc22783bb00c3c2cadd3d800da",
+    6: "c907e7245578d947c6541b1ab2c5c6659ea7789a1519e895b4a4aed122c6f649"
   },
   "src/lib/bcms-content.ts": {
     1: "ae72ae14d706943d481c880d70da5789b4816ba1ba319a10fbc63ded4d0b42f2",
     2: "a18731eb42f7db55dac0591c45f873758cde8e103fefcd6e5caf67936ae6a002",
     3: "0be9c73160361882a038552bc02673c14ed532287823dabaafe36179bc55ed7e",
     4: "0146d027a727ecd3c9e3fc336fcf1299b59ddf75b04091c05703f3f983ec28af",
-    5: "c8c93655320fa65664611ba84541f3fa7bfa292cc9a2fd655373440b99049fba"
+    5: "c8c93655320fa65664611ba84541f3fa7bfa292cc9a2fd655373440b99049fba",
+    6: "63f1fa29e47e70c5193b81ee24addb238ba100247124d55bc17713102d587df5"
   },
   "composables/bcms-content.ts": {
     1: "c272412532efed7db64b6cf313b2bed4291f9951430412289c8a588b7f565407",
     2: "51e2ae65ddd86bf43d14e29b3865e3f16e45f72069692d1fea57e1f986a894f0",
     3: "d4305b2983adcb456ef782d35ea9d083a04465c2b68baa0d44a084dfa01a9227",
     4: "a5742f64dacb1b26ee6dd5e1469a54871487934c71bc8267df19e3a80e417595",
-    5: "0472fe3ffdcfa49e719c7b9da9cb63b6eba637cc22783bb00c3c2cadd3d800da"
+    5: "0472fe3ffdcfa49e719c7b9da9cb63b6eba637cc22783bb00c3c2cadd3d800da",
+    6: "c907e7245578d947c6541b1ab2c5c6659ea7789a1519e895b4a4aed122c6f649"
   }
 };
 var sha256 = (value) => createHash2("sha256").update(value, "utf8").digest("hex");
@@ -5235,6 +5312,138 @@ function assertReceipt(receipt) {
   return receipt;
 }
 
+// src/fix.ts
+var MAX_SNIPPET = 160;
+var MAX_WORDS = 12;
+var escapeRegExp2 = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+function findLiteral(content, literal) {
+  const words = literal.split(/\s+/).filter(Boolean).slice(0, MAX_WORDS);
+  if (words.length === 0) return null;
+  const pattern = new RegExp(words.map(escapeRegExp2).join("(?:\\s|<[^>]*>)+"), "u");
+  const match = pattern.exec(content);
+  return match ? { index: match.index, length: match[0].length } : null;
+}
+function placeOf(content, index) {
+  const before = content.slice(0, index);
+  const line = before.split("\n").length;
+  const start = before.lastIndexOf("\n") + 1;
+  const end = content.indexOf("\n", index);
+  return {
+    line,
+    col: index - start + 1,
+    snippet: content.slice(start, end < 0 ? content.length : end).trim().slice(0, MAX_SNIPPET)
+  };
+}
+function fileHead(content) {
+  return { line: 1, snippet: (content ?? "").split("\n", 1)[0].trim().slice(0, MAX_SNIPPET) };
+}
+var isMarkdown = (file) => /\.mdx?$/i.test(file);
+var isDataModule = (file) => /\.(json|ya?ml|[mc]?[jt]s)$/i.test(file) && !/\.d\.ts$/i.test(file);
+function inDataRegion(content, index) {
+  if (content.startsWith("---")) {
+    const close = content.indexOf("\n---", 3);
+    if (close >= 0 && index < close) return true;
+  }
+  for (const match of content.matchAll(/<script\b[^>]*>([\s\S]*?)<\/script>/gi)) {
+    const start = match.index + match[0].indexOf(">") + 1;
+    if (index >= start && index < start + match[1].length) return true;
+  }
+  return false;
+}
+var ELEMENT_ACTIONS = /* @__PURE__ */ new Set([
+  "wrap-span",
+  "declare-attr",
+  "declare-richtext"
+]);
+function actionFor(reason, input, file, inData) {
+  const chosen = reasonAction(reason, input, file, inData);
+  if (inData && ELEMENT_ACTIONS.has(chosen.action)) {
+    return { action: "bind-data", why: "The copy is a row in this file's own data \u2014 bind that field." };
+  }
+  return chosen;
+}
+function reasonAction(reason, input, file, inData) {
+  const richtext = input.kind === "richtext" || input.inline === true;
+  switch (reason) {
+    case "AMBIGUOUS_LITERAL":
+      if (input.routes > 1) {
+        return {
+          action: "manual",
+          why: `${file} renders this value on ${input.routes} routes, so it is shared chrome rather than page copy: promote it to the project Layout (a Layout field is one value for the whole site) and rerun, or give each route its own element.`
+        };
+      }
+      return {
+        action: "declare-attr",
+        why: input.candidates.length > 1 ? `This copy appears in ${input.candidates.join(", ")}; declare the one this route renders.` : "Two paths want this element and nothing says which \u2014 declare the right one by hand."
+      };
+    case "REPEATER_AMBIGUOUS":
+    case "REPEATER_FIXED_LENGTH":
+      return {
+        action: "declare-attr",
+        why: "Declare this row's leaf on the element itself, or rewrite the loop to read the CMS array."
+      };
+    case "IN_EXPRESSION":
+      if (inData) {
+        return { action: "bind-data", why: "The copy is a row in this file's own data \u2014 bind that field." };
+      }
+      return richtext ? { action: "declare-richtext", why: "The container is fed markup \u2014 bind it with the richtext helper." } : { action: "bind-expression", why: "Replace the computed value with the helper's read for this path." };
+    case "DIALECT_UNSUPPORTED":
+      if (isMarkdown(file)) {
+        return {
+          action: "bind-data",
+          why: "This is a content-collection body: bind the element that renders it and make the entry the source."
+        };
+      }
+      return isDataModule(file) ? { action: "bind-data", why: `${file} holds this copy as data \u2014 bind the element that renders it.` } : { action: "manual", why: `No parser here reads ${file}, so the declaration has to be written by hand.` };
+    case "NOT_IN_SOURCE":
+    case "NO_ORIGINAL":
+      return isDataModule(file) || inData ? { action: "bind-data", why: "The template computes this from data \u2014 bind the data field instead of the text." } : {
+        action: "manual",
+        why: "The built page renders this and no source file holds it verbatim; find what formats it."
+      };
+    case "IN_DATA_FILE":
+    case "IMAGE_ASSET_UNRESOLVED":
+      return { action: "bind-data", why: "Bind the data field this value comes from." };
+    case "PROP_TARGET_NOT_FOUND":
+    case "PROP_DRILLED_DEEP":
+      return {
+        action: "wrap-span",
+        why: "The component renders this in a position no attribute reaches \u2014 wrap it in a span of its own."
+      };
+    case "SUBSTRING_ONLY":
+      return { action: "wrap-span", why: "Only part of the element's text is this value \u2014 give it its own span." };
+    case "SUBTREE_NOT_HTML":
+      return { action: "declare-richtext", why: "The value is the element's whole subtree \u2014 bind it as richtext." };
+    default:
+      return { action: "manual", why: `${reason} \u2014 see the receipt's message for what blocked this path.` };
+  }
+}
+function fixFor(row, input) {
+  const file = row.file ?? input.candidates[0] ?? "";
+  const content = input.contents.get(file);
+  const at = content ? findLiteral(content, input.literal) : null;
+  const place = at ? placeOf(content, at.index) : { ...fileHead(content), col: void 0 };
+  const { action, why } = actionFor(row.reason, input, file, at !== null && inDataRegion(content, at.index));
+  return {
+    file,
+    line: row.line ?? place.line,
+    ...place.col !== void 0 ? { col: place.col } : {},
+    snippet: place.snippet,
+    action,
+    ...why ? { why } : {}
+  };
+}
+function routeCounts(pending) {
+  const routes = /* @__PURE__ */ new Map();
+  for (const row of pending) {
+    const id = `${row.scope}|${row.path}`;
+    const held = routes.get(id) ?? /* @__PURE__ */ new Set();
+    held.add(row.route);
+    routes.set(id, held);
+  }
+  return new Map([...routes].map(([id, set]) => [id, set.size]));
+}
+
 // src/sites/html.ts
 import { parse as parseHtml } from "parse5";
 var RAW_TAGS = /* @__PURE__ */ new Set(["script", "style", "noscript", "template"]);
@@ -6351,7 +6560,9 @@ var SKIP_DIRS = [
   ".vercel/",
   ".cache/",
   "coverage/",
-  "vendor/"
+  "vendor/",
+  "__tests__/",
+  "__mocks__/"
 ];
 var SKIP_FILES = ["package-lock.json", "bun.lock", "bun.lockb", "yarn.lock", "pnpm-lock.yaml"];
 var SOURCE_EXTENSIONS = [
@@ -6389,11 +6600,13 @@ var TEMPLATE_DIRS = /* @__PURE__ */ new Set([
   "_includes",
   "_layouts"
 ]);
+var isAboutTheSite = (lower) => /\.(test|spec)\.[^./]+$/.test(lower) || /^[^/]*\.config\.[^./]+$/.test(lower);
 function isSourceCandidate(path) {
   const lower = path.toLowerCase();
   if (SKIP_DIRS.some((dir) => lower === dir.slice(0, -1) || lower.startsWith(dir) || lower.includes(`/${dir}`)))
     return false;
   if (SKIP_FILES.includes(lower.split("/").pop() ?? "")) return false;
+  if (isAboutTheSite(lower)) return false;
   if (/(^|\/)[jt]sconfig\.json$/.test(lower)) return true;
   if (!SOURCE_EXTENSIONS.some((ext) => lower.endsWith(ext))) return false;
   if (!PROSE_EXTENSIONS.some((ext) => lower.endsWith(ext))) return true;
@@ -6869,6 +7082,7 @@ async function componentizeSources(briefIn, planIn, sources, options) {
     return held;
   };
   const fresh = /* @__PURE__ */ new Set();
+  const freshFiles = /* @__PURE__ */ new Map();
   const bindOf = (section) => instanceOwned(section) ? void 0 : section.groupKey;
   const placementOf = (slug, section) => {
     const bind = bindOf(section);
@@ -7196,6 +7410,7 @@ async function componentizeSources(briefIn, planIn, sources, options) {
       }
       extractable.set(resolved.slug, { name: resolved.name, path, kind: "default", imported: null });
       fresh.add(resolved.slug);
+      freshFiles.set(resolved.slug, path);
       addFile(outFiles, contents, {
         path,
         operation: existing === void 0 ? "add" : "modify",
@@ -7281,6 +7496,7 @@ async function componentizeSources(briefIn, planIn, sources, options) {
       sections,
       // What THIS run wrote a file for. A component an earlier run left is reused, not re-reported.
       components: [...fresh].sort(),
+      componentFiles: [...freshFiles].sort(([a], [b]) => a.localeCompare(b)).map(([slug, path]) => ({ slug, path, export: "default" })),
       planPending,
       notes
     }
@@ -7460,7 +7676,7 @@ async function locateSections(sections, briefPaths, sources, treeOf) {
   for (const section of sections) {
     const paths = fieldPaths(section);
     const literals = new Set(
-      briefPaths.filter((p) => (p.scope ?? "page") === "page" && groupOf(p.path) === section.groupKey && p.original).map((p) => flat(stripTags(p.original))).filter(Boolean)
+      briefPaths.filter((p) => (p.scope ?? "page") === "page" && inSection(section, p.path) && p.original).map((p) => flat(stripTags(p.original))).filter(Boolean)
     );
     const hits = /* @__PURE__ */ new Map();
     for (const source of sources) {
@@ -7471,7 +7687,7 @@ async function locateSections(sections, briefPaths, sources, treeOf) {
       const found = /* @__PURE__ */ new Map();
       for (const declaration2 of declarationsIn(parsed.roots, source.content)) {
         if (declaration2.scope !== "page") continue;
-        if (groupOf(declaration2.path) !== section.groupKey) continue;
+        if (!inSection(section, declaration2.path)) continue;
         const placed2 = elements.get(declaration2.at);
         if (placed2) found.set(declaration2.at, placed2);
       }
@@ -7496,6 +7712,12 @@ async function locateSections(sections, briefPaths, sources, treeOf) {
   return { placed, misses };
 }
 var groupOf = (path) => path.split(/[.[]/)[0] ?? "";
+var inSection = (section, path) => {
+  if (groupOf(path) === section.groupKey) return true;
+  const rowless = (value) => value.replace(/\[\d+\]/g, "[]");
+  const target = rowless(path);
+  return fieldPaths(section).some((fieldPath) => rowless(fieldPath) === target);
+};
 var fieldPaths = (section) => (section.fields ?? []).map((field) => field.path ?? `${section.groupKey}.${field.key ?? ""}`);
 function elementIndex(roots) {
   const out = /* @__PURE__ */ new Map();
@@ -7598,6 +7820,9 @@ function componentFile(dialect, path, fromFile, content, parsed, resolved, pathP
     ...addresses.opaque
   ];
   if (unconvertible.length > 0) return { content: "", free: [], duplicates: [], unconvertible };
+  const flat3 = pathPrefix !== "" && !pathPrefix.endsWith(".");
+  const pathMap = flat3 ? flatPathMap(resolved.section, pathPrefix) : null;
+  if (flat3 && !pathMap) return { content: "", free: [], duplicates: [], unconvertible: [`${pathPrefix}* (a repeater leaf without an override address)`] };
   const cut = content.slice(resolved.root.start, resolved.root.end);
   const reserved = /* @__PURE__ */ new Set([...topLevelBindings(dialect, parsed, content), ...referencedNames2(cut)]);
   const introduced = allocateNames(reserved, [
@@ -7616,7 +7841,7 @@ function componentFile(dialect, path, fromFile, content, parsed, resolved, pathP
   const helpers = [
     .../* @__PURE__ */ new Set([
       ...helperNames.map((h) => alias(h.name, h.local)),
-      "bcmsSection",
+      flat3 ? "bcmsSectionPaths" : "bcmsSection",
       ...bound > 0 ? [alias("bcmsFields", fieldsName)] : []
     ])
   ].sort();
@@ -7646,9 +7871,10 @@ function componentFile(dialect, path, fromFile, content, parsed, resolved, pathP
   const key = /^[A-Za-z_$][\w$]*$/.test(groupKey) ? groupKey : JSON.stringify(groupKey);
   const carriedDeclarations = carry.declarations.length > 0 ? `${carry.declarations.join("\n")}
 ` : "";
-  const copy = snapshot ? `const ${snapshot} = { ${key}: bcmsSection(page, bind, overrides) };` : "";
-  const field = bound > 0 ? `const ${fieldName} = ${fieldsName}({ blockId, bind, overrides }, ${JSON.stringify(pathPrefix)});` : "";
+  const copy = !snapshot ? "" : flat3 ? `const ${snapshot} = bcmsSectionPaths(page, bind, overrides, ${JSON.stringify(pathPrefix)}, ${JSON.stringify(pathMap)});` : `const ${snapshot} = { ${key}: bcmsSection(page, bind, overrides) };`;
+  const field = bound > 0 ? `const ${fieldName} = ${fieldsName}({ blockId, bind, overrides }, ${JSON.stringify(pathPrefix)}${flat3 ? `, ${JSON.stringify(pathMap)}` : ""});` : "";
   const declared = [copy, field].filter(Boolean).join("\n");
+  const styles = dialect === "astro" ? carriedStyles(content) : "";
   if (dialect === "astro") {
     return { free: [], duplicates: [], unconvertible: [], content: `---
 ${SECTION_MARKER}
@@ -7668,7 +7894,9 @@ const { blockId, bind, overrides, page } = Astro.props;
 ${carriedDeclarations}${declared}
 ---
 ${markup}
-` };
+${styles ? `
+${styles}
+` : ""}` };
   }
   return { free: [], duplicates: [], unconvertible: [], content: `${SECTION_MARKER}
 ${[...carried, `import { ${helpers.join(", ")} } from "${helperSpecifier}";`, `import type { BcmsSectionProps } from "${relativeImport(path, SECTIONS_LIB).replace(/\.tsx?$/, "")}";`].join("\n")}
@@ -7942,6 +8170,9 @@ import { bcmsFields } from "${helper}";`);
   return { files, refused };
 }
 function propPrefix(section) {
+  return exactPrefix(section) ?? flatPrefix(section);
+}
+function exactPrefix(section) {
   const prefixes = /* @__PURE__ */ new Set();
   for (const field of section.fields ?? []) {
     const { path, key } = field;
@@ -7952,6 +8183,49 @@ function propPrefix(section) {
   if (prefixes.size > 1) return null;
   return prefixes.size === 1 ? [...prefixes][0] : `${section.groupKey}.`;
 }
+var foldKey = (remainder) => remainder.replace(/\[(\d+)\]/g, "_$1").replace(/[^a-zA-Z0-9]+/g, "_").replace(/^_+|_+$/g, "") || "value";
+function flatPrefix(section) {
+  const prefixes = /* @__PURE__ */ new Set();
+  let informative = false;
+  for (const field of section.fields ?? []) {
+    const { path, key } = field;
+    if (typeof path !== "string" || typeof key !== "string") continue;
+    informative = true;
+    const prefix = ["-", "_"].map((sep2) => `${section.groupKey}${sep2}`).find((candidate) => path.startsWith(candidate) && (typeof field.overrideKey === "string" || foldKey(path.slice(candidate.length)) === key));
+    if (!prefix) return null;
+    prefixes.add(prefix);
+  }
+  return informative && prefixes.size === 1 ? [...prefixes][0] : null;
+}
+function flatPathMap(section, prefix) {
+  const scalars = {};
+  const tables = {};
+  for (const field of section.fields ?? []) {
+    const { path, key } = field;
+    if (typeof path !== "string" || typeof key !== "string" || !path.startsWith(prefix)) continue;
+    const row = /^([^[]+)\[\d+\]\.(.+)$/.exec(path);
+    if (!row) {
+      scalars[path] = field.overrideKey ?? key;
+      continue;
+    }
+    const address = typeof field.overrideKey === "string" ? /^([^[]+)\[\d+\]\.(.+)$/.exec(field.overrideKey) : null;
+    if (!address) return null;
+    const table = tables[row[1]] ??= { key: address[1], columns: {} };
+    if (table.key !== address[1]) return null;
+    table.columns[row[2]] = address[2];
+  }
+  return { scalars, tables };
+}
+function carriedStyles(content) {
+  const blocks = [];
+  for (const match of content.matchAll(/<style\b([^>]*)>([\s\S]*?)<\/style>/g)) {
+    const attributes = match[1] ?? "";
+    if (/\bis:global\b|\bdefine:vars\b/.test(attributes)) continue;
+    if (/\blang\s*=/.test(attributes) || /@(import|use|forward)\b/.test(match[2] ?? "")) continue;
+    blocks.push(match[0]);
+  }
+  return blocks.join("\n");
+}
 function referencedNames2(markup) {
   const out = /* @__PURE__ */ new Set();
   for (const [name] of markup.matchAll(/[A-Za-z_$][\w$]*/g)) out.add(name);
@@ -8273,7 +8547,7 @@ var ConvertError = class extends Error {
   code;
 };
 var keyOf = (route, scope, path) => scope === "layout" ? `layout::${path}` : `${route}::page::${path}`;
-var escapeRegExp2 = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+var escapeRegExp3 = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 var identifierFor2 = (slug) => `bcms${slug.replace(/[^A-Za-z0-9]+(.)?/g, (_, c) => c ? c.toUpperCase() : "").replace(/^./, (c) => c.toUpperCase())}`;
 var UNPLACED = /* @__PURE__ */ new Set(["NOT_IN_SOURCE", "IN_EXPRESSION"]);
 async function drillProp(ctx, fromFile, component, prop, kind, hop) {
@@ -8620,6 +8894,33 @@ async function convertSources(briefIn, sources, options) {
     else outFiles.push({ path, operation: "modify", content });
   }
   pending.push(...canvas.pending);
+  for (const file of outFiles) if (file.operation === "modify") latest.set(file.path, file.content);
+  const pageFilesOrTemplate = (route, files) => {
+    const all = [...files];
+    const exact = pageFilesFor(route, all);
+    if (exact.length > 0) return exact;
+    const wanted = route.split("/").filter(Boolean);
+    return all.filter((file) => {
+      if (!isDynamicRoute(file)) return false;
+      const pattern = routeOfFile(file)?.split("/").filter(Boolean);
+      if (!pattern) return false;
+      const rest = pattern.some((segment) => segment.startsWith("[..."));
+      if (rest ? wanted.length < pattern.length : wanted.length !== pattern.length) return false;
+      return pattern.every((segment, i) => segment.startsWith("[") || segment === wanted[i]);
+    }).sort();
+  };
+  const routes = routeCounts(pending);
+  for (const row of pending) {
+    const target = targets.get(keyOf(row.route, row.scope, row.path));
+    row.fix = fixFor(row, {
+      literal: target?.literal ?? "",
+      kind: row.kind,
+      ...target?.inline ? { inline: true } : {},
+      candidates: locatedByKey.get(keyOf(row.route, row.scope, row.path))?.files ?? pageFilesOrTemplate(row.route, latest.keys()),
+      contents: latest,
+      routes: routes.get(`${row.scope}|${row.path}`) ?? 1
+    });
+  }
   const receipt = assertReceipt({
     briefDigest: digest,
     paths: {
@@ -8832,13 +9133,13 @@ async function plan(file, content, dialect, targets, sites, importAt, outcomes,
       for (const target of sharing) outcomes.set(target.key, missing(literal));
       continue;
     }
-    const assigned = sharing.length === 1 ? /* @__PURE__ */ new Map([[sharing[0].key, forLiteral]]) : resolvePositionally(sharing, forLiteral);
-    if (!assigned) {
-      for (const target of sharing) outcomes.set(target.key, "AMBIGUOUS_LITERAL");
-      continue;
-    }
+    const resolved = sharing.length === 1 ? { assigned: /* @__PURE__ */ new Map([[sharing[0].key, forLiteral]]), ambiguous: /* @__PURE__ */ new Set() } : resolvePositionally(sharing, forLiteral);
     for (const target of sharing) {
-      const mine = assigned.get(target.key) ?? [];
+      if (resolved.ambiguous.has(target.key)) {
+        outcomes.set(target.key, "AMBIGUOUS_LITERAL");
+        continue;
+      }
+      const mine = resolved.assigned.get(target.key) ?? [];
       const rewritable = mine.filter((s) => s.where !== "script" && s.where !== "comment" && !s.partial);
       if (rewritable.length === 0) {
         outcomes.set(
@@ -9183,19 +9484,25 @@ function repeatGroups(targets) {
 }
 function resolvePositionally(targets, sites) {
   const assigned = /* @__PURE__ */ new Map();
-  const claimed = /* @__PURE__ */ new Set();
+  const ambiguous = /* @__PURE__ */ new Set();
+  const picked = /* @__PURE__ */ new Map();
+  const wanters = /* @__PURE__ */ new Map();
   for (const target of targets) {
     const locator = target.locator;
-    if (!locator) return null;
-    const candidates = sites.filter(
-      (s) => s.siblingIndex === locator.siblingIndex && isSubsequence(locator.ancestors, s.ancestors)
-    );
-    const site = locator.repeat ? candidates[locator.repeat.index] : candidates.length === 1 ? candidates[0] : void 0;
-    if (!site || claimed.has(site)) return null;
-    claimed.add(site);
-    assigned.set(target.key, [site]);
+    const candidates = locator ? sites.filter((s) => s.siblingIndex === locator.siblingIndex && isSubsequence(locator.ancestors, s.ancestors)) : [];
+    const site = locator?.repeat ? candidates[locator.repeat.index] : candidates.length === 1 ? candidates[0] : void 0;
+    if (!site) {
+      ambiguous.add(target.key);
+      continue;
+    }
+    picked.set(target.key, site);
+    wanters.set(site, (wanters.get(site) ?? 0) + 1);
+  }
+  for (const [key, site] of picked) {
+    if ((wanters.get(site) ?? 0) > 1) ambiguous.add(key);
+    else assigned.set(key, [site]);
   }
-  return assigned;
+  return { assigned, ambiguous };
 }
 function isSubsequence(wanted, chain) {
   let at = 0;
@@ -9218,7 +9525,7 @@ async function tierThree(file, content, dialect, targets, llmFallback) {
   if (elements.length !== targets.length) return { ok: false, reason: "unverifiable" };
   const locals = helperLocals(reparsed, dialect, file);
   const reads = DIALECT_RULES[dialect].text !== null;
-  const boundary = (name) => `(?<![\\w$])${escapeRegExp2(name)}(?![\\w$])`;
+  const boundary = (name) => `(?<![\\w$])${escapeRegExp3(name)}(?![\\w$])`;
   const claimed = /* @__PURE__ */ new Set();
   for (const element of elements) {
     const candidates = targets.filter(
@@ -9226,7 +9533,7 @@ async function tierThree(file, content, dialect, targets, llmFallback) {
     );
     const match = candidates.find((target) => {
       if (!reads) return true;
-      const quoted = escapeRegExp2(JSON.stringify(target.path));
+      const quoted = escapeRegExp3(JSON.stringify(target.path));
       if (target.scope === "layout") {
         return locals.bcmsLayout.some(
           (name) => new RegExp(`${boundary(name)}\\s*\\(\\s*${quoted}`).test(element.own)
@@ -9288,7 +9595,7 @@ function emitStubs2(dialects, slugs, contents, out) {
 // package.json
 var package_default = {
   name: "@bettercms-ai/convert",
-  version: "0.10.0",
+  version: "0.12.0",
   type: "module",
   description: "Deterministic codemod that turns an imported site's text-matched bindings into declared ones \u2014 parser offsets in, one magic-string pass out, plus a receipt of everything it could not do.",
   bin: {