@bettercms-ai/convert 0.7.0 → 0.8.0

package/dist/index.js

@@ -145,7 +145,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 [];
@@ -186,7 +186,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)));
@@ -3027,7 +3030,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];
@@ -3053,7 +3056,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);
       }
@@ -3063,7 +3066,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();
@@ -3246,8 +3249,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();
@@ -3260,6 +3262,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 ?? []) {
@@ -3284,21 +3299,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();
@@ -3386,11 +3416,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) {
@@ -3403,6 +3433,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);
@@ -3413,7 +3444,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;
@@ -3454,23 +3484,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");
@@ -3486,6 +3529,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}`;
@@ -3495,7 +3568,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) {
@@ -3515,19 +3588,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
@@ -3609,6 +3982,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) {
@@ -3738,7 +4118,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])
@@ -3846,6 +4226,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;
@@ -3937,19 +4341,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");
@@ -4484,8 +4891,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;
       }
@@ -4515,7 +4922,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)) {
@@ -4525,6 +4932,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;
 }
@@ -4597,6 +5006,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;
@@ -4612,7 +5024,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));
   });
 }
 
@@ -5702,6 +6114,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));
@@ -7758,6 +8171,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;
@@ -7783,6 +8197,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);
     }
   }
@@ -7879,13 +8294,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 };
 }
@@ -7907,7 +8334,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) {
@@ -7968,7 +8396,8 @@ async function convertFile(file, content, targets, parsed, declared, llmFallback
         dialect: null,
         dynamic: [],
         componentEdits: [],
-        snapshots: []
+        snapshots: [],
+        notes: []
       };
     }
     if (rescued.reason === "unverifiable") {
@@ -8038,6 +8467,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));
@@ -8229,15 +8660,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);
@@ -8255,6 +8694,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) => {
@@ -8266,7 +8714,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])
@@ -8293,6 +8741,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}`)),
@@ -8307,7 +8759,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) {
@@ -8520,6 +8974,7 @@ export {
   declaringElements,
   dialectOf,
   exportedFunction,
+  extendedConfigs,
   findSites,
   findSitesTolerant,
   flat,