@aotter/mantle 0.2.0-alpha.7 → 0.2.0-alpha.8

package/dist/build/compiler.js

@@ -115,6 +115,7 @@ function canonical(v) {
     return `{${Object.keys(v).sort().filter((k) => v[k] !== void 0).map((k) => `${JSON.stringify(k)}:${canonical(v[k])}`).join(",")}}`;
   return JSON.stringify(v) ?? "null";
 }
+var fnv = (s) => [...s].reduce((h, c) => Math.imul(h ^ c.codePointAt(0), 16777619) >>> 0, 2166136261).toString(16).padStart(8, "0");
 async function planFingerprint(plan) {
   const digest = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(canonical(plan)));
   return [...new Uint8Array(digest)].map((b) => b.toString(16).padStart(2, "0")).join("");
@@ -122,8 +123,6 @@ async function planFingerprint(plan) {
 
 // src/build/spec/domain/model/ManifestGrammar.ts
 var API_VERSION = "cms.mantle.aotter.net/v2";
-var UI_EXTENSION_REF = /^([a-z][a-z0-9-]{0,62})\/([a-z][a-z0-9-]{0,62})$/;
-var isUiExtensionRef = (value2) => typeof value2 === "string" && UI_EXTENSION_REF.test(value2);
 function isMediaMcpHint(value2) {
   return value2 === "media" || value2 === "media-image" || value2 === "media-video" || value2 === "media-file";
 }
@@ -180,6 +179,7 @@ var RESERVED_ENTRY_COLUMNS = [
   "authorId"
 ];
 var EXPECTED_VERSION_PROPERTY = "expectedVersion";
+var INPUT_RULE_KEYWORDS = ["dependentRequired", "anyOf", "if", "then", "else"];
 var RESERVED_PROCEDURE_INPUT_NAMES = [EXPECTED_VERSION_PROPERTY];
 
 // src/build/spec/domain/service/SqlRefusal.ts
@@ -280,6 +280,7 @@ function storageColumns(s) {
   return cols;
 }
 var NATIVE_NOT_NULL = /* @__PURE__ */ new Set(["id", "version", "created_at", "updated_at", "status"]);
+var NATIVE_COLUMNS = { id: "id", status: "status", version: "version", createdAt: "created_at", updatedAt: "updated_at", authorId: "author_id" };
 function notNullColumns(s) {
   const out = /* @__PURE__ */ new Set();
   for (const u of s.userScopes ?? []) out.add(u.column);
@@ -490,8 +491,8 @@ function collectSourceSpans(root, lineCounter) {
 }
 function sourceLocationForNode(sourceId, documentIndex, path, doc, lineCounter) {
   const parts = path === "/" ? [] : path.slice(1).split("/").map((part) => {
-    const decoded = part.replace(/~1/g, "/").replace(/~0/g, "~");
-    return /^\d+$/.test(decoded) ? Number(decoded) : decoded;
+    const decoded2 = part.replace(/~1/g, "/").replace(/~0/g, "~");
+    return /^\d+$/.test(decoded2) ? Number(decoded2) : decoded2;
   });
   let range;
   for (let length = parts.length; length >= 0 && !range; length--) {
@@ -520,34 +521,23 @@ function sourceSpan(lineCounter, range) {
 }
 
 // src/build/spec/domain/model/AdminNav.ts
-var BUILT_IN_NAV_GROUPS = { content: 10, operations: 20, reports: 30, more: 90 };
-var NAV_PLACEMENT_KEYS = ["group", "order", "hidden"];
+var BUILT_IN_NAV_GROUPS = /* @__PURE__ */ new Set(["content", "operations", "reports", "more"]);
 var ID = /^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$/;
-function navPlacementProblem(key, value2) {
-  if (key === "group") return typeof value2 === "string" && ID.test(value2) ? null : "a kebab-case group id";
-  if (key === "order") return Number.isInteger(value2) ? null : "an integer";
-  if (key === "hidden") return typeof value2 === "boolean" ? null : "a boolean";
+var PLACEMENT = {
+  group: [(v) => typeof v === "string" && ID.test(v), "a kebab-case group id"],
+  order: [Number.isInteger, "an integer"],
+  hidden: [(v) => typeof v === "boolean", "a boolean"]
+};
+function navPlacementProblems(nav, own = []) {
+  const keys = [...own, ...Object.keys(PLACEMENT)];
+  for (const [key, value2] of Object.entries(nav)) {
+    if (own.includes(key)) continue;
+    const rule = Object.hasOwn(PLACEMENT, key) ? PLACEMENT[key] : null;
+    if (!rule) return [key, `${keys.slice(0, -1).join(", ")} or ${keys.at(-1)}`];
+    if (!rule[0](value2)) return [key, rule[1]];
+  }
   return null;
 }
-var isText = (v) => typeof v === "string" && v.length > 0 || !!v && typeof v === "object" && !Array.isArray(v) && Object.keys(v).length > 0 && Object.values(v).every((x) => typeof x === "string" && x.length > 0);
-function navGroupProblems(groups) {
-  if (groups === void 0) return [];
-  if (!Array.isArray(groups)) return [["admin/navGroups", "navGroups must be an array."]];
-  const seen = /* @__PURE__ */ new Set(), problems = [];
-  groups.forEach((g, i) => {
-    const path = `admin/navGroups/${i}`;
-    if (!g || typeof g !== "object" || Array.isArray(g)) return problems.push([path, "A nav group is an object { id, title, order? }."]);
-    const { id, title, order, ...extra } = g;
-    if (Object.keys(extra).length) problems.push([`${path}/${Object.keys(extra)[0]}`, "A nav group has only id, title and order."]);
-    if (typeof id !== "string" || !ID.test(id)) problems.push([`${path}/id`, "A nav group id is kebab-case."]);
-    else if (Object.hasOwn(BUILT_IN_NAV_GROUPS, id) || id === "settings") problems.push([`${path}/id`, `'${id}' is a built-in group; place items in it without declaring it.`]);
-    else if (seen.has(id)) problems.push([`${path}/id`, `Duplicate nav group id '${id}'.`]);
-    else seen.add(id);
-    if (!isText(title)) problems.push([`${path}/title`, "A nav group title is text or a { locale: text } map."]);
-    if (order !== void 0 && !Number.isInteger(order)) problems.push([`${path}/order`, "A nav group order is an integer."]);
-  });
-  return problems;
-}
 
 // src/build/spec/domain/service/SchemaIndexChecker.ts
 var SAFE_INDEX_NAME = /^[A-Za-z][A-Za-z0-9_.-]*$/;
@@ -820,10 +810,8 @@ function checkViewAdminUi(view) {
   const nav = uiSchema["nav"];
   if (nav !== void 0) {
     if (!nav || typeof nav !== "object" || Array.isArray(nav)) return { list: EMPTY_VIEW_LIST, problems: [problem("/spec/uiSchema/nav", nav, "an object", "View.spec.uiSchema.nav must be an object.")] };
-    for (const [key, value2] of Object.entries(nav)) {
-      const expected = NAV_PLACEMENT_KEYS.includes(key) ? navPlacementProblem(key, value2) : "group, order or hidden";
-      if (expected) return { list: EMPTY_VIEW_LIST, problems: [problem(`/spec/uiSchema/nav/${key}`, value2, expected, `View.spec.uiSchema.nav.${key} must be ${expected}.`)] };
-    }
+    const bad = navPlacementProblems(nav);
+    if (bad) return { list: EMPTY_VIEW_LIST, problems: [problem(`/spec/uiSchema/nav/${bad[0]}`, nav[bad[0]], bad[1], `View.spec.uiSchema.nav.${bad[0]} must be ${bad[1]}.`)] };
   }
   const list = uiSchema["list"];
   if (list === void 0) return { list: EMPTY_VIEW_LIST, problems: [] };
@@ -836,13 +824,13 @@ function checkViewAdminUi(view) {
     )] };
   }
   const config = list;
-  const allowed = /* @__PURE__ */ new Set(["columns", "searchFields", "filterFields", "cells"]);
+  const allowed = /* @__PURE__ */ new Set(["columns", "searchFields", "filterFields"]);
   const unknown = Object.keys(config).find((key) => !allowed.has(key));
   if (unknown) {
     return { list: EMPTY_VIEW_LIST, problems: [problem(
       `/spec/uiSchema/list/${unknown}`,
       config[unknown],
-      "columns, searchFields, filterFields, or cells",
+      "columns, searchFields, or filterFields",
       `View.spec.uiSchema.list.${unknown} is not supported.`
     )] };
   }
@@ -874,16 +862,13 @@ function checkViewAdminUi(view) {
     }
     normalized[key] = raw;
   }
-  const cellProblem = checkCells(config["cells"], (field) => field.length > 0, "View", "a View output name");
-  if (cellProblem) return { list: EMPTY_VIEW_LIST, problems: [cellProblem] };
   return { list: normalized, problems: [] };
 }
 
 // src/build/spec/domain/service/SchemaAdminUiChecker.ts
 var EMPTY_LIST = { primaryField: null, columns: [] };
-var SCHEMA_UI_ROOTS = /* @__PURE__ */ new Set(["fields", "list", "nav", "panels"]);
-var SCHEMA_LIST_KEYS = /* @__PURE__ */ new Set(["filterField", "primaryField", "columns", "cells"]);
-var SCHEMA_NAV_KEYS = /* @__PURE__ */ new Set(["standalone", "parentField", ...NAV_PLACEMENT_KEYS]);
+var SCHEMA_UI_ROOTS = /* @__PURE__ */ new Set(["fields", "list", "nav"]);
+var SCHEMA_LIST_KEYS = /* @__PURE__ */ new Set(["filterField", "primaryField", "columns"]);
 var SCALAR_TYPES = /* @__PURE__ */ new Set(["string", "number", "integer", "boolean"]);
 function checkSchemaAdminUi(schema) {
   const formProblem = checkFormUiSchema(schema.spec.schema, schema.spec.uiSchema, "Schema")[0];
@@ -896,7 +881,7 @@ function checkSchemaAdminUi(schema) {
     return invalid(problem2(
       `/spec/uiSchema/${unknownRoot}`,
       roots[unknownRoot],
-      "fields, list, nav, or panels",
+      "fields, list, or nav",
       `Schema.spec.uiSchema.${unknownRoot} is not supported.`
     ));
   }
@@ -916,7 +901,7 @@ function checkSchemaAdminUi(schema) {
       return invalid(problem2(
         `/spec/uiSchema/list/${unknownList}`,
         config[unknownList],
-        "filterField, primaryField, columns, or cells",
+        "filterField, primaryField, or columns",
         `Schema.spec.uiSchema.list.${unknownList} is not supported.`
       ));
     }
@@ -981,10 +966,6 @@ function checkSchemaAdminUi(schema) {
       ));
     }
   }
