@ai-matrx/records 0.76.8 → 0.76.10

package/dist/templates/index.js

@@ -371,9 +371,9 @@ function membersAddRowsSteps(spec, tableRef) {
   }));
 }
 function confidentialRequests(spec, made) {
-  const idOf = (token) => made.find((m) => m.kind === "table" && m.ref === `tables.${token}`)?.id ?? null;
+  const idOf2 = (token) => made.find((m) => m.kind === "table" && m.ref === `tables.${token}`)?.id ?? null;
   return (spec.confidential ?? []).map((c) => {
-    const tableId = idOf(c.table);
+    const tableId = idOf2(c.table);
     if (!tableId) throw new Error(`The install made no "${c.table}" table, so it cannot be made Confidential.`);
     const readers = c.readers.map((r) => ({ field: r.field, level: r.level, ...r.when ? { when: whenRule(c.table, r.when, made) } : {} }));
     return {
@@ -1479,6 +1479,7 @@ var TABLE_TYPES = [
 var RELATION_FLAVORS = ["owned", "referenced"];
 var ON_DELETE = ["cascade", "set_null", "restrict"];
 var RELATION_CARDINALITIES = ["one", "many"];
+var FIELD_SOURCES = ["manual", "formula", "agent", "synced"];
 var FIELD_SENSITIVITIES = ["public", "internal", "confidential", "restricted"];
 var CONTEXT_POLICIES = ["include", "summarize", "exclude", "on_request"];
 var TABLE_DISPLAYS = ["list", "grid", "board", "calendar", "timeline"];
@@ -1825,39 +1826,39 @@ function validateUseCase(useCase) {
         `The title field "${table.titleField}" is not one of this table's fields \u2014 without it a record cannot be a chip.`
       );
     }
-    table.fields.forEach((field, fi) => {
-      const fat = `${at}.fields[${fi}] (${field.key})`;
-      if (!/^[a-z][a-z0-9_]*$/.test(field.key ?? "")) {
-        say(`${fat}.key`, `"${field.key}" should be snake_case and start with a letter.`);
+    table.fields.forEach((field2, fi) => {
+      const fat = `${at}.fields[${fi}] (${field2.key})`;
+      if (!/^[a-z][a-z0-9_]*$/.test(field2.key ?? "")) {
+        say(`${fat}.key`, `"${field2.key}" should be snake_case and start with a letter.`);
       }
-      if (!RESOLVABLE_FIELD_TYPE_WORDS.includes(field.parityType)) {
+      if (!RESOLVABLE_FIELD_TYPE_WORDS.includes(field2.parityType)) {
         say(
           `${fat}.parityType`,
-          `The store does not resolve the type word "${field.parityType}". Use one of: ${RESOLVABLE_FIELD_TYPE_WORDS.join(", ")}.`
+          `The store does not resolve the type word "${field2.parityType}". Use one of: ${RESOLVABLE_FIELD_TYPE_WORDS.join(", ")}.`
         );
       }
-      if (!FIELD_SENSITIVITIES.includes(field.sensitivity)) {
+      if (!FIELD_SENSITIVITIES.includes(field2.sensitivity)) {
         say(
           `${fat}.sensitivity`,
           `The store refuses a field that does not say how sensitive its values are. Use one of: ${FIELD_SENSITIVITIES.join(", ")}.`
         );
       }
-      if (!CONTEXT_POLICIES.includes(field.contextPolicy)) {
+      if (!CONTEXT_POLICIES.includes(field2.contextPolicy)) {
         say(
           `${fat}.contextPolicy`,
           `The store refuses a field that does not say whether an agent may see its values. Use one of: ${CONTEXT_POLICIES.join(", ")}.`
         );
       }
-      if (CHOICE_TYPES.has(field.parityType) && !field.choices?.length) {
+      if (CHOICE_TYPES.has(field2.parityType) && !field2.choices?.length) {
         say(
           `${fat}.choices`,
           "A choice field has to list the business's real words, in the order they really happen \u2014 'Scheduled, Confirmed, Seen, No-show'."
         );
       }
-      if (RELATION_TYPES.has(field.parityType) && field.relationTarget && !tablesByToken.has(field.relationTarget)) {
-        say(`${fat}.relationTarget`, `It points at the table "${field.relationTarget}", which this use case does not declare.`);
+      if (RELATION_TYPES.has(field2.parityType) && field2.relationTarget && !tablesByToken.has(field2.relationTarget)) {
+        say(`${fat}.relationTarget`, `It points at the table "${field2.relationTarget}", which this use case does not declare.`);
       }
-      if (field.parityType === "currency" && !field.unit) {
+      if (field2.parityType === "currency" && !field2.unit) {
         say(`${fat}.unit`, "A currency field carries its currency as the unit \u2014 the unit changes the meaning.");
       }
     });
@@ -1872,16 +1873,16 @@ function validateUseCase(useCase) {
           say(`${rat}.values.${valueKey}`, `This row sets "${valueKey}", which the table does not declare as a field.`);
         }
       }
-      for (const field of table.fields) {
-        if (field.required && (row.values?.[field.key] === void 0 || row.values?.[field.key] === null)) {
-          say(`${rat}.values.${field.key}`, `"${field.label}" is required, and this row leaves it empty.`);
+      for (const field2 of table.fields) {
+        if (field2.required && (row.values?.[field2.key] === void 0 || row.values?.[field2.key] === null)) {
+          say(`${rat}.values.${field2.key}`, `"${field2.label}" is required, and this row leaves it empty.`);
         }
-        const value = row.values?.[field.key];
-        if (value !== void 0 && field.choices?.length && !field.multi) {
-          if (typeof value === "string" && !field.choices.includes(value)) {
+        const value = row.values?.[field2.key];
+        if (value !== void 0 && field2.choices?.length && !field2.multi) {
+          if (typeof value === "string" && !field2.choices.includes(value)) {
             say(
-              `${rat}.values.${field.key}`,
-              `"${value}" is not one of "${field.label}"'s choices (${field.choices.join(", ")}).`
+              `${rat}.values.${field2.key}`,
+              `"${value}" is not one of "${field2.label}"'s choices (${field2.choices.join(", ")}).`
             );
           }
         }
@@ -1905,18 +1906,18 @@ function validateUseCase(useCase) {
     if (!tablesByToken.has(rel.toTable)) {
       say(`${at}.toTable`, `There is no table "${rel.toTable}" in this use case.`);
     }
-    const field = resolveField(rel.fromTable, rel.fromField);
-    if (!field) {
+    const field2 = resolveField(rel.fromTable, rel.fromField);
+    if (!field2) {
       say(`${at}.fromField`, `The table "${rel.fromTable}" does not declare a field "${rel.fromField}".`);
-    } else if (!RELATION_TYPES.has(field.parityType)) {
+    } else if (!RELATION_TYPES.has(field2.parityType)) {
       say(
         `${at}.fromField`,
-        `"${rel.fromField}" is a ${field.parityType} field, so it cannot hold a relation. Declare it as a relation.`
+        `"${rel.fromField}" is a ${field2.parityType} field, so it cannot hold a relation. Declare it as a relation.`
       );
-    } else if (field.relationTarget && field.relationTarget !== rel.toTable) {
+    } else if (field2.relationTarget && field2.relationTarget !== rel.toTable) {
       say(
         `${at}.fromField`,
-        `The field points at "${field.relationTarget}" but the relationship says "${rel.toTable}". They have to agree.`
+        `The field points at "${field2.relationTarget}" but the relationship says "${rel.toTable}". They have to agree.`
       );
     }
     if (!RELATION_FLAVORS.includes(rel.flavor)) {
@@ -2074,12 +2075,12 @@ var ACTOR = "user";
 var COMPUTED = /* @__PURE__ */ new Set(["lookup", "rollup", "formula"]);
 var isTimedField = (f) => f.parityType === "datetime" && f.format === "datetime";
 var isSelfDeclaredField = (f) => f.parityType !== "relation" && !COMPUTED.has(f.parityType) && (isTimedField(f) || f.default !== void 0 || f.parityType === "entity_reference");
-function choiceDisplayFormat(field) {
-  if (!field.choices?.length || !field.choiceColors) return void 0;
+function choiceDisplayFormat(field2) {
+  if (!field2.choices?.length || !field2.choiceColors) return void 0;
   return {
-    id: field.parityType === "multi_select" ? "multi_choice" : "choice",
+    id: field2.parityType === "multi_select" ? "multi_choice" : "choice",
     options: {
-      choices: field.choices.filter((c) => field.choiceColors?.[c]).map((c) => ({ value: c, color: field.choiceColors[c] }))
+      choices: field2.choices.filter((c) => field2.choiceColors?.[c]).map((c) => ({ value: c, color: field2.choiceColors[c] }))
     }
   };
 }
@@ -2147,49 +2148,49 @@ function shellsPayload(spec, tables, deferred = deferredRelations(tables)) {
     })
   };
 }
-function timedFieldSpec(field) {
+function timedFieldSpec(field2) {
   return {
-    key: field.key,
-    label: field.label,
+    key: field2.key,
+    label: field2.label,
     type: "datetime",
     kind: "datetime",
-    ...field.required ? { required: true } : {},
-    ...field.rules ? { rules: field.rules } : {},
-    sensitivity: field.sensitivity,
-    context_policy: field.contextPolicy
+    ...field2.required ? { required: true } : {},
+    ...field2.rules ? { rules: field2.rules } : {},
+    sensitivity: field2.sensitivity,
+    context_policy: field2.contextPolicy
   };
 }
-function selfDeclaredFieldSpec(field) {
-  if (isTimedField(field)) return { ...timedFieldSpec(field), ...field.default !== void 0 ? { default: field.default } : {} };
-  const allowed = field.parityType === "entity_reference" ? { allowed_types: field.allowedTypes ?? [] } : {};
-  const displayFormat = choiceDisplayFormat(field);
+function selfDeclaredFieldSpec(field2) {
+  if (isTimedField(field2)) return { ...timedFieldSpec(field2), ...field2.default !== void 0 ? { default: field2.default } : {} };
+  const allowed = field2.parityType === "entity_reference" ? { allowed_types: field2.allowedTypes ?? [] } : {};
+  const displayFormat = choiceDisplayFormat(field2);
   return {
-    key: field.key,
-    label: field.label,
-    type: field.parityType,
-    ...field.multi ? { multi: true } : {},
-    ...field.required ? { required: true } : {},
-    ...field.unit ? { unit: field.unit } : {},
-    ...field.rules ? { rules: field.rules } : {},
-    ...field.choices ? { options: field.choices } : {},
+    key: field2.key,
+    label: field2.label,
+    type: field2.parityType,
+    ...field2.multi ? { multi: true } : {},
+    ...field2.required ? { required: true } : {},
+    ...field2.unit ? { unit: field2.unit } : {},
+    ...field2.rules ? { rules: field2.rules } : {},
+    ...field2.choices ? { options: field2.choices } : {},
     ...displayFormat ? { display_format: displayFormat } : {},
-    ...field.default !== void 0 ? { default: field.default } : {},
+    ...field2.default !== void 0 ? { default: field2.default } : {},
     ...allowed,
-    sensitivity: field.sensitivity,
-    context_policy: field.contextPolicy
+    sensitivity: field2.sensitivity,
+    context_policy: field2.contextPolicy
   };
 }
-function relationFieldSpec(field, targetTableId) {
+function relationFieldSpec(field2, targetTableId) {
   return {
-    key: field.key,
-    label: field.label,
+    key: field2.key,
+    label: field2.label,
     type: "relation",
     relation_target: targetTableId,
-    ...field.multi ? { multi: true } : {},
-    ...field.relationMax ? { relation_max: field.relationMax } : {},
-    ...field.required ? { required: true } : {},
-    sensitivity: field.sensitivity,
-    context_policy: field.contextPolicy
+    ...field2.multi ? { multi: true } : {},
+    ...field2.relationMax ? { relation_max: field2.relationMax } : {},
+    ...field2.required ? { required: true } : {},
+    sensitivity: field2.sensitivity,
+    context_policy: field2.contextPolicy
   };
 }
 function rowLevels(tables) {
@@ -2249,12 +2250,12 @@ function relationPatches(table, ids, deferred) {
     for (const [key, target] of rel) {
       const v = r.values?.[key];
       if (v === null || v === void 0) continue;
-      const idOf = (k) => {
+      const idOf2 = (k) => {
         const id = ids.get(`${target}.${String(k)}`);
         if (!id) throw new Error(`A row points at "${String(k)}" in "${target}", which the template does not have.`);
         return id;
       };
-      patch[key] = Array.isArray(v) ? v.map(idOf) : idOf(v);
+      patch[key] = Array.isArray(v) ? v.map(idOf2) : idOf2(v);
     }
     if (Object.keys(patch).length) out.push({ op: "update", record_id: ids.get(`${table.token}.${r.key}`), patch: { ...patch, _actor: ACTOR } });
   }
@@ -2263,7 +2264,7 @@ function relationPatches(table, ids, deferred) {
 function rowsFor(table, ids, deferred) {
   const relation = new Map(table.fields.filter((f) => f.parityType === "relation").map((f) => [f.key, f]));
   const derived = new Set(table.fields.filter((f) => COMPUTED.has(f.parityType)).map((f) => f.key));
-  const idOf = (target, key) => {
+  const idOf2 = (target, key) => {
     const id = ids.get(`${target}.${String(key)}`);
     if (!id) throw new Error(`A row points at "${String(key)}" in "${target}", which the template does not have.`);
     return id;
@@ -2277,7 +2278,7 @@ function rowsFor(table, ids, deferred) {
         values[key] = value;
         continue;
       }
-      values[key] = Array.isArray(value) ? value.map((v) => idOf(rel.relationTarget, v)) : idOf(rel.relationTarget, value);
+      values[key] = Array.isArray(value) ? value.map((v) => idOf2(rel.relationTarget, v)) : idOf2(rel.relationTarget, value);
     }
     if (typeof r.icon === "string" && r.icon.trim()) values["icon"] = r.icon.trim();
     values["_actor"] = ACTOR;
@@ -2285,17 +2286,17 @@ function rowsFor(table, ids, deferred) {
   });
   return { rows, ids: table.rows.map((r) => ids.get(`${table.token}.${r.key}`)) };
 }
-function derivedFieldSpec(field) {
+function derivedFieldSpec(field2) {
   const base = {
-    key: field.key,
-    label: field.label,
-    type: field.parityType,
-    via: field.via,
-    sensitivity: field.sensitivity,
-    context_policy: field.contextPolicy,
-    ...field.unit ? { unit: field.unit } : {}
+    key: field2.key,
+    label: field2.label,
+    type: field2.parityType,
+    via: field2.via,
+    sensitivity: field2.sensitivity,
+    context_policy: field2.contextPolicy,
+    ...field2.unit ? { unit: field2.unit } : {}
   };
-  return field.parityType === "rollup" ? { ...base, agg: field.agg, of: field.pick, ...field.filter ? { filter: field.filter } : {} } : { ...base, pick: field.pick };
+  return field2.parityType === "rollup" ? { ...base, agg: field2.agg, of: field2.pick, ...field2.filter ? { filter: field2.filter } : {} } : { ...base, pick: field2.pick };
 }
 function viewSpec(view, fieldIds = {}) {
   const definition = { layout: view.kind };
@@ -2341,15 +2342,15 @@ function anyOfWhere(anyOf, fieldIds) {
     })
   };
 }
-function formulaFieldSpec(field) {
+function formulaFieldSpec(field2) {
   return {
-    key: field.key,
-    label: field.label,
+    key: field2.key,
+    label: field2.label,
     type: "formula",
-    formula_text: field.formula,
-    ...field.unit ? { unit: field.unit } : {},
-    sensitivity: field.sensitivity,
-    context_policy: field.contextPolicy
+    formula_text: field2.formula,
+    ...field2.unit ? { unit: field2.unit } : {},
+    sensitivity: field2.sensitivity,
+    context_policy: field2.contextPolicy
   };
 }
 function formulaOrder(table) {
@@ -2967,23 +2968,23 @@ var BUCKETS = ["year", "quarter", "month", "week", "day"];
 var AGG_OPERATIONS = ["count", "sum", "avg", "min", "max", "median", "filled", "empty", "unique"];
 var MEASURE_KEY = /^[a-zA-Z_][a-zA-Z0-9_]{0,62}$/;
 var STORE_LIST_RELATION_MAX = 25;
-function ruleBreak(field, v) {
+function ruleBreak(field2, v) {
   const t = storeText(v) ?? "";
   if (t === "") return null;
-  if (field.choices?.length && !field.multi && typeof v === "string" && !field.choices.includes(v)) return `"${v}" is not one of "${field.label}"'s choices.`;
-  for (const rule of field.rules ?? []) {
+  if (field2.choices?.length && !field2.multi && typeof v === "string" && !field2.choices.includes(v)) return `"${v}" is not one of "${field2.label}"'s choices.`;
+  for (const rule of field2.rules ?? []) {
     if (rule.kind === "min" || rule.kind === "max") {
       const n = parseNumeric(t);
       const bound = parseNumeric(String(rule.value));
-      if (n && bound && (rule.kind === "min" ? qCmp(n, bound) < 0 : qCmp(n, bound) > 0)) return `${t} breaks "${field.label}"'s rule: at ${rule.kind === "min" ? "least" : "most"} ${rule.value}.`;
+      if (n && bound && (rule.kind === "min" ? qCmp(n, bound) < 0 : qCmp(n, bound) > 0)) return `${t} breaks "${field2.label}"'s rule: at ${rule.kind === "min" ? "least" : "most"} ${rule.value}.`;
     } else if (rule.kind === "length") {
-      if (rule.value !== void 0 && t.length > Number(rule.value)) return `"${t}" is longer than "${field.label}" allows (${rule.value}).`;
-      if (rule.min !== void 0 && t.length < rule.min) return `"${t}" is shorter than "${field.label}" allows (${rule.min}).`;
+      if (rule.value !== void 0 && t.length > Number(rule.value)) return `"${t}" is longer than "${field2.label}" allows (${rule.value}).`;
+      if (rule.min !== void 0 && t.length < rule.min) return `"${t}" is shorter than "${field2.label}" allows (${rule.min}).`;
     } else if (rule.kind === "pattern" && rule.value !== void 0) {
       try {
-        if (!new RegExp(String(rule.value)).test(t)) return `"${t}" does not match "${field.label}"'s own pattern.`;
+        if (!new RegExp(String(rule.value)).test(t)) return `"${t}" does not match "${field2.label}"'s own pattern.`;
       } catch {
-        return `"${field.label}"'s pattern is not a pattern.`;
+        return `"${field2.label}"'s pattern is not a pattern.`;
       }
     }
   }
@@ -3020,14 +3021,14 @@ function deriveSingulars(spec) {
   if (form) out.form = form;
   const stages = spec.extras?.find((e) => e.kind === "stage_rules");
   if (stages?.kind === "stage_rules") {
-    const field = allTables(spec).find((t) => t.token === stages.table)?.fields.find((f) => f.key === stages.stageField);
+    const field2 = allTables(spec).find((t) => t.token === stages.table)?.fields.find((f) => f.key === stages.stageField);
     out.pipeline = {
       token: stages.token,
       name: stages.name,
       describes: stages.movesMessage ?? stages.name,
       table: stages.table,
       stageField: stages.stageField,
-      stages: (field?.choices ?? Object.keys(stages.stages ?? {})).map((key) => ({ key, label: key, describes: stages.stages?.[key] ?? "" }))
+      stages: (field2?.choices ?? Object.keys(stages.stages ?? {})).map((key) => ({ key, label: key, describes: stages.stages?.[key] ?? "" }))
     };
   }
   const q6 = spec.agent?.question;
@@ -3146,12 +3147,12 @@ function capabilitiesUsed(spec) {
   }
   if (spec.teaches === "gallery") used.add("seed.attachments");
   for (const table of allTables(spec)) {
-    for (const field of table.fields ?? []) {
-      const word = `field.${field.parityType}`;
+    for (const field2 of table.fields ?? []) {
+      const word = `field.${field2.parityType}`;
       if (CAPABILITY_WORDS.includes(word)) used.add(word);
-      if (field.choiceColors && Object.keys(field.choiceColors).length) used.add("choice.colors");
-      if (field.format === "rating") used.add("field.rating");
-      if (field.format === "signature") used.add("field.signature");
+      if (field2.choiceColors && Object.keys(field2.choiceColors).length) used.add("choice.colors");
+      if (field2.format === "rating") used.add("field.rating");
+      if (field2.format === "signature") used.add("field.signature");
     }
   }
   if (spec.forms?.length) {
@@ -3362,9 +3363,9 @@ function foreignTextProblems(spec, library) {
   const all = hay.map(([, v]) => v).join("\n");
   const esc = (w) => w.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
   const find = (word) => {
-    const lower = word.toLowerCase();
-    if (!all.includes(lower)) return void 0;
-    const re = new RegExp(`(^|[^a-z0-9])${esc(lower)}($|[^a-z0-9])`);
+    const lower2 = word.toLowerCase();
+    if (!all.includes(lower2)) return void 0;
+    const re = new RegExp(`(^|[^a-z0-9])${esc(lower2)}($|[^a-z0-9])`);
     return hay.find(([, v]) => re.test(v));
   };
   const mine = proseOf(spec).map(([at, w]) => {
@@ -3523,6 +3524,10 @@ function validateTemplate(raw, options = {}) {
   }
   for (const table of tablesRaw) {
     const tf = table.fields.find((f) => f.key === table.titleField);
+    if (!tf) say(`tables (${table.token}).titleField`, `The title field "${table.titleField}" is not one of this table's fields; name a plain text-like field of "${table.token}" (a name, a title) \u2014 the install refuses anything else.`);
+    else if (isRelation(tf) || ["lookup", "rollup", "formula"].includes(tf.parityType) || isTimedField(tf) || tf.parityType === "entity_reference") {
+      say(`tables (${table.token}).titleField`, `The title field "${tf.key}" is a ${isRelation(tf) ? "link to another table" : tf.parityType} column, which the store adds after the table is made; the title has to be a plain text-like field made with the table (a name or title). Add one, or point titleField at it.`);
+    }
     if (tf && tf.default !== void 0) say(`tables (${table.token}).fields (${tf.key})`, `"${tf.label}" names each ${table.labelSingular.toLowerCase()}, so it takes no default; ask it on the form instead.`);
   }
   for (const table of tablesRaw) {
@@ -3711,49 +3716,49 @@ function validateTemplate(raw, options = {}) {
   let hasLookupOrRollup = false;
   tables.forEach((table) => {
     const tat = `tables (${table.token})`;
-    table.fields.forEach((field) => {
-      const at = `${tat}.fields (${field.key})`;
-      if (isChoice(field) && field.choices?.length) {
-        const colors = field.choices.map((c) => field.choiceColors?.[c]);
-        field.choices.forEach((c, i) => {
+    table.fields.forEach((field2) => {
+      const at = `${tat}.fields (${field2.key})`;
+      if (isChoice(field2) && field2.choices?.length) {
+        const colors = field2.choices.map((c) => field2.choiceColors?.[c]);
+        field2.choices.forEach((c, i) => {
           const color = colors[i];
           if (!color) say(`${at}.choiceColors`, `The choice "${c}" wears no colour. Give every choice one of: ${CHOICE_COLORS.join(", ")}.`);
           else if (!CHOICE_COLORS.includes(color)) say(`${at}.choiceColors`, `"${color}" is not a colour the grid can paint.`);
         });
-        for (const k of Object.keys(field.choiceColors ?? {})) if (!field.choices.includes(k)) say(`${at}.choiceColors`, `It colours "${k}", which is not one of the field's choices.`);
+        for (const k of Object.keys(field2.choiceColors ?? {})) if (!field2.choices.includes(k)) say(`${at}.choiceColors`, `It colours "${k}", which is not one of the field's choices.`);
         const distinct = new Set(colors.filter(Boolean)).size;
-        const need = Math.min(field.choices.length, CHOICE_COLORS_DISTINCT_UP_TO);
-        if (distinct < need) say(`${at}.choiceColors`, `${field.choices.length} choices wear only ${distinct} distinct colour(s); each choice needs its own (${need}), so the board reads at a glance.`);
+        const need = Math.min(field2.choices.length, CHOICE_COLORS_DISTINCT_UP_TO);
+        if (distinct < need) say(`${at}.choiceColors`, `${field2.choices.length} choices wear only ${distinct} distinct colour(s); each choice needs its own (${need}), so the board reads at a glance.`);
       }
-      if (isNumber(field) && !isComputed(field)) {
-        const kinds2 = new Set((field.rules ?? []).map((r) => r.kind));
-        if (!kinds2.has("min") || !kinds2.has("max")) say(`${at}.rules`, `"${field.label}" is measured, so it declares the least and the most a real value can be (min and max rules).`);
-        const seeds = table.rows.map((r) => parseNumeric(storeText(r.values?.[field.key]) ?? "")).filter((v) => !!v).map((v) => Number(v.n) / Number(v.d));
+      if (isNumber(field2) && !isComputed(field2)) {
+        const kinds2 = new Set((field2.rules ?? []).map((r) => r.kind));
+        if (!kinds2.has("min") || !kinds2.has("max")) say(`${at}.rules`, `"${field2.label}" is measured, so it declares the least and the most a real value can be (min and max rules).`);
+        const seeds = table.rows.map((r) => parseNumeric(storeText(r.values?.[field2.key]) ?? "")).filter((v) => !!v).map((v) => Number(v.n) / Number(v.d));
         if (seeds.length) {
           const hi = Math.max(...seeds);
           const lo = Math.min(...seeds);
-          if (new Set(seeds).size < 2) say(`${at}`, `Every seed row holds the same ${field.label}; real records vary.`);
-          for (const rule of field.rules ?? []) {
+          if (new Set(seeds).size < 2) say(`${at}`, `Every seed row holds the same ${field2.label}; real records vary.`);
+          for (const rule of field2.rules ?? []) {
             const bound = Number(rule.value);
-            if (rule.kind === "max" && hi > 0 && bound > 100 * hi) say(`${at}.rules`, `The most "${field.label}" allows (${rule.value}) is over 100\xD7 the largest real value (${hi}); write the real ceiling.`);
-            if (rule.kind === "min" && bound < -1e3 * Math.abs(lo)) say(`${at}.rules`, `The least "${field.label}" allows (${rule.value}) is far below any real value (${lo}); write the real floor.`);
-            if (rule.kind === "min" && bound < 0 && lo >= 0) say(`${at}.rules`, `"${field.label}" allows negative values, and no real one is negative; the floor is 0 or above.`);
+            if (rule.kind === "max" && hi > 0 && bound > 100 * hi) say(`${at}.rules`, `The most "${field2.label}" allows (${rule.value}) is over 100\xD7 the largest real value (${hi}); write the real ceiling.`);
+            if (rule.kind === "min" && bound < -1e3 * Math.abs(lo)) say(`${at}.rules`, `The least "${field2.label}" allows (${rule.value}) is far below any real value (${lo}); write the real floor.`);
+            if (rule.kind === "min" && bound < 0 && lo >= 0) say(`${at}.rules`, `"${field2.label}" allows negative values, and no real one is negative; the floor is 0 or above.`);
           }
         }
       }
-      if (field.parityType === "lookup" || field.parityType === "rollup") {
-        const via = field.via ? fieldOf(table.token, field.via) : void 0;
+      if (field2.parityType === "lookup" || field2.parityType === "rollup") {
+        const via = field2.via ? fieldOf(table.token, field2.via) : void 0;
         if (!via || !isRelation(via) || !via.relationTarget) {
-          say(`${at}.via`, `A ${field.parityType} reads THROUGH a relation field of this table; "${field.via ?? "(none)"}" is not one.`);
+          say(`${at}.via`, `A ${field2.parityType} reads THROUGH a relation field of this table; "${field2.via ?? "(none)"}" is not one.`);
         } else {
           hasLookupOrRollup = true;
-          if (!field.pick || !fieldOf(via.relationTarget, field.pick)) say(`${at}.pick`, `It reads "${field.pick ?? "(nothing)"}" on "${via.relationTarget}", which that table does not declare.`);
-          if (field.parityType === "rollup" && !field.agg) say(`${at}.agg`, "A rollup says how it adds up the far side.");
-          if (field.parityType === "rollup" && !via.multi && (via.relationMax ?? 1) <= 1) say(`${at}.via`, `"${field.label}" adds up "${via.label}", which links one record. Make "${via.label}" a list (multi), or read its one value with a lookup.`);
+          if (!field2.pick || !fieldOf(via.relationTarget, field2.pick)) say(`${at}.pick`, `It reads "${field2.pick ?? "(nothing)"}" on "${via.relationTarget}", which that table does not declare.`);
+          if (field2.parityType === "rollup" && !field2.agg) say(`${at}.agg`, "A rollup says how it adds up the far side.");
+          if (field2.parityType === "rollup" && !via.multi && (via.relationMax ?? 1) <= 1) say(`${at}.via`, `"${field2.label}" adds up "${via.label}", which links one record. Make "${via.label}" a list (multi), or read its one value with a lookup.`);
         }
       }
-      if (field.parityType === "entity_reference" && !field.allowedTypes?.length) say(`${at}.allowedTypes`, "A column that points at the platform names the kinds it may point at.");
-      if (isRelation(field) && field.relationTarget && !byToken.has(field.relationTarget)) say(`${at}.relationTarget`, `It points at "${field.relationTarget}", which is neither a table nor a shared block of this template.`);
+      if (field2.parityType === "entity_reference" && !field2.allowedTypes?.length) say(`${at}.allowedTypes`, "A column that points at the platform names the kinds it may point at.");
+      if (isRelation(field2) && field2.relationTarget && !byToken.has(field2.relationTarget)) say(`${at}.relationTarget`, `It points at "${field2.relationTarget}", which is neither a table nor a shared block of this template.`);
     });
     const seen = /* @__PURE__ */ new Map();
     const titles = /* @__PURE__ */ new Set();
@@ -3763,47 +3768,47 @@ function validateTemplate(raw, options = {}) {
       const twin = seen.get(sig);
       if (twin) say(rat, `This row is identical to "${twin}" apart from its key. Every seed row is a different real record.`);
       seen.set(sig, row.key);
-      for (const field of table.fields) {
-        if (!isRelation(field) || !field.relationTarget || field.parityType === "attachment") continue;
-        const target = byToken.get(field.relationTarget);
-        const v = row.values?.[field.key];
+      for (const field2 of table.fields) {
+        if (!isRelation(field2) || !field2.relationTarget || field2.parityType === "attachment") continue;
+        const target = byToken.get(field2.relationTarget);
+        const v = row.values?.[field2.key];
         if (!target || v === void 0 || v === null) continue;
         for (const ref2 of Array.isArray(v) ? v : [v]) {
-          if (typeof ref2 === "string" && !target.rows.some((r) => r.key === ref2)) say(`${rat}.values.${field.key}`, `It points at the row "${ref2}", which does not exist in "${field.relationTarget}".`);
+          if (typeof ref2 === "string" && !target.rows.some((r) => r.key === ref2)) say(`${rat}.values.${field2.key}`, `It points at the row "${ref2}", which does not exist in "${field2.relationTarget}".`);
         }
       }
       const title = storeText(row.values?.[table.titleField]);
       if (title) titles.add(title.trim().toLowerCase());
-      for (const field of table.fields) {
-        const v = row.values?.[field.key];
+      for (const field2 of table.fields) {
+        const v = row.values?.[field2.key];
         if (v === void 0 || v === null || v === "") continue;
-        for (const rule of field.rules ?? []) {
+        for (const rule of field2.rules ?? []) {
           const t = storeText(v) ?? "";
           if (rule.kind === "min" || rule.kind === "max") {
             const n = parseNumeric(t);
             const bound = parseNumeric(String(rule.value));
             if (n && bound && (rule.kind === "min" ? qCmp(n, bound) < 0 : qCmp(n, bound) > 0)) {
-              say(`${rat}.values.${field.key}`, `${t} breaks its own rule: "${field.label}" is at ${rule.kind === "min" ? "least" : "most"} ${rule.value}.`);
+              say(`${rat}.values.${field2.key}`, `${t} breaks its own rule: "${field2.label}" is at ${rule.kind === "min" ? "least" : "most"} ${rule.value}.`);
             }
           } else if (rule.kind === "length") {
-            if (rule.value !== void 0 && t.length > Number(rule.value)) say(`${rat}.values.${field.key}`, `"${t}" is longer than "${field.label}" allows (${rule.value}).`);
-            if (rule.min !== void 0 && t.length < rule.min) say(`${rat}.values.${field.key}`, `"${t}" is shorter than "${field.label}" allows (${rule.min}).`);
+            if (rule.value !== void 0 && t.length > Number(rule.value)) say(`${rat}.values.${field2.key}`, `"${t}" is longer than "${field2.label}" allows (${rule.value}).`);
+            if (rule.min !== void 0 && t.length < rule.min) say(`${rat}.values.${field2.key}`, `"${t}" is shorter than "${field2.label}" allows (${rule.min}).`);
           } else if (rule.kind === "pattern" && rule.value !== void 0) {
             let re = null;
             try {
               re = new RegExp(String(rule.value));
             } catch {
-              say(`${tat}.fields (${field.key}).rules`, `The pattern "${rule.value}" is not a pattern.`);
+              say(`${tat}.fields (${field2.key}).rules`, `The pattern "${rule.value}" is not a pattern.`);
             }
-            if (re && !re.test(t)) say(`${rat}.values.${field.key}`, `"${t}" does not match "${field.label}"'s own pattern.`);
+            if (re && !re.test(t)) say(`${rat}.values.${field2.key}`, `"${t}" does not match "${field2.label}"'s own pattern.`);
           }
         }
       }
     });
-    for (const field of table.fields) {
-      if (!(field.rules ?? []).some((r) => r.kind === "unique")) continue;
-      const vals = table.rows.map((r) => storeText(r.values?.[field.key])).filter((v) => !!v).map((v) => v.trim().toLowerCase());
-      if (new Set(vals).size !== vals.length) say(`${tat}.fields (${field.key})`, `"${field.label}" is unique, and two seed rows share a value.`);
+    for (const field2 of table.fields) {
+      if (!(field2.rules ?? []).some((r) => r.kind === "unique")) continue;
+      const vals = table.rows.map((r) => storeText(r.values?.[field2.key])).filter((v) => !!v).map((v) => v.trim().toLowerCase());
+      if (new Set(vals).size !== vals.length) say(`${tat}.fields (${field2.key})`, `"${field2.label}" is unique, and two seed rows share a value.`);
     }
     if (table.rows.length >= 2 && titles.size < Math.ceil(table.rows.length * TITLE_DISTINCT_SHARE)) {
       say(`${tat}.rows`, `Only ${titles.size} of ${table.rows.length} rows have a title of their own; a list of look-alike names reads as generated.`);
@@ -5032,8 +5037,8 @@ function validateTemplate(raw, options = {}) {
   }
   const currencies = new Set(fields.filter((f) => f.parityType === "currency").map((f) => (f.unit ?? "").toUpperCase()));
   if (currencies.size > 1) say("tables", `Money is kept in ${[...currencies].join(" and ")}; one business keeps its books in one currency.`);
-  const GOOD = /^(completed?|done|paid|approved|won|closed won|booked|confirmed|delivered|resolved|published|signed|passed|hired|accepted)$/i;
-  const BAD = /^(cancell?ed|skipped|lost|closed lost|denied|rejected|no[- ]show|failed|overdue|declined|void(ed)?|refunded|churned|expired|blocked)$/i;
+  const GOOD = GOOD_OUTCOME;
+  const BAD = BAD_OUTCOME;
   for (const t of own) {
     for (const f of t.fields) {
       for (const [choice, color] of Object.entries(f.choiceColors ?? {})) {
@@ -5210,14 +5215,25 @@ function validateTemplate(raw, options = {}) {
     if (columns && !(status2 && /writes "booked" and "cancelled"/.test(columns))) say(`${at}.table`, columns);
     for (const qq of e.questions ?? []) if (["slot", "status", "booked_with"].includes(qq.fieldKey)) say(`${at}.questions`, `A booking page never asks for "${qq.fieldKey}": the store fills it in from the slot that was held.`);
     const a = e.availability ?? {};
-    const rng = (v, lo, hi, what) => {
-      if (v !== void 0 && (v < lo || v > hi)) say(`${at}.availability`, `${what} is between ${lo} and ${hi}; this says ${v}.`);
+    const wholeNumber = (key, what) => {
+      const v = a[key];
+      if (v === void 0 || typeof v === "number" && Number.isInteger(v)) return true;
+      say(`${at}.availability.${key}`, key === "days" ? `${what} is ONE whole number such as 21 (how many days ahead a person may book); the weekdays belong in windows, not here.` : `${what} is one whole number; this says ${JSON.stringify(v)}.`);
+      return false;
+    };
+    const rng = (v, lo, hi, what, key) => {
+      if (v !== void 0 && wholeNumber(key, what) && (v < lo || v > hi)) say(`${at}.availability`, `${what} is between ${lo} and ${hi}; this says ${v}.`);
     };
-    rng(a.slotMinutes, 5, 480, "Slot length (minutes)");
-    rng(a.bufferMinutes, 0, 480, "The buffer (minutes)");
-    rng(a.leadMinutes, 0, 43200, "Lead time (minutes)");
-    rng(a.maxPerDay, 1, 100, "Appointments a day");
-    rng(a.days, 1, 90, "Days ahead");
+    (a.windows ?? []).forEach((w, wi) => {
+      const ww = w;
+      if (!Number.isInteger(ww.weekday)) say(`${at}.availability.windows[${wi}]`, `A window's weekday is one whole number, 0 (Sunday) to 6 (Saturday); this says ${JSON.stringify(ww.weekday)}.`);
+      for (const k of ["from", "to"]) if (typeof ww[k] !== "string" || !/^\d{2}:\d{2}$/.test(ww[k])) say(`${at}.availability.windows[${wi}]`, `A window's "${k}" is a time of day written "09:00"; this says ${JSON.stringify(ww[k])}.`);
+    });
+    rng(a.slotMinutes, 5, 480, "Slot length (minutes)", "slotMinutes");
+    rng(a.bufferMinutes, 0, 480, "The buffer (minutes)", "bufferMinutes");
+    rng(a.leadMinutes, 0, 43200, "Lead time (minutes)", "leadMinutes");
+    rng(a.maxPerDay, 1, 100, "Appointments a day", "maxPerDay");
+    rng(a.days, 1, 90, "Days ahead", "days");
     if (a.timezone) {
       try {
         new Intl.DateTimeFormat("en-US", { timeZone: a.timezone });
@@ -5873,6 +5889,8 @@ var RESTRICTED_KEY = /(^|_)(member_id|ssn|social_security|dob|date_of_birth|birt
 var RESTRICTED_LABEL = /\b(bank|routing number|iban|card on file|credit card|card number|cvv|medical conditions?|medications?|diagnos[ie]s|case notes|legal notes|privileged)\b/;
 var PERSONAL_ONLY = /(^|_)(dob|date_of_birth|birth_date|allerg(y|ies)|diagnos(is|es)|medical_conditions?|conditions|medications?|current_medications|clinical_notes?|visit_notes?|progress_notes?|soap_notes?|member_id|ssn|social_security)($|_)/;
 var holdsPeople = (t) => t.subject ? t.subject === "person" : t.fields.some((f) => /name/.test(f.key)) && t.fields.some((f) => f.parityType === "phone" || f.parityType === "email");
+var GOOD_OUTCOME = /^(completed?|done|paid|approved|won|closed won|booked|confirmed|delivered|resolved|published|signed|passed|hired|accepted)$/i;
+var BAD_OUTCOME = /^(cancell?ed|skipped|lost|closed lost|denied|rejected|no[- ]show|failed|overdue|declined|void(ed)?|refunded|churned|expired|blocked)$/i;
 function sensitivityFloorOf(table, f) {
   const text = `${f.key} ${norm(f.label)}`;
   const billingTable = /(invoice|bill|statement|receipt|payment|charge|fee|order|account)/i.test(`${table.token} ${table.labelSingular ?? ""}`);
@@ -6350,7 +6368,719 @@ async function runTemplateDoor(source, door, organizationId, id, options = {}) {
 function planTables(plan) {
   return plan.steps.flatMap((s) => (s.made ?? []).filter((m) => m.kind === "table").map((m) => m.ref));
 }
+
+// src/templates/describe/shape.ts
+var GALLERY_ONLY = ["catalogueId", "strengths", "provenance", "walk", "agent", "requires", "persona", "extraAgents", "workflows", "guide", "__kind"];
+function describeSpec(template) {
+  const s = { ...template };
+  for (const k of GALLERY_ONLY) delete s[k];
+  s.specVersion = 1;
+  if (typeof s.version !== "number") s.version = 1;
+  if (typeof s.audience !== "string") s.audience = "organization";
+  if (typeof s.cleanupTag !== "string" && typeof s.id === "string") s.cleanupTag = `describe:${s.id}`;
+  for (const k of ["relationships", "sharedBlocks", "views", "forms", "dimensions", "extras"]) if (!Array.isArray(s[k])) s[k] = [];
+  if (Array.isArray(s.tables)) s.tables = s.tables.map(describeTable);
+  return s;
+}
+var TABLE_DEFAULTS = { type: "entity", display: "grid", weight: "light", ordered: false };
+var CONTACT_KINDS = /* @__PURE__ */ new Set(["phone", "email"]);
+function describeTable(t) {
+  const own = Array.isArray(t.fields) ? t.fields : null;
+  const shape = { token: String(t.token ?? ""), labelSingular: String(t.labelSingular ?? ""), subject: t.subject, fields: own ?? [] };
+  const fields = own ? own.map((f) => describeField(f, shape)) : t.fields;
+  return {
+    ...TABLE_DEFAULTS,
+    ...t,
+    ...typeof t.labelPlural !== "string" && typeof t.name === "string" ? { labelPlural: t.name } : {},
+    fields,
+    rows: Array.isArray(t.rows) ? t.rows : []
+  };
+}
+function describeField(f, table) {
+  const contact = CONTACT_KINDS.has(String(f.parityType ?? ""));
+  const floor = sensitivityFloorOf(table, { key: String(f.key ?? ""), label: String(f.label ?? ""), parityType: String(f.parityType ?? "") });
+  return {
+    ...contact ? { format: f.parityType } : {},
+    sensitivity: floor ?? "internal",
+    contextPolicy: floor ? "exclude" : "include",
+    ...f
+  };
+}
+
+// src/templates/describe/merge.ts
+var clone = (v) => v === void 0 ? v : JSON.parse(JSON.stringify(v));
+var labelOfKey = (key) => {
+  const w = key.replace(/_/g, " ").trim();
+  return w ? w[0].toUpperCase() + w.slice(1) : key;
+};
+var field = (t, key) => t.fields.find((f) => f.key === key);
+function skeletonTable(p) {
+  return {
+    token: p.token,
+    name: p.name,
+    labelSingular: p.labelSingular,
+    labelPlural: p.name,
+    subject: p.subject,
+    titleField: p.titleField.key,
+    describes: p.purpose.slice(0, 140),
+    fields: [],
+    rows: []
+  };
+}
+function ensureSkeleton(t, p) {
+  if (typeof t.name !== "string") t.name = p.name;
+  if (typeof t.labelSingular !== "string") t.labelSingular = p.labelSingular;
+  if (typeof t.subject !== "string") t.subject = p.subject;
+  if (typeof t.describes !== "string" || !t.describes.trim()) t.describes = p.purpose.slice(0, 140);
+  if (!Array.isArray(t.fields)) t.fields = [];
+  if (typeof t.titleField !== "string" || !t.titleField) t.titleField = p.titleField.key;
+  if (!field(t, p.titleField.key)) t.fields.unshift({ key: p.titleField.key, label: p.titleField.label, parityType: "text", required: true });
+  if (p.status && !field(t, "status")) {
+    t.fields.push({ key: "status", label: "Status", parityType: "select", required: true, choices: [...p.status.choices], default: p.status.default });
+  }
+  if (p.slot && !field(t, "slot")) t.fields.push({ key: "slot", label: "Visit time", parityType: "datetime", format: "datetime", required: true });
+  for (const l of p.links) {
+    if (field(t, l.key)) continue;
+    t.fields.push({ key: l.key, label: l.label, parityType: "relation", relationTarget: l.target, ...l.many ? { multi: true } : { relationMax: 1 } });
+  }
+}
+function addExistingKeys(t, p, existing) {
+  if (!p.reuse) return;
+  const e = existing.find((x) => x.id === p.reuse.existing_table_id);
+  if (!e) return;
+  for (const key of p.reuse.keepKeys) {
+    if (field(t, key)) continue;
+    const ef = e.fields.find((f) => f.key === key);
+    if (!ef) continue;
+    t.fields.push({ key, label: ef.label, parityType: ef.kind, ...ef.choices?.length ? { choices: [...ef.choices] } : {} });
+  }
+}
+function addRequest(t, r) {
+  if (field(t, r.key)) return;
+  const f = { key: r.key, label: r.label, parityType: r.parityType };
+  if (r.choices?.length) f.choices = [...r.choices];
+  if (r.askOfSubject) f.askOfSubject = true;
+  if (r.askOfGuardian) f.askOfGuardian = true;
+  if (r.required) f.required = true;
+  if (r.help) f.help = r.help;
+  t.fields.push(f);
+}
+var CHOICE = ["select", "multi_select", "list"];
+var STAGE_KEY = /(^|_)(status|stage)$/;
+function viewHolds(v, tables) {
+  const t = tables.get(v.table);
+  if (!t) return false;
+  const has = (k) => typeof k === "string" && !!field(t, k);
+  const x = v;
+  const kindOf = (k) => t.fields.find((f) => f.key === k)?.parityType;
+  if (v.kind === "kanban" && !(has(x.groupBy) && CHOICE.includes(kindOf(x.groupBy)))) return false;
+  if (v.kind === "calendar" && !(has(x.dateField) && kindOf(x.dateField) === "datetime")) return false;
+  if (v.kind === "timeline" && !(has(x.startField) && has(x.endField))) return false;
+  if (v.kind === "gallery" && !has(x.coverField)) return false;
+  if (x.groupBy !== void 0 && !has(x.groupBy)) return false;
+  for (const k of Object.keys(x.filters ?? {})) if (!has(k)) return false;
+  for (const k of Object.keys(x.anyOf ?? {})) if (!has(k)) return false;
+  for (const s of x.sorts ?? []) if (!has(s.field)) return false;
+  return typeof v.token === "string" && !!v.token && typeof v.name === "string" && !!v.name;
+}
+function fallbackView(t) {
+  const plural = typeof t.name === "string" ? t.name : labelOfKey(t.token);
+  const stage = t.fields.find((f) => STAGE_KEY.test(f.key) && CHOICE.includes(f.parityType));
+  if (stage) return { token: `${t.token}_board`, name: `${plural} board`, table: t.token, kind: "kanban", groupBy: stage.key, isDefault: true };
+  if (t.fields.some((f) => f.key === "slot" && f.parityType === "datetime")) {
+    return { token: `${t.token}_calendar`, name: `${plural} calendar`, table: t.token, kind: "calendar", dateField: "slot", isDefault: true };
+  }
+  return { token: `${t.token}_list`, name: `All ${plural.toLowerCase()}`, table: t.token, kind: "grid", isDefault: true, sorts: [{ field: String(t.titleField), direction: "asc" }] };
+}
+function mergeViews(plan, part, tables) {
+  const given = Array.isArray(part?.views) ? part.views : [];
+  const seen = /* @__PURE__ */ new Set();
+  const kept = [];
+  for (const v of given) {
+    if (!v || !viewHolds(v, tables) || seen.has(v.token)) continue;
+    seen.add(v.token);
+    kept.push(clone(v));
+  }
+  const defaulted = /* @__PURE__ */ new Set();
+  for (const v of kept) {
+    if (!v.isDefault) continue;
+    if (defaulted.has(v.table)) delete v.isDefault;
+    else defaulted.add(v.table);
+  }
+  if (kept.length) return kept;
+  const wanted = [...new Set(plan.views.map((v) => v.table))].filter((tok) => tables.has(tok));
+  const targets = wanted.length ? wanted : [...tables.keys()].slice(0, 1);
+  return targets.map((tok) => fallbackView(tables.get(tok)));
+}
+function sharedBlocksFor(tables) {
+  const own = new Set(tables.map((t) => t.token));
+  const out = [];
+  for (const id of SHARED_BLOCK_IDS) {
+    const token = SHARED_BLOCKS[id].table;
+    if (own.has(token)) continue;
+    if (tables.some((t) => t.fields.some((f) => f.parityType === "relation" && f.relationTarget === token))) out.push({ block: id, rows: [] });
+  }
+  return out;
+}
+function reusesOf(plan) {
+  return plan.tables.filter((t) => t.reuse).map((t) => ({ token: t.token, existing_table_id: t.reuse.existing_table_id }));
+}
+function mergeDescribeParts(plan, tables, doors, views, existingTables = []) {
+  const out = clone(Array.isArray(tables?.tables) ? tables.tables : []);
+  const byToken = new Map(out.map((t) => [t.token, t]));
+  for (const p of plan.tables) {
+    let t = byToken.get(p.token);
+    if (!t) {
+      t = skeletonTable(p);
+      out.push(t);
+      byToken.set(p.token, t);
+    }
+    ensureSkeleton(t, p);
+    addExistingKeys(t, p, existingTables);
+  }
+  for (const r of doors?.fieldRequests ?? []) {
+    const t = byToken.get(r.table);
+    if (t) addRequest(t, r);
+  }
+  const spec = {
+    specVersion: 1,
+    version: 1,
+    id: plan.id,
+    useCase: plan.useCase,
+    industry: plan.industry,
+    vertical: plan.vertical,
+    job: plan.job,
+    teaches: plan.teaches,
+    audience: plan.audience,
+    cleanupTag: `describe:${plan.id}`,
+    business: clone(plan.business),
+    tables: out,
+    sharedBlocks: sharedBlocksFor(out),
+    relationships: clone(tables?.relationships ?? []),
+    views: mergeViews(plan, views, byToken),
+    forms: clone(doors?.forms ?? []),
+    dimensions: [],
+    extras: doors?.booking ? [clone(doors.booking)] : []
+  };
+  return spec;
+}
+
+// src/templates/describe/autofix.ts
+var clone2 = (v) => JSON.parse(JSON.stringify(v));
+var SENSITIVITY_RANK2 = ["public", "internal", "confidential", "restricted"];
+var isChoice2 = (f) => ["select", "multi_select", "list"].includes(f.parityType);
+var isComputed2 = (f) => ["formula", "lookup", "rollup", "autonumber", "created_time", "modified_time"].includes(f.parityType) || !!f.source && f.source !== "manual";
+var MINOR_VERTICAL = /pediatric|paediatric|youth|child|kids?\b|school|daycare|day care|junior|teen|infant|nursery|camp\b/i;
+var NEUTRAL_ORDER = ["amber", "blue", "violet", "teal", "slate", "orange", "yellow", "pink", "brown", "gray", "green", "red"];
+var GOOD_ORDER = ["green", "teal", "blue", "violet", "slate", "amber", "orange", "yellow", "pink", "brown", "gray"];
+var BAD_ORDER = ["red", "orange", "gray", "slate", "brown", "pink", "amber", "yellow", "violet", "blue", "teal"];
+var DISTINCT_UP_TO = 7;
+var lower = (s) => s.trim().toLowerCase();
+function raiseSensitivity(spec, fixes) {
+  for (const t of spec.tables) {
+    for (const f of t.fields) {
+      const at = `tables.${t.token}.fields.${f.key}`;
+      const floor = sensitivityFloorOf(t, f);
+      const rank = (s) => SENSITIVITY_RANK2.indexOf(s);
+      if (floor && rank(f.sensitivity) < rank(floor)) {
+        fixes.push(`${at}: sensitivity ${f.sensitivity} raised to ${floor}`);
+        f.sensitivity = floor;
+      }
+      if (floor === "restricted" && f.contextPolicy !== "exclude") {
+        fixes.push(`${at}: contextPolicy ${f.contextPolicy} set to exclude (restricted)`);
+        f.contextPolicy = "exclude";
+      }
+      if (/note/.test(`${f.key} ${lower(f.label)}`) && f.sensitivity === "public") {
+        fixes.push(`${at}: notes are never public; raised to internal`);
+        f.sensitivity = "internal";
+      }
+    }
+  }
+}
+function flagAskedOfSubject(spec, ctx, fixes) {
+  const minor = MINOR_VERTICAL.test(`${spec.vertical ?? ""} ${ctx.plan?.vertical ?? ""}`);
+  const byToken = new Map(spec.tables.map((t) => [t.token, t]));
+  for (const form of spec.forms) {
+    if (form.audience !== "public") continue;
+    const t = byToken.get(form.table);
+    if (!t) continue;
+    for (const q2 of form.fields ?? []) {
+      const f = t.fields.find((x) => x.key === q2.fieldKey);
+      if (!f) continue;
+      if (f.sensitivity !== "confidential" && f.sensitivity !== "restricted") continue;
+      if (f.askOfSubject || f.askOfGuardian) continue;
+      if (minor) f.askOfGuardian = true;
+      else f.askOfSubject = true;
+      fixes.push(`tables.${t.token}.fields.${f.key}: ${minor ? "askOfGuardian" : "askOfSubject"} set (asked on the public form "${form.token}")`);
+    }
+  }
+}
+var DOOR_KEYS = ["slot", "status", "booked_with"];
+function colorOf(name) {
+  return /^booked$/i.test(name) ? "blue" : "slate";
+}
+function fixBooking(spec, fixes) {
+  for (const e of spec.extras) {
+    if (e.kind !== "booking") continue;
+    const b = e;
+    const t = spec.tables.find((x) => x.token === b.table);
+    if (t) {
+      const at = `tables.${t.token}.fields`;
+      const slot = t.fields.find((f) => f.key === "slot");
+      if (!slot) {
+        t.fields.push({ key: "slot", label: "Visit time", parityType: "datetime", format: "datetime", required: true, sensitivity: "internal", contextPolicy: "include" });
+        fixes.push(`${at}.slot: added the required datetime the booking page writes`);
+      } else {
+        if (slot.parityType !== "datetime") {
+          slot.parityType = "datetime";
+          fixes.push(`${at}.slot: made a datetime`);
+        }
+        if (!slot.required) {
+          slot.required = true;
+          fixes.push(`${at}.slot: made required`);
+        }
+        if (slot.format !== "datetime") slot.format = "datetime";
+      }
+      let status = t.fields.find((f) => f.key === "status");
+      if (!status) {
+        status = { key: "status", label: "Status", parityType: "select", required: true, choices: ["Booked", "Cancelled"], default: "Booked", choiceColors: { Booked: "blue", Cancelled: "slate" }, sensitivity: "internal", contextPolicy: "include" };
+        t.fields.push(status);
+        fixes.push(`${at}.status: added a Booked / Cancelled choice field`);
+      } else {
+        if (!isChoice2(status)) {
+          status.parityType = "select";
+          status.choices = status.choices ?? [];
+          fixes.push(`${at}.status: made a choice field`);
+        }
+        const have = new Set((status.choices ?? []).map(lower));
+        for (const w of ["Booked", "Cancelled"]) {
+          if (have.has(lower(w))) continue;
+          status.choices = [...status.choices ?? [], w];
+          status.choiceColors = { ...status.choiceColors ?? {}, [w]: colorOf(w) };
+          fixes.push(`${at}.status: added the choice "${w}" the booking page writes`);
+        }
+      }
+    }
+    const before = b.questions?.length ?? 0;
+    b.questions = (b.questions ?? []).filter((q2) => !DOOR_KEYS.includes(q2.fieldKey));
+    if (b.questions.length !== before) fixes.push(`extras.${b.token}.questions: dropped ${before - b.questions.length} question(s) on slot/status/booked_with`);
+  }
+}
+var DEFAULT_DAYS_AHEAD = 28;
+var AVAILABILITY_NUMBERS = ["slotMinutes", "bufferMinutes", "leadMinutes", "maxPerDay"];
+function fixAvailability(spec, fixes) {
+  for (const e of spec.extras) {
+    if (e.kind !== "booking") continue;
+    const b = e;
+    const a = b.availability;
+    if (!a) continue;
+    const at = `extras.${b.token}.availability`;
+    if (Array.isArray(a.days)) {
+      const weekdays = [...new Set(a.days.filter((d) => Number.isInteger(d) && d >= 0 && d <= 6))];
+      a.days = DEFAULT_DAYS_AHEAD;
+      fixes.push(`${at}.days: a weekday list is not "days ahead"; set to ${DEFAULT_DAYS_AHEAD} (weekdays belong in windows)`);
+      const windows = Array.isArray(a.windows) ? a.windows : [];
+      const model = windows[0];
+      if (model && /^\d{2}:\d{2}$/.test(String(model.from))) {
+        for (const d of weekdays.sort((x, y) => x - y)) {
+          if (windows.some((w) => w.weekday === d)) continue;
+          windows.push({ weekday: d, from: model.from, to: model.to });
+          fixes.push(`${at}.windows: added a ${model.from}\u2013${model.to} window on weekday ${d} (it was listed in days)`);
+        }
+        a.windows = windows;
+      }
+    } else if (a.days !== void 0) {
+      const n = typeof a.days === "string" && a.days.trim() !== "" ? Number(a.days) : a.days;
+      if (typeof n === "number" && Number.isFinite(n) && n !== a.days) {
+        a.days = Math.round(n);
+        fixes.push(`${at}.days: written as one whole number (${a.days})`);
+      } else if (typeof n === "number" && Number.isFinite(n) && !Number.isInteger(n)) {
+        a.days = Math.round(n);
+        fixes.push(`${at}.days: rounded to ${a.days}`);
+      }
+    }
+    for (const k of AVAILABILITY_NUMBERS) {
+      const v = a[k];
+      if (v === void 0) continue;
+      const n = typeof v === "string" && v.trim() !== "" ? Number(v) : v;
+      if (typeof n === "number" && Number.isFinite(n) && (!Number.isInteger(n) || n !== v)) {
+        a[k] = Math.round(n);
+        fixes.push(`${at}.${k}: written as one whole number (${a[k]})`);
+      }
+    }
+    for (const w of Array.isArray(a.windows) ? a.windows : []) {
+      if (typeof w.weekday === "string" && /^\d$/.test(w.weekday)) {
+        w.weekday = Number(w.weekday);
+        fixes.push(`${at}.windows: a weekday written as a whole number`);
+      }
+    }
+  }
+}
+function fixViewTokens(spec, fixes) {
+  const taken = /* @__PURE__ */ new Set();
+  const claim = (t) => typeof t === "string" && t.trim() !== "" && taken.add(t);
+  for (const v of spec.views) claim(v.token);
+  for (const f of spec.forms) claim(f.token);
+  for (const e of spec.extras) claim(e.token);
+  const snake = (x) => x.toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "") || "view";
+  spec.views.forEach((v, i) => {
+    if (typeof v.token === "string" && v.token.trim() !== "") return;
+    const base = `${snake(String(v.table ?? "table"))}_${snake(String(v.kind ?? "view"))}`;
+    let token = base;
+    for (let n = 2; taken.has(token); n++) token = `${base}_${n}`;
+    taken.add(token);
+    v.token = token;
+    fixes.push(`views[${i}]: had no token; named "${token}" (table and kind)`);
+  });
+}
+function fixColours(spec, fixes) {
+  for (const t of spec.tables) {
+    for (const f of t.fields) {
+      if (!isChoice2(f) || !f.choices?.length) continue;
+      const choices = f.choices;
+      const palette = CHOICE_COLORS;
+      const colors = {};
+      for (const [k, v] of Object.entries(f.choiceColors ?? {})) if (choices.includes(k) && palette.includes(v)) colors[k] = v;
+      const orderOf = (c) => GOOD_OUTCOME.test(c) ? GOOD_ORDER : BAD_OUTCOME.test(c) ? BAD_ORDER : NEUTRAL_ORDER;
+      const holder = (color, except) => choices.find((c) => c !== except && colors[c] === color);
+      const unused = (order) => order.find((c) => !choices.some((x) => colors[x] === c));
+      const need = Math.min(choices.length, DISTINCT_UP_TO);
+      const seen = /* @__PURE__ */ new Set();
+      for (const c of choices) {
+        const col = colors[c];
+        if (col && seen.has(col) && new Set(Object.values(colors)).size < need) {
+          const next = unused(orderOf(c));
+          if (next) colors[c] = next;
+        }
+        if (colors[c]) seen.add(colors[c]);
+      }
+      for (const c of choices) {
+        if (colors[c]) continue;
+        colors[c] = unused(orderOf(c)) ?? orderOf(c)[choices.indexOf(c) % orderOf(c).length];
+      }
+      for (const c of choices) {
+        const wrong = GOOD_OUTCOME.test(c) ? "red" : BAD_OUTCOME.test(c) ? "green" : null;
+        if (!wrong || colors[c] !== wrong) continue;
+        const want = GOOD_OUTCOME.test(c) ? "green" : "red";
+        const other = holder(want, c);
+        if (!other) colors[c] = want;
+        else if (!(want === "red" ? GOOD_OUTCOME.test(other) : BAD_OUTCOME.test(other))) {
+          colors[other] = wrong;
+          colors[c] = want;
+        } else colors[c] = unused(orderOf(c).filter((x) => x !== wrong)) ?? colors[c];
+      }
+      const ordered = {};
+      for (const c of choices) ordered[c] = colors[c];
+      const was = f.choiceColors ?? {};
+      if (Object.keys(was).length !== choices.length || choices.some((c) => was[c] !== ordered[c])) {
+        f.choiceColors = ordered;
+        fixes.push(`tables.${t.token}.fields.${f.key}: choice colours filled and checked (good never red, bad never green)`);
+      }
+    }
+  }
+}
+function fixRelationships(spec, ctx, fixes) {
+  const everyTable = allTables(spec);
+  const byToken = new Map(everyTable.map((t) => [t.token, t]));
+  const rels = spec.relationships ?? [];
+  for (const t of spec.tables) {
+    for (const f of t.fields) {
+      if (f.parityType !== "relation" || !f.relationTarget) continue;
+      if (rels.some((r) => r.fromTable === t.token && r.fromField === f.key)) continue;
+      const target = byToken.get(f.relationTarget);
+      const toName = lower(target?.labelSingular ?? f.relationTarget.replace(/_/g, " "));
+      const fromName = lower(t.labelSingular ?? t.token.replace(/_/g, " "));
+      const many = !!f.multi || f.relationMax !== void 0 && f.relationMax !== 1;
+      const planned = ctx.plan?.tables.find((p) => p.token === t.token && p.links.some((l) => l.key === f.key))?.purpose?.trim();
+      const describes = planned && planned.length >= 15 && planned.length <= 140 ? planned : many ? `A ${fromName} lists its ${toName} records.` : `A ${fromName} belongs to one ${toName}.`;
+      const taken = /* @__PURE__ */ new Set([...rels.map((r) => r.inverseKey), ...(target?.fields ?? []).map((x) => x.key)]);
+      let inverseKey = `${t.token}s`;
+      if (taken.has(inverseKey)) inverseKey = `${t.token}_${f.key}s`;
+      for (let i = 2; taken.has(inverseKey); i++) inverseKey = `${t.token}_${f.key}s_${i}`;
+      const toPerson = target?.subject === "person" && f.relationTarget !== "team_member";
+      rels.push({ describes, fromTable: t.token, fromField: f.key, toTable: f.relationTarget, flavor: "referenced", cardinality: many ? "many" : "one", onDelete: toPerson ? "restrict" : "set_null", inverseKey });
+      fixes.push(`relationships: stated ${t.token}.${f.key} \u2192 ${f.relationTarget}`);
+    }
+  }
+  spec.relationships = rels;
+}
+function askRequired(spec, fixes) {
+  for (const form of spec.forms) {
+    const t = spec.tables.find((x) => x.token === form.table);
+    if (!t) continue;
+    const asked = new Set((form.fields ?? []).map((q2) => q2.fieldKey));
+    for (const f of t.fields) {
+      if (!f.required || isComputed2(f) || f.default !== void 0 || asked.has(f.key)) continue;
+      form.fields = [...form.fields ?? [], { fieldKey: f.key, ask: `What is the ${lower(f.label)}?`, required: true }];
+      fixes.push(`forms.${form.token}.fields.${f.key}: asked (a required field no question covered); reword in repair`);
+    }
+  }
+}
+var REALISM = ["childDates", "withinParent", "statusAgrees", "countMatches", "datePairs"];
+function switchJob(spec, fixes) {
+  if (spec.job !== "crm_pipeline" && spec.job !== "billing") return;
+  const linked = (spec.relationships ?? []).length > 0 || spec.tables.some((t) => t.fields.some((f) => f.parityType === "relation" && f.relationTarget && spec.tables.some((x) => x.token === f.relationTarget)));
+  if (!linked) return;
+  const declared = spec.tables.some((t) => REALISM.some((k) => Array.isArray(t[k]) && t[k].length > 0));
+  if (declared) return;
+  const to = spec.job === "crm_pipeline" ? "work_orders" : "intake";
+  fixes.push(`job: ${spec.job} switched to ${to} (linked tables, no realism declarations)`);
+  spec.job = to;
+}
+function autofixDescribeSpec(input, ctx = {}) {
+  const spec = describeSpec(clone2(input));
+  const autoFixes = [];
+  raiseSensitivity(spec, autoFixes);
+  flagAskedOfSubject(spec, ctx, autoFixes);
+  fixBooking(spec, autoFixes);
+  fixAvailability(spec, autoFixes);
+  fixViewTokens(spec, autoFixes);
+  fixColours(spec, autoFixes);
+  fixRelationships(spec, ctx, autoFixes);
+  askRequired(spec, autoFixes);
+  switchJob(spec, autoFixes);
+  return { spec, autoFixes };
+}
+function describeCheck(spec, ctx = {}) {
+  const fixed = autofixDescribeSpec(spec, ctx);
+  const v = validateTemplate(fixed.spec, { profile: "describe" });
+  return { ...fixed, problems: v.problems.map((p) => ({ at: p.at, says: p.says })) };
+}
+
+// src/templates/describe/repair.ts
+var clone3 = (v) => JSON.parse(JSON.stringify(v));
+function parseAt(at) {
+  const out = [];
+  const re = /([A-Za-z_][A-Za-z0-9_]*)(?:\[(\d+)\])?(?: \(([^)]*)\))?/g;
+  for (let m = re.exec(at); m; m = re.exec(at)) {
+    const named = m[3] !== void 0 && m[3] !== "" && m[3] !== "undefined" && m[3] !== "null";
+    out.push({ root: m[1], ...named ? { id: m[3] } : m[2] !== void 0 ? { id: `#${m[2]}` } : {} });
+  }
+  return out;
+}
+function pathOfAt(at) {
+  const segs = parseAt(at);
+  const [a, b] = segs;
+  if (!a) return "spec";
+  if ((a.root === "tables" || a.root === "forms") && a.id !== void 0) {
+    if (b && (b.root === "fields" || b.root === "questions") && b.id) return `${a.root}.${a.id}.fields.${b.id}`;
+    return `${a.root}.${a.id}`;
+  }
+  if (a.root === "extras" && a.id) {
+    if (b && b.root === "questions" && b.id) return `extras.${a.id}.questions.${b.id}`;
+    return b && b.root === "availability" ? `extras.${a.id}.availability` : `extras.${a.id}`;
+  }
+  if (a.root === "views" && a.id) return `views.${a.id}`;
+  if (a.root === "business") return "business";
+  return "spec";
+}
+var idOf = (o) => typeof o.key === "string" ? o.key : typeof o.fieldKey === "string" ? o.fieldKey : typeof o.token === "string" ? o.token : void 0;
+function findIn(list, id) {
+  if (!Array.isArray(list)) return void 0;
+  if (/^#\d+$/.test(id)) return list[Number(id.slice(1))];
+  return list.find((x) => x && idOf(x) === id);
+}
+function resolvePath(spec, path) {
+  const s = spec;
+  const parts = path.split(".");
+  const [root, id, sub, subId] = parts;
+  if (root === "spec" || !root) return s;
+  if (root === "business") return s.business;
+  if (root === "relationships") {
+    const rels = s.relationships ?? [];
+    return rels.find((r) => r.fromTable === id && (parts[2] === void 0 || r.fromField === parts[2]));
+  }
+  let item;
+  if (root === "extras") item = findIn(s.extras, id ?? "") ?? (s.extras ?? []).find((e) => e.kind === id);
+  else if (root === "tables" || root === "forms" || root === "views") item = findIn(s[root], id ?? "");
+  if (!item) return void 0;
+  if (!sub) return item;
+  if (sub === "availability") return item.availability;
+  if ((sub === "fields" || sub === "questions") && subId) return findIn(item[sub], subId);
+  return void 0;
+}
+function specBrief(spec, problems) {
+  const s = spec;
+  const brief = { job: spec.job, industry: spec.industry, vertical: spec.vertical, business: spec.business, tables: spec.tables.map((t) => t.token), forms: spec.forms.map((f) => f.token), views: spec.views.map((v) => v.token) };
+  for (const p of problems) {
+    const root = parseAt(p.at)[0]?.root;
+    if (root && root !== "spec" && root in s && !(root in brief)) brief[root] = clone3(s[root]);
+  }
+  return brief;
+}
+function tableBrief(t) {
+  const { fields, rows: _rows, ...own } = t;
+  return { ...own, fields: fields.map((f) => ({ key: f.key, label: f.label, parityType: f.parityType, ...f.choices ? { choices: f.choices } : {}, ...f.relationTarget ? { relationTarget: f.relationTarget } : {}, ...f.required ? { required: true } : {} })) };
+}
+function repairSlices(spec, problems) {
+  const byPath = /* @__PURE__ */ new Map();
+  for (const p of problems) {
+    const first = parseAt(p.at)[0];
+    const rel = first?.root === "relationships" && first.id !== void 0 && /^#\d+$/.test(first.id) ? spec.relationships?.[Number(first.id.slice(1))] : void 0;
+    const path = rel ? `relationships.${rel.fromTable}.${rel.fromField}` : pathOfAt(p.at);
+    let slice = byPath.get(path);
+    if (!slice) {
+      const found = resolvePath(spec, path);
+      const isTable = path.startsWith("tables.") && path.split(".").length === 2;
+      const value = path === "spec" ? specBrief(spec, problems.filter((q2) => pathOfAt(q2.at) === "spec")) : isTable && found ? tableBrief(found) : found ? clone3(found) : null;
+      slice = { path, slice: value, problems: [] };
+      byPath.set(path, slice);
+    }
+    slice.problems.push({ at: p.at, says: p.says });
+  }
+  return [...byPath.values()];
+}
+var IMMUTABLE = /* @__PURE__ */ new Set(["key", "token", "fieldKey"]);
+function applyRepairPatches(input, patches) {
+  const spec = clone3(input);
+  const applied = [];
+  const skipped = [];
+  for (const patch of patches ?? []) {
+    const path = String(patch?.path ?? "");
+    const set = patch?.set;
+    if (!path || !set || typeof set !== "object" || Array.isArray(set)) {
+      skipped.push({ path, why: "a patch needs a path and a set object" });
+      continue;
+    }
+    let target = resolvePath(spec, path);
+    if (!target) {
+      const parts = path.split(".");
+      const parent = resolvePath(spec, parts.slice(0, 2).join("."));
+      const [root, , sub, subId] = parts;
+      if (parent && root === "tables" && sub === "fields" && subId && parts.length === 4 && typeof set.label === "string" && typeof set.parityType === "string") {
+        const f = { key: subId, sensitivity: "internal", contextPolicy: "include", ...set };
+        parent.fields.push(f);
+        target = f;
+        applied.push(path);
+        continue;
+      }
+      if (parent && root === "forms" && sub === "fields" && subId && parts.length === 4 && typeof set.ask === "string") {
+        (parent.fields ??= []).push({ fieldKey: subId, ...set });
+        applied.push(path);
+        continue;
+      }
+      skipped.push({ path, why: "no such piece in the spec" });
+      continue;
+    }
+    for (const [k, v] of Object.entries(set)) {
+      if (IMMUTABLE.has(k) && v !== target[k]) {
+        skipped.push({ path: `${path}.${k}`, why: `${k} is never renamed by a patch` });
+        continue;
+      }
+      if (v === null) delete target[k];
+      else target[k] = v;
+    }
+    applied.push(path);
+  }
+  return { spec, applied, skipped };
+}
+function lastResortTrim(input, problems) {
+  const spec = clone3(input);
+  const notes = [];
+  const droppedViews = /* @__PURE__ */ new Set();
+  const views = spec.views;
+  for (const p of problems) {
+    const segs = parseAt(p.at);
+    const [a, b] = segs;
+    const last = segs[segs.length - 1];
+    if (!a || !a.id) continue;
+    if (a.root === "views") {
+      const v = findIn(views, a.id);
+      if (v && views.length - droppedViews.size > 1 && !droppedViews.has(v)) {
+        droppedViews.add(v);
+        notes.push(`Left out the view "${v.name}": it did not pass the store's check.`);
+      }
+      continue;
+    }
+    if (last?.root === "help") {
+      const holder = a.root === "tables" ? resolvePath(spec, `tables.${a.id}.fields.${b?.id ?? ""}`) : a.root === "forms" ? resolvePath(spec, `forms.${a.id}.fields.${b?.id ?? ""}`) : a.root === "extras" ? resolvePath(spec, `extras.${a.id}.questions.${b?.id ?? ""}`) : void 0;
+      if (holder && "help" in holder) {
+        delete holder.help;
+        notes.push(`Left out the help text on "${b?.id}": it did not pass the store's check.`);
+      }
+      continue;
+    }
+    if (last?.root === "ask" && b?.id) {
+      const holder = a.root === "forms" ? findIn(spec.forms, a.id) : a.root === "extras" ? findIn(spec.extras, a.id) : void 0;
+      const list = (a.root === "forms" ? holder?.fields : holder?.questions) ?? null;
+      const table = holder?.table;
+      const field2 = spec.tables.find((t) => t.token === table)?.fields.find((f) => f.key === b.id);
+      const q2 = list?.find((x) => x.fieldKey === b.id);
+      if (list && q2 && !q2.required && !field2?.required) {
+        list.splice(list.indexOf(q2), 1);
+        notes.push(`Left out the question on "${b.id}": it did not pass the store's check.`);
+      }
+    }
+  }
+  if (droppedViews.size) spec.views = spec.views.filter((x) => !droppedViews.has(x));
+  return { spec, notes };
+}
+
+// src/templates/describe/package.ts
+var WORTH_SAYING = /^job:|: added |: asked |: dropped |dropped \d+ question/;
+var NOTES_MAX = 7;
+function packageDescribeResult(spec, plan, autoFixes, reuses, extraNotes = []) {
+  const tokens = new Set(spec.tables.map((t) => t.token));
+  const left = plan?.leaveOut?.length ? [`Left out: ${plan.leaveOut.join("; ")}.`] : [];
+  const said = autoFixes.filter((f) => WORTH_SAYING.test(f)).map((f) => f.startsWith("job:") ? `Used a simpler setup type: ${f.slice(5)}.` : f);
+  const notes = [...plan?.assumptions ?? [], ...left, ...said, ...extraNotes].map((n) => n.trim()).filter(Boolean).slice(0, NOTES_MAX);
+  return {
+    __kind: "describe_template_result",
+    template: JSON.parse(JSON.stringify(spec)),
+    notes,
+    reuses: (reuses ?? []).filter((r) => r && tokens.has(r.token))
+  };
+}
+
+// src/templates/describe/vocabulary.ts
+var BOOKING_AVAILABILITY_FACTS = {
+  timezone: "text \u2014 an IANA time zone such as America/Los_Angeles; defaults to the business's",
+  slotMinutes: "one whole number 5 to 480 \u2014 how long one appointment is, in minutes",
+  bufferMinutes: "one whole number 0 to 480 \u2014 rest between appointments, in minutes",
+  leadMinutes: "one whole number 0 to 43200 \u2014 how much notice a person must give, in minutes",
+  maxPerDay: "one whole number 1 to 100 \u2014 appointments accepted in one day",
+  days: "how many days ahead a person may book \u2014 ONE whole number such as 21 or 28 (1 to 90); weekdays belong in windows, never here",
+  windows: "list of {weekday, from, to}: weekday one whole number 0 (Sunday) to 6 (Saturday), from and to written HH:MM with to later than from; one entry per weekday offered"
+};
+var VIEW_SHAPE_FACTS = {
+  token: "snake_case, unique among every view, form and extra \u2014 always written",
+  name: 'what a person clicks, such as "Intake board"',
+  table: "the token of one of the template's tables",
+  kind: TEMPLATE_VIEW_KINDS,
+  groupBy: "kanban only, required: the key of a select field whose choices become the columns",
+  dateField: "calendar only, required: the key of a datetime field",
+  startField_endField: "timeline only, required: keys of two datetime fields",
+  coverField: "gallery only, required: the key of a file field"
+};
+function describeVocabulary() {
+  return {
+    field_kinds: RESOLVABLE_FIELD_TYPE_WORDS,
+    table_types: TABLE_TYPES,
+    table_displays: TABLE_DISPLAYS,
+    storage_modes: STORAGE_MODES,
+    field_sensitivities: FIELD_SENSITIVITIES,
+    context_policies: CONTEXT_POLICIES,
+    field_sources: FIELD_SOURCES,
+    relation_flavors: RELATION_FLAVORS,
+    relation_cardinalities: RELATION_CARDINALITIES,
+    on_delete: ON_DELETE,
+    industry_groups: INDUSTRY_GROUPS,
+    template_jobs: TEMPLATE_JOBS,
+    teaches_features: TEACHES_FEATURES,
+    choice_colors: CHOICE_COLORS,
+    template_view_kinds: TEMPLATE_VIEW_KINDS,
+    template_audiences: TEMPLATE_AUDIENCES,
+    form_audiences: ["public", "member", "staff"],
+    extra_kinds_for_describe: ["booking"],
+    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,
+    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"
+  };
+}
 export {
+  BAD_OUTCOME,
+  BOOKING_AVAILABILITY_FACTS,
   CAPABILITY_WORDS,
   CATALOGUE_QUOTAS,
   CATALOGUE_STATUSES,
@@ -6360,6 +7090,8 @@ export {
   DESIGNATED_REAL_NUMBERS,
   ENTITY_REFERENCE_KINDS,
   FORMULA_FUNCTIONS,
+  GALLERY_ONLY,
+  GOOD_OUTCOME,
   INDUSTRY_GROUPS,
   INSTALL_PLAN_VERSION,
   MAIN_TABLE_ROWS_MAX,
@@ -6387,11 +7119,14 @@ export {
   TEMPLATE_VIEW_KINDS,
   TIME_BOUND_STAGE,
   TITLE_DISTINCT_SHARE,
+  VIEW_SHAPE_FACTS,
   agentCopyRequest,
   allTables,
   anyOfWhere,
+  applyRepairPatches,
   assertTemplate,
   attachmentProblems,
+  autofixDescribeSpec,
   automationHeld,
   blockTable,
   bookingArgs,
@@ -6408,12 +7143,16 @@ export {
   deferredRelationFields,
   deferredRelations,
   derivedFieldSpec,
+  describeCheck,
+  describeSpec,
+  describeVocabulary,
   digestSpec,
   documentBody,
   domainsIn,
   drillDownDashboard,
   evalFormula,
   extrasProblems,
+  fallbackView,
   footprintOf,
   foreignTextProblems,
   formArgs,
@@ -6423,13 +7162,18 @@ export {
   foundationTokens,
   isSelfDeclaredField,
   isTimedField,
+  lastResortTrim,
   membersAddRowsSteps,
+  mergeDescribeParts,
   normalizeForPhones,
   notificationParts,
   numberText,
   numberedStreet,
+  packageDescribeResult,
+  parseAt,
   parseFormula,
   parseNumeric,
+  pathOfAt,
   peopleOf,
   phonesOutsideFictionalRange,
   planTables,
@@ -6437,9 +7181,12 @@ export {
   relationFieldSpec,
   relationPatches,
   relativeHasTime,
+  repairSlices,
   requiredCircleProblem,
   resolveDateToken,
+  resolvePath,
   resolveRelativeDates,
+  reusesOf,
   rowActionList,
   rowLevels,
   rowsFor,