@bettercms-ai/convert 0.2.1 → 0.4.0

package/dist/cli.js

@@ -134,7 +134,7 @@ function propsAttribute(props) {
 
 // src/helper.ts
 import { createHash as createHash2 } from "crypto";
-var HELPER_VERSION = 3;
+var HELPER_VERSION = 4;
 var HEADER = "// @bettercms-ai/convert helper v";
 var HELPER_PATH = Object.fromEntries(
   Object.keys(DIALECT_RULES).map((d) => [d, DIALECT_RULES[d].helper])
@@ -217,32 +217,97 @@ export function bcmsRows<T>(page: unknown, path: string, fallback: T[], slug?: s
 /**
  * ONE SECTION's copy, for a component extracted by \`--componentize\`.
  *
- * \`overrides ?? pageGroup(bind) ?? defaults\` \u2014 the instance's own values when the editor gave it
- * any, otherwise the page field group the placement is bound to, otherwise nothing at all, in
- * which case every \`bcms(...)\` below renders the fallback the template shipped with. That last
- * step is why a section renders correctly against the committed \`{}\` stub.
+ * OVERRIDES FIRST, PER KEY: \`overrides[key] ?? group[key]\`. An instance that owns its copy
+ * (Phase B) carries an override for every prop it declares, so the group underneath it is never
+ * read; a placement still bound to a page field group (Phase A) carries none, so the group is all
+ * there is. The interesting case is the one in between \u2014 a section half moved \u2014 where a key the
+ * instance does not hold has to keep rendering the page's value rather than nothing.
+ *
+ * \u{1F534} \`??\`, NOT \`||\`. An empty string is a value an editor typed, and treating it as absent put
+ * the page's old copy back into a heading somebody had deliberately cleared.
+ *
+ * With neither an override nor a group, the answer is \`{}\` and every \`bcms(...)\` below renders
+ * the fallback the template shipped with \u2014 which is why a section renders correctly against the
+ * committed \`{}\` stub.
  */
 export function bcmsSection(page: unknown, bind?: string, overrides?: unknown): Record<string, unknown> {
-  // \u{1F534} AN EMPTY OBJECT IS AN ANSWER. \`overrides: {}\` is an instance an editor cleared, and
-  // "\`??\` unless it happens to be empty" quietly put the page's copy back into it.
-  if (isRecord(overrides)) return overrides;
   const group = bind ? readPath(page, bind) : undefined;
-  return isRecord(group) ? group : {};
+  const base: Record<string, unknown> = isRecord(group) ? { ...group } : {};
+  if (!isRecord(overrides)) return base;
+  for (const key of Object.keys(overrides)) {
+    const value = overrides[key];
+    if (value === undefined || value === null) continue;
+    /**
+     * \u{1F534} A TABLE PROP IS STORED AS \`{ rows: [...] }\` AND READ AS A LIST. That is the shape the
+     * dashboard edits a repeater in; handing it to \`bcmsRows\` unchanged is not an array, so the
+     * helper fell back to the rows the template shipped with and the editor's work never showed.
+     */
+    base[key] = isRecord(value) && Array.isArray(value.rows) ? value.rows : value;
+  }
+  return base;
+}
+
+/**
+ * WHICH ADDRESS one bound element declares \u2014 decided at RENDER time, from the placement.
+ *
+ * An element carries exactly ONE \`data-bcms-field\`, and which lane it names depends on where its
+ * copy lives. A placement that owns its copy declares the BLOCK lane \u2014
+ * \`<blockId>__overrides.<propKey>\` \u2014 because that is the address the editor commits an instance's
+ * own value to. A placement bound to a page field group declares the PAGE path, which is what the
+ * page form and the coverage meter already know.
+ *
+ * \u{1F534} THE BOUND ADDRESS IS RE-BASED ONTO **THIS** PLACEMENT'S GROUP. The markup was cut from ONE
+ * page and carries that page's paths (\`hero.title\`); the whole point of \`shapeHash\` is that a
+ * second page renders the same component bound to a group of its own (\`bind="landingHero"\`).
+ * Handing the embedded path through unchanged declared \`hero.title\` on a page whose field is
+ * \`landingHero.title\` \u2014 an address that page does not have, so the editor wrote into nothing and
+ * the meter counted a binding that was never there. The prefix the markup was cut with comes out,
+ * the placement's own group goes in.
+ *
+ * \u{1F534} THE SAME EXTRACTED FILE SERVES BOTH LANES. The choice is a function of the props, never of
+ * 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.
+ */
+export function bcmsFields(
+  placement: { blockId?: string; bind?: string; overrides?: unknown },
+  pathPrefix: string,
+): (path: string) => string {
+  const id = placement.blockId;
+  const own = typeof id === "string" && id !== "" && !placement.bind && isRecord(placement.overrides);
+  /**
+   * What replaces the prefix the markup was cut with, or null for "leave every path alone".
+   *
+   * Null covers a placement with neither a bind nor an instance \u2014 a shipped fallback, or a page
+   * nobody has componentized yet \u2014 and a bound placement in a component whose prefix is EMPTY,
+   * where the plan said the prop key IS the whole page path: there is no group segment to swap,
+   * so prepending one would invent an address rather than correct it.
+   */
+  const lane = own ? \`\${id}__overrides.\` : placement.bind && pathPrefix ? \`\${placement.bind}.\` : null;
+  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.
+    // (An EMPTY prefix is a plan saying the prop key IS the page path, and matches everything.)
+    if (lane === null || !path.startsWith(pathPrefix)) return path;
+    return lane + path.slice(pathPrefix.length);
+  };
 }
 `;
 }
 var HISTORICAL = {
   "src/bcms-content.ts": {
     1: "c272412532efed7db64b6cf313b2bed4291f9951430412289c8a588b7f565407",
-    2: "51e2ae65ddd86bf43d14e29b3865e3f16e45f72069692d1fea57e1f986a894f0"
+    2: "51e2ae65ddd86bf43d14e29b3865e3f16e45f72069692d1fea57e1f986a894f0",
+    3: "d4305b2983adcb456ef782d35ea9d083a04465c2b68baa0d44a084dfa01a9227"
   },
   "src/lib/bcms-content.ts": {
     1: "ae72ae14d706943d481c880d70da5789b4816ba1ba319a10fbc63ded4d0b42f2",
-    2: "a18731eb42f7db55dac0591c45f873758cde8e103fefcd6e5caf67936ae6a002"
+    2: "a18731eb42f7db55dac0591c45f873758cde8e103fefcd6e5caf67936ae6a002",
+    3: "0be9c73160361882a038552bc02673c14ed532287823dabaafe36179bc55ed7e"
   },
   "composables/bcms-content.ts": {
     1: "c272412532efed7db64b6cf313b2bed4291f9951430412289c8a588b7f565407",
-    2: "51e2ae65ddd86bf43d14e29b3865e3f16e45f72069692d1fea57e1f986a894f0"
+    2: "51e2ae65ddd86bf43d14e29b3865e3f16e45f72069692d1fea57e1f986a894f0",
+    3: "d4305b2983adcb456ef782d35ea9d083a04465c2b68baa0d44a084dfa01a9227"
   }
 };
 var sha256 = (value) => createHash2("sha256").update(value, "utf8").digest("hex");
@@ -2628,6 +2693,71 @@ function locate(brief, sources, options) {
 // src/loops.ts
 import MagicString from "magic-string";
 
+// src/declarations.ts
+var BINDING_ATTR = /data-bcms-(?:layout-)?field\s*=\s*["']([^"']+)["']/g;
+var PROPS_ATTR = /data-bcms-props\s*=\s*["']([^"']+)["']/g;
+var TEMPLATE_SCAN = /:?data-bcms-(?:layout-)?field\s*=\s*(?:\{\s*`([^`]+)`\s*\}|"\s*`([^`]+)`\s*")/g;
+var BINDINGS_SCAN = /bcmsBindings\s*=\s*\{\{[^}]*\}\}/g;
+var propsDeclarations = (value, at) => value.split(";").flatMap((entry) => {
+  const [address, kind] = entry.split("|");
+  if (!address) return [];
+  const scope = address.startsWith("layout:") ? "layout" : "page";
+  return [{ scope, path: stripLayoutPrefix(address), kind: kind ?? "", at, via: "props" }];
+});
+var propsPaths = (value) => propsDeclarations(value, 0).map((d) => ({ scope: d.scope, path: d.path }));
+var TEMPLATE_BINDING = /^:?data-bcms-(?:layout-)?field\s*=\s*(?:\{\s*`([^`]+)`\s*\}|"\s*`([^`]+)`\s*")$/;
+var shapeOfPath = (path) => path.replace(/\[(?:\d+|\$\{[^}]*\})\]/g, "[*]");
+function declarationsIn(roots, content) {
+  const out = [];
+  const visit = (node) => {
+    if (node.type === "expr") {
+      for (const child of node.children) visit(child);
+      return;
+    }
+    if (node.type !== "element") return;
+    const kind = node.attrs.find((a) => a.name === "data-bcms-kind")?.value ?? "";
+    const at = node.attrInsertAt;
+    for (const attr of node.attrs) {
+      const name = attr.name.replace(/^:/, "");
+      if (name === "data-bcms-field" || name === "data-bcms-layout-field") {
+        const scope = name === "data-bcms-layout-field" ? "layout" : "page";
+        const template = content.slice(attr.range.start, attr.range.end).match(TEMPLATE_BINDING);
+        const templated = template?.[1] ?? template?.[2];
+        if (templated) out.push({ scope, path: shapeOfPath(stripLayoutPrefix(templated)), kind, at, via: "field" });
+        else if (attr.value) out.push({ scope, path: stripLayoutPrefix(attr.value), kind, at, via: "field" });
+      } else if (attr.name === "data-bcms-props") {
+        out.push(...propsDeclarations(attr.value, at));
+      } else if (attr.name === "bcmsBindings") {
+        for (const path of bindingsPaths(content.slice(attr.range.start, attr.range.end))) {
+          out.push({ scope: "page", path, kind: "", at, via: "prop" });
+        }
+      }
+    }
+    for (const child of node.children) visit(child);
+  };
+  for (const root of roots) visit(root);
+  return out;
+}
+var bindingsPaths = (text) => [...text.matchAll(/["']([^"']+)["']/g)].map((match) => match[1]);
+var scopedPath = (scope, path) => `${scope}::${path}`;
+var covers = (declared, target) => declared !== void 0 && (declared.has(scopedPath(target.scope, target.path)) || declared.has(scopedPath(target.scope, shapeOfPath(target.path))));
+var declaredInTree = (roots, content) => new Set(declarationsIn(roots, content).map((d) => scopedPath(d.scope, d.path)));
+function declaredByScan(content) {
+  const out = /* @__PURE__ */ new Set();
+  const add = (scope, path) => void out.add(scopedPath(scope, path));
+  for (const match of content.matchAll(BINDING_ATTR)) {
+    add(match[0].includes("layout-field") ? "layout" : "page", stripLayoutPrefix(match[1]));
+  }
+  for (const match of content.matchAll(TEMPLATE_SCAN)) {
+    add(match[0].includes("layout-field") ? "layout" : "page", shapeOfPath(stripLayoutPrefix(match[1] ?? match[2])));
+  }
+  for (const match of content.matchAll(BINDINGS_SCAN)) for (const path of bindingsPaths(match[0])) add("page", path);
+  for (const match of content.matchAll(PROPS_ATTR))
+    for (const entry of propsPaths(match[1])) add(entry.scope, entry.path);
+  return out;
+}
+var stripLayoutPrefix = (value) => value.startsWith("layout:") ? value.slice("layout:".length) : value;
+
 // src/scope.ts
 function patternNames(node, out) {
   if (!node || typeof node !== "object") return;
@@ -2914,7 +3044,10 @@ function wordBounded(haystack, needle) {
 }
 
 // src/loops.ts
-var shapeOf = (arrayPath, leaf) => `${arrayPath}[*].${leaf}`;
+function splitNested(leaf) {
+  const match = leaf.match(/^([^[\]]+)\[(\d+)\]\.(.+)$/);
+  return match ? { array: match[1], index: Number(match[2]), leaf: match[3] } : null;
+}
 var elementEnd = (node) => node.inner ? node.inner.end + node.tag.length + 3 : null;
 function findRows(roots, members) {
   const wanted = new Set(members.map((m) => m.index));
@@ -2986,6 +3119,69 @@ function indentOf(content, at) {
   const prefix = content.slice(lineStart, at);
   return prefix.trim() === "" ? prefix : "";
 }
+function writeLeaf(source, shift, member, rule, read, row, literal) {
+  const site = member.site;
+  const expression = `${read}(${row}, ${JSON.stringify(member.leaf)}, "")`;
+  if (member.kind === "richtext" && rule.richtext) {
+    source.remove(site.inner.start + shift, site.inner.end + shift);
+    source.appendLeft(site.attrInsertAt + shift, ` ${rule.richtext(expression)}`);
+  } else {
+    source.overwrite(site.inner.start + shift, site.inner.end + shift, rule.text(expression));
+  }
+  const kind = member.kind ? ` data-bcms-kind="${member.kind}"` : "";
+  source.appendLeft(site.attrInsertAt + shift, ` ${rule.attr("data-bcms-field", `\`${literal}\``)}${kind}`);
+}
+function emitNested(rule, array, members, prefix, outer, parent, ctx) {
+  if (!rule.loop || !rule.text) return null;
+  const inner = [];
+  for (const member of members) {
+    const split = splitNested(member.leaf);
+    if (!split || splitNested(split.leaf) !== null) return null;
+    inner.push({ ...member, index: split.index, leaf: split.leaf });
+  }
+  const rows = findRows([parent.node], inner);
+  if (!rows || rows.length === 0) return null;
+  if (!consecutive(rows, ctx.content)) return null;
+  if (!sameShape(rows, ctx.content)) return null;
+  const template = rows[0];
+  const used = /* @__PURE__ */ new Set([
+    ...ctx.content.slice(template.range.start, template.range.end).match(/[A-Za-z_$][\w$]*/g) ?? [],
+    outer.row,
+    outer.index
+  ]);
+  const allocated = allocateNames(used, [
+    { key: "row", name: "item" },
+    { key: "index", name: "j" }
+  ]);
+  const names = { row: allocated.get("row"), index: allocated.get("index") };
+  const fallback = [];
+  const writable = inner.every((member) => setLeaf(fallback[member.index] ??= emptyRow(), member.leaf, member.fallback));
+  if (!writable) return null;
+  const source = new MagicString(ctx.content.slice(template.range.start, template.range.end));
+  const shift = -template.range.start;
+  const declarations = [];
+  for (const member of template.members) {
+    const literal = `${prefix}.${array}[\${${names.index}}].${member.leaf}`;
+    writeLeaf(source, shift, member, rule, ctx.read, names.row, literal);
+    declarations.push({ path: shapeOfPath(literal), literal });
+  }
+  const rowsExpr = `${ctx.rows}(${outer.row}, ${JSON.stringify(array)}, ${JSON.stringify(fallback.filter(Boolean))})`;
+  if (rule.loop.kind === "attr") {
+    source.appendRight(template.attrInsertAt + shift, ` ${rule.loop.attr(rowsExpr, names.row, names.index)}`);
+  }
+  if (rule.loopKey) {
+    const key = rule.loopKey(names.index);
+    if (!template.keyAttr) source.appendRight(template.attrInsertAt + shift, ` ${key}`);
+    else if (template.keyAttr.end > template.keyAttr.start)
+      source.overwrite(template.keyAttr.start + shift, template.keyAttr.end + shift, key);
+    else return null;
+  }
+  const indent = indentOf(ctx.content, template.range.start);
+  const text = rule.loop.kind === "wrap" ? `${rule.loop.open(rowsExpr, names.row, names.index)}
+${indented(source.toString(), indent)}
+${indent}${rule.loop.close}` : source.toString();
+  return { range: { start: template.range.start, end: rows[rows.length - 1].range.end }, text, declarations };
+}
 function emitRepeater(dialect, group, arrayPath, fallbackRows, ctx) {
   const rule = DIALECT_RULES[dialect];
   if (!rule.loop || !rule.text || group.length === 0) return null;
@@ -3003,20 +3199,25 @@ function emitRepeater(dialect, group, arrayPath, fallbackRows, ctx) {
   const names = { row: allocated.get("row"), index: allocated.get("index") };
   const source = new MagicString(ctx.content.slice(template.range.start, template.range.end));
   const shift = -template.range.start;
-  const bindings = [];
+  const declarations = [];
+  const nested = /* @__PURE__ */ new Map();
+  const direct = [];
   for (const member of template.members) {
-    const site = member.site;
-    const expression = `${ctx.read}(${names.row}, ${JSON.stringify(member.leaf)}, "")`;
-    if (member.kind === "richtext" && rule.richtext) {
-      source.remove(site.inner.start + shift, site.inner.end + shift);
-      source.appendLeft(site.attrInsertAt + shift, ` ${rule.richtext(expression)}`);
-    } else {
-      source.overwrite(site.inner.start + shift, site.inner.end + shift, rule.text(expression));
-    }
-    const kind = member.kind ? ` data-bcms-kind="${member.kind}"` : "";
-    const path = `\`${arrayPath}[\${${names.index}}].${member.leaf}\``;
-    source.appendLeft(site.attrInsertAt + shift, ` ${rule.attr("data-bcms-field", path)}${kind}`);
-    bindings.push(shapeOf(arrayPath, member.leaf));
+    const inner = splitNested(member.leaf);
+    if (inner === null) direct.push(member);
+    else nested.set(inner.array, [...nested.get(inner.array) ?? [], member]);
+  }
+  for (const [array, members] of nested) {
+    const plan2 = emitNested(rule, array, members, `${arrayPath}[\${${names.index}}]`, names, template, ctx);
+    if (!plan2) return null;
+    if (direct.some((m) => m.site.range.start >= plan2.range.start && m.site.range.end <= plan2.range.end)) return null;
+    source.overwrite(plan2.range.start + shift, plan2.range.end + shift, plan2.text);
+    declarations.push(...plan2.declarations);
+  }
+  for (const member of direct) {
+    const literal = `${arrayPath}[\${${names.index}}].${member.leaf}`;
+    writeLeaf(source, shift, member, rule, ctx.read, names.row, literal);
+    declarations.push({ path: shapeOfPath(literal), literal });
   }
   const args = [ctx.snapshot, JSON.stringify(arrayPath), JSON.stringify(fallbackRows), ...ctx.slug ? [ctx.slug] : []];
   const rowsExpr = `${ctx.rows}(${args.join(", ")})`;
@@ -3037,7 +3238,8 @@ ${indent}${rule.loop.close}` : source.toString();
   return {
     range: { start: template.range.start, end: rows[rows.length - 1].range.end },
     text,
-    bindings: [...new Set(bindings)],
+    declarations,
+    bindings: [...new Set(declarations.map((d) => d.path))],
     names
   };
 }
@@ -3067,9 +3269,9 @@ function setLeaf(row, leaf, value) {
 var FORBIDDEN = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
 var emptyRow = () => /* @__PURE__ */ Object.create(null);
 function splitIndexed(arrayPath, path) {
-  const match = path.match(/^(.*)\[(\d+)\]\.(.+)$/);
-  if (!match || match[1] !== arrayPath) return null;
-  return { index: Number(match[2]), leaf: match[3] };
+  if (!path.startsWith(`${arrayPath}[`)) return null;
+  const match = path.slice(arrayPath.length).match(/^\[(\d+)\]\.(.+)$/);
+  return match ? { index: Number(match[1]), leaf: match[2] } : null;
 }
 
 // src/sites/jsx.ts
@@ -3562,22 +3764,68 @@ var firstPresent = (base, files) => [base, ...EXTENSIONS.map((ext) => `${base}${
 function aliasesFrom(sources) {
   const out = /* @__PURE__ */ new Map();
   for (const source of sources) {
-    if (!source.path.endsWith("tsconfig.json") && !source.path.endsWith("jsconfig.json")) continue;
-    try {
-      const parsed = JSON.parse(source.content.replace(/^\s*\/\/.*$/gm, ""));
-      const base = parsed.compilerOptions?.baseUrl?.replace(/^\.\/?/, "").replace(/\/$/, "") ?? "";
-      const root = source.path.split("/").slice(0, -1).join("/");
-      for (const [pattern, targets] of Object.entries(parsed.compilerOptions?.paths ?? {})) {
-        out.set(
-          pattern,
-          targets.map((target) => [root, base, target.replace(/^\.\/?/, "")].filter(Boolean).join("/"))
-        );
-      }
-    } catch {
+    if (!isProjectConfig(source.path)) continue;
+    const parsed = readJsonc(source.content);
+    if (parsed === null) continue;
+    const base = parsed.compilerOptions?.baseUrl?.replace(/^\.\/?/, "").replace(/\/$/, "") ?? "";
+    const root = source.path.split("/").slice(0, -1).join("/");
+    for (const [pattern, targets] of Object.entries(parsed.compilerOptions?.paths ?? {})) {
+      out.set(
+        pattern,
+        targets.map((target) => [root, base, target.replace(/^\.\/?/, "")].filter(Boolean).join("/"))
+      );
     }
   }
   return out;
 }
+var isProjectConfig = (path) => path.endsWith("tsconfig.json") || path.endsWith("jsconfig.json");
+function readJsonc(content) {
+  let out = "";
+  let at = 0;
+  while (at < content.length) {
+    const char = content[at];
+    if (char === '"') {
+      const start = at++;
+      while (at < content.length && content[at] !== '"') at += content[at] === "\\" ? 2 : 1;
+      out += content.slice(start, Math.min(at + 1, content.length));
+      at++;
+      continue;
+    }
+    if (char === "/" && content[at + 1] === "/") {
+      while (at < content.length && content[at] !== "\n") at++;
+      continue;
+    }
+    if (char === "/" && content[at + 1] === "*") {
+      const close = content.indexOf("*/", at + 2);
+      at = close < 0 ? content.length : close + 2;
+      continue;
+    }
+    out += char;
+    at++;
+  }
+  try {
+    const parsed = JSON.parse(out.replace(/,(?=\s*[}\]])/g, ""));
+    return isAliasShaped(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+function isAliasShaped(value) {
+  if (!isRecord(value)) return false;
+  const options = value.compilerOptions;
+  if (options === void 0) return true;
+  if (!isRecord(options)) return false;
+  if (options.baseUrl !== void 0 && typeof options.baseUrl !== "string") return false;
+  if (options.paths === void 0) return true;
+  if (!isRecord(options.paths)) return false;
+  return Object.values(options.paths).every(
+    (targets) => Array.isArray(targets) && targets.every((target) => typeof target === "string")
+  );
+}
+function unreadableConfigs(sources) {
+  return sources.filter((source) => isProjectConfig(source.path) && readJsonc(source.content) === null).map((source) => source.path);
+}
 function expand(specifier, aliases) {
   const out = [];
   for (const [pattern, targets] of aliases) {
@@ -3746,70 +3994,6 @@ function typeMember(content, literal) {
   return { start: at, end: at, text: `${terminated ? "" : ";"} ${text}` };
 }
 
-// src/declarations.ts
-var BINDING_ATTR = /data-bcms-(?:layout-)?field\s*=\s*["']([^"']+)["']/g;
-var PROPS_ATTR = /data-bcms-props\s*=\s*["']([^"']+)["']/g;
-var TEMPLATE_SCAN = /:?data-bcms-(?:layout-)?field\s*=\s*(?:\{\s*`([^`]+)`\s*\}|"\s*`([^`]+)`\s*")/g;
-var BINDINGS_SCAN = /bcmsBindings\s*=\s*\{\{[^}]*\}\}/g;
-var propsDeclarations = (value, at) => value.split(";").flatMap((entry) => {
-  const [address, kind] = entry.split("|");
-  if (!address) return [];
-  const scope = address.startsWith("layout:") ? "layout" : "page";
-  return [{ scope, path: stripLayoutPrefix(address), kind: kind ?? "", at, via: "props" }];
-});
-var propsPaths = (value) => propsDeclarations(value, 0).map((d) => ({ scope: d.scope, path: d.path }));
-var TEMPLATE_BINDING = /^:?data-bcms-(?:layout-)?field\s*=\s*(?:\{\s*`([^`]+)`\s*\}|"\s*`([^`]+)`\s*")$/;
-var shapeOfPath = (path) => path.replace(/\[(?:\d+|\$\{[^}]*\})\]/g, "[*]");
-function declarationsIn(roots, content) {
-  const out = [];
-  const visit = (node) => {
-    if (node.type === "expr") {
-      for (const child of node.children) visit(child);
-      return;
-    }
-    if (node.type !== "element") return;
-    const kind = node.attrs.find((a) => a.name === "data-bcms-kind")?.value ?? "";
-    const at = node.attrInsertAt;
-    for (const attr of node.attrs) {
-      const name = attr.name.replace(/^:/, "");
-      if (name === "data-bcms-field" || name === "data-bcms-layout-field") {
-        const scope = name === "data-bcms-layout-field" ? "layout" : "page";
-        const template = content.slice(attr.range.start, attr.range.end).match(TEMPLATE_BINDING);
-        const templated = template?.[1] ?? template?.[2];
-        if (templated) out.push({ scope, path: shapeOfPath(stripLayoutPrefix(templated)), kind, at, via: "field" });
-        else if (attr.value) out.push({ scope, path: stripLayoutPrefix(attr.value), kind, at, via: "field" });
-      } else if (attr.name === "data-bcms-props") {
-        out.push(...propsDeclarations(attr.value, at));
-      } else if (attr.name === "bcmsBindings") {
-        for (const path of bindingsPaths(content.slice(attr.range.start, attr.range.end))) {
-          out.push({ scope: "page", path, kind: "", at, via: "prop" });
-        }
-      }
-    }
-    for (const child of node.children) visit(child);
-  };
-  for (const root of roots) visit(root);
-  return out;
-}
-var bindingsPaths = (text) => [...text.matchAll(/["']([^"']+)["']/g)].map((match) => match[1]);
-var scopedPath = (scope, path) => `${scope}::${path}`;
-var declaredInTree = (roots, content) => new Set(declarationsIn(roots, content).map((d) => scopedPath(d.scope, d.path)));
-function declaredByScan(content) {
-  const out = /* @__PURE__ */ new Set();
-  const add = (scope, path) => void out.add(scopedPath(scope, path));
-  for (const match of content.matchAll(BINDING_ATTR)) {
-    add(match[0].includes("layout-field") ? "layout" : "page", stripLayoutPrefix(match[1]));
-  }
-  for (const match of content.matchAll(TEMPLATE_SCAN)) {
-    add(match[0].includes("layout-field") ? "layout" : "page", shapeOfPath(stripLayoutPrefix(match[1] ?? match[2])));
-  }
-  for (const match of content.matchAll(BINDINGS_SCAN)) for (const path of bindingsPaths(match[0])) add("page", path);
-  for (const match of content.matchAll(PROPS_ATTR))
-    for (const entry of propsPaths(match[1])) add(entry.scope, entry.path);
-  return out;
-}
-var stripLayoutPrefix = (value) => value.startsWith("layout:") ? value.slice("layout:".length) : value;
-
 // src/converted.ts
 var escapeRegExp = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 function splitArrayPath(path) {
@@ -4643,7 +4827,7 @@ var ValidationError = class extends Error {
   }
   code;
 };
-var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var isRecord2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 var Check = class {
   constructor(code) {
     this.code = code;
@@ -4653,7 +4837,7 @@ var Check = class {
     throw new ValidationError(this.code, `${where} ${why}.`);
   }
   record(value, where) {
-    if (!isRecord(value)) this.fail(where, "is not an object");
+    if (!isRecord2(value)) this.fail(where, "is not an object");
     return value;
   }
   array(value, where) {
@@ -4720,6 +4904,7 @@ function readPlan(value) {
       const section = check.record(held, at2);
       check.segment(section.groupKey, `${at2}.groupKey`);
       check.optionalString(section.sectionType, `${at2}.sectionType`);
+      check.optionalString(section.copy, `${at2}.copy`);
       if (section.fields !== void 0) {
         for (const [f, field] of check.array(section.fields, `${at2}.fields`).entries()) {
           const shape = check.record(field, `${at2}.fields[${f}]`);
@@ -5101,30 +5286,84 @@ var SectionInvariantError = class extends Error {
   }
 };
 function assertSections(total, sections) {
-  const sum = sections.extracted + sections.inlineOnly + sections.alreadyExtracted + sections.pending.length;
+  const sum = sections.extracted + sections.inlineOnly + sections.alreadyExtracted + sections.registered + sections.pending.length;
   if (sum !== total) {
     throw new SectionInvariantError(
-      `The receipt does not account for every section: ${total} planned but ${sections.extracted} extracted + ${sections.inlineOnly} inline-only + ${sections.alreadyExtracted} already extracted + ${sections.pending.length} pending = ${sum}.`
+      `The receipt does not account for every section: ${total} planned but ${sections.extracted} extracted + ${sections.inlineOnly} inline-only + ${sections.alreadyExtracted} already extracted + ${sections.registered} registered + ${sections.pending.length} pending = ${sum}.`
     );
   }
   return sections;
 }
-var SECTION_MARKER = "// @bettercms-ai/convert section v1";
+var SECTION_MARKER = "// @bettercms-ai/convert section v2";
+var SECTION_MARKERS = [SECTION_MARKER, "// @bettercms-ai/convert section v1"];
 var REGISTRY_MARKER = "// @bettercms-ai/convert sections v1";
 var COMPONENT_DIR = "src/components/bcms";
 var SECTIONS_LIB = "src/lib/bcms-sections.ts";
 var EXTRACTABLE = ["astro", "jsx"];
+var registryValue = (entry) => entry.member ? `${entry.name}.${entry.member}` : entry.name;
+function importLine(name, specifier, entry) {
+  if (entry.kind === "namespace") return `import * as ${name} from "${specifier}";`;
+  if (entry.kind === "named") {
+    const exported = entry.imported ?? name;
+    return `import { ${exported === name ? name : `${exported} as ${name}`} } from "${specifier}";`;
+  }
+  return `import ${name} from "${specifier}";`;
+}
 async function componentizeSources(briefIn, planIn, sources, options) {
   const pending = [];
   let extracted = 0;
   let inlineOnly = 0;
   let alreadyExtracted = 0;
+  let registered = 0;
   let planPending = 0;
   let total = 0;
+  const pend = (route, groupKey, reason, message) => void pending.push({ route, groupKey, reason, ...message ? { message } : {} });
   const brief = readBrief(briefIn);
   const plan2 = readPlan(planIn);
+  const copy = options?.copy ?? "bind";
+  const instanceOwned = (section) => section.copy === "instance";
+  const notes = unreadableConfigs(sources).map(
+    (path) => ({
+      code: "TSCONFIG_UNREADABLE",
+      file: path,
+      message: `${path} is not JSON this package can read, so its \`paths\` aliases resolved to nothing.`
+    })
+  );
+  const refuseRun = (reason, message) => {
+    for (const page of plan2.pages ?? []) {
+      for (const section of page.sections ?? []) {
+        if (section.pending) {
+          planPending++;
+          continue;
+        }
+        total++;
+        pend(page.route, section.groupKey, reason, message);
+      }
+    }
+    return {
+      files: [],
+      receipt: {
+        planDigest: plan2.digest ?? "",
+        copy,
+        sections: assertSections(total, { extracted: 0, inlineOnly: 0, alreadyExtracted: 0, registered: 0, pending }),
+        components: [],
+        planPending,
+        notes
+      }
+    };
+  };
+  const movesCopy = (plan2.pages ?? []).some(
+    (page) => (page.sections ?? []).some((section) => !section.pending && instanceOwned(section))
+  );
+  if (copy === "instance" && !movesCopy) {
+    return refuseRun(
+      "COPY_MODE_MISMATCH",
+      'this run was asked for --copy instance, but no placement in the plan carries copy: "instance" \u2014 run componentize_sections { copy: "instance" } on the server first, then fetch the plan again.'
+    );
+  }
   const contents = new Map(sources.map((s) => [s.path, s.content]));
-  const pend = (route, groupKey, reason, message) => void pending.push({ route, groupKey, reason, ...message ? { message } : {} });
+  const fileSet = new Set(contents.keys());
+  const aliases = aliasesFrom(sources);
   const trees = /* @__PURE__ */ new Map();
   const treeOf = async (file) => {
     if (trees.has(file)) return trees.get(file);
@@ -5138,7 +5377,9 @@ async function componentizeSources(briefIn, planIn, sources, options) {
   const helperPath = HELPER_PATH.astro;
   const helperExisting = contents.get(helperPath);
   const helperVersion = helperExisting === void 0 ? null : isKnownHelper(helperExisting, "astro");
-  const helperBlocked = helperExisting !== void 0 && helperVersion === null && options?.overwriteHelper !== true;
+  if (helperExisting !== void 0 && helperVersion === null && options?.overwriteHelper !== true) {
+    return refuseRun("HELPER_CONFLICT", `${helperPath} is not a module this package wrote.`);
+  }
   const outFiles = /* @__PURE__ */ new Map();
   const written = /* @__PURE__ */ new Map();
   const shipped = /* @__PURE__ */ new Map();
@@ -5148,7 +5389,31 @@ async function componentizeSources(briefIn, planIn, sources, options) {
     return held;
   };
   const fresh = /* @__PURE__ */ new Set();
+  const bindOf = (section) => instanceOwned(section) ? void 0 : section.groupKey;
+  const placementOf = (slug, section) => {
+    const bind = bindOf(section);
+    return bind === void 0 ? { slug } : { slug, bind };
+  };
+  const rebind = (dialect, pageSlug, all, usable) => {
+    if (dialect === null || !EXTRACTABLE.includes(dialect)) return;
+    const order = shipped.get(dialect);
+    const held = order?.get(pageSlug);
+    if (!order || !held) return;
+    const queues = /* @__PURE__ */ new Map();
+    for (const section of all) {
+      const slug = resolveComponent(plan2, section).slug;
+      queues.set(slug, [...queues.get(slug) ?? [], section]);
+    }
+    order.set(
+      pageSlug,
+      held.map((placement) => {
+        const section = queues.get(placement.slug)?.shift();
+        return section && usable.has(section) ? placementOf(placement.slug, section) : placement;
+      })
+    );
+  };
   const registryConflicts = [];
+  const registryUnreadable = [];
   for (const dialect of EXTRACTABLE) {
     const path = `${COMPONENT_DIR}/Sections.${dialect === "astro" ? "astro" : "tsx"}`;
     const existing = contents.get(path);
@@ -5157,7 +5422,11 @@ async function componentizeSources(briefIn, planIn, sources, options) {
       registryConflicts.push(path);
       continue;
     }
-    const held = readRegistry(existing, dialect);
+    const held = await readRegistry(existing, dialect, path, fileSet, aliases);
+    if (held === null) {
+      registryUnreadable.push(path);
+      continue;
+    }
     componentsOf(dialect);
     for (const [slug, component] of held.components) written.get(dialect).set(slug, component);
     const order = shipped.get(dialect) ?? /* @__PURE__ */ new Map();
@@ -5167,6 +5436,12 @@ async function componentizeSources(briefIn, planIn, sources, options) {
   const lib = contents.get(SECTIONS_LIB);
   if (lib !== void 0 && !isGenerated(lib)) registryConflicts.push(SECTIONS_LIB);
   const registryBlocked = registryConflicts.length > 0 && options?.overwriteHelper !== true;
+  const registryUnread = registryUnreadable.length > 0;
+  const migrated = registryBlocked || registryUnread ? { files: [], refused: /* @__PURE__ */ new Map() } : await migrateSections(plan2, contents, written, fileSet, aliases);
+  for (const file of migrated.files) {
+    addFile(outFiles, contents, file);
+    contents.set(file.path, file.content);
+  }
   for (const page of plan2.pages ?? []) {
     const sections2 = (page.sections ?? []).filter((section) => {
       if (section.pending) {
@@ -5177,46 +5452,81 @@ async function componentizeSources(briefIn, planIn, sources, options) {
     });
     total += sections2.length;
     if (sections2.length === 0) continue;
+    const prefixes = /* @__PURE__ */ new Map();
+    for (const section of sections2) {
+      const prefix = propPrefix(section);
+      if (prefix === null) {
+        pend(
+          page.route,
+          section.groupKey,
+          "PROP_MAP_INCONSISTENT",
+          "the plan's fields do not spell every path as one common prefix plus its key, so a page path cannot be turned into a prop key."
+        );
+        continue;
+      }
+      prefixes.set(section, prefix);
+    }
+    const usable = sections2.filter((section) => prefixes.has(section));
+    if (usable.length === 0) continue;
+    const pendingBefore = pending.length;
     const briefPage = brief.pages.find((p) => p.route === page.route);
     const pageSlug = briefPage?.slug ?? slugify(page.route === "/" ? "home" : page.route);
-    if (helperBlocked) {
-      for (const section of sections2) {
-        pend(page.route, section.groupKey, "HELPER_CONFLICT", `${helperPath} is not a module this package wrote.`);
+    if (registryBlocked) {
+      for (const section of usable) {
+        pend(page.route, section.groupKey, "REGISTRY_CONFLICT", `${registryConflicts.join(", ")} is not a file this package wrote.`);
       }
       continue;
     }
-    if (registryBlocked) {
-      for (const section of sections2) {
-        pend(page.route, section.groupKey, "REGISTRY_CONFLICT", `${registryConflicts.join(", ")} is not a file this package wrote.`);
+    if (registryUnread) {
+      for (const section of usable) {
+        pend(
+          page.route,
+          section.groupKey,
+          "REGISTRY_UNREADABLE",
+          `${registryUnreadable.join(", ")} carries our marker but its REGISTRY/SHIPPED tables cannot be read back \u2014 rebuilding it would drop the components it names.`
+        );
       }
       continue;
     }
     const snapshotPath = `${CONTENT_DIR}/${pageSlug}.json`;
     if (!snapshotUsable(contents.get(snapshotPath))) {
-      for (const section of sections2) {
+      for (const section of usable) {
         pend(page.route, section.groupKey, "SNAPSHOT_INVALID", `${snapshotPath} is not a JSON object.`);
       }
       continue;
     }
     const pageFiles = pageFilesFor(page.route, contents.keys());
     if (pageFiles.length > 1) {
-      for (const section of sections2) {
+      for (const section of usable) {
         pend(page.route, section.groupKey, "ROUTE_FILE_AMBIGUOUS", `${pageFiles.join(" and ")} both serve ${page.route}.`);
       }
       continue;
     }
     const file = pageFiles[0];
     if (file === void 0) {
-      for (const section of sections2) {
+      for (const section of usable) {
         pend(page.route, section.groupKey, "NOT_IN_SOURCE", `no page file found for ${page.route}.`);
       }
       continue;
     }
-    const done = new Set(alreadyOn(contents.get(file) ?? "", pageSlug, sections2));
+    const pageDialect = dialectOf(file, contents.get(file) ?? "");
+    const done = new Set(alreadyOn(contents.get(file) ?? "", pageSlug, usable));
+    let stuck = 0;
+    for (const section of usable) {
+      if (!done.has(section.groupKey)) continue;
+      const why = pageDialect ? migrated.refused.get(refusalKey(pageDialect, resolveComponent(plan2, section).slug)) : void 0;
+      if (why === void 0) continue;
+      done.delete(section.groupKey);
+      stuck++;
+      pend(page.route, section.groupKey, "SECTION_UNMIGRATABLE", why);
+    }
     alreadyExtracted += done.size;
-    if (done.size === sections2.length) continue;
+    if (done.size + stuck === usable.length) {
+      rebind(pageDialect, pageSlug, page.sections ?? [], new Set(usable));
+      continue;
+    }
     const found = await locateSections(
-      sections2.filter((section) => !done.has(section.groupKey)),
+      usable.filter((section) => !done.has(section.groupKey)),
       briefPage?.paths ?? [],
       sources,
       treeOf
@@ -5226,37 +5536,115 @@ async function componentizeSources(briefIn, planIn, sources, options) {
     }
     const live = found.placed;
     if (live.length === 0) continue;
+    const content = contents.get(file);
+    const dialect = dialectOf(file, content);
+    if (!dialect || !EXTRACTABLE.includes(dialect)) {
+      for (const placed of live) {
+        pend(page.route, placed.section.groupKey, "DIALECT_UNSUPPORTED", `${file} is ${dialect ?? "not a template"}.`);
+      }
+      continue;
+    }
+    const tree = await treeOf(file);
+    if (!tree) {
+      for (const placed of live) {
+        pend(page.route, placed.section.groupKey, "NOT_IN_SOURCE", `${file} did not parse.`);
+      }
+      continue;
+    }
+    const parsed = tree.parsed;
+    const importedFiles = /* @__PURE__ */ new Map();
+    for (const [local, from] of importsIn(parsed, dialect)) {
+      const resolved = resolveSpecifier(file, from.specifier, fileSet, aliases);
+      if (resolved === null) continue;
+      importedFiles.set(resolved, [
+        ...importedFiles.get(resolved) ?? [],
+        { local, kind: from.kind, imported: from.imported }
+      ]);
+    }
+    const bindingOf = (held) => {
+      const bindings = importedFiles.get(held) ?? [];
+      return bindings.find((binding) => calledIn(tree, binding)) ?? bindings[0];
+    };
     const placedHere = [];
+    const importedSections = [];
     for (const placed of live) {
       const elements = placed.byFile.get(file);
+      const alsoRendered = [...placed.byFile.keys()].filter((held2) => held2 !== file && importedFiles.has(held2));
       if (elements && elements.length > 0) {
+        if (alsoRendered.length > 0) {
+          pend(
+            page.route,
+            placed.section.groupKey,
+            "SECTION_ROOT_AMBIGUOUS",
+            `rendered inline by ${file} AND by ${alsoRendered.join(", ")}, which it imports.`
+          );
+          continue;
+        }
         placedHere.push({ section: placed.section, elements });
         continue;
       }
+      if (alsoRendered.length > 1) {
+        pend(
+          page.route,
+          placed.section.groupKey,
+          "SECTION_ROOT_AMBIGUOUS",
+          `rendered by ${alsoRendered.join(" and ")}, both imported by ${file}.`
+        );
+        continue;
+      }
+      const only = alsoRendered[0] ?? [...placed.byFile.keys()][0];
+      const held = bindingOf(only);
+      if (held !== void 0 && dialectOf(only, contents.get(only) ?? "") === dialect) {
+        importedSections.push({ section: placed.section, path: only, call: held.local });
+        continue;
+      }
       pend(
         page.route,
         placed.section.groupKey,
         "SECTION_ROOT_AMBIGUOUS",
-        `rendered by ${[...placed.byFile.keys()].join(", ")}, not ${file}.`
+        held === void 0 ? `rendered by ${[...placed.byFile.keys()].join(", ")}, which ${file} does not import.` : `rendered by ${only}, which is ${dialectOf(only, contents.get(only) ?? "") ?? "not a template"}, not ${dialect} like ${file}.`
       );
     }
-    if (placedHere.length === 0) continue;
-    const content = contents.get(file);
-    const dialect = dialectOf(file, content);
-    if (!dialect || !EXTRACTABLE.includes(dialect)) {
-      for (const placed of placedHere) {
-        pend(page.route, placed.section.groupKey, "DIALECT_UNSUPPORTED", `${file} is ${dialect ?? "not a template"}.`);
+    if (placedHere.length === 0 && importedSections.length === 0) continue;
+    const extractable = componentsOf(dialect);
+    const registeredHere = [];
+    for (const held of importedSections) {
+      const component = resolveComponent(plan2, held.section);
+      const already = extractable.get(component.slug);
+      if (already !== void 0 && already.path !== held.path) {
+        pend(
+          page.route,
+          held.section.groupKey,
+          "COMPONENT_CONFLICT",
+          `the slug "${component.slug}" already names ${already.path}, not ${held.path}.`
+        );
+        continue;
       }
-      continue;
-    }
-    const tree = await treeOf(file);
-    if (!tree) {
-      for (const placed of placedHere) {
-        pend(page.route, placed.section.groupKey, "NOT_IN_SOURCE", `${file} did not parse.`);
+      const binding = bindingOf(held.path);
+      const member = binding.kind === "namespace" ? namespaceMember(tree, binding.local) : void 0;
+      if (binding.kind === "namespace" && member === void 0) {
+        pend(
+          page.route,
+          held.section.groupKey,
+          "SECTION_ROOT_AMBIGUOUS",
+          `${held.path} is imported as a namespace and ${file} never calls one of its components, so nothing names the export that renders it.`
+        );
+        continue;
       }
-      continue;
+      extractable.set(component.slug, {
+        name: component.name,
+        path: held.path,
+        kind: binding.kind,
+        imported: binding.imported,
+        ...member ? { member } : {}
+      });
+      registered++;
+      registeredHere.push({
+        slug: component.slug,
+        section: held.section,
+        call: callSiteOf(tree, member ? `${binding.local}.${member}` : held.call)
+      });
     }
-    const parsed = tree.parsed;
     const roots = [];
     for (const placed of placedHere) {
       const root = lowestCommonAncestor(placed.elements);
@@ -5265,7 +5653,13 @@ async function componentizeSources(briefIn, planIn, sources, options) {
         continue;
       }
       const component = resolveComponent(plan2, placed.section);
-      roots.push({ section: placed.section, route: page.route, root, ...component });
+      roots.push({
+        section: placed.section,
+        route: page.route,
+        root,
+        pathPrefix: prefixes.get(placed.section),
+        ...component
+      });
     }
     const nested = /* @__PURE__ */ new Set();
     for (const a of roots) {
@@ -5280,8 +5674,6 @@ async function componentizeSources(briefIn, planIn, sources, options) {
       pend(page.route, resolved.section.groupKey, "SECTION_ROOT_AMBIGUOUS", "its root contains another section's.");
     }
     const candidates = roots.filter((r) => !nested.has(r)).sort((a, b) => a.root.start - b.root.start);
-    if (candidates.length === 0) continue;
-    const extractable = componentsOf(dialect);
     const placeable = [];
     for (const resolved of candidates) {
       const path = `${COMPONENT_DIR}/${resolved.name}.${dialect === "astro" ? "astro" : "tsx"}`;
@@ -5294,7 +5686,25 @@ async function componentizeSources(briefIn, planIn, sources, options) {
         placeable.push(resolved);
         continue;
       }
-      const built = componentFile(dialect, path, file, content, parsed, resolved);
+      const built = componentFile(dialect, path, file, content, parsed, resolved, resolved.pathPrefix);
+      if (built.unconvertible.length > 0) {
+        pend(
+          page.route,
+          resolved.section.groupKey,
+          "PROP_MAP_INCONSISTENT",
+          `its fields map to the prefix "${resolved.pathPrefix}", which ${[...new Set(built.unconvertible)].slice(0, 3).join(", ")} cannot be converted through \u2014 so those elements would stay on the page lane whatever the placement says.`
+        );
+        continue;
+      }
+      if (built.duplicates.length > 0) {
+        pend(
+          page.route,
+          resolved.section.groupKey,
+          "DUPLICATE_FIELD_BINDING",
+          `${built.duplicates.join(", ")} carries more than one data-bcms-field, so there is no single address to rewrite.`
+        );
+        continue;
+      }
       if (built.free.length > 0) {
         pend(
           page.route,
@@ -5304,7 +5714,7 @@ async function componentizeSources(briefIn, planIn, sources, options) {
         );
         continue;
       }
-      extractable.set(resolved.slug, { name: resolved.name, path });
+      extractable.set(resolved.slug, { name: resolved.name, path, kind: "default", imported: null });
       fresh.add(resolved.slug);
       addFile(outFiles, contents, {
         path,
@@ -5313,24 +5723,54 @@ async function componentizeSources(briefIn, planIn, sources, options) {
       });
       placeable.push(resolved);
     }
-    if (placeable.length === 0) continue;
-    const layout = runOf(placeable, parsed.roots);
+    if (placeable.length === 0 && registeredHere.length === 0) continue;
+    const spans = [
+      ...placeable.map((r) => ({ slug: r.slug, bind: bindOf(r.section), root: r.root })),
+      ...registeredHere.map((r) => ({ slug: r.slug, bind: bindOf(r.section), root: r.call }))
+    ].sort((a, b) => (a.root?.start ?? Number.MAX_SAFE_INTEGER) - (b.root?.start ?? Number.MAX_SAFE_INTEGER));
+    const known = spans.filter((s) => s.root !== null);
+    const layout = runOf(known, parsed.roots, content);
     if (layout === null) {
       for (const resolved of placeable) {
         pend(page.route, resolved.section.groupKey, "SECTION_NOT_CONTIGUOUS", "its roots share no container.");
       }
       continue;
     }
+    const wholePage = registeredHere.length === 0 || known.length === spans.length && pending.length === pendingBefore;
+    const useRun = layout.contiguous && wholePage;
     const order = shipped.get(dialect) ?? /* @__PURE__ */ new Map();
     shipped.set(dialect, order);
     order.set(
       pageSlug,
-      placeable.map((r) => ({ slug: r.slug, bind: r.section.groupKey }))
+      spans.map((s) => s.bind === void 0 ? { slug: s.slug } : { slug: s.slug, bind: s.bind })
     );
-    const rewritten = layout.contiguous ? splicePageRun(file, content, dialect, parsed, placeable, pageSlug) : splicePageInline(file, content, dialect, parsed, placeable, pageSlug, extractable);
-    addFile(outFiles, contents, { path: file, operation: "modify", content: rewritten });
-    if (layout.contiguous) extracted += placeable.length;
-    else inlineOnly += placeable.length;
+    if (useRun) {
+      addFile(outFiles, contents, {
+        path: file,
+        operation: "modify",
+        content: splicePageRun(file, content, dialect, parsed, known, pageSlug)
+      });
+      extracted += placeable.length;
+    } else {
+      const inline = placeable.filter((resolved) => !instanceOwned(resolved.section));
+      for (const resolved of placeable) {
+        if (inline.includes(resolved)) continue;
+        pend(
+          page.route,
+          resolved.section.groupKey,
+          "INLINE_NEEDS_INSTANCE",
+          `${file} cannot be replaced by one <Sections page="${pageSlug}" />, and an in-place call site carries no blockId or overrides \u2014 so this placement's own copy could not be rendered or addressed.`
+        );
+      }
+      if (inline.length > 0) {
+        addFile(outFiles, contents, {
+          path: file,
+          operation: "modify",
+          content: splicePageInline(file, content, dialect, parsed, inline, pageSlug, extractable)
+        });
+      }
+      inlineOnly += inline.length;
+    }
   }
   const componentSlugs = [...written.values()].flatMap((held) => [...held.keys()]);
   if (componentSlugs.length > 0) {
@@ -5352,15 +5792,17 @@ async function componentizeSources(briefIn, planIn, sources, options) {
     emitHelper(outFiles, contents, helperVersion, options?.overwriteHelper);
     emitStubs(outFiles, contents, pageSlugs);
   }
-  const sections = assertSections(total, { extracted, inlineOnly, alreadyExtracted, pending });
+  const sections = assertSections(total, { extracted, inlineOnly, alreadyExtracted, registered, pending });
   return {
     files: [...outFiles.values()].sort((a, b) => a.path.localeCompare(b.path)),
     receipt: {
       planDigest: plan2.digest ?? "",
+      copy,
       sections,
       // What THIS run wrote a file for. A component an earlier run left is reused, not re-reported.
       components: [...fresh].sort(),
-      planPending
+      planPending,
+      notes
     }
   };
 }
@@ -5373,29 +5815,152 @@ function alreadyOn(content, pageSlug, sections) {
   }
   return sections.map((section) => section.groupKey).filter((groupKey) => new RegExp(`bind=\\s*["']${groupKey.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}["']`).test(content));
 }
-function readRegistry(content, dialect) {
+async function readRegistry(content, dialect, path, files, aliases) {
   const components = /* @__PURE__ */ new Map();
   const shipped = /* @__PURE__ */ new Map();
-  const paths = /* @__PURE__ */ new Map();
-  for (const match of content.matchAll(/^import\s+(\w+)\s+from\s+"\.\/([^"]+)";$/gm)) {
-    const [, name, file] = match;
-    paths.set(name, `${COMPONENT_DIR}/${file}${dialect === "astro" ? "" : ".tsx"}`);
-  }
-  const registry = content.match(/const REGISTRY[^=]*=\s*\{([\s\S]*?)\n\};/);
-  for (const match of (registry?.[1] ?? "").matchAll(/^\s*"([^"]+)":\s*(\w+),$/gm)) {
-    const [, slug, name] = match;
-    const path = paths.get(name);
-    if (path) components.set(slug, { name, path });
-  }
-  const table = content.match(/const SHIPPED[^=]*=\s*\{([\s\S]*?)\n\};/);
-  for (const match of (table?.[1] ?? "").matchAll(/^\s*"([^"]+)":\s*(\[.*\]),$/gm)) {
+  const parsed = await parseFile4(dialect, content);
+  if (parsed.error) return null;
+  const imports = /* @__PURE__ */ new Map();
+  for (const [local, from] of importsIn(parsed, dialect)) {
+    if (!from.specifier.startsWith(".")) continue;
+    const resolved = resolveSpecifier(path, from.specifier, files, aliases);
+    if (resolved !== null) {
+      imports.set(local, { name: local, path: preferDialect(resolved, dialect, files), kind: from.kind, imported: from.imported });
+    }
+  }
+  const registry = blockOf(content, "REGISTRY");
+  const table = blockOf(content, "SHIPPED");
+  if (registry === null || table === null) return null;
+  const registryRows = propertiesOf(registry);
+  const shippedRows = propertiesOf(table);
+  if (registryRows === null || shippedRows === null) return null;
+  if (registryRows.length === 0) return null;
+  for (const row of registryRows) {
+    const named = row.value.match(/^([A-Za-z_$][\w$]*)(?:\.([A-Za-z_$][\w$]*))?$/);
+    const entry = named ? imports.get(named[1]) : void 0;
+    if (!named || !entry) return null;
+    components.set(row.key, named[2] === void 0 ? entry : { ...entry, member: named[2] });
+  }
+  for (const row of shippedRows) {
     try {
-      shipped.set(match[1], JSON.parse(match[2]));
+      const placements = JSON.parse(row.value);
+      if (!Array.isArray(placements) || placements.length === 0 || !placements.every(isPlacement)) return null;
+      if (placements.some((placement) => !components.has(placement.slug))) return null;
+      shipped.set(row.key, placements);
     } catch {
+      return null;
     }
   }
   return { components, shipped };
 }
+function preferDialect(resolved, dialect, files) {
+  const wanted = dialect === "astro" ? [".astro"] : [".tsx", ".jsx"];
+  if (wanted.some((extension) => resolved.endsWith(extension))) return resolved;
+  const base = resolved.replace(/\.[^./]+$/, "");
+  return wanted.map((extension) => `${base}${extension}`).find((candidate) => files.has(candidate)) ?? resolved;
+}
+function isPlacement(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+  const held = value;
+  if (typeof held.slug !== "string") return false;
+  return ["bind", "blockId"].every((key) => held[key] === void 0 || typeof held[key] === "string");
+}
+function blockOf(content, name) {
+  const declaration2 = content.indexOf(`const ${name}`);
+  if (declaration2 < 0) return null;
+  const open = content.indexOf("{", declaration2);
+  if (open < 0) return null;
+  let depth = 0;
+  let at = open;
+  while (at < content.length) {
+    const skip = skipTrivia(content, at);
+    if (skip >= 0) {
+      at = skip;
+      continue;
+    }
+    if (content[at] === "{") depth++;
+    else if (content[at] === "}" && --depth === 0) return content.slice(open + 1, at);
+    at++;
+  }
+  return null;
+}
+function skipTrivia(source, at) {
+  const char = source[at];
+  if (char === '"' || char === "'" || char === "`") {
+    let cursor = at + 1;
+    while (cursor < source.length && source[cursor] !== char) cursor += source[cursor] === "\\" ? 2 : 1;
+    return Math.min(cursor + 1, source.length);
+  }
+  if (char === "/" && source[at + 1] === "/") {
+    const line = source.indexOf("\n", at);
+    return line < 0 ? source.length : line;
+  }
+  if (char === "/" && source[at + 1] === "*") {
+    const close = source.indexOf("*/", at + 2);
+    return close < 0 ? source.length : close + 2;
+  }
+  return -1;
+}
+function withoutComments(text) {
+  let out = "";
+  let at = 0;
+  while (at < text.length) {
+    const skip = skipTrivia(text, at);
+    if (skip < 0) {
+      out += text[at];
+      at++;
+      continue;
+    }
+    out += text[at] === '"' || text[at] === "'" || text[at] === "`" ? text.slice(at, skip) : "";
+    at = skip;
+  }
+  return out;
+}
+function propertiesOf(block) {
+  const out = [];
+  const push = (text) => {
+    const held = text.trim();
+    if (held === "") return true;
+    let depth2 = 0;
+    for (let at = 0; at < held.length; ) {
+      const skip = skipTrivia(held, at);
+      if (skip >= 0) {
+        at = skip;
+        continue;
+      }
+      const char = held[at];
+      if ("{[(".includes(char)) depth2++;
+      else if ("}])".includes(char)) depth2--;
+      else if (char === ":" && depth2 === 0) {
+        const key = withoutComments(held.slice(0, at)).trim().replace(/^["'`]|["'`]$/g, "");
+        const value = withoutComments(held.slice(at + 1)).trim();
+        if (key === "" || value === "") return false;
+        out.push({ key, value });
+        return true;
+      }
+      at++;
+    }
+    return false;
+  };
+  let depth = 0;
+  let start = 0;
+  for (let at = 0; at < block.length; ) {
+    const skip = skipTrivia(block, at);
+    if (skip >= 0) {
+      at = skip;
+      continue;
+    }
+    const char = block[at];
+    if ("{[(".includes(char)) depth++;
+    else if ("}])".includes(char)) depth--;
+    else if (char === "," && depth === 0) {
+      if (!push(block.slice(start, at))) return null;
+      start = at + 1;
+    }
+    at++;
+  }
+  return push(block.slice(start)) ? out : null;
+}
 function snapshotUsable(existing) {
   if (existing === void 0) return true;
   try {
@@ -5480,7 +6045,22 @@ function lowestCommonAncestor(elements) {
   }
   return common[common.length - 1] ?? null;
 }
-function runOf(placeable, roots) {
+var calledIn = (tree, binding) => [...tree.elements.values()].some(
+  (placed) => binding.kind === "namespace" ? placed.node.tag.startsWith(`${binding.local}.`) : placed.node.tag === binding.local
+);
+function namespaceMember(tree, local) {
+  const members = new Set(
+    [...tree.elements.values()].map((placed) => placed.node.tag).filter((tag) => tag.startsWith(`${local}.`)).map((tag) => tag.slice(local.length + 1))
+  );
+  return members.size === 1 ? [...members][0] : void 0;
+}
+function callSiteOf(tree, local) {
+  const calls = [...tree.elements.values()].map((placed) => placed.node).filter((node) => node.tag === local);
+  const only = calls.length === 1 ? calls[0] : null;
+  return only !== null && only.attrs.length === 0 ? only : null;
+}
+function runOf(placeable, roots, content) {
+  if (placeable.length === 0) return null;
   const parents = placeable.map((r) => parentOf(r.root, roots));
   if (parents.some((p) => p === void 0)) return null;
   const [first, ...rest] = parents;
@@ -5490,9 +6070,14 @@ function runOf(placeable, roots) {
   );
   const indices = placeable.map((r) => siblings.indexOf(r.root)).sort((a, b) => a - b);
   if (indices.some((at) => at < 0)) return null;
-  const contiguous = indices.every((at, i) => i === 0 || at === indices[i - 1] + 1);
-  return { contiguous };
+  const consecutive2 = indices.every((at, i) => i === 0 || at === indices[i - 1] + 1);
+  const ordered = [...placeable].sort((a, b) => a.root.start - b.root.start);
+  const clean = ordered.every(
+    (span, at) => at === 0 || isTrivia(content.slice(ordered[at - 1].root.end, span.root.start))
+  );
+  return { contiguous: consecutive2 && clean };
 }
+var isTrivia = (between) => between.replace(/<!--[\s\S]*?-->/g, "").replace(/\{\s*\/\*[\s\S]*?\*\/\s*\}/g, "").trim() === "";
 function parentOf(target, roots) {
   if (roots.some((node) => node === target)) return null;
   const search = (nodes, parent) => {
@@ -5526,14 +6111,35 @@ function pascal(value) {
   return /^[A-Za-z]/.test(name) ? name : `Section${name}`;
 }
 var slugify = (value) => value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "") || "section";
-function componentFile(dialect, path, fromFile, content, parsed, resolved) {
-  const markup = sliceWithBlockId(content, resolved.root);
+function componentFile(dialect, path, fromFile, content, parsed, resolved, pathPrefix) {
+  const addresses = fieldAddresses(content, elementsUnder(resolved.root));
+  const unconvertible = [
+    ...addresses.heads.filter((address) => !address.startsWith(pathPrefix)),
+    ...addresses.opaque
+  ];
+  if (unconvertible.length > 0) return { content: "", free: [], duplicates: [], unconvertible };
+  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, [
+    { key: "bcmsFields", name: "bcmsFields" },
+    { key: "bcmsField", name: "bcmsField" }
+  ]);
+  const fieldsName = introduced.get("bcmsFields");
+  const fieldName = introduced.get("bcmsField");
+  const { markup, bound, duplicates } = sectionMarkup(content, resolved.root, fieldName);
+  if (duplicates.length > 0) return { content: "", free: [], duplicates, unconvertible: [] };
   const groupKey = resolved.section.groupKey;
   const locals = helperLocals(parsed, dialect, fromFile);
   const helperNames = ["bcms", "bcmsRows", "bcmsLayout"].flatMap(
     (name) => locals[name].filter((local) => mentions(markup, local)).map((local) => ({ name, local }))
   );
-  const helpers = [.../* @__PURE__ */ new Set([...helperNames.map((h) => alias(h.name, h.local)), "bcmsSection"])].sort();
+  const helpers = [
+    .../* @__PURE__ */ new Set([
+      ...helperNames.map((h) => alias(h.name, h.local)),
+      "bcmsSection",
+      ...bound > 0 ? [alias("bcmsFields", fieldsName)] : []
+    ])
+  ].sort();
   const helperSpecifier = relativeImport(path, HELPER_PATH[dialect]).replace(/\.tsx?$/, "");
   const snapshot = snapshotOf(parsed, dialect, fromFile, markup);
   const carry = carryFor({
@@ -5548,20 +6154,23 @@ function componentFile(dialect, path, fromFile, content, parsed, resolved) {
       "bind",
       "overrides",
       "page",
+      fieldName,
       ...helperNames.map((h) => h.local),
       ...snapshot ? [snapshot] : []
     ],
     // The helper and the snapshots are what the component declares for itself.
     skipSpecifier: (repoPath, specifier) => specifier.includes(`${CONTENT_DIR}/`) || repoPath.startsWith(HELPER_PATH[dialect].replace(/\.tsx?$/, ""))
   });
-  if (carry.free.length > 0) return { content: "", free: carry.free };
+  if (carry.free.length > 0) return { content: "", free: carry.free, duplicates: [], unconvertible: [] };
   const carried = [...carry.imports];
   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 ?? ${JSON.stringify(groupKey)}, overrides) };` : "";
+  const copy = snapshot ? `const ${snapshot} = { ${key}: bcmsSection(page, bind, overrides) };` : "";
+  const field = bound > 0 ? `const ${fieldName} = ${fieldsName}({ blockId, bind, overrides }, ${JSON.stringify(pathPrefix)});` : "";
+  const declared = [copy, field].filter(Boolean).join("\n");
   if (dialect === "astro") {
-    return { free: [], content: `---
+    return { free: [], duplicates: [], unconvertible: [], content: `---
 ${SECTION_MARKER}
 ${[...carried, `import { ${helpers.join(", ")} } from "${helperSpecifier}";`].join("\n")}
 
@@ -5576,27 +6185,297 @@ interface Props {
   page?: unknown;
 }
 const { blockId, bind, overrides, page } = Astro.props;
-${carriedDeclarations}${copy}
+${carriedDeclarations}${declared}
 ---
 ${markup}
 ` };
   }
-  return { free: [], content: `${SECTION_MARKER}
+  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")}
 ${carriedDeclarations === "" ? "" : `
 ${carriedDeclarations}`}
 export default function ${resolved.name}({ blockId, bind, overrides, page }: BcmsSectionProps) {
-  ${copy}
+  ${declared.split("\n").join("\n  ")}
   return (
     ${markup}
   );
 }
 ` };
 }
-function sliceWithBlockId(content, root) {
+function sectionMarkup(content, root, fieldName) {
   const slice = new MagicString3(content.slice(root.start, root.end));
-  slice.appendLeft(root.attrInsertAt - root.start, " data-bcms-block={blockId}");
-  return slice.toString();
+  const at = (offset) => offset - root.start;
+  const stamps = root.attrs.filter((attr) => attr.name === "data-bcms-block");
+  if (stamps.length === 0) slice.appendLeft(at(root.attrInsertAt), " data-bcms-block={blockId}");
+  else {
+    slice.overwrite(at(stamps[0].range.start), at(stamps[0].range.end), "data-bcms-block={blockId}");
+    for (const extra of stamps.slice(1)) {
+      let from = extra.range.start;
+      while (from > root.start && /\s/.test(content[from - 1])) from--;
+      slice.remove(at(from), at(extra.range.end));
+    }
+  }
+  const wrapped = wrapFieldAttrs(slice, content, elementsUnder(root), at, fieldName);
+  return { markup: slice.toString(), ...wrapped };
+}
+function wrapFieldAttrs(slice, content, elements, at, fieldName) {
+  let bound = 0;
+  const duplicates = [];
+  for (const element of elements) {
+    const fields = element.attrs.filter((attr) => attr.name === "data-bcms-field");
+    if (fields.length > 1) {
+      duplicates.push(`<${element.tag}>`);
+      continue;
+    }
+    for (const attr of fields) {
+      bound++;
+      if (attr.expressionRange) {
+        slice.appendRight(at(attr.expressionRange.start) + 1, `${fieldName}(`);
+        slice.appendLeft(at(attr.expressionRange.end) - 1, ")");
+        continue;
+      }
+      const value = attr.valueRange ? content.slice(attr.valueRange.start, attr.valueRange.end) : "";
+      slice.overwrite(
+        at(attr.range.start),
+        at(attr.range.end),
+        `data-bcms-field={${fieldName}(${JSON.stringify(value)})}`
+      );
+    }
+  }
+  return { bound, duplicates };
+}
+function provableAddress(expression) {
+  const first = expression[0];
+  if (first === '"' || first === "'") {
+    for (let at = 1; at < expression.length; at++) {
+      if (expression[at] === "\\") {
+        at++;
+        continue;
+      }
+      if (expression[at] === first) return at === expression.length - 1 ? expression.slice(1, at) : null;
+    }
+    return null;
+  }
+  if (first !== "`" || expression.length < 2 || !expression.endsWith("`")) return null;
+  const body = expression.slice(1, -1);
+  if (body.includes("`") || body.includes("\\")) return null;
+  let head = null;
+  for (let at = 0; at < body.length; at++) {
+    if (body[at] !== "$" || body[at + 1] !== "{") continue;
+    const close = body.indexOf("}", at + 2);
+    if (close < 0) return null;
+    if (!/^[A-Za-z_$][\w$]*$/.test(body.slice(at + 2, close).trim())) return null;
+    if (body[at - 1] !== "[" || body[close + 1] !== "]") return null;
+    head ??= body.slice(0, at);
+    at = close;
+  }
+  return head ?? body;
+}
+function fieldAddresses(content, elements) {
+  const heads = [];
+  const opaque = [];
+  for (const element of elements) {
+    for (const attr of element.attrs) {
+      if (attr.name !== "data-bcms-field") continue;
+      if (!attr.expression && attr.valueRange) {
+        heads.push(content.slice(attr.valueRange.start, attr.valueRange.end));
+        continue;
+      }
+      const inner = attr.expressionRange ? content.slice(attr.expressionRange.start + 1, attr.expressionRange.end - 1).trim() : "";
+      const head = provableAddress(inner);
+      if (head === null) opaque.push(`data-bcms-field={${inner}}`);
+      else heads.push(head);
+    }
+  }
+  return { heads, opaque };
+}
+function elementsUnder(...roots) {
+  const out = [];
+  const walk = (node) => {
+    if (node.type === "element") {
+      out.push(node);
+      for (const child of node.children) walk(child);
+      return;
+    }
+    if (node.type === "expr") for (const child of node.children) walk(child);
+  };
+  for (const root of roots) walk(root);
+  return out;
+}
+var V1_ANCHOR = {
+  astro: "const { blockId, bind, overrides, page } = Astro.props;",
+  jsx: "}: BcmsSectionProps) {"
+};
+var refusalKey = (dialect, slug) => `${dialect}\0${slug}`;
+function generatedBindings(parsed) {
+  const program = parsed.ast?.program;
+  const body = program?.body ?? [];
+  const scopes = [body];
+  for (const statement of body) {
+    const declaration2 = statement.type === "ExportDefaultDeclaration" ? statement.declaration : void 0;
+    const inner = declaration2?.type === "FunctionDeclaration" ? declaration2.body?.body : void 0;
+    if (inner) scopes.push(inner);
+  }
+  const out = /* @__PURE__ */ new Map();
+  for (const scope of scopes) {
+    for (const statement of scope) {
+      if (statement.type !== "VariableDeclaration") continue;
+      for (const declarator of statement.declarations ?? []) {
+        const id = declarator.id;
+        const name = id?.type === "Identifier" ? id.name : void 0;
+        if (name !== void 0 && !out.has(name)) out.set(name, declarator.init);
+      }
+    }
+  }
+  return out;
+}
+function stripBindFallback(parsed, source, content, locals) {
+  if (!parsed.ast?.program) return "unreadable";
+  const offset = parsed.script?.offset ?? 0;
+  let rewritten = 0;
+  let unproven = 0;
+  walkAst(parsed.ast, (node) => {
+    if (node.type !== "CallExpression") return;
+    const argument = (node.arguments ?? [])[1];
+    if (argument?.type !== "LogicalExpression" || argument.operator !== "??") return;
+    const callee = node.callee;
+    if (callee?.type !== "Identifier" || !locals.has(callee.name)) {
+      unproven++;
+      return;
+    }
+    const left = argument.left;
+    source.overwrite(
+      offset + argument.start,
+      offset + argument.end,
+      content.slice(offset + left.start, offset + left.end)
+    );
+    rewritten++;
+  });
+  return rewritten === 0 && unproven > 0 ? "unproven" : "ok";
+}
+var isCallOf = (init, callee) => {
+  const fn = init?.type === "CallExpression" ? init.callee : void 0;
+  return fn?.type === "Identifier" && fn.name === callee;
+};
+async function migrateSections(plan2, contents, written, fileSet, aliases) {
+  const files = [];
+  const refused = /* @__PURE__ */ new Map();
+  const prefixesFor = (slug) => {
+    const out = /* @__PURE__ */ new Set();
+    for (const page of plan2.pages ?? []) {
+      for (const section of page.sections ?? []) {
+        if (resolveComponent(plan2, section).slug !== slug) continue;
+        const prefix = propPrefix(section);
+        if (prefix !== null) out.add(prefix);
+      }
+    }
+    return [...out];
+  };
+  for (const [dialect, components] of written) {
+    for (const [slug, entry] of components) {
+      const content = contents.get(entry.path);
+      if (content === void 0 || content.includes(SECTION_MARKER)) continue;
+      const older = SECTION_MARKERS.find((marker) => content.includes(marker));
+      if (older === void 0) continue;
+      const candidates = prefixesFor(slug);
+      if (candidates.length === 0) continue;
+      const parsed = await parseFile4(dialect, content);
+      if (parsed.error) {
+        refused.set(refusalKey(dialect, slug), `${entry.path} carries our marker but does not parse (${parsed.error.message}).`);
+        continue;
+      }
+      const elements = elementsUnder(...parsed.roots);
+      const imports = [...importsIn(parsed, dialect)];
+      const helperModule = HELPER_PATH[dialect];
+      const helperLocalsFor = (exported) => new Set(
+        imports.filter(
+          ([, from]) => from.imported === exported && resolveSpecifier(entry.path, from.specifier, fileSet, aliases) === helperModule
+        ).map(([local]) => local)
+      );
+      const { heads: evidence, opaque } = fieldAddresses(content, elements);
+      const pathPrefix = evidence.length + opaque.length === 0 ? "" : opaque.length > 0 ? null : onlyOne(candidates.filter((prefix) => evidence.every((head) => head.startsWith(prefix)))) ?? null;
+      if (pathPrefix === null) {
+        const matching = candidates.filter((prefix) => evidence.every((head) => head.startsWith(prefix)));
+        refused.set(
+          refusalKey(dialect, slug),
+          opaque.length > 0 ? `${entry.path} carries ${[...new Set(opaque)].slice(0, 3).join(", ")}, whose address this cannot read \u2014 so there is no prefix it can be shown to convert through.` : matching.length === 0 ? `${entry.path} declares ${evidence.length > 0 ? `addresses (${[...new Set(evidence)].slice(0, 3).join(", ")})` : "addresses"} that match none of this slug's placements (${candidates.join(", ") || "none with a usable prop map"}), so the prefix its markup was cut with cannot be recovered.` : `${entry.path} matches more than one of this slug's placements (${matching.join(", ")}), so the prefix its markup was cut with is ambiguous.`
+        );
+        continue;
+      }
+      const source = new MagicString3(content);
+      const { bound, duplicates } = wrapFieldAttrs(source, content, elements, (at) => at, "bcmsField");
+      if (duplicates.length > 0) {
+        refused.set(refusalKey(dialect, slug), `${entry.path} has ${duplicates.join(", ")} carrying more than one data-bcms-field, so there is no single address to rewrite.`);
+        continue;
+      }
+      const markerEnd = content.indexOf(older) + older.length;
+      source.overwrite(markerEnd - older.length, markerEnd, SECTION_MARKER);
+      const stripped = stripBindFallback(parsed, source, content, helperLocalsFor("bcmsSection"));
+      if (stripped !== "ok") {
+        refused.set(
+          refusalKey(dialect, slug),
+          stripped === "unreadable" ? `${entry.path} carries our marker but its module could not be read as a program, so the Phase A \`bind ?? "\u2026"\` fallback cannot be shown to be gone.` : `${entry.path} carries a \`?? \` fallback in a call this cannot identify as ${helperModule}'s bcmsSection, so the Phase A page-group default cannot be shown to be gone.`
+        );
+        continue;
+      }
+      if (bound > 0) {
+        const locals = generatedBindings(parsed);
+        const names = /* @__PURE__ */ new Set([...topLevelBindings(dialect, parsed, content), ...locals.keys()]);
+        const fieldsLocal = [...helperLocalsFor("bcmsFields")][0];
+        if (fieldsLocal === void 0 && names.has("bcmsFields")) {
+          refused.set(
+            refusalKey(dialect, slug),
+            `${entry.path} already binds "bcmsFields" to something other than ${helperModule}'s export.`
+          );
+          continue;
+        }
+        const declared = names.has("bcmsField");
+        if (declared && (fieldsLocal === void 0 || !isCallOf(locals.get("bcmsField"), fieldsLocal))) {
+          refused.set(
+            refusalKey(dialect, slug),
+            `${entry.path} already binds "bcmsField" to something other than a call of ${helperModule}'s bcmsFields.`
+          );
+          continue;
+        }
+        if (!declared) {
+          const anchor = V1_ANCHOR[dialect];
+          const at = anchor ? content.indexOf(anchor) : -1;
+          if (anchor === void 0 || at < 0) {
+            refused.set(refusalKey(dialect, slug), `${entry.path} carries our marker but no longer declares its placement, so there is nowhere the chooser can be put.`);
+            continue;
+          }
+          source.appendLeft(
+            at + anchor.length,
+            `
+${dialect === "astro" ? "" : "  "}const bcmsField = ${fieldsLocal ?? "bcmsFields"}({ blockId, bind, overrides }, ${JSON.stringify(pathPrefix)});`
+          );
+        }
+        if (fieldsLocal === void 0) {
+          const helper = imports.find(([, from]) => from.imported === "bcmsSection")?.[1].specifier ?? relativeImport(entry.path, HELPER_PATH[dialect]).replace(/\.tsx?$/, "");
+          source.appendLeft(markerEnd, `
+import { bcmsFields } from "${helper}";`);
+        }
+      }
+      files.push({ path: entry.path, operation: "modify", content: source.toString() });
+    }
+  }
+  return { files, refused };
+}
+function propPrefix(section) {
+  const prefixes = /* @__PURE__ */ new Set();
+  for (const field of section.fields ?? []) {
+    const { path, key } = field;
+    if (typeof path !== "string" || typeof key !== "string") continue;
+    if (!path.endsWith(key)) return null;
+    prefixes.add(path.slice(0, path.length - key.length));
+  }
+  if (prefixes.size > 1) return null;
+  return prefixes.size === 1 ? [...prefixes][0] : `${section.groupKey}.`;
+}
+function referencedNames2(markup) {
+  const out = /* @__PURE__ */ new Set();
+  for (const [name] of markup.matchAll(/[A-Za-z_$][\w$]*/g)) out.add(name);
+  return out;
 }
 var alias = (name, local) => name === local ? name : `${name} as ${local}`;
 var mentions = (markup, name) => new RegExp(`(?<![\\w$])${name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}(?![\\w$])`).test(markup);
@@ -5712,9 +6591,9 @@ function registryFile(dialect, path, written, shipped) {
   const entries = [...written].sort(([a], [b]) => a.localeCompare(b));
   const imports = entries.map(([, component]) => {
     const specifier = relativeImport(path, component.path);
-    return `import ${component.name} from "${dialect === "astro" ? specifier : specifier.replace(/\.tsx?$/, "")}";`;
+    return importLine(component.name, dialect === "astro" ? specifier : specifier.replace(/\.tsx?$/, ""), component);
   }).join("\n");
-  const registry = entries.map(([slug, component]) => `  ${JSON.stringify(slug)}: ${component.name},`).join("\n");
+  const registry = entries.map(([slug, component]) => `  ${JSON.stringify(slug)}: ${registryValue(component)},`).join("\n");
   const shippedTable = [...shipped].sort(([a], [b]) => a.localeCompare(b)).map(([page, list]) => `  ${JSON.stringify(page)}: ${JSON.stringify(list)},`).join("\n");
   const lib = relativeImport(path, SECTIONS_LIB).replace(/\.tsx?$/, "");
   const registryType = dialect === "astro" ? "Record<string, unknown>" : "Record<string, (props: BcmsSectionProps) => JSX.Element | null>";
@@ -5822,17 +6701,24 @@ function splicePageInline(file, content, dialect, parsed, placeable, pageSlug, w
   const snapshot = names.get("pageSnapshot");
   const source = new MagicString3(content);
   for (const resolved of placeable) {
+    const component = written.get(resolved.slug);
+    const tag = component.member ? `${names.get(resolved.slug)}.${component.member}` : names.get(resolved.slug);
     source.overwrite(
       resolved.root.start,
       resolved.root.end,
-      `<${names.get(resolved.slug)} bind=${JSON.stringify(resolved.section.groupKey)} page={${snapshot}(${JSON.stringify(pageSlug)})} />`
+      `<${tag} bind=${JSON.stringify(resolved.section.groupKey)} page={${snapshot}(${JSON.stringify(pageSlug)})} />`
     );
   }
   const lib = relativeImport(file, SECTIONS_LIB).replace(/\.tsx?$/, "");
   const imports = [
     ...wanted.map(({ key }) => {
-      const specifier = relativeImport(file, written.get(key).path);
-      return `import ${names.get(key)} from "${dialect === "astro" ? specifier : specifier.replace(/\.tsx?$/, "")}";`;
+      const component = written.get(key);
+      const specifier = relativeImport(file, component.path);
+      return importLine(
+        names.get(key),
+        dialect === "astro" ? specifier : specifier.replace(/\.tsx?$/, ""),
+        component
+      );
     }),
     `import { pageSnapshot${snapshot === "pageSnapshot" ? "" : ` as ${snapshot}`} } from "${lib}";`
   ];
@@ -5848,7 +6734,7 @@ function addImports(source, parsed, lines) {
   else source.appendLeft(at.at, `
 ${lines.join("\n")}`);
 }
-var isGenerated = (content) => content.includes(SECTION_MARKER) || content.includes(REGISTRY_MARKER);
+var isGenerated = (content) => SECTION_MARKERS.some((marker) => content.includes(marker)) || content.includes(REGISTRY_MARKER);
 function emitHelper(out, contents, version, overwrite) {
   const path = HELPER_PATH.astro;
   const source = helperSource("astro");
@@ -6005,28 +6891,78 @@ async function convertSources(briefIn, sources, options) {
     );
   }
   let declaredOnly = 0;
+  const declaredRows = [];
+  const briefRoutes = new Set(brief.pages.map((page) => page.route));
+  const declaredRow = (target, readsFromCms, file) => {
+    declaredRows.push({
+      route: target.route,
+      scope: target.scope,
+      path: target.path,
+      kind: target.kind,
+      ...file ? { file } : {},
+      readsFromCms
+    });
+  };
   const witnessed = async (target) => {
     for (const source of sources) {
       const parsed = await parseOf(source.path);
       const dialect = dialectOf(source.path, source.content);
       if (!parsed || !dialect) continue;
-      if (convertedHere(source.content, parsed, dialect, target, source.path)) return true;
+      if (convertedHere(source.content, parsed, dialect, target, source.path) && attributable(target, source.path)) {
+        return source.path;
+      }
     }
-    return false;
+    return null;
   };
   const locatedByKey = /* @__PURE__ */ new Map();
   for (const hit of located) {
     const key = keyOf(hit.route, hit.scope ?? "page", hit.path);
     if (!locatedByKey.has(key)) locatedByKey.set(key, hit);
   }
+  const sharingPath = /* @__PURE__ */ new Map();
+  for (const [key, hit] of locatedByKey) {
+    const held = targets.get(key);
+    if (!held) continue;
+    const id = scopedPath(held.scope, held.path);
+    sharingPath.set(id, [...sharingPath.get(id) ?? [], { key, files: hit.files }]);
+  }
+  const claimedByAnother = (target, file) => (sharingPath.get(scopedPath(target.scope, target.path)) ?? []).some(
+    (other) => other.key !== target.key && other.files.includes(file)
+  );
+  const attributable = (target, file, claimed) => {
+    if (target.scope === "layout") return true;
+    const serves = routeOfFile(file);
+    if (serves !== null && serves !== target.route && briefRoutes.has(serves)) return false;
+    if (serves === target.route && pageFilesFor(target.route, contents.keys()).length !== 1) return false;
+    return claimed !== true;
+  };
+  const declaredByHand = (target, within) => {
+    const candidates = within ?? (target.scope === "layout" ? sources.map((s) => s.path) : pageFilesFor(target.route, contents.keys()));
+    for (const file of candidates) {
+      if (!covers(declarations.get(file), target)) continue;
+      if (attributable(target, file, within !== void 0 && claimedByAnother(target, file))) return file;
+    }
+    return null;
+  };
   const missed = /* @__PURE__ */ new Set();
   for (const miss of unlocated) {
     const key = keyOf(miss.route, miss.scope ?? "page", miss.path);
     const target = targets.get(key);
     if (!target || locatedByKey.has(key) || missed.has(key)) continue;
     missed.add(key);
-    if (await witnessed(target)) declaredOnly++;
-    else pend(target, miss.reason === "no-original" ? "NO_ORIGINAL" : "NOT_IN_SOURCE");
+    const witness = await witnessed(target);
+    if (witness !== null) {
+      declaredOnly++;
+      declaredRow(target, true, witness);
+      continue;
+    }
+    const byHand = declaredByHand(target);
+    if (byHand !== null) {
+      declaredOnly++;
+      declaredRow(target, false, byHand);
+      continue;
+    }
+    pend(target, miss.reason === "no-original" ? "NO_ORIGINAL" : "NOT_IN_SOURCE");
   }
   const byFile = /* @__PURE__ */ new Map();
   for (const [key, hit] of locatedByKey) {
@@ -6084,8 +7020,21 @@ async function convertSources(briefIn, sources, options) {
     if (worst) {
       const file = hit.files[outcomes.indexOf(worst)];
       pend(target, worst, file);
-    } else if (outcomes.every((o) => o === "declared")) alreadyDeclared++;
-    else rewritten++;
+    } else if (outcomes.every((o) => o === "declared")) {
+      const witness = await witnessed(target);
+      const byHand = witness === null ? declaredByHand(target, hit.files) : null;
+      if (witness === null && byHand === null) {
+        pend(
+          target,
+          "AMBIGUOUS_LITERAL",
+          hit.files[0],
+          `${hit.files.join(", ")} already declares ${target.path}, and nothing there says it is ${target.route}'s.`
+        );
+        continue;
+      }
+      alreadyDeclared++;
+      declaredRow(target, witness !== null, witness ?? byHand);
+    } else rewritten++;
   }
   for (const [file, splices] of [...componentEdits].sort(([a], [b]) => a.localeCompare(b))) {
     const source = new MagicString4(contents.get(file));
@@ -6111,12 +7060,27 @@ async function convertSources(briefIn, sources, options) {
   emitStubs2(dialects, snapshotSlugs, contents, outFiles);
   const receipt = assertReceipt({
     briefDigest: digest,
-    paths: { declared: targets.size, rewritten, alreadyDeclared, pending },
+    paths: {
+      declared: targets.size,
+      rewritten,
+      alreadyDeclared,
+      declarations: declaredRows.sort(
+        (a, b) => a.route.localeCompare(b.route) || a.scope.localeCompare(b.scope) || a.path.localeCompare(b.path)
+      ),
+      pending
+    },
     occurrences: { located: occurrencesLocated, rewritten: occurrencesRewritten },
     files: receiptFiles,
     helpers,
     helperUpgraded,
-    dynamicBindings
+    dynamicBindings,
+    notes: unreadableConfigs(sources).map(
+      (file) => ({
+        code: "TSCONFIG_UNREADABLE",
+        file,
+        message: `${file} is not JSON this package can read, so its \`paths\` aliases resolved to nothing.`
+      })
+    )
   });
   return { files: outFiles.sort((a, b) => a.path.localeCompare(b.path)), receipt };
 }
@@ -6384,14 +7348,12 @@ async function plan(file, content, dialect, targets, sites, importAt, outcomes,
       looped.add(member.key);
       outcomes.set(member.key, "rewritten");
     }
-    for (const leaf of [...new Set(members.map((m) => m.leaf))]) {
+    for (const declaration2 of plan2.declarations) {
       dynamic.push({
         file,
         prop: null,
-        path: shapeOf(arrayPath, leaf),
-        // The loop's OWN index name — `i_1` when the row already bound `i`. Hardcoding `i` here
-        // described a binding the file does not contain, which is what the proposer looks for.
-        callSites: [{ file, literal: `${arrayPath}[\${${plan2.names.index}}].${leaf}` }]
+        path: declaration2.path,
+        callSites: [{ file, literal: declaration2.literal }]
       });
     }
     rewrites.push({
@@ -6625,7 +7587,7 @@ function emitStubs2(dialects, slugs, contents, out) {
 }
 
 // src/cli.ts
-var VERSION = "0.2.0";
+var VERSION = "0.4.0";
 var MAX_FILE_BYTES = 512 * 1024;
 var CliError = class extends Error {
 };
@@ -6634,6 +7596,7 @@ function parseArgs(argv) {
     brief: void 0,
     componentize: false,
     plan: void 0,
+    copy: "bind",
     root: ".",
     dryRun: false,
     receipt: void 0,
@@ -6647,7 +7610,13 @@ function parseArgs(argv) {
     if (arg === "--brief") args.brief = argv[++i];
     else if (arg === "--componentize") args.componentize = true;
     else if (arg === "--plan") args.plan = argv[++i];
-    else if (arg === "--root") args.root = argv[++i] ?? ".";
+    else if (arg === "--copy") {
+      const mode = argv[++i];
+      if (mode !== "bind" && mode !== "instance") {
+        throw new CliError(`--copy takes "bind" or "instance", not ${JSON.stringify(mode ?? "")}. See --help.`);
+      }
+      args.copy = mode;
+    } else if (arg === "--root") args.root = argv[++i] ?? ".";
     else if (arg === "--receipt") args.receipt = argv[++i];
     else if (arg === "--dry-run") args.dryRun = true;
     else if (arg === "--strict") args.strict = true;
@@ -6671,6 +7640,10 @@ var HELP = `bettercms-convert ${VERSION}
   --componentize       Lift each planned SECTION into a component the CMS can reorder.
   --plan <file>        The componentize plan, as get_componentize_plan returns it.
                        Required with --componentize.
+  --copy bind|instance Which copy model the plan is expected to describe. Default: bind
+                       (the copy stays in the page's field groups). "instance" is refused
+                       \u2014 COPY_MODE_MISMATCH \u2014 unless the plan's placements say the server
+                       has already moved it onto them.
   --root <dir>         The repository to convert. Default: the working directory.
   --dry-run            Print what would change; write nothing.
   --receipt <file>     Write the receipt as JSON.
@@ -6748,14 +7721,14 @@ ${rewritten} of ${declared} paths bound (${alreadyDeclared} already declared, ${
   }
 }
 function reportSections(files, receipt, dryRun) {
-  const { extracted, inlineOnly, alreadyExtracted, pending } = receipt.sections;
+  const { extracted, inlineOnly, alreadyExtracted, registered, pending } = receipt.sections;
   for (const file of files) {
     process.stdout.write(`${dryRun ? "would " : ""}${file.operation} ${file.path}
 `);
   }
   process.stdout.write(
     `
-${extracted} sections extracted (${inlineOnly} inline-only, ${alreadyExtracted} already extracted, ${pending.length} pending)
+${extracted} sections extracted (${registered} registered, ${inlineOnly} inline-only, ${alreadyExtracted} already extracted, ${pending.length} pending), copy: ${receipt.copy}
 `
   );
   for (const section of pending) {
@@ -6775,6 +7748,9 @@ async function main() {
   if (args.plan && !args.componentize) {
     throw new CliError("--plan is only read with --componentize. See --help.");
   }
+  if (args.copy === "instance" && !args.componentize) {
+    throw new CliError("--copy is only read with --componentize. See --help.");
+  }
   const root = resolve(args.root);
   const brief = JSON.parse(await readFile(resolve(args.brief), "utf-8"));
   if (!Array.isArray(brief.pages)) {
@@ -6808,7 +7784,7 @@ async function main() {
       brief,
       plan2,
       [...sources, ...await readSnapshots(root)],
-      { overwriteHelper: args.overwriteHelper }
+      { overwriteHelper: args.overwriteHelper, copy: args.copy }
     );
     await written(files2);
     await saveReceipt(receipt2);