-  const cellProblem = checkCells(config["cells"], (field) => NATIVE_LIST_FIELDS.has(field) || !!schema.spec.schema.properties?.[field], "Schema", "a top-level key in spec.schema.properties or a native entry column");
-  if (cellProblem) return invalid(cellProblem);
-  const panelProblem = checkPanels(roots["panels"]);
-  if (panelProblem) return invalid(panelProblem);
   const navResult = checkNav(schema, roots["nav"]);
   if (navResult.problem) return invalid(navResult.problem);
   return {
@@ -1062,41 +1043,21 @@ function checkFormUiSchema(schema, uiSchema, owner) {
       )];
     }
     const config2 = rawConfig;
-    const unknownKey = Object.keys(config2).find((key) => key !== "widget" && key !== "options");
+    const unknownKey = Object.keys(config2).find((key) => key !== "widget");
     if (unknownKey) {
       return [problem2(
         `/spec/uiSchema/fields/${field}/${unknownKey}`,
         config2[unknownKey],
-        "widget and, for an extension widget, options",
+        "widget",
         `${owner}.spec.uiSchema.fields.${field}.${unknownKey} is not supported.`
       )];
     }
-    if (isUiExtensionRef(config2["widget"])) {
-      const options = config2["options"];
-      if (options !== void 0 && (!options || typeof options !== "object" || Array.isArray(options))) {
-        return [problem2(
-          `/spec/uiSchema/fields/${field}/options`,
-          options,
-          "an object",
-          `${owner}.spec.uiSchema.fields.${field}.options must be an object.`
-        )];
-      }
-      continue;
-    }
     if (config2["widget"] !== "textarea") {
       return [problem2(
         `/spec/uiSchema/fields/${field}/widget`,
         config2["widget"],
-        '"textarea" or an Admin extension contribution <extension>/<contribution>',
-        `${owner}.spec.uiSchema.fields.${field}.widget must be 'textarea' or name an Admin extension contribution.`
-      )];
-    }
-    if (config2["options"] !== void 0) {
-      return [problem2(
-        `/spec/uiSchema/fields/${field}/options`,
-        config2["options"],
-        "options only with an extension widget",
-        `${owner}.spec.uiSchema.fields.${field}.options needs an extension widget.`
+        '"textarea"',
+        `${owner}.spec.uiSchema.fields.${field}.widget must be 'textarea'.`
       )];
     }
     if (!isString(property)) {
@@ -1172,22 +1133,8 @@ function checkNav(schema, nav) {
     };
   }
   const config = nav;
