@bettercms-ai/convert 0.7.0 → 0.9.0

package/dist/cli.js

@@ -5,7 +5,7 @@ import { readdir, readFile, writeFile, mkdir, stat } from "fs/promises";
 import { dirname, join as join2, relative, resolve, sep } from "path";
 
 // src/index.ts
-import MagicString5 from "magic-string";
+import MagicString6 from "magic-string";
 
 // src/brief.ts
 import { createHash } from "crypto";
@@ -151,7 +151,7 @@ function propsAttribute(props) {
 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 BINDINGS_SCAN = /bcmsBindings\s*=\s*\{\{(?:`[^`]*`|[^}])*\}\}/g;
 var propsDeclarations = (value, at) => value.split(";").flatMap((entry) => {
   const [address, kind] = entry.split("|");
   if (!address) return [];
@@ -192,7 +192,10 @@ function declarationsIn(roots, content) {
   for (const root of roots) visit(root);
   return out;
 }
-var bindingsPaths = (text) => [...text.matchAll(/["']([^"']+)["']/g)].map((match) => match[1]);
+var bindingsPaths = (text) => [
+  ...[...text.matchAll(/["']([^"']+)["']/g)].map((match) => match[1]),
+  ...[...text.matchAll(/`([^`]+)`/g)].map((match) => shapeOfPath(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)));
@@ -2560,7 +2563,16 @@ var IMAGE_SOURCES = {
 };
 var isImageSource = (site) => site.where === "attr" && (IMAGE_SOURCES[site.tag.toLowerCase()] ?? []).includes(site.attr ?? "");
 var norm = (value) => decodeEntities(value.normalize("NFC")).replace(/\s+/g, " ").trim();
-var BCMS_ATTRS = ["data-bcms-field", "data-bcms-kind", "data-bcms-props", "data-bcms-layout-field"];
+var BCMS_ATTRS = [
+  "data-bcms-field",
+  "data-bcms-kind",
+  "data-bcms-props",
+  "data-bcms-layout-field",
+  // The forms lane's two. Listed here so `collectSites` never matches a brief literal against a
+  // marker this package itself wrote — a form id or a field key is not the page's copy.
+  "data-bcms-form",
+  "data-bcms-form-field"
+];
 var attrInsertAfter = (attrs, start, tag) => attrs.length > 0 ? Math.max(...attrs.map((a) => a.range.end)) : start + 1 + tag.length;
 function openTagEnd(content, start) {
   let quote = null;
@@ -3029,7 +3041,7 @@ function receptionIn(component, propName, offset, content) {
   let receiver = null;
   let rest = null;
   let hasBindings = false;
-  let destructured = false;
+  let destructured2 = false;
   for (const node of component ? [component] : []) {
     const params = node.params ?? [];
     const first = params[0];
@@ -3055,7 +3067,7 @@ function receptionIn(component, propName, offset, content) {
         if (key !== propName) continue;
         const value = property.value;
         if (value?.type === "Identifier") names.add(String(value.name));
-        destructured = true;
+        destructured2 = true;
         receivable = true;
         receive = patternClose(content, first, offset);
       }
@@ -3065,7 +3077,7 @@ function receptionIn(component, propName, offset, content) {
       viaProps = true;
     }
   }
-  return { names, receive, viaProps, typeName, receivable, inline, receiver, rest, hasBindings, destructured };
+  return { names, receive, viaProps, typeName, receivable, inline, receiver, rest, hasBindings, destructured: destructured2 };
 }
 function astroReception(ast, propName, offset, content) {
   const names = /* @__PURE__ */ new Set();
@@ -3248,8 +3260,7 @@ function splitGroup(path) {
   return match ? { array: match[1], index: Number(match[2]), leaf: match[3] } : null;
 }
 function moduleOf(parsed) {
-  if (!parsed.ast) return null;
-  return { ast: parsed.ast, offset: parsed.script?.offset ?? 0 };
+  return { ast: parsed.ast ?? null, offset: parsed.script?.offset ?? 0 };
 }
 function arrayLiterals(ast) {
   const out = /* @__PURE__ */ new Map();
@@ -3262,6 +3273,19 @@ function arrayLiterals(ast) {
   });
   return out;
 }
+function exportedNames(ast) {
+  const out = /* @__PURE__ */ new Set();
+  walkAst(ast, (node) => {
+    if (node.type !== "ExportNamedDeclaration") return;
+    const declaration2 = node.declaration;
+    if (declaration2?.type !== "VariableDeclaration") return;
+    for (const declarator of declaration2.declarations ?? []) {
+      const id = declarator.id;
+      if (id?.type === "Identifier") out.add(String(id.name));
+    }
+  });
+  return out;
+}
 function propertyFor(row, literal) {
   if (row?.type !== "ObjectExpression") return null;
   for (const property of row.properties ?? []) {
@@ -3286,21 +3310,36 @@ function iterations(roots, identifier2) {
   for (const root of roots) visit(root);
   return out;
 }
-function callbackParams(expression, identifier2) {
-  const pattern = new RegExp(
-    `(?<![\\w$])${identifier2}(?![\\w$])\\s*\\.\\s*map\\s*\\(\\s*(?:\\(\\s*([A-Za-z_$][\\w$]*)\\s*(,\\s*([A-Za-z_$][\\w$]*)\\s*)?\\)|([A-Za-z_$][\\w$]*))\\s*=>`
-  );
-  const match = expression.value.match(pattern);
+var CALLBACK = String.raw`\s*\.\s*map\s*\(\s*(?:\(\s*(?:([A-Za-z_$][\w$]*)|(\[[^\]]*\]))\s*(,\s*([A-Za-z_$][\w$]*)\s*)?\)|([A-Za-z_$][\w$]*))\s*=>`;
+function paramsIn(text, pattern, base) {
+  const match = text.match(pattern);
   if (!match || match.index === void 0) return null;
-  const row = match[1] ?? match[4];
-  if (match[4] !== void 0) return { row, index: null, addIndexAt: -1 };
-  const within = match[0].lastIndexOf(row);
+  if (match[5] !== void 0) return { row: match[5], names: null, index: null, addIndexAt: -1 };
+  const bound = match[1] ?? match[2];
+  const within = match[0].lastIndexOf(bound);
   return {
-    row,
-    index: match[3] ?? null,
-    addIndexAt: expression.range.start + match.index + within + row.length
+    // One of the two, never both: a row is either named or taken apart. @see bindLists for the
+    // second shape — `([question, answer]) =>`, which is how a TUPLE reaches the markup.
+    row: match[1] ?? null,
+    names: match[2] === void 0 ? null : destructured(match[2]),
+    index: match[4] ?? null,
+    addIndexAt: base + match.index + within + bound.length
   };
 }
+function callbackParams(expression, identifier2) {
+  return paramsIn(
+    expression.value,
+    new RegExp(`(?<![\\w$])${identifier2}(?![\\w$])${CALLBACK}`),
+    expression.range.start
+  );
+}
+function mapParams(content, at, until) {
+  return paramsIn(content.slice(at, until), new RegExp(`^${CALLBACK}`), at);
+}
+function destructured(pattern) {
+  const names = pattern.slice(1, -1).split(",").map((part) => part.trim());
+  return names.every((name) => /^[A-Za-z_$][\w$]*$/.test(name)) ? names : null;
+}
 function renders(content, node, row) {
   if (!node.inner) return null;
   const inner = content.slice(node.inner.start, node.inner.end).trim();
@@ -3388,11 +3427,11 @@ function bindScalar(ctx, member, literals, offset) {
   }
   return { splices, refusal: null };
 }
-function bindDataLiterals(ctx, members) {
-  const out = { splices: [], usesRead: false, usesRows: false, slugs: [], bound: [], declarations: [], refused: [] };
+async function bindDataLiterals(ctx, members) {
+  const out = { splices: [], usesRead: false, usesRows: false, usesList: false, usesTuples: false, notes: [], slugs: [], bound: [], declarations: [], refused: [], componentEdits: [], props: [] };
   const rule = DIALECT_RULES[ctx.dialect];
   const module = moduleOf(ctx.parsed);
-  if (!module || !rule.text) return out;
+  if (!rule.text) return out;
   const groups = /* @__PURE__ */ new Map();
   const scalars = [];
   for (const member of members) {
@@ -3405,6 +3444,7 @@ function bindDataLiterals(ctx, members) {
     const key = `${member.slug}\0${split.array}`;
     groups.set(key, [...groups.get(key) ?? [], held]);
   }
+  const indexes = /* @__PURE__ */ new Set();
   const strings = stringLiterals(module.ast);
   for (const member of scalars) {
     const scalar = bindScalar(ctx, member, strings, module.offset);
@@ -3415,7 +3455,6 @@ function bindDataLiterals(ctx, members) {
     out.slugs.push(member.slug);
     out.bound.push(member.key);
   }
-  if (groups.size === 0) return out;
   const literals = arrayLiterals(module.ast);
   for (const all of groups.values()) {
     const array = all[0].array;
@@ -3456,23 +3495,36 @@ function bindDataLiterals(ctx, members) {
     }
     const loop = loops[0];
     const params = callbackParams(loop, identifier2);
-    if (!params) {
+    if (!params || params.row === null) {
       refuse("IN_EXPRESSION");
       continue;
     }
-    const elements = leafElements(ctx.content, loop, params.row);
+    const rowName = params.row;
+    const elements = leafElements(ctx.content, loop, rowName);
     const placed = /* @__PURE__ */ new Map();
+    const passed = [];
     let refusal = null;
     for (const property of keys.keys()) {
       const found = elements.get(property) ?? [];
-      if (found.length === 1) placed.set(property, found[0]);
-      else refusal = found.length > 1 ? "REPEATER_AMBIGUOUS" : leafRefusal(loop.value, params.row, property);
+      if (found.length === 1) {
+        placed.set(property, found[0]);
+        continue;
+      }
+      if (found.length > 1) {
+        refusal = "REPEATER_AMBIGUOUS";
+        continue;
+      }
+      const calls = propCalls(ctx.content, loop, rowName, property);
+      if (ctx.drill && calls.length === 1) passed.push({ property, ...calls[0] });
+      else if (calls.length > 1) refusal = "REPEATER_AMBIGUOUS";
+      else refusal = leafRefusal(loop.value, rowName, property);
     }
     if (refusal !== null) {
       refuse(refusal);
       continue;
     }
-    const index = params.index ?? allocateIndex(loop.value);
+    const index = params.index ?? allocateIndex(loop.value, indexes);
+    indexes.add(index);
     const splices = [];
     if (rule.loopKey) {
       const rows = loop.children.filter((child) => child.type === "element");
@@ -3488,6 +3540,36 @@ function bindDataLiterals(ctx, members) {
       }
       splices.push({ start: params.addIndexAt, end: params.addIndexAt, text: `, ${index}` });
     }
+    const drilled = [];
+    const edits = [];
+    const bindings = /* @__PURE__ */ new Map();
+    for (const entry of passed) {
+      const leaf = keys.get(entry.property);
+      const literal = `${array}[\${${index}}].${leaf}`;
+      const outcome = entry.call.attrs.some((a) => a.name === "bcmsBindings") ? { ok: false, reason: "PROP_TARGET_NOT_FOUND" } : await ctx.drill(entry.call.tag, entry.prop, group.find((member) => member.leaf === leaf).kind);
+      if (!outcome.ok) {
+        refusal = outcome.reason;
+        break;
+      }
+      edits.push(...outcome.edits);
+      bindings.set(entry.call.attrInsertAt, [
+        ...bindings.get(entry.call.attrInsertAt) ?? [],
+        `${entry.prop}: \`${literal}\``
+      ]);
+      drilled.push({
+        file: outcome.edits[0].file,
+        prop: entry.prop,
+        path: shapeOfPath(literal),
+        literal: `${entry.prop}: \`${literal}\``
+      });
+    }
+    if (refusal !== null) {
+      refuse(refusal);
+      continue;
+    }
+    for (const [at2, entries] of bindings) {
+      splices.push({ start: at2, end: at2, text: ` bcmsBindings={{ ${entries.join(", ")} }}` });
+    }
     for (const [property, element] of placed) {
       const leaf = keys.get(property);
       const literal = `${array}[\${${index}}].${leaf}`;
@@ -3497,7 +3579,7 @@ function bindDataLiterals(ctx, members) {
         ...kind ? [`data-bcms-kind="${kind}"`] : [],
         // A richtext row value is html, so it goes into the dialect's html sink rather than being
         // printed as characters — the same rule `writeLeaf` follows one level down. @see loops.ts
-        ...kind === "richtext" && rule.richtext ? [rule.richtext(`${params.row}.${property}`)] : []
+        ...kind === "richtext" && rule.richtext ? [rule.richtext(`${rowName}.${property}`)] : []
       ];
       splices.push({ start: element.attrInsertAt, end: element.attrInsertAt, text: ` ${attributes.join(" ")}` });
       if (kind === "richtext" && rule.richtext && element.inner) {
@@ -3517,19 +3599,319 @@ function bindDataLiterals(ctx, members) {
     splices.push({ start: at.start, end: at.end, text: `${ctx.rowsAs}(${args.join(", ")})` });
     out.splices.push(...splices);
     out.usesRows = true;
+    out.componentEdits.push(...edits);
+    out.props.push(...drilled);
     out.slugs.push(...group.map((member) => member.slug));
     out.bound.push(...group.map((member) => member.key));
   }
+  const settled = /* @__PURE__ */ new Set([...out.bound, ...out.refused.map((refusal) => refusal.key)]);
+  bindLists(ctx, members.filter((member) => !settled.has(member.key)), module, out, indexes);
+  return out;
+}
+function literalTable(init) {
+  const elements = (init.elements ?? []).filter((e) => e !== null);
+  const first = elements[0];
+  if (!first || elements.length !== (init.elements ?? []).length) return null;
+  if (elements.some((element) => element.type !== first.type)) return null;
+  if (first.type === "StringLiteral") {
+    return { tuple: false, rows: elements.map((element) => [norm(String(element.value))]) };
+  }
+  if (first.type !== "ArrayExpression") return null;
+  const rows = [];
+  for (const element of elements) {
+    const inner = (element.elements ?? []).filter((x) => x !== null);
+    if (inner.length === 0 || inner.some((x) => x.type !== "StringLiteral")) return null;
+    if (inner.length !== (element.elements ?? []).length) return null;
+    rows.push(inner.map((x) => norm(String(x.value))));
+  }
+  if (new Set(rows.map((row) => row.length)).size !== 1) return null;
+  return { tuple: true, rows };
+}
+function openingBracket(text, closeAt) {
+  let depth = 0;
+  for (let at = closeAt; at >= 0; at--) {
+    if (text[at] === "]") depth++;
+    else if (text[at] === "[") {
+      depth--;
+      if (depth === 0) return at;
+    }
+  }
+  return -1;
+}
+function arrayLiteral(source) {
+  try {
+    const ast = parseProgram(`(${source})`);
+    const expression = ast.program.body[0]?.expression;
+    if (!expression || expression.type !== "ArrayExpression") return null;
+    return (expression.start ?? -1) === 1 && (expression.end ?? -1) === source.length + 1 ? expression : null;
+  } catch {
+    return null;
+  }
+}
+function inlineTables(ctx) {
+  const out = /* @__PURE__ */ new Map();
+  const visit = (node) => {
+    if (node.type === "element") {
+      if (!node.raw) for (const child of node.children) visit(child);
+      return;
+    }
+    if (node.type !== "expr") return;
+    for (const match of node.value.matchAll(/\]\s*\.\s*map\s*\(/g)) {
+      const closeAt = match.index;
+      const openAt = openingBracket(node.value, closeAt);
+      if (openAt <= 0 || /[\w$)\]]/.test(node.value[openAt - 1] ?? "")) continue;
+      const init = arrayLiteral(node.value.slice(openAt, closeAt + 1));
+      const table = init ? literalTable(init) : null;
+      if (!table) continue;
+      const at = { start: node.range.start + openAt, end: node.range.start + closeAt + 1 };
+      out.set(at.start, {
+        ...table,
+        at,
+        label: "an inline array literal",
+        render: () => ({ loop: node, params: mapParams(ctx.content, at.end, node.range.end) })
+      });
+    }
+    for (const child of node.children) visit(child);
+  };
+  for (const root of ctx.parsed.roots) visit(root);
+  return [...out.values()];
+}
+function readerElements(content, expression, reads) {
+  const wanted = new Set(reads);
+  const out = /* @__PURE__ */ new Map();
+  const visit = (node) => {
+    if (node.type === "expr") {
+      for (const child of node.children) visit(child);
+      return;
+    }
+    if (node.type !== "element" || node.raw) return;
+    const inner = isIntrinsic(node.tag) && node.inner ? content.slice(node.inner.start, node.inner.end).trim() : "";
+    const read = inner.match(/^\{\s*([A-Za-z_$][\w$]*(?:\[\d+\])?)\s*\}$/)?.[1];
+    if (read && wanted.has(read)) out.set(read, [...out.get(read) ?? [], node]);
+    for (const child of node.children) visit(child);
+  };
+  for (const child of expression.children) visit(child);
+  return out;
+}
+function readerWraps(expression, reads) {
+  const wanted = new Set(reads);
+  const out = /* @__PURE__ */ new Map();
+  const visit = (node, parent) => {
+    if (node.type === "expr") {
+      const read = node.value.trim().match(/^\{\s*([A-Za-z_$][\w$]*(?:\[\d+\])?)\s*\}$/)?.[1];
+      const beside = parent !== null && isIntrinsic(parent.tag) && parent.children.some((child) => child !== node && !(child.type === "text" && child.value.trim() === ""));
+      if (read && wanted.has(read) && beside) out.set(read, [...out.get(read) ?? [], node.range]);
+      for (const child of node.children) visit(child, parent);
+      return;
+    }
+    if (node.type !== "element" || node.raw) return;
+    for (const child of node.children) visit(child, node);
+  };
+  for (const child of expression.children) visit(child, null);
+  return out;
+}
+function pathTemplates(paths, index) {
+  const out = [];
+  for (let position = 0; position < paths[0].length; position++) {
+    const split = paths.map((row) => splitGroup(row[position]));
+    const first = split[0];
+    if (!first) return null;
+    if (split.some((held, row) => !held || held.array !== first.array || held.leaf !== first.leaf || held.index !== row)) {
+      return null;
+    }
+    out.push(`${first.array}[\${${index}}].${first.leaf}`);
+  }
+  return out;
+}
+function bindLists(ctx, members, module, out, indexes) {
+  const rule = DIALECT_RULES[ctx.dialect];
+  const escapes = exportedNames(module.ast);
+  const candidates = [];
+  for (const [name, init] of arrayLiterals(module.ast)) {
+    const table = literalTable(init);
+    if (!table) continue;
+    candidates.push({
+      ...table,
+      at: { start: module.offset + (init.start ?? 0), end: module.offset + (init.end ?? 0) },
+      label: `\`${name}\``,
+      render: () => {
+        const loops = iterations(ctx.parsed.roots, name);
+        if (loops.length > 1) return { refuse: "REPEATER_AMBIGUOUS" };
+        if (loops.length === 0) return null;
+        const mentions2 = ctx.content.match(new RegExp(`(?<![\\w$])${name}(?![\\w$])`, "g")) ?? [];
+        if (mentions2.length !== 2 || escapes.has(name)) return { refuse: "IN_EXPRESSION" };
+        return { loop: loops[0], params: callbackParams(loops[0], name) };
+      }
+    });
+  }
+  candidates.push(...inlineTables(ctx));
+  const siblings = /* @__PURE__ */ new Map();
+  const groupOf2 = (member) => `${member.slug}\0${splitGroup(member.path)?.array ?? member.path}`;
+  for (const member of members) {
+    siblings.set(groupOf2(member), [...siblings.get(groupOf2(member)) ?? [], member]);
+  }
+  const fit = (candidate, member) => (siblings.get(groupOf2(member)) ?? [member]).filter(
+    (leaf) => candidate.rows.some((row) => row.includes(leaf.literal))
+  ).length;
+  const best = /* @__PURE__ */ new Map();
+  const bestFit = (member) => {
+    const key = groupOf2(member);
+    if (!best.has(key)) best.set(key, Math.max(0, ...candidates.map((candidate) => fit(candidate, member))));
+    return best.get(key);
+  };
+  const claims = (candidate, member) => candidate.rows.some((row) => row.includes(member.literal)) && fit(candidate, member) === bestFit(member);
+  const holders = (member) => candidates.filter((candidate) => fit(candidate, member) === bestFit(member)).length;
+  for (const candidate of candidates) {
+    const mine = members.filter((member) => claims(candidate, member));
+    if (mine.length === 0 || mine.some((member) => holders(member) > 1)) continue;
+    if (new Set(mine.map((member) => member.slug)).size !== 1) continue;
+    const refuse = (reason) => {
+      for (const member of mine) out.refused.push({ key: member.key, reason });
+    };
+    const paths = candidate.rows.map((row) => row.map(() => ""));
+    const kinds = candidate.rows.map((row) => row.map(() => ""));
+    let clash = false;
+    for (const member of mine) {
+      const spots = candidate.rows.flatMap(
+        (row, r) => row.flatMap((value, p) => value === member.literal ? [[r, p]] : [])
+      );
+      if (spots.length !== 1 || paths[spots[0][0]][spots[0][1]] !== "") clash = true;
+      else {
+        paths[spots[0][0]][spots[0][1]] = member.path;
+        kinds[spots[0][0]][spots[0][1]] = member.kind;
+      }
+    }
+    if (clash || paths.some((row) => row.some((path) => path === ""))) {
+      refuse("IN_EXPRESSION");
+      continue;
+    }
+    const kindAt = kinds[0];
+    if (kinds.some((row) => row.some((kind, position) => kind !== kindAt[position]))) {
+      refuse("IN_EXPRESSION");
+      continue;
+    }
+    const rendered = candidate.render();
+    if (rendered === null) continue;
+    if ("refuse" in rendered) {
+      refuse(rendered.refuse);
+      continue;
+    }
+    const { loop, params } = rendered;
+    const reads = !params ? null : candidate.tuple ? params.names ?? (params.row === null ? null : candidate.rows[0].map((_, p) => `${params.row}[${p}]`)) : params.row === null ? null : [params.row];
+    if (!params || !reads || reads.length !== candidate.rows[0].length) {
+      refuse("IN_EXPRESSION");
+      continue;
+    }
+    const elements = readerElements(ctx.content, loop, reads);
+    const wraps = readerWraps(loop, reads);
+    const hosts = [];
+    let refusal = null;
+    for (const read of reads) {
+      const found = elements.get(read) ?? [];
+      const beside = elements.has(read) ? [] : wraps.get(read) ?? [];
+      if (found.length === 1) hosts.push({ element: found[0] });
+      else if (found.length === 0 && beside.length === 1) hosts.push({ wrap: beside[0] });
+      else refusal = found.length + beside.length > 1 ? "REPEATER_AMBIGUOUS" : "IN_EXPRESSION";
+    }
+    if (refusal !== null) {
+      refuse(refusal);
+      continue;
+    }
+    const index = params.index ?? allocateIndex(loop.value, indexes);
+    indexes.add(index);
+    const splices = [];
+    if (rule.loopKey) {
+      const rows = loop.children.filter((child) => child.type === "element");
+      const row = rows.length === 1 ? rows[0] : null;
+      if (row && row.tag !== "" && !row.attrs.some((a) => a.name.replace(/^:/, "") === "key")) {
+        splices.push({ start: row.attrInsertAt, end: row.attrInsertAt, text: ` ${rule.loopKey(index)}` });
+      }
+    }
+    if (params.index === null) {
+      if (params.addIndexAt < 0) {
+        refuse("IN_EXPRESSION");
+        continue;
+      }
+      splices.push({ start: params.addIndexAt, end: params.addIndexAt, text: `, ${index}` });
+    }
+    const templates = pathTemplates(paths, index);
+    if (!templates) {
+      refuse("IN_EXPRESSION");
+      continue;
+    }
+    const list = JSON.stringify(candidate.tuple ? paths : paths.map((row) => row[0]));
+    for (const [position, host] of hosts.entries()) {
+      const kind = kindAt[position];
+      const attributes = [
+        rule.attr("data-bcms-field", `\`${templates[position]}\``),
+        ...kind ? [`data-bcms-kind="${kind}"`] : [],
+        // A richtext value is html, so it goes into the dialect's html sink rather than being
+        // printed as characters — the same rule one level up. @see bindDataLiterals
+        ...kind === "richtext" && rule.richtext ? [rule.richtext(reads[position])] : []
+      ];
+      if ("element" in host) {
+        splices.push({ start: host.element.attrInsertAt, end: host.element.attrInsertAt, text: ` ${attributes.join(" ")}` });
+        if (kind === "richtext" && rule.richtext && host.element.inner) {
+          splices.push({ start: host.element.inner.start, end: host.element.inner.end, text: "" });
+        }
+      } else {
+        const inner = kind === "richtext" && rule.richtext ? "" : ctx.content.slice(host.wrap.start, host.wrap.end);
+        splices.push({ start: host.wrap.start, end: host.wrap.end, text: `<span ${attributes.join(" ")}>${inner}</span>` });
+      }
+      out.declarations.push({ path: shapeOfPath(templates[position]), literal: templates[position] });
+    }
+    const args = [
+      ctx.snapshotName(mine[0].slug),
+      list,
+      ctx.content.slice(candidate.at.start, candidate.at.end),
+      ...ctx.slug ? [ctx.slug] : []
+    ];
+    splices.push({
+      start: candidate.at.start,
+      end: candidate.at.end,
+      text: `${candidate.tuple ? ctx.tuples : ctx.list}(${args.join(", ")})`
+    });
+    out.splices.push(...splices);
+    if (candidate.tuple) out.usesTuples = true;
+    else out.usesList = true;
+    out.slugs.push(...mine.map((member) => member.slug));
+    out.bound.push(...mine.map((member) => member.key));
+    out.notes.push(
+      `${candidate.label} renders exactly the ${paths.length} row(s) this run wrote paths for: a row ADDED in the CMS does not appear, and a row DELETED falls back to the copy the template shipped with.`
+    );
+  }
+}
+function propCalls(content, expression, row, property) {
+  const named = new RegExp(`^\\{\\s*${row}\\s*\\.\\s*${property}\\s*\\}$`);
+  const spread = new RegExp(`^\\{\\s*\\.\\.\\.\\s*${row}\\s*\\}$`);
+  const out = [];
+  const visit = (node) => {
+    if (node.type === "expr") {
+      for (const child of node.children) visit(child);
+      return;
+    }
+    if (node.type !== "element" || node.raw) return;
+    if (node.tag !== "" && !isIntrinsic(node.tag)) {
+      for (const attr of node.attrs) {
+        if (!attr.expressionRange) continue;
+        const text = content.slice(attr.expressionRange.start, attr.expressionRange.end).trim();
+        if (spread.test(text)) out.push({ call: node, prop: property });
+        else if (named.test(text)) out.push({ call: node, prop: attr.name });
+      }
+    }
+    for (const child of node.children) visit(child);
+  };
+  for (const child of expression.children) visit(child);
   return out;
 }
 function leafRefusal(loop, row, property) {
   const prop = new RegExp(`=\\s*\\{\\s*${row}\\s*\\.\\s*${property}\\s*\\}|\\{\\s*\\.\\.\\.\\s*${row}\\s*\\}`);
   return prop.test(loop) ? "PROP_TARGET_NOT_FOUND" : "IN_EXPRESSION";
 }
-function allocateIndex(loop) {
+function allocateIndex(loop, taken) {
   const used = new Set(loop.match(/[A-Za-z_$][\w$]*/g) ?? []);
-  if (!used.has("i")) return "i";
-  for (let n = 1; ; n++) if (!used.has(`i_${n}`)) return `i_${n}`;
+  if (!used.has("i") && !taken.has("i")) return "i";
+  for (let n = 1; ; n++) if (!used.has(`i_${n}`) && !taken.has(`i_${n}`)) return `i_${n}`;
 }
 
 // src/resolve.ts
@@ -3611,6 +3993,13 @@ function isAliasShaped(value) {
 function unreadableConfigs(sources) {
   return sources.filter((source) => isProjectConfig(source.path) && readJsonc(source.content) === null).map((source) => source.path);
 }
+function extendedConfigs(sources) {
+  return sources.filter((source) => {
+    if (!isProjectConfig(source.path)) return false;
+    const parsed = readJsonc(source.content);
+    return parsed !== null && parsed.extends !== void 0 && parsed.compilerOptions?.paths === void 0;
+  }).map((source) => source.path);
+}
 function expand(specifier, aliases) {
   const out = [];
   for (const [pattern, targets] of aliases) {
@@ -3740,7 +4129,7 @@ function bindImages(ctx, targets) {
 
 // src/helper.ts
 import { createHash as createHash2 } from "crypto";
-var HELPER_VERSION = 5;
+var HELPER_VERSION = 6;
 var HEADER = "// @bettercms-ai/convert helper v";
 var HELPER_PATH = Object.fromEntries(
   Object.keys(DIALECT_RULES).map((d) => [d, DIALECT_RULES[d].helper])
@@ -3848,6 +4237,30 @@ export function bcmsRowsAs<T>(
   });
 }
 
+/**
+ * A list of PRIMITIVES \u2014 \`const tags = ["\u2026", "\u2026"]\` \u2014 with one CMS field per ELEMENT.
+ *
+ * \u{1F534} THE LENGTH IS \`paths\`, NOT THE CMS. Unlike \`bcmsRows\`, which reads the array itself and
+ * renders as many rows as the CMS holds, this maps over the path list the codemod wrote \u2014 so a row
+ * an editor ADDS has no path here and never renders, and a row an editor DELETES leaves its path
+ * resolving to nothing, which falls back to the copy the template shipped with. Every row's TEXT is
+ * editable; the number of rows is the template's. @see the PRIMITIVE_LIST receipt note, which says
+ * this out loud rather than leaving an editor to discover it.
+ */
+export function bcmsList(page: unknown, paths: string[], fallback: string[], slug?: string): string[] {
+  const entries = isRecord(page) ? page.entries : undefined;
+  const root = slug !== undefined && isRecord(entries) ? entries[slug] : page;
+  return paths.map((path, index) => render(readPath(root, path)) ?? fallback[index] ?? "");
+}
+
+/**
+ * The same for a list of TUPLES \u2014 \`[["q", "a"], \u2026]\` \u2014 with one field per tuple POSITION, and the
+ * same ceiling: \`paths\` decides how many rows render, and an added or deleted CMS row does not.
+ */
+export function bcmsTuples(page: unknown, paths: string[][], fallback: string[][], slug?: string): string[][] {
+  return paths.map((row, index) => bcmsList(page, row, fallback[index] ?? [], slug));
+}
+
 /** An image field's url, or the asset the template already imports. @see IMAGE_ASSET_UNRESOLVED */
 export function bcmsImage<T>(page: unknown, path: string, fallback: T, slug?: string): T | string {
   const entries = isRecord(page) ? page.entries : undefined;
@@ -3939,19 +4352,22 @@ var HISTORICAL = {
     1: "c272412532efed7db64b6cf313b2bed4291f9951430412289c8a588b7f565407",
     2: "51e2ae65ddd86bf43d14e29b3865e3f16e45f72069692d1fea57e1f986a894f0",
     3: "d4305b2983adcb456ef782d35ea9d083a04465c2b68baa0d44a084dfa01a9227",
-    4: "a5742f64dacb1b26ee6dd5e1469a54871487934c71bc8267df19e3a80e417595"
+    4: "a5742f64dacb1b26ee6dd5e1469a54871487934c71bc8267df19e3a80e417595",
+    5: "0472fe3ffdcfa49e719c7b9da9cb63b6eba637cc22783bb00c3c2cadd3d800da"
   },
   "src/lib/bcms-content.ts": {
     1: "ae72ae14d706943d481c880d70da5789b4816ba1ba319a10fbc63ded4d0b42f2",
     2: "a18731eb42f7db55dac0591c45f873758cde8e103fefcd6e5caf67936ae6a002",
     3: "0be9c73160361882a038552bc02673c14ed532287823dabaafe36179bc55ed7e",
-    4: "0146d027a727ecd3c9e3fc336fcf1299b59ddf75b04091c05703f3f983ec28af"
+    4: "0146d027a727ecd3c9e3fc336fcf1299b59ddf75b04091c05703f3f983ec28af",
+    5: "c8c93655320fa65664611ba84541f3fa7bfa292cc9a2fd655373440b99049fba"
   },
   "composables/bcms-content.ts": {
     1: "c272412532efed7db64b6cf313b2bed4291f9951430412289c8a588b7f565407",
     2: "51e2ae65ddd86bf43d14e29b3865e3f16e45f72069692d1fea57e1f986a894f0",
     3: "d4305b2983adcb456ef782d35ea9d083a04465c2b68baa0d44a084dfa01a9227",
-    4: "a5742f64dacb1b26ee6dd5e1469a54871487934c71bc8267df19e3a80e417595"
+    4: "a5742f64dacb1b26ee6dd5e1469a54871487934c71bc8267df19e3a80e417595",
+    5: "0472fe3ffdcfa49e719c7b9da9cb63b6eba637cc22783bb00c3c2cadd3d800da"
   }
 };
 var sha256 = (value) => createHash2("sha256").update(value, "utf8").digest("hex");
@@ -4486,8 +4902,8 @@ function declaringElements(roots, content) {
       const name = attr.name.replace(/^:/, "");
       if (name === "bcmsBindings") {
         const own = ownBytes(node, content);
-        for (const quoted of content.slice(attr.range.start, attr.range.end).matchAll(/["']([^"']+)["']/g)) {
-          out.push({ scope: "page", path: quoted[1], kind, own });
+        for (const path of bindingsPaths(content.slice(attr.range.start, attr.range.end))) {
+          out.push({ scope: "page", path, kind, own });
         }
         continue;
       }
@@ -4517,7 +4933,7 @@ function declaringElements(roots, content) {
   return out;
 }
 function helperLocals(parsed, dialect, file) {
-  const out = { bcms: [], bcmsRows: [], bcmsRowsAs: [], bcmsImage: [], bcmsLayout: [] };
+  const out = { bcms: [], bcmsRows: [], bcmsRowsAs: [], bcmsImage: [], bcmsLayout: [], bcmsList: [], bcmsTuples: [] };
   const helper = HELPER_PATH[dialect];
   if (!helper) return out;
   for (const [local, from] of importsIn(parsed, dialect)) {
@@ -4527,6 +4943,8 @@ function helperLocals(parsed, dialect, file) {
     if (from.imported === "bcmsRowsAs") out.bcmsRowsAs.push(local);
     if (from.imported === "bcmsImage") out.bcmsImage.push(local);
     if (from.imported === "bcmsLayout") out.bcmsLayout.push(local);
+    if (from.imported === "bcmsList") out.bcmsList.push(local);
+    if (from.imported === "bcmsTuples") out.bcmsTuples.push(local);
   }
   return out;
 }
@@ -4599,6 +5017,9 @@ function convertedHere(content, parsed, dialect, target, file) {
     keyed = reads(locals.bcmsRowsAs);
     rows = keyed || reads(locals.bcmsRows);
   }
+  const listed = indexed !== null && snapshot !== null && content.includes(JSON.stringify(target.path)) && [...locals.bcmsList, ...locals.bcmsTuples].some(
+    (name) => new RegExp(`${identifier(name)}\\s*\\(\\s*${identifier(snapshot)}\\s*,`).test(content)
+  );
   let cached = null;
   const moduleRead = () => {
     if (indexed || snapshot === null) return false;
@@ -4614,7 +5035,7 @@ function convertedHere(content, parsed, dialect, target, file) {
       return elementReads(element.own, target, locals, snapshot, false) || moduleRead();
     }
     if (element.path !== shape) return false;
-    return rows && (keyed || elementReads(element.own, target, locals, snapshot, true));
+    return listed || rows && (keyed || elementReads(element.own, target, locals, snapshot, true));
   });
 }
 
@@ -4750,6 +5171,22 @@ function importLines(imports) {
 
 // src/receipt.ts
 var CANVAS_REASONS = /* @__PURE__ */ new Set(["CANVAS_BRIDGE_MANUAL", "SSR_DRAFT_ROUTE"]);
+var FormInvariantError = class extends Error {
+  code = "FORM_INVARIANT";
+  constructor(message) {
+    super(message);
+    this.name = "FormInvariantError";
+  }
+};
+function assertForms(total, forms) {
+  const sum = forms.wired + forms.alreadyWired + forms.pending.length;
+  if (sum !== total) {
+    throw new FormInvariantError(
+      `The receipt does not account for every form: ${total} listed but ${forms.wired} wired + ${forms.alreadyWired} already wired + ${forms.pending.length} pending = ${sum}.`
+    );
+  }
+  return forms;
+}
 var ReceiptInvariantError = class extends Error {
   code = "RECEIPT_INVARIANT";
   constructor(message) {
@@ -5589,6 +6026,17 @@ function readBrief(value) {
       }
     }
   }
+  for (const [at, entry] of check.array(brief.forms ?? [], `the brief's "forms"`).entries()) {
+    const where = `brief.forms[${at}]`;
+    const form = check.record(entry, where);
+    check.segment(form.id, `${where}.id`);
+    check.string(form.name, `${where}.name`);
+    check.string(form.submitUrl, `${where}.submitUrl`);
+    check.optionalString(form.successMessage, `${where}.successMessage`);
+    for (const [n, held] of check.array(form.fields, `${where}.fields`).entries()) {
+      check.segment(check.record(held, `${where}.fields[${n}]`).key, `${where}.fields[${n}].key`);
+    }
+  }
   return brief;
 }
 function readPlan(value) {
@@ -5635,6 +6083,236 @@ function readPlan(value) {
   return plan2;
 }
 
+// src/forms.ts
+import MagicString4 from "magic-string";
+var WIRABLE = ["html", "astro", "jsx"];
+var CONTROLS = /* @__PURE__ */ new Set(["input", "select", "textarea"]);
+var FORM_SCRIPT = `<script>
+document.querySelectorAll('form[data-bcms-form]').forEach(function(f){
+  f.addEventListener('submit',function(e){
+    e.preventDefault();
+    var msg=f.querySelector('.bcms-form-msg');
+    var data={};
+    // A checkboxes group posts one entry per checked box under the SAME name; the old
+    // one-at-a-time assignment kept only the last, so "pick many" delivered one answer.
+    // One checked box still arrives as a scalar \u2014 FormData cannot tell a group from a
+    // lone field \u2014 which is exactly why lib/forms/validate.ts's chosenValues() accepts
+    // both an array and a comma string.
+    new FormData(f).forEach(function(v,k){
+      if(k==='cf-turnstile-response')return;
+      if(Object.prototype.hasOwnProperty.call(data,k))data[k]=(Array.isArray(data[k])?data[k]:[data[k]]).concat(v);
+      else data[k]=v;
+    });
+    var body={data:data};
+    var tok=f.querySelector('[name="cf-turnstile-response"]');
+    if(tok&&tok.value)body['cf-turnstile-response']=tok.value;
+    fetch(f.action,{method:'POST',headers:{'Content-Type':'application/json'},body:JSON.stringify(body)})
+      .then(function(r){return r.ok;})
+      .then(function(ok){if(msg){msg.hidden=false;msg.textContent=ok?(f.getAttribute('data-bcms-form-success')||'Thanks! Your submission was received.'):'Sorry, something went wrong.';}if(ok)f.reset();})
+      .catch(function(){if(msg){msg.hidden=false;msg.textContent='Sorry, something went wrong.';}});
+  });
+});
+</script>`;
+var SCRIPT_BODY = FORM_SCRIPT.slice("<script>".length, -"</script>".length);
+function scriptFor(dialect) {
+  if (dialect === "jsx") return `<script dangerouslySetInnerHTML={{ __html: \`${SCRIPT_BODY}\` }} />`;
+  if (dialect === "astro") return `<script is:inline>${SCRIPT_BODY}</script>`;
+  return FORM_SCRIPT;
+}
+var messageFor = (dialect) => dialect === "jsx" ? `<p className="bcms-form-msg" hidden></p>` : `<p class="bcms-form-msg" hidden></p>`;
+var escapeAttr = (value) => value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/"/g, "&quot;");
+var attrOf = (el, name) => el.attrs.find((a) => a.name.toLowerCase() === name);
+function* elementsIn(nodes) {
+  for (const node of nodes) {
+    if (node.type === "expr") {
+      yield* elementsIn(node.children);
+      continue;
+    }
+    if (node.type !== "element") continue;
+    yield node;
+    yield* elementsIn(node.children);
+  }
+}
+var childElements = (node) => node.children.flatMap(
+  (child) => child.type === "element" ? [child] : child.type === "expr" ? childElements(child) : []
+);
+function candidateOf(file, dialect, form) {
+  const controls = /* @__PURE__ */ new Map();
+  const wrapper = /* @__PURE__ */ new Map();
+  const all = [];
+  const walk = (parent) => {
+    const own = [];
+    for (const child of childElements(parent)) {
+      if (CONTROLS.has(child.tag.toLowerCase())) {
+        own.push(child);
+        all.push(child);
+      }
+      walk(child);
+    }
+    if (own.length === 1 && parent !== form) wrapper.set(own[0], parent);
+  };
+  walk(form);
+  for (const control of all) {
+    const name = attrOf(control, "name")?.value;
+    if (name && !controls.has(name)) controls.set(name, control);
+  }
+  for (const control of all) {
+    const id = attrOf(control, "id")?.value;
+    if (id && !controls.has(id)) controls.set(id, control);
+  }
+  return { file, dialect, el: form, controls, wrapper };
+}
+var hasMessage = (form) => [...elementsIn([form])].some((el) => (attrOf(el, "class") ?? attrOf(el, "classname"))?.value.includes("bcms-form-msg") ?? false);
+function wire(source, candidate, form) {
+  const { el, dialect } = candidate;
+  const inserts = [];
+  const set = (name, value) => {
+    const attr = attrOf(el, name);
+    if (!attr) inserts.push(`${name}="${escapeAttr(value)}"`);
+    else if (attr.valueRange) source.overwrite(attr.valueRange.start, attr.valueRange.end, escapeAttr(value));
+    else source.overwrite(attr.range.start, attr.range.end, `${name}="${escapeAttr(value)}"`);
+  };
+  set("action", form.submitUrl);
+  set("method", "post");
+  inserts.push(`data-bcms-form="${escapeAttr(form.id)}"`);
+  if (form.successMessage) inserts.push(`data-bcms-form-success="${escapeAttr(form.successMessage)}"`);
+  source.appendLeft(el.attrInsertAt, ` ${inserts.join(" ")}`);
+  for (const field of form.fields) {
+    const control = candidate.controls.get(field.key);
+    const host = candidate.wrapper.get(control) ?? control;
+    source.appendLeft(host.attrInsertAt, ` data-bcms-form-field="${escapeAttr(field.key)}"`);
+    const name = attrOf(control, "name");
+    if (!name) source.appendLeft(control.attrInsertAt, ` name="${escapeAttr(field.key)}"`);
+    else if (!name.expression && name.value !== field.key && name.valueRange) {
+      source.overwrite(name.valueRange.start, name.valueRange.end, escapeAttr(field.key));
+    }
+  }
+  if (el.inner && !hasMessage(el)) {
+    const tail = /\s*$/.exec(source.original.slice(el.inner.start, el.inner.end))[0];
+    source.appendLeft(el.inner.end - tail.length, `${tail || "\n"}${messageFor(dialect)}`);
+  }
+}
+async function wireForms(briefIn, sources) {
+  const brief = readBrief(briefIn);
+  const forms = brief.forms ?? [];
+  const candidates = [];
+  const unreadable = [];
+  for (const source of sources) {
+    if (!/<form[\s/>]/i.test(source.content)) continue;
+    const dialect = dialectOf(source.path, source.content);
+    if (!dialect || !WIRABLE.includes(dialect)) {
+      unreadable.push({
+        file: source.path,
+        reason: "DIALECT_UNSUPPORTED",
+        message: `${source.path} is ${dialect ?? "not a template"}.`
+      });
+      continue;
+    }
+    const parsed = await parseFile4(dialect, source.content);
+    if (parsed.error) {
+      unreadable.push({
+        file: source.path,
+        reason: parsed.error.code === "DIALECT_UNSUPPORTED" ? "DIALECT_UNSUPPORTED" : "PARSE_ERROR",
+        message: parsed.error.message
+      });
+      continue;
+    }
+    for (const el of elementsIn(parsed.roots)) {
+      if (el.tag.toLowerCase() === "form") candidates.push(candidateOf(source.path, dialect, el));
+    }
+  }
+  const holds = (c, f) => f.fields.filter((field) => c.controls.has(field.key)).length;
+  const covers2 = (c, f) => f.fields.length > 0 && holds(c, f) === f.fields.length;
+  const options = new Map(forms.map((f) => [f.id, candidates.filter((c) => covers2(c, f))]));
+  const wanted = /* @__PURE__ */ new Map();
+  for (const list of options.values()) for (const c of list) wanted.set(c, (wanted.get(c) ?? 0) + 1);
+  const matched = [];
+  const pending = [];
+  const onSite = [];
+  let alreadyWired = 0;
+  const pend2 = (f, reason, file, message) => void pending.push({ id: f.id, name: f.name, reason, ...file ? { file } : {}, ...message ? { message } : {} });
+  for (const form of forms) {
+    const list = options.get(form.id) ?? [];
+    if (list.length > 1) {
+      pend2(form, "FORM_AMBIGUOUS", void 0, `${list.length} forms post every field of "${form.name}": ${list.map((c) => c.file).join(", ")}.`);
+      continue;
+    }
+    if (list.length === 1 && (wanted.get(list[0]) ?? 0) > 1) {
+      pend2(form, "FORM_AMBIGUOUS", list[0].file, "more than one CMS form's fields are posted by this <form>.");
+      continue;
+    }
+    if (list.length === 0) {
+      const [best] = candidates.map((c) => ({ c, n: holds(c, form) })).filter((x) => x.n > 0).sort((a, b) => b.n - a.n);
+      if (best) {
+        const missing = form.fields.filter((f) => !best.c.controls.has(f.key)).map((f) => f.key);
+        pend2(form, "FIELD_UNMATCHED", best.c.file, `no control posts ${missing.join(", ")} in the <form> that posts its other fields.`);
+      } else if (unreadable[0]) {
+        pend2(form, unreadable[0].reason, unreadable[0].file, unreadable[0].message);
+      } else {
+        pend2(form, "FORM_NOT_IN_SOURCE", void 0, `no <form> posts ${form.fields.map((f) => f.key).join(", ") || "any field of this form"}.`);
+      }
+      continue;
+    }
+    const candidate = list[0];
+    if (attrOf(candidate.el, "action")?.expression) {
+      pend2(form, "ACTION_IS_EXPRESSION", candidate.file, "its action is an expression, so this run will not replace it.");
+      continue;
+    }
+    const misnamed = form.fields.find((field) => {
+      const attr = attrOf(candidate.controls.get(field.key), "name");
+      return !!attr && attr.value !== field.key && (attr.expression || !attr.valueRange);
+    });
+    if (misnamed) {
+      pend2(form, "FIELD_UNMATCHED", candidate.file, `the control for ${misnamed.key} posts under an expression, so its name cannot be set to the CMS key.`);
+      continue;
+    }
+    if (attrOf(candidate.el, "data-bcms-form")) {
+      alreadyWired++;
+      onSite.push(form);
+      continue;
+    }
+    matched.push({ form, candidate });
+    onSite.push(form);
+  }
+  const contents = new Map(sources.map((s) => [s.path, s.content]));
+  const byFile = /* @__PURE__ */ new Map();
+  for (const m of matched) byFile.set(m.candidate.file, [...byFile.get(m.candidate.file) ?? [], m]);
+  const files = [];
+  for (const [path, list] of [...byFile].sort(([a], [b]) => a.localeCompare(b))) {
+    const content = contents.get(path);
+    const source = new MagicString4(content);
+    for (const { form, candidate } of list) wire(source, candidate, form);
+    if (!content.includes("form[data-bcms-form]")) {
+      const last = list.reduce((a, b) => b.candidate.el.end > a.candidate.el.end ? b : a);
+      const indent = /[^\S\n]*$/.exec(content.slice(0, last.candidate.el.start))[0];
+      source.appendRight(last.candidate.el.end, `
+${indent}${scriptFor(last.candidate.dialect)}`);
+    }
+    files.push({ path, operation: "modify", content: source.toString() });
+  }
+  const notes = onSite.filter((f) => f.status === "draft").map((f) => `publish form ${f.name} in the Forms tab \u2014 a draft form rejects every submission with 403.`);
+  return {
+    files,
+    receipt: {
+      briefDigest: briefDigest(brief),
+      // This lane binds no brief PATH, and says so rather than leaving the arithmetic to a reader:
+      // a receipt claiming zero of zero paths is exactly what a forms-only run did.
+      paths: { declared: 0, rewritten: 0, alreadyDeclared: 0, pending: [] },
+      occurrences: { located: 0, rewritten: 0 },
+      files: [],
+      helpers: [],
+      helperUpgraded: false,
+      dynamicBindings: [],
+      forms: assertForms(forms.length, {
+        wired: matched.length,
+        alreadyWired,
+        pending,
+        ...notes.length > 0 ? { notes } : {}
+      })
+    }
+  };
+}
+
 // src/scan.ts
 var SKIP_DIRS = [
   "node_modules/",
@@ -5692,6 +6370,7 @@ function isSourceCandidate(path) {
   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 (/(^|\/)[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;
   return lower.split("/").slice(0, -1).some((segment) => TEMPLATE_DIRS.has(segment));
@@ -5994,7 +6673,7 @@ function moduleScope(parsed, content) {
 }
 
 // src/componentize.ts
-import MagicString4 from "magic-string";
+import MagicString5 from "magic-string";
 var SectionInvariantError = class extends Error {
   code = "SECTION_INVARIANT";
   constructor(message) {
@@ -6920,7 +7599,7 @@ export default function ${resolved.name}({ blockId, bind, overrides, page }: Bcm
 ` };
 }
 function sectionMarkup(content, root, fieldName) {
-  const slice = new MagicString4(content.slice(root.start, root.end));
+  const slice = new MagicString5(content.slice(root.start, root.end));
   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}");
@@ -7119,7 +7798,7 @@ async function migrateSections(plan2, contents, written, fileSet, aliases) {
         );
         continue;
       }
-      const source = new MagicString4(content);
+      const source = new MagicString5(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.`);
@@ -7396,7 +8075,7 @@ export default function Sections({ page }: { page: string }) {
 function splicePageRun(file, content, dialect, parsed, placeable, pageSlug) {
   const names = allocateNames(topLevelBindings(dialect, parsed, content), [{ key: "Sections", name: "Sections" }]);
   const local = names.get("Sections");
-  const source = new MagicString4(content);
+  const source = new MagicString5(content);
   const first = placeable[0].root;
   const last = placeable[placeable.length - 1].root;
   source.overwrite(first.start, last.end, `<${local} page="${pageSlug}" />`);
@@ -7416,7 +8095,7 @@ function splicePageInline(file, content, dialect, parsed, placeable, pageSlug, w
     { key: "pageSnapshot", name: "pageSnapshot" }
   ]);
   const snapshot = names.get("pageSnapshot");
-  const source = new MagicString4(content);
+  const source = new MagicString5(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);
@@ -7740,6 +8419,7 @@ async function convertSources(briefIn, sources, options) {
   const receiptFiles = [];
   const dialects = /* @__PURE__ */ new Set();
   const dynamicBindings = [];
+  const laneNotes = [];
   const snapshotSlugs = /* @__PURE__ */ new Set();
   let occurrencesLocated = 0;
   let occurrencesRewritten = 0;
@@ -7765,6 +8445,7 @@ async function convertSources(briefIn, sources, options) {
       outFiles.push({ path: file, operation: "modify", content: result.content });
       receiptFiles.push({ path: file, bindings: result.bindings, tier: result.tier });
       dynamicBindings.push(...result.dynamic);
+      laneNotes.push(...result.notes);
       for (const slug of result.snapshots) snapshotSlugs.add(slug);
     }
   }
@@ -7801,7 +8482,7 @@ async function convertSources(briefIn, sources, options) {
     } else rewritten++;
   }
   for (const [file, splices] of [...componentEdits].sort(([a], [b]) => a.localeCompare(b))) {
-    const source = new MagicString5(contents.get(file));
+    const source = new MagicString6(contents.get(file));
     const seen = /* @__PURE__ */ new Set();
     for (const splice of splices) {
       const id = `${splice.start}:${splice.end}:${splice.text}`;
@@ -7861,13 +8542,25 @@ async function convertSources(briefIn, sources, options) {
     helperUpgraded,
     dynamicBindings,
     canvas: { lane: canvas.lane, ...canvas.files.length > 0 ? { files: canvas.files } : {} },
-    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.`
-      })
-    )
+    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.`
+        })
+      ),
+      // An absent alias table looks exactly like a project that has none, and the two have
+      // opposite consequences for every component reached through one. @see extendedConfigs
+      ...extendedConfigs(sources).map(
+        (file) => ({
+          code: "TSCONFIG_EXTENDS_ONLY",
+          file,
+          message: `${file} declares no \`compilerOptions.paths\` of its own and extends another config, which this package does not follow \u2014 so an import through a path alias resolved to nothing and any prop drilled through one is PROP_TARGET_NOT_FOUND.`
+        })
+      ),
+      ...laneNotes
+    ]
   });
   return { files: outFiles.sort((a, b) => a.path.localeCompare(b.path)), receipt };
 }
@@ -7889,7 +8582,8 @@ async function convertFile(file, content, targets, parsed, declared, llmFallback
     dialect: dialectOf(file, content),
     dynamic: [],
     componentEdits: [],
-    snapshots: []
+    snapshots: [],
+    notes: []
   };
   if (pendingTargets.length === 0) return empty;
   if (!dialect) {
@@ -7950,7 +8644,8 @@ async function convertFile(file, content, targets, parsed, declared, llmFallback
         dialect: null,
         dynamic: [],
         componentEdits: [],
-        snapshots: []
+        snapshots: [],
+        notes: []
       };
     }
     if (rescued.reason === "unverifiable") {
@@ -8020,6 +8715,8 @@ async function plan(file, content, dialect, targets, sites, importAt, outcomes,
     { key: "helper:bcmsLayout", name: "bcmsLayout" },
     { key: "helper:bcmsRowsAs", name: "bcmsRowsAs" },
     { key: "helper:bcmsImage", name: "bcmsImage" },
+    { key: "helper:bcmsList", name: "bcmsList" },
+    { key: "helper:bcmsTuples", name: "bcmsTuples" },
     // Keyed by the SLUG: two slugs that spell one identifier are still two pages. @see scope.ts
     ...slugs.map((slug) => ({ key: `slug:${slug}`, name: identifierFor2(slug) }))
   ].filter((entry) => !preset.has(entry.key));
@@ -8211,15 +8908,23 @@ async function plan(file, content, dialect, targets, sites, importAt, outcomes,
   const collided = new Set(overlapping(kept).map((r) => r.key));
   const applied = kept.filter((r) => !collided.has(r.key));
   for (const key of collided) outcomes.set(key, "AMBIGUOUS_LITERAL");
-  const data = bindDataLiterals(
+  const data = await bindDataLiterals(
     {
       content,
       parsed,
       dialect: writing,
       rowsAs: helperName("bcmsRowsAs"),
+      list: helperName("bcmsList"),
+      tuples: helperName("bcmsTuples"),
       read: helperName("bcms"),
       snapshotName,
-      slug: params?.slug ?? null
+      slug: params?.slug ?? null,
+      // The row's leaf travels to another file exactly as a scalar prop does, and by the same
+      // machinery — the lane decides WHICH props, this decides what may be touched. @see props.ts
+      drill: async (component, prop, kind) => {
+        const drilled = await drillProp(drill, file, component, prop, kind, 1);
+        return drilled.ok ? { ok: true, edits: drilled.edits } : { ok: false, reason: drilled.reason ?? "PROP_TARGET_NOT_FOUND" };
+      }
     },
     targets.filter((t) => {
       const outcome = outcomes.get(t.key);
@@ -8237,6 +8942,15 @@ async function plan(file, content, dialect, targets, sites, importAt, outcomes,
   for (const declaration2 of data.declarations) {
     dynamic.push({ file, prop: null, path: declaration2.path, callSites: [{ file, literal: declaration2.literal }] });
   }
+  componentEdits.push(...data.componentEdits);
+  for (const drilledProp of data.props) {
+    dynamic.push({
+      file: drilledProp.file,
+      prop: drilledProp.prop,
+      path: drilledProp.path,
+      callSites: [{ file, literal: drilledProp.literal }]
+    });
+  }
   const images = bindImages(
     { content, parsed, dialect: writing, image: helperName("bcmsImage"), snapshotName, slug: params?.slug ?? null },
     targets.filter((t) => {
@@ -8248,7 +8962,7 @@ async function plan(file, content, dialect, targets, sites, importAt, outcomes,
   for (const refusal of images.refused) outcomes.set(refusal.key, refusal.reason);
   const lanes = [...data.splices, ...images.splices];
   if (applied.length === 0 && lanes.length === 0) {
-    return { tier, content: null, outcomes, bindings: [], occurrences: { located, rewritten: 0 }, dialect: writing, dynamic: [], componentEdits, snapshots: [] };
+    return { tier, content: null, outcomes, bindings: [], occurrences: { located, rewritten: 0 }, dialect: writing, dynamic: [], componentEdits, snapshots: [], notes: [] };
   }
   const readSlugs = [
     .../* @__PURE__ */ new Set([...applied.filter((r) => r.scope === "page").map((r) => r.slug), ...data.slugs, ...images.slugs])
@@ -8275,6 +8989,10 @@ async function plan(file, content, dialect, targets, sites, importAt, outcomes,
       ] : [],
       ...applied.some((r) => r.scope === "layout") ? [{ name: "bcmsLayout", alias: helperName("bcmsLayout") }] : [],
       ...data.usesRows ? [{ name: "bcmsRowsAs", alias: helperName("bcmsRowsAs") }] : [],
+      ...data.usesList ? [{ name: "bcmsList", alias: helperName("bcmsList") }] : [],
+      // `bcmsTuples` reads each row through `bcmsList`, but the emitted helper exports both and the
+      // page imports only the one it calls — an unused import is dead code in someone else's repo.
+      ...data.usesTuples ? [{ name: "bcmsTuples", alias: helperName("bcmsTuples") }] : [],
       ...data.usesRead ? [{ name: "bcms", alias: helperName("bcms") }] : [],
       ...images.splices.length > 0 ? [{ name: "bcmsImage", alias: helperName("bcmsImage") }] : []
     ].filter((helper2, at, all) => all.findIndex((h) => h.name === helper2.name) === at).filter((helper2) => !preset.has(`helper:${helper2.name}`)),
@@ -8289,7 +9007,9 @@ async function plan(file, content, dialect, targets, sites, importAt, outcomes,
     dialect: writing,
     dynamic,
     componentEdits,
-    snapshots: rule.text ? readSlugs : []
+    snapshots: rule.text ? readSlugs : [],
+    // The lane reports one sentence per list it bound; the FILE is added here, where it is known.
+    notes: data.notes.map((message) => ({ code: "PRIMITIVE_LIST", file, message }))
   };
 }
 function mergeInto(content, site) {
@@ -8465,8 +9185,62 @@ function emitStubs2(dialects, slugs, contents, out) {
   }
 }
 
+// package.json
+var package_default = {
+  name: "@bettercms-ai/convert",
+  version: "0.9.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: {
+    "bettercms-convert": "dist/cli.js"
+  },
+  main: "./dist/index.js",
+  module: "./dist/index.js",
+  types: "./dist/index.d.ts",
+  sideEffects: false,
+  exports: {
+    ".": {
+      types: "./dist/index.d.ts",
+      import: "./dist/index.js",
+      default: "./dist/index.js"
+    }
+  },
+  files: [
+    "dist",
+    "README.md",
+    "CHANGELOG.md"
+  ],
+  scripts: {
+    typecheck: "tsc --noEmit",
+    build: "tsup",
+    test: "vitest run",
+    "test:watch": "vitest",
+    briefs: "bun --conditions=development scripts/build-briefs.ts"
+  },
+  dependencies: {
+    "@astrojs/compiler": "^2.13.1",
+    "@babel/parser": "^7.29.2",
+    "@bettercms-ai/types": "^1.12.0",
+    "@vue/compiler-sfc": "^3.5.0",
+    "magic-string": "^0.30.21",
+    parse5: "^7.3.0",
+    svelte: "^5.0.0"
+  },
+  devDependencies: {
+    "@types/node": "^20",
+    esbuild: "^0.27.7",
+    tsup: "^8.5.1",
+    typescript: "^5",
+    vitest: "^4.1.4"
+  },
+  publishConfig: {
+    access: "public",
+    registry: "https://registry.npmjs.org/"
+  }
+};
+
 // src/cli.ts
-var VERSION = "0.4.0";
+var { version: VERSION } = package_default;
 var MAX_FILE_BYTES = 512 * 1024;
 var CliError = class extends Error {
 };
@@ -8474,6 +9248,7 @@ function parseArgs(argv) {
   const args = {
     brief: void 0,
     componentize: false,
+    forms: false,
     plan: void 0,
     copy: "bind",
     root: ".",
@@ -8488,6 +9263,7 @@ function parseArgs(argv) {
     const arg = argv[i];
     if (arg === "--brief") args.brief = argv[++i];
     else if (arg === "--componentize") args.componentize = true;
+    else if (arg === "--forms") args.forms = true;
     else if (arg === "--plan") args.plan = argv[++i];
     else if (arg === "--copy") {
       const mode = argv[++i];
@@ -8514,9 +9290,14 @@ var HELP = `bettercms-convert ${VERSION}
 
   bettercms-convert --brief <json> --root . [options]
   bettercms-convert --componentize --brief <json> --plan <json> --root . [options]
+  bettercms-convert --forms --brief <json> --root . [options]
 
   --brief <file>       The conversion brief, as get_conversion_brief returns it. Required.
   --componentize       Lift each planned SECTION into a component the CMS can reorder.
+  --forms              Point each <form> in the repository at the CMS form behind it \u2014 the
+                       endpoint, the id, a marker per field and the submit script. A form
+                       the brief lists as a DRAFT is wired and receipted: publish it in the
+                       Forms tab, or it rejects every submission with a 403.
   --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
@@ -8599,6 +9380,26 @@ ${rewritten} of ${declared} paths bound (${alreadyDeclared} already declared, ${
 `);
   }
 }
+function reportForms(files, receipt, dryRun) {
+  const { wired, alreadyWired, pending, notes } = receipt.forms;
+  for (const file of files) {
+    process.stdout.write(`${dryRun ? "would " : ""}${file.operation} ${file.path}
+`);
+  }
+  process.stdout.write(
+    `
+${wired} forms wired (${alreadyWired} already wired, ${pending.length} pending)
+`
+  );
+  for (const form of pending) {
+    process.stdout.write(
+      `  pending ${form.name} \u2014 ${form.reason}${form.message ? ` (${form.message})` : ""}${form.file ? ` [${form.file}]` : ""}
+`
+    );
+  }
+  for (const note of notes ?? []) process.stdout.write(`  todo ${note}
+`);
+}
 function reportSections(files, receipt, dryRun) {
   const { extracted, inlineOnly, alreadyExtracted, registered, pending } = receipt.sections;
   for (const file of files) {
@@ -8630,6 +9431,9 @@ async function main() {
   if (args.copy === "instance" && !args.componentize) {
     throw new CliError("--copy is only read with --componentize. See --help.");
   }
+  if (args.forms && args.componentize) {
+    throw new CliError("--forms and --componentize are separate runs. Do one, then the other. See --help.");
+  }
   const root = resolve(args.root);
   const brief = JSON.parse(await readFile(resolve(args.brief), "utf-8"));
   if (!Array.isArray(brief.pages)) {
@@ -8670,6 +9474,13 @@ async function main() {
     reportSections(files2, receipt2, args.dryRun);
     return args.strict && receipt2.sections.pending.length > 0 ? 2 : 0;
   }
+  if (args.forms) {
+    const { files: files2, receipt: receipt2 } = await wireForms(brief, sources);
+    await written(files2);
+    await saveReceipt(receipt2);
+    reportForms(files2, receipt2, args.dryRun);
+    return args.strict && receipt2.forms.pending.length > 0 ? 2 : 0;
+  }
   const { files, receipt } = await convertSources(brief, sources, {
     overwriteHelper: args.overwriteHelper
   });