@ai-matrx/records 0.81.3 → 0.82.1

package/dist/templates/index.js

@@ -1922,7 +1922,7 @@ function validateUseCase(useCase) {
       `${primary.rows.length} rows makes the screen look empty. Seed at least ${MIN_ROWS_IN_PRIMARY_TABLE} \u2014 dozens is better.`
     );
   }
-  const resolveField = (tableToken, fieldKey) => tablesByToken.get(tableToken)?.fields.find((f) => f.key === fieldKey);
+  const resolveField = (tableToken, fieldKey2) => tablesByToken.get(tableToken)?.fields.find((f) => f.key === fieldKey2);
   useCase.relationships?.forEach((rel, i) => {
     const at = `relationships[${i}]`;
     if (!tablesByToken.has(rel.fromTable)) {
@@ -4401,8 +4401,8 @@ function validateTemplate(raw, options = {}) {
       for (const k of rule.filled ?? []) if (!filled(val(k))) say(at, `"${row.key}" is ${st}, so "${fieldOf(table, k)?.label ?? k}" is filled; it is empty.`);
       for (const [k, v] of Object.entries(rule.equals ?? {})) {
         const got = val(k) ?? null;
-        const same2 = sameJson(got, v) || typeof v === "number" && parseNumeric(storeText(got) ?? "") !== null && qCmp(parseNumeric(storeText(got) ?? ""), parseNumeric(String(v))) === 0;
-        if (!same2) say(at, `"${row.key}" is ${st}, so "${fieldOf(table, k)?.label ?? k}" is ${JSON.stringify(v)}; it is ${JSON.stringify(got)}.`);
+        const same4 = sameJson(got, v) || typeof v === "number" && parseNumeric(storeText(got) ?? "") !== null && qCmp(parseNumeric(storeText(got) ?? ""), parseNumeric(String(v))) === 0;
+        if (!same4) say(at, `"${row.key}" is ${st}, so "${fieldOf(table, k)?.label ?? k}" is ${JSON.stringify(v)}; it is ${JSON.stringify(got)}.`);
       }
     }
   };
@@ -5740,7 +5740,7 @@ ${e.body}`.matchAll(MERGE_TOKEN)].map((m) => m[1]));
       }
     }
     const rows = t.rows;
-    const same2 = (x, y) => {
+    const same4 = (x, y) => {
       const a = storeText(x);
       const b = storeText(y);
       if (a === null || b === null) return false;
@@ -5758,7 +5758,7 @@ ${e.body}`.matchAll(MERGE_TOKEN)].map((m) => m[1]));
       };
       for (const sf of t.fields.filter((ff) => !isComputed(ff) && !isRelation(ff) && ff.key !== l.key)) {
         const have = rows.filter((r) => filled(r.values?.[sf.key]));
-        if (have.length >= 3 && have.every((r) => same2(r.values?.[sf.key], far(r)))) {
+        if (have.length >= 3 && have.every((r) => same4(r.values?.[sf.key], far(r)))) {
           say(`tables (${t.token}).fields (${sf.key})`, `"${sf.label}" repeats "${l.label}" on every row; drop it and use the lookup, which follows the linked record.`);
         }
       }
@@ -6654,6 +6654,502 @@ function mergeDescribeParts(plan, tables, doors, views, existingTables = [], not
   return spec;
 }
 
+// src/templates/describe/computed-shape.ts
+var VIA_KEYS = ["via", "relation", "relationField", "relation_field", "relationKey", "through", "rollupVia", "lookupVia", "rollupRelation", "lookupRelation", "rollupThrough", "lookupThrough", "from", "link", "linkField"];
+var PICK_KEYS = ["pick", "field", "targetField", "target_field", "fieldKey", "rollupField", "lookupField", "rollupTarget", "lookupTarget", "target", "of", "column", "sourceField", "source"];
+var AGG_KEYS = ["agg", "fn", "func", "function", "operation", "aggregation", "aggregate", "op", "aggregator", "calculation", "rollupFn", "rollupFunction", "rollupAgg", "rollupAggregate", "rollupAggregation", "rollupOperation", "rollupOp"];
+var AGG_WORDS = {
+  sum: "sum",
+  total: "sum",
+  add: "sum",
+  sumof: "sum",
+  summation: "sum",
+  count: "count",
+  countall: "count",
+  countrows: "count",
+  number: "count",
+  numberof: "count",
+  n: "count",
+  tally: "count",
+  avg: "avg",
+  average: "avg",
+  mean: "avg",
+  min: "min",
+  minimum: "min",
+  lowest: "min",
+  smallest: "min",
+  earliest: "min",
+  max: "max",
+  maximum: "max",
+  highest: "max",
+  largest: "max",
+  latest: "max",
+  median: "median",
+  filled: "filled",
+  countfilled: "filled",
+  empty: "empty",
+  countempty: "empty",
+  unique: "unique",
+  distinct: "unique",
+  countunique: "unique",
+  countdistinct: "unique"
+};
+var squash = (s) => String(s ?? "").toLowerCase().replace(/[^a-z0-9]/g, "");
+var singular = (s) => s.replace(/ies$/, "y").replace(/s$/, "");
+var same2 = (a, b) => squash(a) === squash(b) || singular(squash(a)) === singular(squash(b));
+function aggWord(v) {
+  return typeof v === "string" ? AGG_WORDS[squash(v)] : void 0;
+}
+function take(f, nested, keys) {
+  for (const k of keys) if (nested && nested[k] !== void 0 && nested[k] !== null && nested[k] !== "") return { value: nested[k], key: k, from: "nested" };
+  for (const k of keys) if (f[k] !== void 0 && f[k] !== null && f[k] !== "") return { value: f[k], key: k, from: "field" };
+  return void 0;
+}
+function normalizeComputedFields(spec, fixes) {
+  const every = allTables(spec);
+  const byToken = new Map(every.map((t) => [t.token, t]));
+  for (const t of spec.tables) {
+    for (const f of t.fields) {
+      const raw = f;
+      const nestedKind = ["rollup", "lookup"].find((k) => raw[k] && typeof raw[k] === "object");
+      const kind = f.parityType === "rollup" || f.parityType === "lookup" ? f.parityType : !f.parityType && nestedKind ? nestedKind : void 0;
+      if (!kind) continue;
+      const nested = nestedKind ? raw[nestedKind] : void 0;
+      const at = `tables.${t.token}.fields.${f.key}`;
+      const consumed = [];
+      let changed = false;
+      const hasVia = typeof f.via === "string" && t.fields.some((x) => x.key === f.via);
+      let via = hasVia ? t.fields.find((x) => x.key === f.via) : void 0;
+      if (!via) {
+        const got = take(raw, nested, VIA_KEYS);
+        if (got && typeof got.value === "string") {
+          const rels = t.fields.filter((x) => x.parityType === "relation" && x.relationTarget && x.key !== f.key);
+          const hits = [
+            rels.filter((x) => x.key === got.value),
+            rels.filter((x) => same2(x.key, got.value)),
+            rels.filter((x) => same2(x.label, got.value)),
+            rels.filter((x) => same2(x.relationTarget, got.value))
+          ].find((h) => h.length === 1);
+          if (hits) {
+            via = hits[0];
+            f.via = via.key;
+            consumed.push([got.from, got.key]);
+            changed = true;
+          }
+        }
+      }
+      if (!via || !via.relationTarget) {
+        if (changed) fixes.push(`${at}: ${kind} written as ${nestedKind ? `{${nestedKind}:\u2026}` : "loose keys"}, read into via/pick${kind === "rollup" ? "/agg" : ""} where unambiguous`);
+        continue;
+      }
+      const far = byToken.get(via.relationTarget);
+      if (kind === "rollup" && !f.agg) {
+        const got = take(raw, nested, AGG_KEYS);
+        const word = got ? aggWord(got.value) : void 0;
+        if (got && word) {
+          f.agg = word;
+          consumed.push([got.from, got.key]);
+          changed = true;
+        }
+      }
+      if (!f.pick || !far?.fields.some((x) => x.key === f.pick)) {
+        const got = take(raw, nested, PICK_KEYS);
+        const named = got && typeof got.value === "string" ? got.value : void 0;
+        const farField = named ? far?.fields.find((x) => x.key === named) ?? far?.fields.find((x) => same2(x.key, named)) ?? far?.fields.find((x) => same2(x.label, named)) : void 0;
+        if (farField) {
+          f.pick = farField.key;
+          if (got) consumed.push([got.from, got.key]);
+          changed = true;
+        } else if (kind === "rollup" && (f.agg === "count" || !f.agg && !named) && far) {
+          const title = far.titleField;
+          const stand = far.fields.find((x) => x.key === title) ?? far.fields.find((x) => !["relation", "formula", "lookup", "rollup", "autonumber"].includes(x.parityType));
+          if (stand) {
+            f.pick = stand.key;
+            if (got) consumed.push([got.from, got.key]);
+            changed = true;
+          }
+        }
+      }
+      if (kind === "rollup" && changed && via && !via.multi && (via.relationMax ?? 1) <= 1) {
+        via.multi = true;
+        delete via.relationMax;
+        for (const r of spec.relationships ?? []) if (r.fromTable === t.token && r.fromField === via.key) r.cardinality = "many";
+        fixes.push(`${at}.via: "${via.key}" made a list (a rollup adds up many linked records)`);
+      }
+      if (!changed) continue;
+      f.parityType = kind;
+      if (kind === "lookup") delete raw["agg"];
+      for (const [from, k] of consumed) if (from === "field") delete raw[k];
+      if (nestedKind) delete raw[nestedKind];
+      fixes.push(`${at}: ${kind} written in a shape the check does not read, rewritten as via "${f.via}", pick "${f.pick ?? "(none)"}"${kind === "rollup" ? `, agg "${f.agg ?? "(none)"}"` : ""}`);
+    }
+  }
+}
+
+// src/templates/describe/mechanical-shapes.ts
+var squash2 = (s) => String(s ?? "").toLowerCase().replace(/[^a-z0-9]/g, "");
+var singular2 = (s) => s.replace(/ies$/, "y").replace(/s$/, "");
+var same3 = (a, b) => squash2(a) !== "" && (squash2(a) === squash2(b) || singular2(squash2(a)) === singular2(squash2(b)));
+var tableOf = (spec, token) => allTables(spec).find((t) => t.token === token);
+function fieldKey(t, name) {
+  if (!t || typeof name !== "string") return void 0;
+  return t.fields.find((f) => f.key === name)?.key ?? t.fields.find((f) => same3(f.key, name))?.key ?? t.fields.find((f) => same3(f.label, name))?.key;
+}
+var VIEW_ALIASES = {
+  groupBy: ["group_by", "groupby", "groupField", "group_field", "columnField", "column_field"],
+  dateField: ["date_field", "datefield", "dateColumn", "date_column", "calendarField"],
+  startField: ["start_field", "startDate", "start_date", "start"],
+  endField: ["end_field", "endDate", "end_date", "end"],
+  coverField: ["cover_field", "coverImage", "cover_image", "imageField", "image_field", "photoField", "photo_field"],
+  swimlaneBy: ["swimlane_by", "swimlaneField", "swimlane_field", "lanes"]
+};
+var EQ_OPS = /* @__PURE__ */ new Set(["eq", "is", "equals", "equal", "=", "==", "===", "equal_to", "is_equal"]);
+var NEQ_OPS = /* @__PURE__ */ new Set(["neq", "ne", "is_not", "isnot", "not_equal", "!=", "<>", "not_equals", "not_in", "nin", "not_any_of"]);
+var IN_OPS = /* @__PURE__ */ new Set(["in", "is_any_of", "any_of", "one_of", "in_list", "is_one_of"]);
+var EMPTY_OPS = /* @__PURE__ */ new Set(["is_empty", "empty", "is_null", "null", "unset", "is_blank", "blank", "is_unset"]);
+function sortDirection(v) {
+  const s = String(v ?? "").toLowerCase().replace(/[^a-z]/g, "");
+  if (["asc", "ascending", "up", "az", "oldest", "lowest", "first"].includes(s)) return "asc";
+  if (["desc", "descending", "down", "za", "newest", "highest", "last"].includes(s)) return "desc";
+  return void 0;
+}
+function fixViewShapes(spec, fixes) {
+  for (const view of spec.views ?? []) {
+    const t = tableOf(spec, view.table);
+    const at = `views.${view.token}`;
+    for (const [canon, alts] of Object.entries(VIEW_ALIASES)) {
+      if (view[canon] == null) {
+        const alt = alts.find((a) => view[a] != null && typeof view[a] === "string");
+        if (alt) {
+          view[canon] = view[alt];
+          delete view[alt];
+          fixes.push(`${at}.${canon}: written as "${alt}"`);
+        }
+      }
+      if (typeof view[canon] === "string") {
+        const k = fieldKey(t, view[canon]);
+        if (k && k !== view[canon]) {
+          fixes.push(`${at}.${canon}: "${view[canon]}" is the field "${k}"`);
+          view[canon] = k;
+        }
+      }
+    }
+    const rawSorts = view.sorts ?? view.sort ?? view.orderBy ?? view.order_by;
+    if (rawSorts !== void 0) {
+      const list = Array.isArray(rawSorts) ? rawSorts : typeof rawSorts === "string" ? rawSorts.split(",") : rawSorts && typeof rawSorts === "object" ? [rawSorts] : [];
+      const out = [];
+      for (const s of list) {
+        let name, dir;
+        if (typeof s === "string") {
+          const m = /^\s*(-?)\s*([^\s]+)(?:\s+(asc|desc|ascending|descending))?\s*$/i.exec(s);
+          if (m) {
+            name = m[2];
+            dir = m[3] ?? (m[1] ? "desc" : "asc");
+          }
+        } else if (s && typeof s === "object") {
+          name = s.field ?? s.key ?? s.column ?? s.by ?? s.name;
+          dir = s.direction ?? s.dir ?? s.order ?? s.sort ?? "asc";
+        }
+        const key = fieldKey(t, name) ?? (typeof name === "string" ? name : void 0);
+        const d = sortDirection(dir);
+        if (key && d) out.push({ field: key, direction: d });
+      }
+      const changed = JSON.stringify(rawSorts) !== JSON.stringify(out) || view.sort !== void 0 || view.orderBy !== void 0 || view.order_by !== void 0;
+      delete view.sort;
+      delete view.orderBy;
+      delete view.order_by;
+      if (out.length) view.sorts = out;
+      else delete view.sorts;
+      if (changed) fixes.push(`${at}.sorts: written in the store's shape [{field, direction}]`);
+    }
+    if (Array.isArray(view.filters)) {
+      const filters = {};
+      const anyOf = { ...view.anyOf ?? {} };
+      const dropped = [];
+      for (const c of view.filters) {
+        if (!c || typeof c !== "object") continue;
+        const name = c.field ?? c.key ?? c.column ?? c.name;
+        const key = fieldKey(t, name) ?? (typeof name === "string" ? name : void 0);
+        if (!key) continue;
+        const f = t?.fields.find((x) => x.key === key);
+        const op = String(c.op ?? c.operator ?? c.comparison ?? "eq").toLowerCase().trim().replace(/[\s-]+/g, "_");
+        const has = "value" in c || "values" in c;
+        const val = "value" in c ? c.value : c.values;
+        const setEq = (v) => {
+          if (key in filters || key in anyOf) dropped.push(`${key} (two conditions on one field)`);
+          else filters[key] = v;
+        };
+        const setAny = (vals) => {
+          if (key in filters || key in anyOf) dropped.push(`${key} (two conditions on one field)`);
+          else if (vals.length === 1) filters[key] = vals[0];
+          else anyOf[key] = vals;
+        };
+        const universe = f?.parityType === "checkbox" ? [true, false] : f?.choices?.length ? [...f.choices] : void 0;
+        if (EMPTY_OPS.has(op)) setEq(null);
+        else if (EQ_OPS.has(op) && has && !Array.isArray(val)) setEq(val);
+        else if ((IN_OPS.has(op) || EQ_OPS.has(op)) && Array.isArray(val) && val.length) setAny(val);
+        else if (NEQ_OPS.has(op) && has && universe) {
+          const gone = new Set(Array.isArray(val) ? val : [val]);
+          const left = universe.filter((x) => !gone.has(x));
+          if (left.length) setAny(left);
+          else dropped.push(`${key} ${op}`);
+        } else dropped.push(`${key} ${op}`);
+      }
+      view.filters = filters;
+      if (Object.keys(anyOf).length) view.anyOf = anyOf;
+      fixes.push(`${at}.filters: an array of conditions written as the store's map (field \u2192 value; several values \u2192 anyOf)${dropped.length ? `; not expressible and dropped, so the view shows more rows than asked: ${dropped.join(", ")}` : ""}`);
+    }
+  }
+}
+function dropDuplicateViews(spec, fixes) {
+  const seen = /* @__PURE__ */ new Map();
+  const kept = [];
+  for (const v of spec.views ?? []) {
+    const { token: _t, name: _n, isDefault: _d, ...shape } = v;
+    const sig = JSON.stringify(Object.keys(shape).sort().map((k) => [k, shape[k]]));
+    const twin = seen.get(sig);
+    if (!twin) {
+      seen.set(sig, v);
+      kept.push(v);
+      continue;
+    }
+    if (v.isDefault) twin.isDefault = true;
+    fixes.push(`views.${v.token}: "${v.name}" showed exactly what "${twin.name}" shows; dropped`);
+  }
+  if (kept.length !== (spec.views ?? []).length) spec.views = kept;
+}
+var KIND_KEYS = ["kind", "type", "fieldType", "field_type", "dataType", "data_type", "parity_type"];
+var KIND_SYNONYMS = {
+  string: "text",
+  shorttext: "text",
+  singlelinetext: "text",
+  varchar: "text",
+  longtext: "long_text",
+  textarea: "long_text",
+  paragraph: "long_text",
+  multiline: "long_text",
+  richtext: "long_text",
+  integer: "number",
+  int: "number",
+  decimal: "number",
+  float: "number",
+  numeric: "number",
+  money: "currency",
+  price: "currency",
+  amount: "currency",
+  boolean: "checkbox",
+  bool: "checkbox",
+  tick: "checkbox",
+  yesno: "checkbox",
+  date: "datetime",
+  timestamp: "datetime",
+  datetime: "datetime",
+  time: "datetime",
+  dropdown: "select",
+  enum: "select",
+  choice: "select",
+  singleselect: "select",
+  multiselect: "multi_select",
+  tags: "multi_select",
+  tel: "phone",
+  telephone: "phone",
+  mobile: "phone",
+  mail: "email",
+  emailaddress: "email",
+  website: "url",
+  link: "url",
+  uri: "url"
+};
+function inferKind(label, key) {
+  const s = `${key.replace(/_/g, " ")} ${label}`.toLowerCase();
+  if (/\be-?mail\b/.test(s)) return "email";
+  if (/\b(phone|mobile|cell|telephone|fax)\b/.test(s)) return "phone";
+  if (/\b(url|website|web site|link)\b/.test(s)) return "url";
+  if (/\b(amount|fee|price|cost|total|balance|budget|salary|wage|deposit|revenue|payment)\b/.test(s)) return "currency";
+  if (/\b(date|when|due|deadline|birthday|dob|start|end|time|at)\b/.test(s) || /_(on|at)$/.test(key)) return "datetime";
+  if (/\b(notes?|description|details|comments?|summary|instructions)\b/.test(s)) return "long_text";
+  if (/\b(count|quantity|qty|hours|score|age|number of|size|weight|rating)\b/.test(s)) return "number";
+  if (/\b(name|title|owner|label|code|id|reference)\b/.test(s)) return "text";
+  return void 0;
+}
+var wordOf = (v) => {
+  if (typeof v !== "string") return void 0;
+  if (RESOLVABLE_FIELD_TYPE_WORDS.includes(v)) return v;
+  const syn = KIND_SYNONYMS[squash2(v)];
+  return syn && RESOLVABLE_FIELD_TYPE_WORDS.includes(syn) ? syn : void 0;
+};
+function fixFieldKinds(spec, fixes) {
+  for (const t of spec.tables) {
+    for (const f of t.fields) {
+      const raw = f;
+      if (typeof raw.parityType === "string" && RESOLVABLE_FIELD_TYPE_WORDS.includes(raw.parityType)) continue;
+      const at = `tables.${t.token}.fields.${f.key}`;
+      const alias = KIND_KEYS.find((k) => raw[k] != null && typeof raw[k] === "string");
+      let kind = wordOf(raw.parityType) ?? (alias ? wordOf(raw[alias]) : void 0);
+      let how = alias ? `its "${alias}" says "${raw[alias]}"` : raw.parityType ? `"${raw.parityType}" is not a type word` : "it names no type";
+      if (!kind && !alias && !raw.parityType) {
+        kind = inferKind(String(f.label ?? ""), String(f.key ?? ""));
+        how = `it names no type; "${f.label}" plainly is one`;
+      }
+      if (!kind) continue;
+      for (const k of KIND_KEYS) if (k !== "parityType" && raw[k] === raw[alias ?? ""] && alias) delete raw[k];
+      f.parityType = kind;
+      if ((kind === "phone" || kind === "email") && !raw.format) raw.format = kind;
+      fixes.push(`${at}: type ${kind} (${how})`);
+    }
+  }
+}
+function fixFormulaRefs(spec, fixes) {
+  for (const t of spec.tables) {
+    for (const f of t.fields) {
+      if (f.parityType !== "formula" || typeof f.formula !== "string") continue;
+      const others = t.fields.filter((x) => x.key !== f.key);
+      const labelFor = (name) => others.find((x) => x.label === name)?.label ?? others.find((x) => x.key === name)?.label ?? others.find((x) => same3(x.key, name))?.label ?? others.find((x) => same3(x.label, name))?.label;
+      const text = f.formula.replace(/^\s*=\s*/, "");
+      let out = "";
+      let i = 0;
+      while (i < text.length) {
+        const c = text[i];
+        if (c === "{") {
+          const j = text.indexOf("}", i);
+          if (j < 0) {
+            out += text.slice(i);
+            break;
+          }
+          const name = text.slice(i + 1, j).trim();
+          out += `{${labelFor(name) ?? name}}`;
+          i = j + 1;
+        } else if (c === "'" || c === '"') {
+          const j = text.indexOf(c, i + 1);
+          if (j < 0) {
+            out += text.slice(i);
+            break;
+          }
+          out += text.slice(i, j + 1);
+          i = j + 1;
+        } else if (/[A-Za-z_]/.test(c)) {
+          const m = /^[A-Za-z_][A-Za-z_0-9]*/.exec(text.slice(i))[0];
+          const after = text.slice(i + m.length).trimStart()[0];
+          const label = after === "(" ? void 0 : labelFor(m);
+          out += label ? `{${label}}` : m;
+          i += m.length;
+        } else {
+          out += c;
+          i += 1;
+        }
+      }
+      if (out !== f.formula) {
+        fixes.push(`tables.${t.token}.fields.${f.key}.formula: fields named by label in braces ("${f.formula}" \u2192 "${out}")`);
+        f.formula = out;
+      }
+    }
+  }
+}
+function fixInverseKeys(spec, fixes) {
+  const rels = spec.relationships ?? [];
+  const taken = /* @__PURE__ */ new Set();
+  for (const t of allTables(spec)) for (const f of t.fields) taken.add(`${t.token}.${f.key}`);
+  for (const r of rels) if (r.inverseKey) taken.add(`${r.toTable}.${r.inverseKey}`);
+  for (const r of rels) {
+    if (!r.inverseKey) continue;
+    const target = tableOf(spec, r.toTable);
+    if (!target?.fields.some((f) => f.key === r.inverseKey)) continue;
+    let k = `${r.fromTable}_${r.fromField}_back`;
+    for (let n = 2; taken.has(`${r.toTable}.${k}`); n++) k = `${r.fromTable}_${r.fromField}_back_${n}`;
+    fixes.push(`relationships: ${r.fromTable}.${r.fromField} \u2192 ${r.toTable}: inverseKey "${r.inverseKey}" is already a field of ${r.toTable}; renamed "${k}"`);
+    taken.add(`${r.toTable}.${k}`);
+    r.inverseKey = k;
+  }
+}
+var STATUS_WORDS = /\b(open|booked|upcoming|unpaid|outstanding|active|ordered|pending|overdue|scheduled|confirmed|paid|completed|current|remaining)\b/i;
+function fixRollupFilters(spec, fixes) {
+  for (const t of spec.tables) {
+    for (const f of t.fields) {
+      if (f.parityType !== "rollup" || f.filter && Object.keys(f.filter).length || !f.via) continue;
+      const hit = STATUS_WORDS.exec(`${f.label} ${f.key.replace(/_/g, " ")}`);
+      const via = t.fields.find((x) => x.key === f.via);
+      const far = via?.relationTarget ? tableOf(spec, via.relationTarget) : void 0;
+      if (!hit || !far) continue;
+      const word = hit[1].toLowerCase();
+      const cands = [];
+      for (const x of far.fields) {
+        if (["select", "multi_select"].includes(x.parityType)) {
+          for (const c of x.choices ?? []) if (c.toLowerCase() === word) cands.push({ key: x.key, value: c });
+        }
+        if (x.parityType === "checkbox" && new RegExp(`(^|_)${word}($|_)`).test(x.key)) cands.push({ key: x.key, value: true });
+        if (x.parityType === "checkbox" && word === "unpaid" && /(^|_)paid($|_)/.test(x.key)) cands.push({ key: x.key, value: false });
+      }
+      if (cands.length !== 1) continue;
+      f.filter = { [cands[0].key]: cands[0].value };
+      fixes.push(`tables.${t.token}.fields.${f.key}: "${hit[1]}" in its name now picks those records: filter ${JSON.stringify(f.filter)}`);
+    }
+  }
+}
+function fictional(p) {
+  const h = [...p].reduce((n, ch) => (n * 31 + ch.charCodeAt(0)) % 1e3, 7);
+  const nn = String(h % 100).padStart(2, "0");
+  const uk = String(h).padStart(3, "0");
+  if (/^\s*\+/.test(p) && !/^\s*\+1\b/.test(p)) return `+44 20 7946 0${uk}`;
+  if (/^\s*0\d/.test(p)) return `020 7946 0${uk}`;
+  return p.replace(/(\d{3})([\s.-]?)(\d{4})\s*$/, (_m, _a, sep) => `555${sep}01${nn}`);
+}
+function fixFictionalPhones(spec, fixes) {
+  const json = JSON.stringify(spec);
+  const hits = /* @__PURE__ */ new Set();
+  const isPhoneField = (f) => f.parityType === "phone" || /(^|_)(phone|mobile|cell|fax|tel)(_|$)/.test(f.key);
+  const biz = spec.business?.phone;
+  if (typeof biz === "string") for (const p of phonesOutsideFictionalRange(biz, true)) hits.add(p);
+  for (const t of spec.tables) for (const r of t.rows ?? []) for (const f of t.fields) {
+    const v = r.values?.[f.key];
+    if (typeof v === "string") for (const p of phonesOutsideFictionalRange(v, isPhoneField(f))) hits.add(p);
+  }
+  for (const p of phonesOutsideFictionalRange(json)) hits.add(p);
+  let out = json;
+  let n = 0;
+  for (const p of hits) {
+    const escaped = JSON.stringify(p).slice(1, -1);
+    if (!out.includes(escaped)) continue;
+    out = out.split(escaped).join(JSON.stringify(fictional(p)).slice(1, -1));
+    n += 1;
+  }
+  if (!n) return;
+  const next = JSON.parse(out);
+  for (const k of Object.keys(spec)) delete spec[k];
+  Object.assign(spec, next);
+  fixes.push(`phones: ${n} number(s) that could reach a real phone replaced with fictional ones (555-0100\u20260199, UK Ofcom drama range)`);
+}
+function fixTeamBlockCopy(spec, fixes) {
+  const block = SHARED_BLOCKS.team_member;
+  const used = /* @__PURE__ */ new Set();
+  for (const v of spec.views ?? []) for (const k of ["groupBy", "dateField", "startField", "endField", "coverField", "swimlaneBy", "measure"]) if (v.table && v[k]) used.add(`${v.table}.${v[k]}`);
+  for (const fm of spec.forms ?? []) for (const q2 of fm.fields ?? []) used.add(`${fm.table}.${q2.fieldKey}`);
+  for (const e of spec.extras ?? []) for (const q2 of e.questions ?? []) used.add(`${e.table}.${q2.fieldKey}`);
+  for (const t of spec.tables) {
+    const meaning = (f) => block.fields.find((bf) => bf.parityType === f.parityType && bf.sameAs.some((w) => same3(w, f.label) || same3(w, f.key)));
+    const hits = t.fields.map((f) => ({ f, bf: meaning(f) })).filter((x) => x.bf);
+    if (hits.length < block.copyThreshold) continue;
+    const hired = hits.some((h) => h.bf.key === "start_date");
+    const hasRole = hits.some((h) => h.bf.key === "role");
+    const contactOfSomeone = t.fields.some((f) => f.parityType === "relation" && f.relationTarget && f.relationTarget !== block.table && spec.tables.some((o) => o.token === f.relationTarget));
+    if (!(hired || hasRole && !contactOfSomeone)) continue;
+    const order = ["full_name", "role", "work_email", "mobile", "start_date"];
+    const keep = new Set(hits.filter((h) => ["full_name", "role"].includes(h.bf.key)).map((h) => h.f.key));
+    const dropped = [];
+    let left = hits.length;
+    for (const h of [...hits].sort((a, b) => order.indexOf(b.bf.key) - order.indexOf(a.bf.key))) {
+      if (left < block.copyThreshold) break;
+      if (keep.has(h.f.key) || used.has(`${t.token}.${h.f.key}`) || t.titleField === h.f.key) continue;
+      dropped.push(h.f.label);
+      t.fields = t.fields.filter((x) => x.key !== h.f.key);
+      for (const r of t.rows ?? []) if (r.values) delete r.values[h.f.key];
+      left -= 1;
+    }
+    if (left >= block.copyThreshold) continue;
+    if (!t.fields.some((f) => f.key === "notes")) t.fields.push({ key: "notes", label: "Notes", parityType: "long_text", sensitivity: "internal", contextPolicy: "include" });
+    fixes.push(`tables.${t.token}: copied the shared team_member block; kept as an ordinary table (${t.fields.map((f) => f.label).join(", ")}); dropped ${dropped.join(", ") || "nothing"}`);
+  }
+}
+
 // src/templates/describe/autofix.ts
 var clone2 = (v) => JSON.parse(JSON.stringify(v));
 var SENSITIVITY_RANK2 = ["public", "internal", "confidential", "restricted"];
@@ -6975,6 +7471,15 @@ function switchJob(spec, fixes) {
 function autofixDescribeSpec(input, ctx = {}) {
   const spec = describeSpec(clone2(input));
   const autoFixes = [];
+  fixFieldKinds(spec, autoFixes);
+  normalizeComputedFields(spec, autoFixes);
+  fixFormulaRefs(spec, autoFixes);
+  fixViewShapes(spec, autoFixes);
+  dropDuplicateViews(spec, autoFixes);
+  fixInverseKeys(spec, autoFixes);
+  fixRollupFilters(spec, autoFixes);
+  fixTeamBlockCopy(spec, autoFixes);
+  fixFictionalPhones(spec, autoFixes);
   fixMissingQuestionFields(spec, autoFixes);
   raiseSensitivity(spec, autoFixes);
   flagAskedOfSubject(spec, ctx, autoFixes);
@@ -7198,6 +7703,30 @@ var VIEW_SHAPE_FACTS = {
   startField_endField: "timeline only, required: keys of two datetime fields",
   coverField: "gallery only, required: the key of a file field"
 };
+var ROLLUP_SHAPE_FACTS = {
+  rule: 'a rollup is a field of the PARENT table that adds up the records linked to it: parityType "rollup", via = the key of a relation field of THIS table (that link must be a list: multi true), pick = the key of a field on the far table, agg = sum | count | avg | min | max; an optional filter picks which linked records. Write exactly these keys on the field itself \u2014 never a nested {rollup:{\u2026}} object, never relation/field/fn.',
+  example: { key: "total_paid", label: "Total paid", parityType: "rollup", via: "payments", pick: "amount", agg: "sum" }
+};
+var LOOKUP_SHAPE_FACTS = {
+  rule: 'a lookup is a field that shows one value of the record a relation field points at: parityType "lookup", via = the key of a relation field of THIS table, pick = the key of a field on the far table. Write exactly these keys on the field itself \u2014 never a nested {lookup:{\u2026}} object.',
+  example: { key: "client_phone", label: "Client phone", parityType: "lookup", via: "client", pick: "phone" }
+};
+var VIEW_FILTERS_SHAPE_FACTS = {
+  rule: "a view's `filters` is ONE object of field key \u2192 value (a plain value is equality, null means empty); several allowed values of one field go in `anyOf` as field key \u2192 [values]; `sorts` is a list of {field, direction: asc|desc}; groupBy, dateField, startField, endField, coverField are field KEYS. Never write filters or sort as a list of {field, op, value}. The store cannot filter on 'not', 'contains', 'less than' or 'is not empty' \u2014 leave such a condition out.",
+  example: { token: "open_requests", name: "Open requests", table: "request", kind: "kanban", groupBy: "stage", filters: { priority: "High" }, anyOf: { stage: ["New", "In progress"] }, sorts: [{ field: "due_on", direction: "asc" }] }
+};
+var FIELD_SHAPE_FACTS = {
+  rule: "every field is {key, label, parityType, sensitivity, contextPolicy}; the type word goes in `parityType` (never `kind` or `type`) and is one of field_kinds.",
+  example: { key: "visit_fee", label: "Visit fee", parityType: "currency", sensitivity: "internal", contextPolicy: "include" }
+};
+var FORMULA_SHAPE_FACTS = {
+  rule: "a formula names every field by its LABEL in braces ({Quantity}), never by key; operators are + - * / % only (no >, <, = or comparisons), functions are IF, ROUND, SUM, DATEDIFF and the other store functions; it never reads a lookup or rollup, nor itself.",
+  example: { key: "line_total", label: "Line total", parityType: "formula", formula: "{Quantity} * {Unit price}" }
+};
+var RELATIONSHIP_SHAPE_FACTS = {
+  rule: "a relationship's inverseKey is the name the OTHER table sees this link under; it must not be a key that table already has as a field. A parent that lists its children owns ONE multi relation field (multi true); the child's single link to the parent is a second field, and their inverseKeys differ from every field key.",
+  example: { fromTable: "request", fromField: "client", toTable: "client", flavor: "referenced", cardinality: "one", onDelete: "restrict", inverseKey: "requests_from" }
+};
 function describeVocabulary() {
   return {
     field_kinds: RESOLVABLE_FIELD_TYPE_WORDS,
@@ -7221,6 +7750,14 @@ function describeVocabulary() {
     booking_window: { weekday: "0 = Sunday \u2026 6 = Saturday", from: "HH:MM", to: "HH:MM later than from" },
     booking_availability: BOOKING_AVAILABILITY_FACTS,
     view_shape: VIEW_SHAPE_FACTS,
+    rollup_shape: ROLLUP_SHAPE_FACTS,
+    lookup_shape: LOOKUP_SHAPE_FACTS,
+    view_filters_shape: VIEW_FILTERS_SHAPE_FACTS,
+    field_shape: FIELD_SHAPE_FACTS,
+    formula_shape: FORMULA_SHAPE_FACTS,
+    relationship_shape: RELATIONSHIP_SHAPE_FACTS,
+    phone_rule: "seed phone numbers are fictional: 555-0100 to 555-0199 in North America (e.g. (813) 555-0142) or a UK Ofcom drama number (e.g. 020 7946 0123); never a real-looking number.",
+    team_rule: "the team (name, role, work email, mobile, start date) is the shared team_member block; do not declare a table with those fields \u2014 keep a table of your own to just name and role, or point a relation field at team_member.",
     title_field: "a table's titleField is the key of a plain text-like field of that same table (a name, a title) \u2014 never a link to another table, a formula or a timed date"
   };
 }