-  const unknown = Object.keys(config).find((key) => !SCHEMA_NAV_KEYS.has(key));
-  if (unknown) {
-    return {
-      nav: null,
-      problem: problem2(
-        `/spec/uiSchema/nav/${unknown}`,
-        config[unknown],
-        "standalone, parentField, group, order or hidden",
-        `Schema.spec.uiSchema.nav.${unknown} is not supported.`
-      )
-    };
-  }
-  for (const key of NAV_PLACEMENT_KEYS) {
-    const expected = config[key] === void 0 ? null : navPlacementProblem(key, config[key]);
-    if (expected) return { nav: null, problem: problem2(`/spec/uiSchema/nav/${key}`, config[key], expected, `Schema.spec.uiSchema.nav.${key} must be ${expected}.`) };
-  }
+  const bad = navPlacementProblems(config, ["standalone", "parentField"]);
+  if (bad) return { nav: null, problem: problem2(`/spec/uiSchema/nav/${bad[0]}`, config[bad[0]], bad[1], `Schema.spec.uiSchema.nav.${bad[0]} must be ${bad[1]}.`) };
   const standalone = config["standalone"];
   if (standalone !== void 0 && typeof standalone !== "boolean") {
     return {
@@ -1213,13 +1160,15 @@ function checkNav(schema, nav) {
     };
   }
   if (parentField !== void 0 && standalone !== true) {
-    return {
+    const required = new Set(schema.spec.schema.required ?? []);
+    const ok = !schema.spec.translates && required.has(parentField) && resolveMantleRef(schema.spec.schema.properties?.[parentField]) !== null;
+    return ok ? { nav: null } : {
       nav: null,
       problem: problem2(
         "/spec/uiSchema/nav/parentField",
         parentField,
-        "parentField only with standalone: true",
-        "Schema.spec.uiSchema.nav.parentField requires nav.standalone: true."
+        "a required x-mantle-ref field of a Schema that is not a translates child",
+        schema.spec.translates ? `Schema '${schema.metadata.name}' cannot declare nav.parentField because it is a translates child.` : `Schema '${schema.metadata.name}' nav.parentField must name a required x-mantle-ref field.`
       )
     };
   }
@@ -1235,7 +1184,7 @@ function checkNav(schema, nav) {
       )
     };
   }
-  const eligible = requiredMantleRefFields(schema);
+  const eligible = requiredMantleRefFields(schema.spec.schema);
   if (eligible.length === 0) {
     return {
       nav: null,
@@ -1264,17 +1213,7 @@ function checkNav(schema, nav) {
       nav: { standalone: true, parentField: only.field, parentCollection: only.collection }
     };
   }
-  if (typeof parentField !== "string") {
-    return {
-      nav: null,
-      problem: problem2(
-        "/spec/uiSchema/nav/parentField",
-        parentField,
-        `one of ${eligible.map((item) => item.field).join(", ")}`,
-        `Schema '${schema.metadata.name}' declares more than one required x-mantle-ref; nav.parentField is required.`
-      )
-    };
-  }
+  if (typeof parentField !== "string") return { nav: null };
   const matched = eligible.find((item) => item.field === parentField);
   if (!matched) {
     return {
@@ -1291,9 +1230,9 @@ function checkNav(schema, nav) {
     nav: { standalone: true, parentField: matched.field, parentCollection: matched.collection }
   };
 }
-function requiredMantleRefFields(schema) {
-  const required = new Set(schema.spec.schema.required ?? []);
-  const properties = schema.spec.schema.properties ?? {};
+function requiredMantleRefFields(body) {
+  const required = new Set(body.required ?? []);
+  const properties = body.properties ?? {};
   const fields = [];
   for (const [field, property] of Object.entries(properties)) {
     if (!required.has(field)) continue;
@@ -1304,18 +1243,62 @@ function requiredMantleRefFields(schema) {
 }
 function checkSchemaNavTargets(schema, schemasByName) {
   const { nav, problems } = checkSchemaAdminUi(schema);
-  if (problems.length > 0 || !nav) return null;
-  const parent = schemasByName.get(nav.parentCollection);
-  if (!parent || parent.spec.translates) {
-    const declaredParentField = schema.spec.uiSchema && typeof schema.spec.uiSchema === "object" && !Array.isArray(schema.spec.uiSchema) && schema.spec.uiSchema["nav"] && typeof schema.spec.uiSchema["nav"] === "object" && !Array.isArray(schema.spec.uiSchema["nav"]) && "parentField" in schema.spec.uiSchema["nav"];
+  if (problems.length > 0 || schema.spec.translates) return null;
+  const declared = declaredParentField(schema);
+  const target2 = nav?.parentCollection ?? (declared === void 0 ? void 0 : resolveMantleRef(schema.spec.schema.properties?.[declared])?.schema);
+  if (target2 !== void 0 && !isFoldParent(schemasByName.get(target2))) {
     return problem2(
-      declaredParentField ? "/spec/uiSchema/nav/parentField" : "/spec/uiSchema/nav/standalone",
-      nav.parentCollection,
+      declared === void 0 ? "/spec/uiSchema/nav/standalone" : "/spec/uiSchema/nav/parentField",
+      target2,
       "the metadata.name of an existing non-translates Schema",
-      `Schema '${schema.metadata.name}' nav parent collection '${nav.parentCollection}' is not an eligible fold parent.`
+      `Schema '${schema.metadata.name}' nav parent collection '${target2}' is not an eligible fold parent.`
     );
   }
-  return null;
+  if (declared === void 0) {
+    const eligible = eligibleIdRefs(schema, schemasByName);
+    if (eligible.length < 2) return null;
+    const names = eligible.join(", ");
+    const keep = eligible.find((field) => !closesParentCycle(schema, field, schemasByName));
+    return problem2(
+      "/spec/uiSchema/nav/parentField",
+      void 0,
+      `one of ${names}`,
+      `Schema '${schema.metadata.name}' has more than one required id x-mantle-ref (${names}); set uiSchema.nav.parentField to choose its parent.${keep === void 0 ? "" : ` To keep the current choice, add nav: { parentField: ${keep} }.`}`
+    );
+  }
+  return closesParentCycle(schema, declared, schemasByName) ? problem2(
+    "/spec/uiSchema/nav/parentField",
+    declared,
+    "a reference whose parent chain does not lead back to this Schema",
+    `Schema '${schema.metadata.name}' nav.parentField '${declared}' creates a parent cycle.`
+  ) : null;
+}
+function closesParentCycle(schema, field, schemasByName) {
+  const seen = /* @__PURE__ */ new Set();
+  for (let at = resolveMantleRef(schema.spec.schema.properties?.[field])?.schema; at !== void 0 && !seen.has(at); at = foldParentOf(schemasByName.get(at), schemasByName)) {
+    if (at === schema.metadata.name) return true;
+    seen.add(at);
+  }
+  return false;
+}
+function declaredParentField(schema) {
+  const nav = schema.spec.uiSchema?.["nav"];
+  return typeof nav?.["parentField"] === "string" ? nav["parentField"] : void 0;
+}
+var isFoldParent = (s) => !!s && !s.spec.translates;
+function eligibleIdRefs(schema, schemasByName) {
+  return requiredMantleRefFields(schema.spec.schema).filter((r) => isFoldParent(schemasByName.get(r.collection))).map((r) => r.field);
+}
+function foldParentOf(schema, schemasByName) {
+  if (!schema || schema.spec.translates) return void 0;
+  const field = foldParentField(schema.spec.schema, declaredParentField(schema), (name4) => isFoldParent(schemasByName.get(name4)));
+  return field === void 0 ? void 0 : resolveMantleRef(schema.spec.schema.properties?.[field])?.schema;
+}
+function foldParentField(body, declared, isParent) {
+  const props = body.properties ?? {};
+  const required = new Set(body.required ?? []);
+  const refs = Object.keys(props).filter((f) => required.has(f) && isParent(resolveMantleRef(props[f])?.schema ?? ""));
+  return declared ?? requiredMantleRefFields(body).find((r) => isParent(r.collection))?.field ?? refs[0];
 }
 var NATIVE_LIST_FIELDS = new Set(RESERVED_ENTRY_COLUMNS);
 function isScalar3(schema) {
@@ -1326,24 +1309,6 @@ function isString(schema) {
   const types = Array.isArray(schema.type) ? schema.type : schema.type ? [schema.type] : [];
   return types.includes("string") && types.every((type) => type === "string" || type === "null");
 }
-function checkCells(cells, known, owner, expected) {
-  if (cells === void 0) return null;
-  if (!cells || typeof cells !== "object" || Array.isArray(cells)) {
-    return problem2("/spec/uiSchema/list/cells", cells, "an object of field -> <extension>/<contribution>", `${owner}.spec.uiSchema.list.cells must be an object.`);
-  }
-  for (const [field, ref2] of Object.entries(cells)) {
-    if (!known(field)) return problem2(`/spec/uiSchema/list/cells/${field}`, field, expected, `${owner}.spec.uiSchema.list.cells references unknown field '${field}'.`);
-    if (!isUiExtensionRef(ref2)) return problem2(`/spec/uiSchema/list/cells/${field}`, ref2, "<extension>/<contribution>", `${owner}.spec.uiSchema.list.cells.${field} must name an Admin extension contribution.`);
-  }
-  return null;
-}
-function checkPanels(panels) {
-  if (panels === void 0) return null;
-  if (!Array.isArray(panels) || panels.length > 16 || !panels.every(isUiExtensionRef) || new Set(panels).size !== panels.length) {
-    return problem2("/spec/uiSchema/panels", panels, "up to 16 distinct <extension>/<contribution> names", "Schema.spec.uiSchema.panels must list Admin extension contributions.");
-  }
-  return null;
-}
 function problem2(pointer2, value2, expected, message2) {
   return { pointer: pointer2, value: value2, expected, message: message2 };
 }
@@ -1684,12 +1649,8 @@ function validateSchemaSpec(m, idx) {
   return m;
 }
 var UNSUPPORTED_JSON_SCHEMA_KEYWORDS = /* @__PURE__ */ new Set([
-  "anyOf",
   "allOf",
   "not",
-  "if",
-  "then",
-  "else",
   "$anchor",
   "$dynamicAnchor",
   "$dynamicRef",
@@ -1731,6 +1692,16 @@ function validateJsonSchema(root, idx, kind, name4, basePointer) {
         );
       }
     }
+    if (basePointer !== "/spec/input") for (const keyword of INPUT_RULE_KEYWORDS) {
+      if (keyword in value2) {
+        throw new ManifestParseError(
+          `${kind} '${name4}' uses JSON Schema keyword '${keyword}', which is supported only in View and Procedure input`,
+          idx,
+          `${pointer2}/${escapeJsonPointerSegment(keyword)}`,
+          "JSON_SCHEMA_UNSUPPORTED"
+        );
+      }
+    }
     if ("$ref" in value2) refs.push([`${pointer2}/$ref`, value2["$ref"], validateLocalSchemaRef(value2["$ref"], rootObject, idx, kind, name4, `${pointer2}/$ref`)]);
     if (value2["enum"] !== void 0 && (!Array.isArray(value2["enum"]) || value2["enum"].length > MAX_JSON_SCHEMA_ENUM)) {
       throw new ManifestParseError(
@@ -2026,23 +1997,23 @@ function validateViewCache(raw, view, idx) {
   }
 }
 function validateViewInput(raw, idx) {
-  const invalid3 = (message2, pointer2, code = "VIEW_INPUT_INVALID_SHAPE") => {
+  const invalid2 = (message2, pointer2, code = "VIEW_INPUT_INVALID_SHAPE") => {
     throw new ManifestParseError(message2, idx, pointer2, code);
   };
   if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
-    invalid3("View.spec.input must be a JSON Schema object", "/spec/input");
+    invalid2("View.spec.input must be a JSON Schema object", "/spec/input");
   }
   const p = raw;
   if (p["type"] !== "object") {
-    invalid3(`View.spec.input.type must be "object"; got ${JSON.stringify(p["type"])}`, "/spec/input/type");
+    invalid2(`View.spec.input.type must be "object"; got ${JSON.stringify(p["type"])}`, "/spec/input/type");
   }
   const props = p["properties"];
   if (typeof props !== "object" || props === null || Array.isArray(props)) {
-    invalid3("View.spec.input.properties is required (declare each accepted parameter)", "/spec/input/properties");
+    invalid2("View.spec.input.properties is required (declare each accepted parameter)", "/spec/input/properties");
   }
   for (const reserved2 of VIEW_INPUT_RESERVED) {
     if (Object.hasOwn(props, reserved2)) {
-      invalid3(
+      invalid2(
         `View.spec.input.properties.${reserved2} is reserved (the runtime owns ${VIEW_INPUT_RESERVED.join(", ")} for pagination); rename it.`,
         `/spec/input/properties/${reserved2}`,
         "VIEW_INPUT_RESERVED_NAME"
@@ -2829,10 +2800,41 @@ function jsonValueWithinLimits() {
   });
 }
 
+// src/build/spec/domain/service/RootRefChain.ts
+function lookupLocalRef(root, ref2) {
+  if (typeof ref2 !== "string" || !ref2.startsWith("#/")) return void 0;
+  let value2 = root;
+  try {
+    for (const key of decodeURIComponent(ref2.slice(2)).split("/").map((key2) => key2.replace(/~1/g, "/").replace(/~0/g, "~"))) value2 = value2 && typeof value2 === "object" && Object.hasOwn(value2, key) ? value2[key] : void 0;
+  } catch {
+    return void 0;
+  }
+  return value2 && typeof value2 === "object" ? value2 : void 0;
+}
+function rootRefChain(input) {
+  const chain = [];
+  for (let schema = input; schema !== void 0; schema = lookupLocalRef(input, schema.$ref)) {
+    if (chain.includes(schema)) return void 0;
+    chain.push(schema);
+    if (schema.$ref === void 0) return chain;
+  }
+  return void 0;
+}
+
 // src/build/spec/domain/service/McpToolNaming.ts
 function mcpToolNameSegment(name4) {
   return name4.toLowerCase().replace(/-/g, "_");
 }
+function toolTitle(name4) {
+  const words = name4.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/[-_.\s]+/g, " ").trim().toLowerCase();
+  return words.charAt(0).toUpperCase() + words.slice(1);
+}
+var viewAnnotations = { readOnlyHint: true, destructiveHint: false };
+function procedureAnnotations(p) {
+  const readOnlyHint = p.mcp?.readOnlyHint ?? false;
+  return { readOnlyHint, destructiveHint: !readOnlyHint && ("ref" in p.handler || overwrites(p.handler.sql.stmts)), ...p.mcp };
+}
+var overwrites = (node) => !!node && typeof node === "object" && ("DeleteStmt" in node || "UpdateStmt" in node || node.onConflictClause?.action === "ONCONFLICT_UPDATE" || Object.values(node).some(overwrites));
 function mcpTools(plan, surface, locale = "en") {
   const text = (t) => resolveLocalizedText(t, locale, "en") ?? void 0;
   const tools = /* @__PURE__ */ new Map();
@@ -2849,33 +2851,61 @@ function mcpTools(plan, surface, locale = "en") {
       name: mcpToolNameSegment(t.procedure),
       kind: "procedure",
       source: t.procedure,
-      ...title ? { title } : {},
+      title: title ?? toolTitle(t.procedure),
       description: text(p.description) ?? title ?? t.procedure,
       inputSchema: p.input,
       // structuredContent must be an object
       ...p.output.type === "object" ? { outputSchema: p.output } : {},
-      ...p.mcp ? { annotations: p.mcp } : {},
+      annotations: procedureAnnotations(p),
       requires: p.requires
     });
   }
   for (const [name4, v] of Object.entries(plan.views)) {
     if (v.surface !== surface) continue;
-    const props = v.input?.properties ?? {};
+    const chain = (v.input ? rootRefChain(v.input) ?? [v.input] : []).reverse();
+    const props = Object.assign({}, ...chain.map((s) => s.properties ?? {}));
+    const required = [...new Set(chain.flatMap((s) => s.required ?? []))];
     if ("limit" in props || "cursor" in props) throw new TypeError(`View '${name4}' declares an input named limit or cursor; the MCP tool reserves both for paging.`);
+    const rules = chain.map((s) => Object.fromEntries(INPUT_RULE_KEYWORDS.flatMap((k) => s[k] === void 0 ? [] : [[k, s[k]]]))).filter((r) => Object.keys(r).length);
+    const defs = v.input ? referencedDefs(v.input, props) : {};
     const title = text(v.title);
     add({
       name: mcpToolNameSegment(name4),
       kind: "view",
       source: name4,
-      ...title ? { title } : {},
+      title: title ?? toolTitle(name4),
       description: text(v.description) ?? title ?? name4,
-      inputSchema: { type: "object", properties: { ...props, limit: { type: "integer", minimum: 1, maximum: 500 }, cursor: { type: "string" } }, ...v.input?.required ? { required: v.input.required } : {} },
-      annotations: { readOnlyHint: true },
+      inputSchema: {
+        type: "object",
+        properties: { ...props, limit: { type: "integer", minimum: 1, maximum: 500 }, cursor: { type: "string" } },
+        ...required.length ? { required } : {},
+        ...rules.length > 1 ? { allOf: rules } : rules[0],
+        ...Object.keys(defs).length ? { $defs: defs } : {}
+      },
+      annotations: viewAnnotations,
       requires: v.requires
     });
   }
   return [...tools.values()];
 }
+function referencedDefs(root, node, found = {}) {
+  if (!node || typeof node !== "object") return found;
+  const ref2 = node.$ref, [head, segment] = typeof ref2 === "string" && ref2.startsWith("#/") ? decoded(ref2.slice(2)).split("/") : [];
+  const key = head === "$defs" ? segment?.replace(/~1/g, "/").replace(/~0/g, "~") : void 0;
+  if (key !== void 0 && !Object.hasOwn(found, key) && root.$defs && Object.hasOwn(root.$defs, key)) {
+    found[key] = root.$defs[key];
+    referencedDefs(root, found[key], found);
+  }
+  for (const child2 of Object.values(node)) referencedDefs(root, child2, found);
+  return found;
+}
+var decoded = (pointer2) => {
+  try {
+    return decodeURIComponent(pointer2);
+  } catch {
+    return "";
+  }
+};
 
 // src/build/spec/domain/service/TriggerGraphChecks.ts
 function checkProcedureTarget(procedure, schemasByName, filePaths) {
@@ -4459,7 +4489,6 @@ function writePolicy(s, kind, o = {}) {
 }
 
 // src/build/spec/infrastructure/sql/compilePlan.ts
-var NATIVE_COLUMNS = { id: "id", status: "status", version: "version", createdAt: "created_at", updatedAt: "updated_at", authorId: "author_id" };
 var indexColumn = (field) => Object.hasOwn(NATIVE_COLUMNS, field) ? NATIVE_COLUMNS[field] : field.toLowerCase();
 function toDiagnostic2(d, source, pointer2) {
   const at = d.line === void 0 ? void 0 : { line: d.line, column: d.column, ...d.token ? { token: d.token } : {} };
@@ -4651,10 +4680,6 @@ async function compileLinkedPlan(linked, dialect = compile_exports) {
       diagnostics.push(validateDiagnostic({ code: "VIEW_UI_INVALID", severity: "error", path: `${source.sourceId}#/${source.documentIndex}/spec/uiSchema/list/${key}/${i}`, source: { ...source, path: `/spec/uiSchema/list/${key}/${i}` }, value: f, expected: `one of the View's outputs: ${outputs.keys.join(", ")}`, message: `View '${v.metadata.name}' uiSchema.list.${key} names '${f}', which the View's SELECT does not output.` }));
     }
     const wire = (outputs?.keys ?? []).map((k) => columns2[k]?.field === k ? schemas[columns2[k].schema].names?.[k] ?? k : k);
-    for (const f of Object.keys(v.spec.uiSchema?.["list"]?.cells ?? {})) {
-      if (!outputs?.keys || wire.includes(f)) continue;
-      diagnostics.push(validateDiagnostic({ code: "VIEW_UI_INVALID", severity: "error", path: `${source.sourceId}#/${source.documentIndex}/spec/uiSchema/list/cells/${f}`, source: { ...source, path: `/spec/uiSchema/list/cells/${f}` }, value: f, expected: `one of the View's outputs: ${wire.join(", ")}`, message: `View '${v.metadata.name}' uiSchema.list.cells names '${f}', which the View's SELECT does not output.` }));
-    }
     for (const [i, f] of (list["columns"] ?? []).entries()) {
       if (!outputs?.keys || wire.includes(f)) continue;
       const folded = wire.find((k) => k.toLowerCase() === f.toLowerCase());
@@ -4887,7 +4912,7 @@ function toCanonicalLocale(input) {
 }
 function canonicalizeLocaleList(inputs) {
   const valid = [];
-  const invalid3 = [];
+  const invalid2 = [];
   const seen = /* @__PURE__ */ new Set();
   for (const raw of inputs) {
     try {
@@ -4897,10 +4922,10 @@ function canonicalizeLocaleList(inputs) {
         valid.push(canonical2);
       }
     } catch {
-      invalid3.push(raw);
+      invalid2.push(raw);
     }
   }
-  return { valid, invalid: invalid3 };
+  return { valid, invalid: invalid2 };
 }
 function containsScriptSubtagLocale(inputs) {
   return inputs.some((raw) => SCRIPT_SUBTAG_SHAPE.test(raw));
@@ -4956,13 +4981,13 @@ var InvalidSiteIconsError = class extends Error {
 };
 function assertSiteDefaultsCanonical(defaults) {
   if (defaults?.locales && defaults.locales.length > 0) {
-    const { invalid: invalid3 } = canonicalizeLocaleList(defaults.locales);
-    if (invalid3.length > 0) throw new InvalidSiteDefaultsError(invalid3);
+    const { invalid: invalid2 } = canonicalizeLocaleList(defaults.locales);
+    if (invalid2.length > 0) throw new InvalidSiteDefaultsError(invalid2);
   }
   if (defaults?.icons) {
-    const invalid3 = defaults.icons.filter((icon) => !validSiteIcon(icon));
-    if (defaults.icons.length === 0 || invalid3.length > 0) {
-      throw new InvalidSiteIconsError(invalid3.length > 0 ? invalid3 : defaults.icons);
+    const invalid2 = defaults.icons.filter((icon) => !validSiteIcon(icon));
+    if (defaults.icons.length === 0 || invalid2.length > 0) {
+      throw new InvalidSiteIconsError(invalid2.length > 0 ? invalid2 : defaults.icons);
     }
   }
   const origin = defaults?.origin;
@@ -5069,7 +5094,7 @@ function lifecycleHookSets(plan) {
 }
 
 // src/build/core/version.ts
-var MANTLE_VERSION = "0.2.0-alpha.7";
+var MANTLE_VERSION = "0.2.0-alpha.8";
 
 // src/build/core/sql/ast.ts
 var S = (s) => ({ String: { sval: s } });
@@ -6368,7 +6393,6 @@ function initialStorageSql(plan) {
 // src/build/postgres/storage.ts
 var q4 = (id) => `"${id.replace(/"/g, '""')}"`;
 var ident = (n) => new TextEncoder().encode(n).length <= 63 ? n : `${n.slice(0, 50)}_${fnv(n)}`;
-var fnv = (s) => [...s].reduce((h, c) => Math.imul(h ^ c.codePointAt(0), 16777619) >>> 0, 2166136261).toString(16).padStart(8, "0");
 function columns(s) {
   return [
     ...s.scope ? [{ name: s.scope, type: "text", native: true }] : [],
@@ -6418,15 +6442,13 @@ function adminIndexColumns(s) {
 function collectionOf(s, schemas) {
   const names = new Set(schemas.filter((x) => !x.translates).map((x) => x.name));
   const props = propsOf(s.schema);
-  const required = new Set(s.schema.required ?? []);
   const ui = s.uiSchema ?? {};
   const list = ui["list"] ?? {};
   const nav = ui["nav"];
   const filterField = list["filterField"];
-  const refs = Object.keys(props).filter((f) => required.has(f) && names.has(resolveMantleRef(props[f])?.schema ?? ""));
-  const byId = refs.find((f) => resolveMantleRef(props[f]).field === "id");
-  const parentField = byId ?? refs[0];
-  const navField = nav?.["standalone"] === true ? nav["parentField"] ?? byId : void 0;
+  const declared = nav?.["parentField"];
+  const parentField = foldParentField(s.schema, declared, (name4) => names.has(name4));
+  const navField = nav?.["standalone"] === true ? declared ?? (s.translates ? void 0 : requiredMantleRefFields(s.schema).find((r) => names.has(r.collection))?.field) : void 0;
   const navParent = navField ? resolveMantleRef(props[navField]) : null;
   const children = schemas.filter((c) => c.translates?.parent === s.name);
   return {
@@ -6448,6 +6470,10 @@ function collectionOf(s, schemas) {
     nav: navField && navParent ? { standalone: true, parentField: navField, parentCollection: navParent.schema } : null
   };
 }
+function isPrimaryCollection(s, schemas) {
+  const c = collectionOf(s, schemas);
+  return !s.translates && (!c.parent || c.nav !== null);
+}
 
 // src/build/admin/procedureFlow.ts
 function expression(node) {
@@ -6780,114 +6806,6 @@ function developerConsole(plan) {
   };
 }
 
-// src/build/admin/extensions.ts
-var invalid2 = (code, path, message2, value2) => new DiagnosticError(makeDiagnostic({ code, phase: "boot", severity: "error", path, message: message2, ...value2 === void 0 ? {} : { value: value2 } }));
-var isObject = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
-var isText2 = (v) => typeof v === "string" && v.length > 0 || isObject(v) && Object.keys(v).length > 0 && Object.values(v).every((x) => typeof x === "string" && x.length > 0);
-var keysWithin = (o, allowed) => Object.keys(o).find((k) => !allowed.includes(k));
-var FORM_TYPES = ["string", "number", "integer", "boolean"];
-var FORM_PROPERTY_KEYS = ["type", "title", "description", "default", "enum", "oneOf", "minimum", "maximum", "minLength", "maxLength"];
-function formSchemaProblem(schema) {
-  if (!isObject(schema) || schema["type"] !== "object" || !isObject(schema["properties"])) return "an object schema with properties";
-  const extra = keysWithin(schema, ["type", "properties", "required", "title", "description", "additionalProperties"]);
-  if (extra) return `no '${extra}' at the top level`;
-  if (schema["additionalProperties"] !== void 0 && schema["additionalProperties"] !== false) return "additionalProperties false or absent";
-  const props = schema["properties"];
-  const names = Object.keys(props);
-  if (names.length === 0 || names.length > 64) return "1 to 64 properties";
-  if (names.includes("__proto__")) return "no property named __proto__";
-  const required = schema["required"];
-  if (required !== void 0 && (!Array.isArray(required) || required.some((r) => typeof r !== "string" || !names.includes(r)))) return "required naming declared properties";
-  for (const [name4, p] of Object.entries(props)) {
-    if (!isObject(p) || typeof p["type"] !== "string" || !FORM_TYPES.includes(p["type"])) return `property '${name4}' typed string, number, integer or boolean`;
-    const bad = keysWithin(p, FORM_PROPERTY_KEYS);
-    if (bad) return `property '${name4}' without '${bad}'`;
-    if (p["title"] !== void 0 && !isText2(p["title"])) return `property '${name4}' with a text title`;
-    if (p["description"] !== void 0 && !isText2(p["description"])) return `property '${name4}' with a text description`;
-    if (p["enum"] !== void 0 && (!Array.isArray(p["enum"]) || p["enum"].length === 0 || p["enum"].some((x) => !matchesType(p["type"], x)))) return `property '${name4}' with an enum of its type`;
-    if (p["oneOf"] !== void 0 && (!Array.isArray(p["oneOf"]) || p["oneOf"].length === 0 || p["oneOf"].some((o) => !isObject(o) || keysWithin(o, ["const", "title"]) || !matchesType(p["type"], o["const"]) || o["title"] !== void 0 && !isText2(o["title"])))) return `property '${name4}' with a oneOf of { const, title }`;
-    for (const k of ["minimum", "maximum", "minLength", "maxLength"]) if (p[k] !== void 0 && (typeof p[k] !== "number" || !Number.isFinite(p[k]))) return `property '${name4}' with a numeric ${k}`;
-    if (p["default"] !== void 0 && checkValue(p, p["default"]) !== null) return `property '${name4}' with a default it accepts`;
-  }
-  return null;
-}
-function matchesType(type, v) {
-  if (type === "string") return typeof v === "string";
-  if (type === "boolean") return typeof v === "boolean";
-  if (type === "integer") return Number.isInteger(v);
-  return typeof v === "number" && Number.isFinite(v);
-}
-function checkValue(p, v) {
-  const type = p["type"];
-  if (!matchesType(type, v)) return type === "integer" ? "an integer" : `a ${type}`;
-  if (Array.isArray(p["enum"]) && !p["enum"].includes(v)) return "one of the listed values";
-  if (Array.isArray(p["oneOf"]) && !p["oneOf"].some((o) => o["const"] === v)) return "one of the listed values";
-  if (typeof v === "number") {
-    if (typeof p["minimum"] === "number" && v < p["minimum"]) return `at least ${p["minimum"]}`;
-    if (typeof p["maximum"] === "number" && v > p["maximum"]) return `at most ${p["maximum"]}`;
-  }
-  if (typeof v === "string") {
-    const length = [...v].length;
-    if (typeof p["minLength"] === "number" && length < p["minLength"]) return `at least ${p["minLength"]} characters`;
-    if (typeof p["maxLength"] === "number" && length > p["maxLength"]) return `at most ${p["maxLength"]} characters`;
-  }
-  return null;
-}
-function checkFormValue(schema, value2) {
-  if (!isObject(value2)) return { "": "an object" };
-  const props = schema.properties ?? {};
-  const errors = /* @__PURE__ */ Object.create(null);
-  const has = (name4) => Object.hasOwn(value2, name4) && value2[name4] !== void 0;
-  for (const k of Object.keys(value2)) if (!Object.hasOwn(props, k)) errors[k] = "no such field";
-  for (const name4 of schema.required ?? []) if (!has(name4)) errors[name4] = "required";
-  for (const [name4, p] of Object.entries(props)) {
-    if (!has(name4) || Object.hasOwn(errors, name4)) continue;
-    const problem3 = checkValue(p, value2[name4]);
-    if (problem3) errors[name4] = `expected ${problem3}`;
-  }
-  return errors;
-}
-function planUiExtensionRefs(plan) {
-  const refs = [];
-  const fields = (owner, ui) => {
-    for (const [name4, c] of Object.entries(isObject(ui?.["fields"]) ? ui["fields"] : {})) {
-      if (isObject(c) && typeof c["widget"] === "string" && UI_EXTENSION_REF.test(c["widget"])) refs.push({ path: `${owner}/uiSchema/fields/${name4}/widget`, ref: c["widget"], target: "field.input/v1", ...c["options"] === void 0 ? {} : { options: c["options"] } });
-    }
-  };
-  const cells = (owner, ui) => {
-    const list = ui?.["list"];
-    for (const [name4, ref2] of Object.entries(isObject(list) && isObject(list["cells"]) ? list["cells"] : {})) if (typeof ref2 === "string") refs.push({ path: `${owner}/uiSchema/list/cells/${name4}`, ref: ref2, target: "field.cell/v1" });
-  };
-  for (const [name4, s] of Object.entries(plan.schemas)) {
-    const owner = `schema:${s.name ?? name4}`;
-    const ui = s.uiSchema;
-    fields(owner, ui);
-    cells(owner, ui);
-    const panels = ui?.["panels"];
-    if (Array.isArray(panels)) {
-      for (const ref2 of panels) if (typeof ref2 === "string") refs.push({ path: `${owner}/uiSchema/panels`, ref: ref2, target: "record.sidebar/v1" });
-    }
-  }
-  for (const [name4, p] of Object.entries(plan.procedures)) fields(`procedure:${name4}`, p.uiSchema);
-  for (const [name4, v] of Object.entries(plan.views)) cells(`view:${name4}`, v.uiSchema);
-  return refs;
-}
-function checkPlanUiExtensions(plan, extensions) {
-  for (const { path, ref: ref2, target: target2, options } of planUiExtensionRefs(plan)) {
-    const [, extId, cId] = UI_EXTENSION_REF.exec(ref2);
-    const ext = extensions.find((e) => e.id === extId);
-    const c = ext ? [...ext.contributes.fields ?? [], ...ext.contributes.panels ?? []].find((x) => x.id === cId) : void 0;
-    if (!c) throw invalid2("UI_EXTENSION_UNKNOWN", path, `no Admin extension contribution '${ref2}'`, ref2);
-    if (c.target !== target2) throw invalid2("UI_EXTENSION_TARGET", path, `'${ref2}' is a ${c.target} contribution; this key needs ${target2}`, ref2);
-    if (options === void 0) continue;
-    const schema = c.optionsSchema;
-    if (!schema) throw invalid2("UI_EXTENSION_OPTIONS", path, `'${ref2}' takes no options`, options);
-    const errors = checkFormValue(schema, options);
-    const first = Object.entries(errors)[0];
-    if (first) throw invalid2("UI_EXTENSION_OPTIONS", `${path}/${first[0]}`, `options for '${ref2}': ${first[0] || "options"} ${first[1]}`, options);
-  }
-}
-
 // src/build/mcp/catalog.ts
 var nativeSchema = (field) => Object.hasOwn(NATIVE_OUTPUT_TYPES, field) ? NATIVE_OUTPUT_TYPES[field] === "integer" ? { type: "integer" } : { type: "string", format: "date-time" } : void 0;
 function entrySchema(plan, v) {
@@ -6932,12 +6850,14 @@ function appCatalog(plan, surface) {
 export {
   BUILT_IN_NAV_GROUPS,
   DiagnosticError,
+  INPUT_RULE_KEYWORDS,
+  NATIVE_COLUMNS,
   NATIVE_NOT_NULL,
   adminIndexColumns,
   appCatalog,
   assertSiteDefaultsCanonical,
+  canonical,
   canonicalizeLocaleList,
-  checkPlanUiExtensions,
   collectionOf,
   compilePlan,
   compileProgram,
@@ -6946,26 +6866,31 @@ export {
   entrySchema,
   enumOptions,
   expandPolicyRequired,
-  formSchemaProblem,
+  fnv,
+  isPrimaryCollection,
+  lookupLocalRef,
   lowerPlan,
   mcpToolNameSegment,
   mcpTools,
-  navGroupProblems,
+  navPlacementProblems,
   notNullColumns,
   pagedOf,
   parseNumeric,
   parsePgSql,
-  planUiExtensionRefs,
   compile_exports2 as postgresCompiler,
   postgresDialect,
   initialStorageSql2 as postgresSchema,
+  procedureAnnotations,
   protectedColumns,
   resolveLocalizedText,
+  rootRefChain,
   rowPolicy,
   rowPreconditions,
   compile_exports as sqliteCompiler,
   initialStorageSql as sqliteSchema,
+  toolTitle,
   userScopeTerm,
+  viewAnnotations,
   viewOutputs,
   writePolicy
 };