@ai-matrx/records 0.72.12 → 0.72.23

package/dist/memory/index.js

@@ -0,0 +1,2658 @@
+// src/templates/payloads.ts
+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;
+  return {
+    id: field.parityType === "multi_select" ? "multi_choice" : "choice",
+    options: {
+      choices: field.choices.filter((c) => field.choiceColors?.[c]).map((c) => ({ value: c, color: field.choiceColors[c] }))
+    }
+  };
+}
+function foundationTokens(spec) {
+  const main = spec.tables?.[0]?.token;
+  return new Set((spec.foundation ?? []).map((f) => f.table).filter((token) => token && token !== main));
+}
+function tableShellPayload(spec, t) {
+  return {
+    business: spec.business.name,
+    tables: [
+      {
+        token: t.token,
+        ...foundationTokens(spec).has(t.token) ? { foundation: true } : {},
+        name: t.name,
+        labelSingular: t.labelSingular,
+        labelPlural: t.labelPlural,
+        type: t.type,
+        display: t.display,
+        weight: t.weight,
+        ordered: t.ordered,
+        titleField: t.titleField,
+        describes: t.describes,
+        fields: t.fields.filter((f) => !COMPUTED.has(f.parityType) && f.parityType !== "relation" && !isSelfDeclaredField(f)).map((f) => {
+          const displayFormat = choiceDisplayFormat(f);
+          return {
+            key: f.key,
+            label: f.label,
+            parityType: f.parityType,
+            multi: f.multi,
+            dated: f.dated,
+            required: f.required,
+            unit: f.unit ?? void 0,
+            rules: f.rules,
+            choices: f.choices,
+            source: f.source,
+            computeOn: f.computeOn,
+            sensitivity: f.sensitivity,
+            contextPolicy: f.contextPolicy,
+            ...displayFormat ? { displayFormat } : {}
+          };
+        }),
+        rows: []
+      }
+    ]
+  };
+}
+function timedFieldSpec(field) {
+  return {
+    key: field.key,
+    label: field.label,
+    type: "datetime",
+    kind: "datetime",
+    ...field.required ? { required: true } : {},
+    ...field.rules ? { rules: field.rules } : {},
+    sensitivity: field.sensitivity,
+    context_policy: field.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);
+  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 } : {},
+    ...displayFormat ? { display_format: displayFormat } : {},
+    ...field.default !== void 0 ? { default: field.default } : {},
+    ...allowed,
+    sensitivity: field.sensitivity,
+    context_policy: field.contextPolicy
+  };
+}
+function relationFieldSpec(field, targetTableId) {
+  return {
+    key: field.key,
+    label: field.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
+  };
+}
+function rowLevels(tables) {
+  const done = /* @__PURE__ */ new Set();
+  const levels = [];
+  let left = [...tables];
+  while (left.length) {
+    let ready = left.filter(
+      (t) => t.fields.every((f) => f.parityType !== "relation" || !f.relationTarget || f.relationTarget === t.token || done.has(f.relationTarget))
+    );
+    if (!ready.length) {
+      const optionalOnly = left.find(
+        (t) => t.fields.every(
+          (f) => f.parityType !== "relation" || !f.relationTarget || f.relationTarget === t.token || done.has(f.relationTarget) || !f.required
+        )
+      );
+      ready = [optionalOnly ?? left[0]];
+    }
+    for (const t of ready) done.add(t.token);
+    levels.push(ready);
+    left = left.filter((t) => !done.has(t.token));
+  }
+  return levels;
+}
+function deferredRelations(tables) {
+  const levelOf = /* @__PURE__ */ new Map();
+  rowLevels(tables).forEach((level, i) => level.forEach((t) => levelOf.set(t.token, i)));
+  const out = /* @__PURE__ */ new Map();
+  for (const t of tables) {
+    const mine = levelOf.get(t.token) ?? 0;
+    for (const f of t.fields) {
+      if (f.parityType !== "relation" || !f.relationTarget) continue;
+      if (f.relationTarget === t.token || (levelOf.get(f.relationTarget) ?? -1) >= mine) {
+        out.set(t.token, /* @__PURE__ */ new Set([...out.get(t.token) ?? [], f.key]));
+      }
+    }
+  }
+  return out;
+}
+function relationPatches(table, ids, deferred) {
+  if (!deferred?.size) return [];
+  const rel = new Map(table.fields.filter((f) => deferred.has(f.key)).map((f) => [f.key, f.relationTarget]));
+  const out = [];
+  for (const r of table.rows) {
+    const patch = {};
+    for (const [key, target] of rel) {
+      const v = r.values?.[key];
+      if (v === null || v === void 0) continue;
+      const idOf = (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);
+    }
+    if (Object.keys(patch).length) out.push({ op: "update", record_id: ids.get(`${table.token}.${r.key}`), patch: { ...patch, _actor: ACTOR } });
+  }
+  return out;
+}
+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 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;
+  };
+  const rows = table.rows.map((r) => {
+    const values = {};
+    for (const [key, value] of Object.entries(r.values ?? {})) {
+      if (derived.has(key) || deferred?.has(key) || value === null || value === void 0) continue;
+      const rel = relation.get(key);
+      if (!rel?.relationTarget) {
+        values[key] = value;
+        continue;
+      }
+      values[key] = Array.isArray(value) ? value.map((v) => idOf(rel.relationTarget, v)) : idOf(rel.relationTarget, value);
+    }
+    values["_actor"] = ACTOR;
+    return values;
+  });
+  return { rows, ids: table.rows.map((r) => ids.get(`${table.token}.${r.key}`)) };
+}
+function derivedFieldSpec(field) {
+  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 } : {}
+  };
+  return field.parityType === "rollup" ? { ...base, agg: field.agg, of: field.pick, ...field.filter ? { filter: field.filter } : {} } : { ...base, pick: field.pick };
+}
+function viewSpec(view, fieldIds = {}) {
+  const definition = { layout: view.kind };
+  const where = anyOfWhere(view.anyOf, fieldIds);
+  if (where) definition["where"] = where;
+  if (view.sorts?.length) definition["sorts"] = view.sorts;
+  if (view.isDefault) definition["is_default"] = true;
+  if (view.hiddenFields?.length) definition["presentation"] = { hiddenFields: view.hiddenFields };
+  switch (view.kind) {
+    case "kanban":
+      definition["group_field"] = view.groupBy;
+      if (view.swimlaneBy) definition["swimlane_field"] = view.swimlaneBy;
+      if (view.measure) definition["measure"] = view.measure;
+      break;
+    case "calendar":
+      definition["date_field"] = view.dateField;
+      break;
+    case "gallery":
+      definition["image_field"] = view.coverField;
+      break;
+    case "grid":
+      if (view.groupBy) {
+        definition["presentation"] = { ...definition["presentation"] ?? {}, grouping: { field: view.groupBy } };
+      }
+      break;
+    case "timeline":
+      definition["start_field"] = view.startField;
+      definition["end_field"] = view.endField;
+      if (view.groupBy) definition["group_field"] = view.groupBy;
+      break;
+  }
+  return { name: view.name, definition, ...view.filters ? { filters: view.filters } : {} };
+}
+function anyOfWhere(anyOf, fieldIds) {
+  const entries = Object.entries(anyOf ?? {}).filter(([, vals]) => vals.length);
+  if (!entries.length) return void 0;
+  return {
+    op: "and",
+    args: entries.map(([key, vals]) => {
+      const id = fieldIds[key];
+      if (!id) throw new Error(`The view filters on "${key}", which the install has no field id for.`);
+      return { op: "or", args: vals.map((v) => ({ op: "eq", args: [{ field: id }, { const: v }] })) };
+    })
+  };
+}
+function formulaFieldSpec(field) {
+  return {
+    key: field.key,
+    label: field.label,
+    type: "formula",
+    formula_text: field.formula,
+    ...field.unit ? { unit: field.unit } : {},
+    sensitivity: field.sensitivity,
+    context_policy: field.contextPolicy
+  };
+}
+function formulaOrder(table) {
+  const formulas = table.fields.filter((f) => f.parityType === "formula");
+  const out = [];
+  const left = [...formulas];
+  while (left.length) {
+    const i = left.findIndex((f) => !left.some((g) => g !== f && (f.formula ?? "").includes(`{${g.label}}`)));
+    out.push(...left.splice(i < 0 ? 0 : i, 1));
+  }
+  return out;
+}
+function question(q) {
+  return { field: q.fieldKey, ask: q.ask, ...q.help ? { help: q.help } : {}, ...q.required ? { required: true } : {} };
+}
+function formArgs(org, tableId, form) {
+  return {
+    p_organization_id: org,
+    p_table_id: tableId,
+    p_title: form.name,
+    p_questions: form.fields.map(question),
+    p_presentation: { submit_label: form.submitLabel, thank_you: { title: "Thank you", body: form.confirmation } },
+    p_submission_cap: null,
+    p_quarantine_rule_id: null,
+    p_notify_rule_id: null,
+    p_form_id: null,
+    p_slug: null
+  };
+}
+function bookingArgs(org, tableId, booking) {
+  const a = booking.availability;
+  return {
+    p_organization_id: org,
+    p_table_id: tableId,
+    p_title: booking.title,
+    p_questions: booking.questions.map(question),
+    p_availability: {
+      timezone: a.timezone,
+      slot_minutes: a.slotMinutes,
+      buffer_minutes: a.bufferMinutes,
+      lead_minutes: a.leadMinutes,
+      max_per_day: a.maxPerDay,
+      days: a.days,
+      windows: a.windows
+    },
+    p_presentation: {},
+    p_submission_cap: null,
+    p_quarantine_rule_id: null,
+    p_notify_rule_id: null,
+    p_form_id: null,
+    p_slug: booking.slug ?? null,
+    p_home_id: null
+  };
+}
+function dashboardBlocks(dashboard, tables) {
+  return dashboard.blocks.map((b) => ({
+    title: b.title,
+    kind: b.kind,
+    ...b.table && b.table !== dashboard.table ? { table_id: tables[b.table] } : {},
+    ...b.groupBy ? { group_by: b.groupBy } : {},
+    ...b.measures ? { measures: b.measures } : {},
+    ...b.bucket ? { bucket: b.bucket } : {},
+    ...b.filter ? { filter: b.filter } : {},
+    ...b.span ? { span: b.span } : {},
+    ...b.stateKey ? { state_key: b.stateKey } : {},
+    ...b.days ? { days: b.days } : {}
+  }));
+}
+function stageRulesSpec(rules) {
+  return {
+    stage_field: { key: rules.stageField },
+    ...rules.transitions ? { transitions: rules.transitions } : {},
+    ...rules.requires ? { requires: rules.requires } : {},
+    ...rules.limits ? { limits: rules.limits } : {},
+    ...rules.movesMessage ? { moves_message: rules.movesMessage } : {}
+  };
+}
+function documentBody(doc, fieldIds, businessName) {
+  return doc.body.replace(/\{\{\s*([a-zA-Z_][a-zA-Z0-9_]*)\s*\}\}/g, (whole, key) => {
+    if (key === "business") return businessName;
+    const id = fieldIds[key];
+    return id ? `{{field:${id}}}` : whole;
+  });
+}
+function rowActionList(actions, fieldIds) {
+  return actions.map(
+    (a) => a.actionKind === "agent" ? { name: a.name, kind: "agent", prompt: a.prompt, ...a.color ? { color: a.color } : {}, confirm: !!a.confirm } : {
+      name: a.name,
+      kind: "update",
+      ...a.color ? { color: a.color } : {},
+      confirm: !!a.confirm,
+      steps: (a.steps ?? []).map(
+        (s) => s.set === "value" ? { field: fieldIds[s.field] ?? s.field, set: "value", value: s.value } : { field: fieldIds[s.field] ?? s.field, set: "clear" }
+      )
+    }
+  );
+}
+function stageFieldOf(tables, table, stage) {
+  if (!stage) return null;
+  const t = tables.find((x) => x.token === table);
+  return t?.fields.find((f) => (f.parityType === "select" || f.parityType === "multi_select") && f.choices?.includes(stage))?.key ?? null;
+}
+function drillDownDashboard(drill, dimensions) {
+  const path = dimensions.find((d) => d.table === drill.table)?.paths?.find((p) => p.key === drill.path);
+  if (!path?.levels.length) throw new Error(`The drill-down "${drill.name}" names the path "${drill.path}", which the Dimensions of "${drill.table}" do not declare.`);
+  const [key, grain] = path.levels[0].split(":");
+  const block = { title: drill.name, kind: grain ? "line" : "bar", measures: [{ op: "count" }] };
+  if (grain) block["bucket"] = { key, by: grain };
+  else block["group_by"] = [key];
+  return { name: drill.name, blocks: [block] };
+}
+function digestSpec(digest, viewId) {
+  return {
+    name: digest.name,
+    saved_view_id: viewId,
+    cadence: digest.cadence,
+    ...digest.schedule ? { schedule: digest.schedule } : {},
+    channel: digest.channel ?? "in_app",
+    event_key: "records.changed"
+  };
+}
+function checklistSpec(checklist, tables, forms, documents) {
+  const trigger = checklist.trigger ?? { kind: "manual" };
+  return {
+    name: checklist.name,
+    about_table_id: tables[checklist.aboutTable],
+    roles: (checklist.roles ?? []).map((r) => ({ role: r.role, ...r.label ? { label: r.label } : {} })),
+    steps: checklist.steps.map((st) => {
+      const req = st.requires;
+      const requires = !req ? void 0 : req.kind === "form" ? { kind: "form", form_id: forms[req.form] } : req.kind === "document" ? { kind: "document", template_id: documents[req.document] } : req;
+      return {
+        ref: st.ref,
+        title: st.title,
+        ...st.role ? { role: st.role } : {},
+        ...st.dueDays !== void 0 ? { due_days: st.dueDays } : {},
+        ...st.dependsOn?.length ? { depends_on: st.dependsOn } : {},
+        ...requires ? { requires } : {}
+      };
+    }),
+    trigger: trigger.kind === "manual" ? { kind: "manual" } : trigger.kind === "record_created" ? { kind: "record_created", table_id: tables[trigger.table] } : { kind: "status_reached", table_id: tables[trigger.table], status: trigger.status }
+  };
+}
+function automationHeld(a) {
+  return `The automation "${a.name}" is held for lane 11: no store door runs automations yet, so a template carrying one is held, never installed without it.`;
+}
+function bookingColumnsProblem(tables, booking) {
+  const t = tables.find((x) => x.token === booking.table);
+  if (!t) return `The booking page "${booking.title}" takes bookings into "${booking.table}", which the template does not have.`;
+  const slot = t.fields.find((f) => f.key === "slot");
+  if (!slot) {
+    return `The booking page "${booking.title}" writes each booked time into a column keyed "slot" on "${t.name}", and that table has none. Declare it (a required date-and-time, like "Visit time") so the seeded rows carry it; the door would add it after the rows and leave every seeded row missing a required value.`;
+  }
+  if (!slot.required) return `"${t.name}"'s "slot" column holds the booked time and the door requires it; declare it required and seed it on every row.`;
+  const missing = t.rows.filter((r) => r.values?.["slot"] === void 0 || r.values?.["slot"] === null || r.values?.["slot"] === "");
+  if (missing.length) return `"${t.name}" has ${missing.length} seeded row(s) with no "slot" (${missing[0].key}); the booking page makes it required, so those rows could never be edited.`;
+  for (const [key, label] of [["status", "Status"], ["booked_with", "With"]]) {
+    if (t.fields.some((f) => f.key === key)) continue;
+    const clash = t.fields.find((f) => f.label.trim().toLowerCase() === label.toLowerCase());
+    if (clash) return `The booking page adds a "${label}" column to "${t.name}", which already has one ("${clash.key}"). Rename that column, or key it "${key}".`;
+  }
+  const status = t.fields.find((f) => f.key === "status");
+  const words = new Set((status?.choices ?? []).map((c) => c.toLowerCase()));
+  if (status && (!words.has("booked") || !words.has("cancelled"))) {
+    return `The booking page writes "booked" and "cancelled" into "${t.name}"'s status, and its choices do not hold both.`;
+  }
+  return null;
+}
+function notificationParts(n, stageField) {
+  const filters = {};
+  if (n.when.event === "stage_entered" && n.when.stage && stageField) filters[stageField] = n.when.stage;
+  return {
+    view: { name: n.name, definition: { layout: "grid" }, filters },
+    subscription: { name: n.name, cadence: "instant", channel: n.channel, event_key: "records.changed" }
+  };
+}
+function portalArgs(org, portal, tables) {
+  return {
+    p_organization_id: org,
+    p_title: portal.title,
+    p_client_table_id: tables[portal.clientTable],
+    p_tables: portal.tables.map((t) => ({
+      table_id: tables[t.table],
+      names_via: t.namesVia,
+      visible_fields: t.visibleFields,
+      editable_fields: t.editableFields ?? [],
+      comments: !!t.comments
+    })),
+    p_portal_id: null,
+    p_slug: portal.slug ?? null,
+    p_sign_in_method: "magic_link",
+    p_config: null
+  };
+}
+
+// src/templates/types.ts
+var RELATIVE_DATE = /^@(today|(?:last-|next-)?(?:mon|tue|wed|thu|fri|sat|sun))(?:([+-])(\d{1,4})([dwmyb]))?(~b)?(?: ([01]\d|2[0-3]):([0-5]\d))?$/;
+var SHARED_BLOCKS = {
+  team_member: {
+    table: "team_member",
+    name: "Team",
+    labelSingular: "Team member",
+    labelPlural: "Team",
+    titleField: "full_name",
+    describes: "The people on the business's own team \u2014 who is assigned, who answers, who signs.",
+    fields: [
+      { key: "full_name", label: "Name", parityType: "text", sensitivity: "internal", contextPolicy: "include", required: true, sameAs: ["name", "full name", "employee name", "staff name"] },
+      { key: "role", label: "Role", parityType: "text", sensitivity: "internal", contextPolicy: "include", sameAs: ["role", "job title", "title", "position"] },
+      { key: "work_email", label: "Work email", parityType: "email", sensitivity: "confidential", contextPolicy: "summarize", sameAs: ["email", "work email", "email address"] },
+      { key: "mobile", label: "Mobile", parityType: "phone", sensitivity: "confidential", contextPolicy: "exclude", sameAs: ["phone", "mobile", "work phone", "cell", "phone number"] },
+      { key: "start_date", label: "Start date", parityType: "datetime", sensitivity: "internal", contextPolicy: "include", sameAs: ["start date", "hire date", "started", "date hired"] }
+    ],
+    copyThreshold: 3
+  }
+};
+var SHARED_BLOCK_IDS = Object.keys(SHARED_BLOCKS);
+
+// src/templates/confidential.ts
+var TABLE_KERNEL_ID = "11111111-0000-4000-8000-000000000001";
+function membersAddRowsSteps(spec, tableRef) {
+  return (spec.membersAddRows ?? []).map((token) => ({
+    label: `members_add_rows.${token}`,
+    door: "record_change_many",
+    args: {
+      p_organization_id: "${org}",
+      p_table_id: TABLE_KERNEL_ID,
+      p_changes: [{ op: "update", record_id: tableRef(token), patch: { members_add_rows: true } }]
+    }
+  }));
+}
+
+// src/templates/extras.ts
+function tablesOf(spec) {
+  return new Map((spec.tables ?? []).map((t) => [t.token, t]));
+}
+function planBinding(b, tables) {
+  const { rowIndex, ...rest } = b;
+  if (rowIndex === void 0) return rest;
+  const row = tables.get(b.table)?.rows?.[rowIndex];
+  if (!row) throw new Error(`The binding points at seed row ${rowIndex} of "${b.table}", which has no such row.`);
+  return { ...rest, rowKey: row.key };
+}
+function compileHostExtras(spec) {
+  const tables = tablesOf(spec);
+  const agentBindings = /* @__PURE__ */ new Map();
+  for (const v of spec.agent?.variables ?? []) if (v.binding) agentBindings.set(v.name, planBinding(v.binding, tables));
+  const extras = {};
+  if (spec.extraAgents?.length) {
+    extras.extraAgents = spec.extraAgents.map((a) => ({
+      key: a.key,
+      platformAgent: a.platformAgent,
+      name: a.name,
+      bindings: a.variables.map((v) => ({ variable: v.name, describes: v.describes, binding: planBinding(v.binding, tables) })),
+      ...a.tryIt ? { tryIt: a.tryIt } : {}
+    }));
+  }
+  if (spec.workflows?.length) extras.workflows = spec.workflows;
+  return { agentBindings, extras };
+}
+
+// src/store.generated.ts
+var PARITY_FIELD_TYPES = [
+  { parity_type: "attachment", behavior: "relation", made_of: "REC-31: a File record reached through a relation, target the kernel `File` Table" },
+  { parity_type: "checkbox", behavior: "boolean", made_of: "a ticked or unticked answer, stored as a REAL boolean \u2014 and a record that never answered holds neither, so filters and group-by see three states, not two" },
+  { parity_type: "currency", behavior: "range", made_of: "FLD-N-1: a number whose UNIT is the currency and whose format is currency \u2014 on the Field, never in presentation" },
+  { parity_type: "datetime", behavior: "range", made_of: "a range of kind date or datetime \u2014 the dated modifier says the VALUES are dated, which is a different question" },
+  { parity_type: "email", behavior: "text", made_of: "text whose format is email" },
+  { parity_type: "formula", behavior: "formula", made_of: "FLD-9: a declared computation, on read or on write, evaluated by custom.rule_eval" },
+  { parity_type: "lookup", behavior: "formula", made_of: "a Value read THROUGH a relation \u2014 config.via names the relation field, config.pick the Value on the far side" },
+  { parity_type: "member", behavior: "relation", made_of: "a person: a relation whose target is the kernel `Person` Table" },
+  { parity_type: "multi_select", behavior: "list", made_of: "many choices from the same Table \u2014 the multi modifier, never a second behaviour" },
+  { parity_type: "percent", behavior: "range", made_of: "a number whose unit is % and whose format is percent" },
+  { parity_type: "phone", behavior: "text", made_of: "text whose format is phone" },
+  { parity_type: "rollup", behavior: "formula", made_of: "an aggregate ALONG a relation \u2014 config.via, config.of, config.agg; far-side ids are taken DISTINCT, so nothing is counted twice" },
+  { parity_type: "select", behavior: "list", made_of: "one choice from a Table shown as a list (FLD-5/FLD-6)" },
+  { parity_type: "url", behavior: "text", made_of: "text whose format is url, with the pattern Rule that makes the format enforceable" }
+];
+var DECLARABLE_FIELD_KINDS = [
+  { kind: "address", behavior: "text", parity: false, made_of: "P4: behaviour text, format address; the value is {street, city, region, postal_code, country}, every part optional, at least one filled" },
+  { kind: "attachment", behavior: "relation", parity: true, made_of: "REC-31: a File record reached through a relation, target the kernel `File` Table" },
+  { kind: "barcode", behavior: "text", parity: false, made_of: "P4: behaviour text, format barcode; one printable line a scanner reads, config.symbology optional (custom.barcode_symbologies()), EAN/UPC digits and check digit enforced" },
+  { kind: "checkbox", behavior: "boolean", parity: true, made_of: "a ticked or unticked answer, stored as a REAL boolean \u2014 and a record that never answered holds neither, so filters and group-by see three states, not two" },
+  { kind: "count", behavior: "formula", parity: false, made_of: "P4: a roll-up whose config.agg is count, with format count: how many records a many-relation points at, as a number of its own" },
+  { kind: "created_by", behavior: "formula", parity: false, made_of: "P4: a formula Field whose config.system is created_by: who made the record, {id, name}, filled by the store from the record's writer on read and never typed" },
+  { kind: "currency", behavior: "range", parity: true, made_of: "FLD-N-1: a number whose UNIT is the currency and whose format is currency \u2014 on the Field, never in presentation" },
+  { kind: "datetime", behavior: "range", parity: true, made_of: "a range of kind date or datetime \u2014 the dated modifier says the VALUES are dated, which is a different question" },
+  { kind: "duration", behavior: "range", parity: false, made_of: "P4: behaviour range, format duration, unit seconds; a length of time kept as seconds, never below zero" },
+  { kind: "email", behavior: "text", parity: true, made_of: "text whose format is email" },
+  { kind: "entity_reference", behavior: "relation", parity: false, made_of: "SC-R / P12: a relation whose target mode is any (REL-8), restricted by config.allowed_types to the platform kinds it may name (custom.entity_reference_kinds() \u2014 agents, notes, web sites, workbooks, datasets, conversations \u2026); each value is {token, id}, the edge a platform.associations row record \u2192 <token>. File and Person stay relations to their kernel Tables" },
+  { kind: "formula", behavior: "formula", parity: true, made_of: "FLD-9: a declared computation, on read or on write, evaluated by custom.rule_eval" },
+  { kind: "long_text", behavior: "text", parity: false, made_of: "behaviour text with format long and config.multiline, for several lines rather than one" },
+  { kind: "lookup", behavior: "formula", parity: true, made_of: "a Value read THROUGH a relation \u2014 config.via names the relation field, config.pick the Value on the far side" },
+  { kind: "member", behavior: "relation", parity: true, made_of: "a person: a relation whose target is the kernel `Person` Table" },
+  { kind: "modified_by", behavior: "formula", parity: false, made_of: "P4: a formula Field whose config.system is modified_by: who last changed the record, {id, name}, filled by the store on read and never typed" },
+  { kind: "multi_select", behavior: "list", parity: true, made_of: "many choices from the same Table \u2014 the multi modifier, never a second behaviour" },
+  { kind: "number", behavior: "range", parity: false, made_of: "a plain number: behaviour range with no date kind and neither the currency nor the percent format" },
+  { kind: "percent", behavior: "range", parity: true, made_of: "a number whose unit is % and whose format is percent" },
+  { kind: "phone", behavior: "text", parity: true, made_of: "text whose format is phone" },
+  { kind: "rating", behavior: "range", parity: false, made_of: "P4: behaviour range, format rating; a whole number of stars from 0 to its max Rule (1 to 10, default 5), shown as stars" },
+  { kind: "relation", behavior: "relation", parity: false, made_of: "REL / FLD-11: a relation a person aims themselves \u2014 relation_target names a Table of this organization, and it is a BEHAVIOUR, never a parity type of its own" },
+  { kind: "rich_text", behavior: "text", parity: false, made_of: "P4: behaviour text, format rich_text; Markdown with no raw HTML and no script links, shown formatted" },
+  { kind: "rollup", behavior: "formula", parity: true, made_of: "an aggregate ALONG a relation \u2014 config.via, config.of, config.agg; far-side ids are taken DISTINCT, so nothing is counted twice" },
+  { kind: "select", behavior: "list", parity: true, made_of: "one choice from a Table shown as a list (FLD-5/FLD-6)" },
+  { kind: "signature", behavior: "text", parity: false, made_of: "VAL-10: behaviour text whose format is signature \u2014 the one shape custom.doc_sign accepts, sealed by custom.doc_signature_write and checked by custom.doc_signature_intact" },
+  { kind: "status", behavior: "list", parity: false, made_of: "P4: a single-choice list with format status; config.status_groups puts each choice key in todo, in_progress or done (Notion's Status)" },
+  { kind: "text", behavior: "text", parity: false, made_of: "plain text: behaviour text with no format \u2014 it carries no parity type, which is exactly what custom.parity_type answers for it" },
+  { kind: "url", behavior: "text", parity: true, made_of: "text whose format is url, with the pattern Rule that makes the format enforceable" }
+];
+var STORE_DOORS = [
+  { name: "absence_reasons", args: "", returns: "text[]", security: "invoker" },
+  { name: "action_declare", args: "p_organization_id uuid, p_table_id uuid, p_actions jsonb", returns: "jsonb", security: "definer" },
+  { name: "action_run", args: "p_organization_id uuid, p_action_id uuid, p_record_ids uuid[]", returns: "jsonb", security: "definer" },
+  { name: "actor_vocabulary", args: "", returns: "text[]", security: "invoker" },
+  { name: "actor_word", args: "p_declared text", returns: "text", security: "invoker" },
+  { name: "addressed_cap", args: "p_user_id uuid, p_type text, p_id uuid, p_organization_id uuid DEFAULT NULL::uuid, p_table_id uuid DEFAULT NULL::uuid", returns: "permission_level", security: "definer" },
+  { name: "addressed_cap_specific", args: "p_user_id uuid, p_type text, p_id uuid, p_organization_id uuid DEFAULT NULL::uuid, p_table_id uuid DEFAULT NULL::uuid", returns: "permission_level", security: "definer" },
+  { name: "agent_change_approval", args: "p_organization uuid, p_conversation uuid DEFAULT NULL::uuid, p_table uuid DEFAULT NULL::uuid", returns: "jsonb", security: "definer" },
+  { name: "agent_change_trust", args: "p_organization_id uuid, p_approval_id uuid", returns: "jsonb", security: "definer" },
+  { name: "agent_context", args: "p_organization_id uuid, p_table_id uuid, p_limit integer DEFAULT 50", returns: "jsonb", security: "invoker" },
+  { name: "agent_context_value", args: "p_doc jsonb, p_key text, p_type text, p_organization_id uuid, p_record_id uuid, p_cap bigint", returns: "jsonb", security: "invoker" },
+  { name: "agent_context_value_cap", args: "p_organization_id uuid", returns: "bigint", security: "invoker" },
+  { name: "agent_table_claim", args: "p_organization uuid, p_table uuid, p_conversation uuid DEFAULT NULL::uuid", returns: "void", security: "definer" },
+  { name: "agg_assert_key", args: "p_key text", returns: "text", security: "invoker" },
+  { name: "agg_bucket_ordinal", args: "p_by text, p_window_from timestamp without time zone, p_at timestamp without time zone, p_week_start text", returns: "integer", security: "invoker" },
+  { name: "agg_buckets", args: "", returns: "text[]", security: "invoker" },
+  { name: "agg_cadence_normalize", args: "p_cadence text", returns: "text", security: "invoker" },
+  { name: "agg_calendar", args: "p_organization_id uuid", returns: "jsonb", security: "invoker" },
+  { name: "agg_compare_kinds", args: "", returns: "text[]", security: "invoker" },
+  { name: "agg_compare_windows", args: "p_organization_id uuid, p_compare jsonb, p_bucket jsonb DEFAULT NULL::jsonb", returns: "jsonb", security: "invoker" },
+  { name: "agg_deliver", args: "p_organization_id uuid, p_rule_id uuid, p_record_id uuid, p_channel text, p_recipient_user_id uuid, p_event_key text, p_subject text, p_body text, p_payload jsonb DEFAULT '{}'::jsonb, p_dedupe_suffix text DEFAULT NULL::text", returns: "uuid", security: "invoker" },
+  { name: "agg_deliver_quietly", args: "p_organization_id uuid, p_rule_id uuid, p_subject_id uuid, p_channel text, p_recipient_user_id uuid, p_event_key text, p_subject text, p_body text, p_payload jsonb, p_quiet_hours jsonb, p_link text, p_dedupe_suffix text DEFAULT NULL::text", returns: "uuid", security: "invoker" },
+  { name: "agg_delta", args: "p_current jsonb, p_prior jsonb", returns: "jsonb", security: "invoker" },
+  { name: "agg_digest_assemble", args: "p_organization_id uuid, p_rule_id uuid, p_since timestamp with time zone DEFAULT NULL::timestamp with time zone, p_until timestamp with time zone DEFAULT NULL::timestamp with time zone", returns: "jsonb", security: "invoker" },
+  { name: "agg_digest_due_at", args: "p_cadence text, p_schedule text, p_quiet jsonb, p_after timestamp with time zone", returns: "timestamp with time zone", security: "invoker" },
+  { name: "agg_digest_judged_at", args: "p_organization_id uuid, p_rule_id uuid", returns: "timestamp with time zone", security: "invoker" },
+  { name: "agg_digest_run", args: "p_organization_id uuid, p_rule_id uuid DEFAULT NULL::uuid, p_since timestamp with time zone DEFAULT NULL::timestamp with time zone", returns: "integer", security: "invoker" },
+  { name: "agg_digest_run_at", args: "p_organization_id uuid, p_rule_id uuid, p_since timestamp with time zone, p_now timestamp with time zone", returns: "integer", security: "invoker" },
+  { name: "agg_digest_tick", args: "", returns: "integer", security: "invoker" },
+  { name: "agg_digest_tick_at", args: "p_now timestamp with time zone, p_organization_id uuid DEFAULT NULL::uuid", returns: "integer", security: "invoker" },
+  { name: "agg_explain", args: "p_organization_id uuid, p_table_id uuid, p_group_by jsonb DEFAULT '[]'::jsonb, p_measures jsonb DEFAULT '[]'::jsonb, p_bucket jsonb DEFAULT NULL::jsonb, p_filter jsonb DEFAULT '{}'::jsonb, p_required text DEFAULT 'viewer'::text", returns: "jsonb", security: "definer" },
+  { name: "agg_field_kind", args: "p_organization_id uuid, p_table_id uuid, p_key text", returns: "text", security: "invoker" },
+  { name: "agg_field_value_sql", args: "p_organization_id uuid, p_table_id uuid, p_key text", returns: "text", security: "invoker" },
+  { name: "agg_fields_readable_assert", args: "p_organization_id uuid, p_table_id uuid, p_keys text[], p_required text DEFAULT 'viewer'::text", returns: "void", security: "invoker" },
+  { name: "agg_last_digest_at", args: "p_organization_id uuid, p_rule_id uuid", returns: "timestamp with time zone", security: "invoker" },
+  { name: "agg_local_label", args: "p_local timestamp without time zone, p_tz text", returns: "text", security: "invoker" },
+  { name: "agg_moment_sql", args: "p_key text, p_tz text", returns: "text", security: "invoker" },
+  { name: "agg_operations", args: "", returns: "text[]", security: "invoker" },
+  { name: "agg_parse_moment", args: "p_raw text, p_tz text, p_what text", returns: "timestamp with time zone", security: "invoker" },
+  { name: "agg_period_start", args: "p_local timestamp without time zone, p_by text, p_week_start text DEFAULT 'monday'::text", returns: "timestamp without time zone", security: "invoker" },
+  { name: "agg_period_step", args: "p_by text", returns: "interval", security: "invoker" },
+  { name: "agg_quiet_until", args: "p_quiet jsonb, p_at timestamp with time zone", returns: "timestamp with time zone", security: "invoker" },
+  { name: "agg_record_name", args: "p_organization_id uuid, p_record_id uuid, p_state jsonb DEFAULT NULL::jsonb", returns: "text", security: "invoker" },
+  { name: "agg_sql", args: "p_organization_id uuid, p_table_id uuid, p_group_by jsonb DEFAULT '[]'::jsonb, p_measures jsonb DEFAULT '[]'::jsonb, p_bucket jsonb DEFAULT NULL::jsonb, p_filter jsonb DEFAULT '{}'::jsonb, p_limit integer DEFAULT 200, p_required text DEFAULT 'viewer'::text, p_window jsonb DEFAULT NULL::jsonb, p_search text DEFAULT NULL::text, p_time_zone text DEFAULT NULL::text", returns: "text", security: "invoker" },
+  { name: "agg_subscription_cadences", args: "", returns: "text[]", security: "invoker" },
+  { name: "agg_subscription_fire", args: "p_organization_id uuid, p_record_id uuid, p_table_id uuid DEFAULT NULL::uuid, p_changed_field_ids jsonb DEFAULT '[]'::jsonb", returns: "integer", security: "invoker" },
+  { name: "agg_subscription_fire_entered", args: "p_organization_id uuid, p_record_id uuid, p_table_id uuid DEFAULT NULL::uuid, p_since timestamp with time zone DEFAULT NULL::timestamp with time zone", returns: "integer", security: "invoker" },
+  { name: "agg_subscription_tick", args: "p_window interval DEFAULT '00:15:00'::interval", returns: "integer", security: "invoker" },
+  { name: "agg_subscriptions", args: "p_organization_id uuid, p_saved_view_id uuid DEFAULT NULL::uuid, p_cadence text DEFAULT NULL::text", returns: "TABLE(rule_id uuid, saved_view_id uuid, table_id uuid, cadence text, schedule text, quiet_hours jsonb, channel text, recipient_user_id uuid, event_key text, name text)", security: "invoker" },
+  { name: "agg_value_sql", args: "p_key text", returns: "text", security: "invoker" },
+  { name: "agg_value_text", args: "p_value jsonb", returns: "text", security: "invoker" },
+  { name: "agg_view_admits", args: "p_organization_id uuid, p_saved_view_id uuid, p_record_id uuid", returns: "boolean", security: "invoker" },
+  { name: "agg_view_admits_state", args: "p_definition jsonb, p_state jsonb", returns: "boolean", security: "invoker" },
+  { name: "agg_withheld_marker", args: "p_organization_id uuid, p_table_id uuid, p_key text, p_required text DEFAULT 'viewer'::text", returns: "jsonb", security: "invoker" },
+  { name: "agg_zero", args: "p_measures jsonb", returns: "jsonb", security: "invoker" },
+  { name: "anon_capture", args: "p_organization_id uuid, p_client_key text, p_table_id uuid, p_payload jsonb, p_device text DEFAULT NULL::text, p_captured_at timestamp with time zone DEFAULT NULL::timestamp with time zone", returns: "uuid", security: "definer" },
+  { name: "anon_clear", args: "p_organization_id uuid, p_submission_id uuid", returns: "uuid", security: "definer" },
+  { name: "anon_inbound_land", args: "p_address text, p_secret text, p_payload jsonb, p_raw_payload jsonb DEFAULT '{}'::jsonb, p_client_key text DEFAULT NULL::text", returns: "uuid", security: "definer" },
+  { name: "anon_publish", args: "p_organization_id uuid, p_form_id uuid, p_published boolean DEFAULT true", returns: "timestamp with time zone", security: "definer" },
+  { name: "anon_rate_take", args: "p_organization_id uuid, p_form_id uuid, p_bucket text, p_token_id uuid DEFAULT NULL::uuid", returns: "integer", security: "definer" },
+  { name: "anon_submissions", args: "p_organization_id uuid, p_table_id uuid DEFAULT NULL::uuid, p_state text DEFAULT NULL::text, p_limit integer DEFAULT 100, p_offset integer DEFAULT 0", returns: "TABLE(id uuid, form_id uuid, inbound_id uuid, table_id uuid, source text, state text, payload jsonb, raw_payload jsonb, client_key text, record_id uuid, remote_origin text, rejection_reason text, created_at timestamp with time zone, cleared_at timestamp with time zone)", security: "definer" },
+  { name: "anon_token_issue", args: "p_organization_id uuid, p_mode text, p_allowed_origins jsonb, p_form_id uuid DEFAULT NULL::uuid, p_saved_view_id uuid DEFAULT NULL::uuid, p_record_id uuid DEFAULT NULL::uuid, p_expires_at timestamp with time zone DEFAULT NULL::timestamp with time zone", returns: "TABLE(token_id uuid, secret text)", security: "definer" },
+  { name: "anon_token_revoke", args: "p_organization_id uuid, p_token_id uuid", returns: "boolean", security: "definer" },
+  { name: "anon_token_verify", args: "p_secret text, p_origin text, p_required_mode text", returns: "TABLE(token_id uuid, organization_id uuid, form_id uuid, saved_view_id uuid, record_id uuid, mode text)", security: "definer" },
+  { name: "anon_write", args: "p_secret text, p_origin text, p_payload jsonb, p_client_key text DEFAULT NULL::text, p_raw_payload jsonb DEFAULT '{}'::jsonb", returns: "uuid", security: "definer" },
+  { name: "applicable_fields", args: "p_organization_id uuid, p_table_id uuid, p_record_type text DEFAULT NULL::text", returns: "SETOF custom.record", security: "definer" },
+  { name: "archive_event_of", args: "p_organization_id uuid, p_record_id uuid", returns: "history.migration_log", security: "definer" },
+  { name: "archived_tables_everywhere", args: "p_lane text DEFAULT 'org'::text, p_limit integer DEFAULT 100, p_offset integer DEFAULT 0, p_sort text DEFAULT 'archived_at'::text, p_desc boolean DEFAULT true", returns: "jsonb", security: "definer" },
+  { name: "assert_client_may_change", args: "p_organization_id uuid, p_subject_id uuid, p_door text, p_required permission_level DEFAULT 'editor'::permission_level, p_subject_word text DEFAULT 'record'::text", returns: "void", security: "invoker" },
+  { name: "assert_client_may_open", args: "p_organization_id uuid, p_subject_id uuid, p_door text, p_required permission_level DEFAULT 'viewer'::permission_level, p_subject_word text DEFAULT 'record'::text", returns: "void", security: "invoker" },
+  { name: "assert_client_may_reach", args: "p_organization_id uuid, p_door text", returns: "void", security: "invoker" },
+  { name: "assert_columns_are_defined", args: "p_organization_id uuid, p_record_id uuid, p_patch jsonb", returns: "void", security: "definer" },
+  { name: "assert_entity_door", args: "p_organization_id uuid, p_door text", returns: "void", security: "definer" },
+  { name: "assert_entity_is_organization_scoped", args: "p_token text, p_label text, p_scoped boolean", returns: "void", security: "invoker" },
+  { name: "assert_may_know_table", args: "p_organization_id uuid, p_table_id uuid, p_door text", returns: "void", security: "invoker" },
+  { name: "assert_organization_admin", args: "p_organization_id uuid, p_door text, p_what text", returns: "void", security: "invoker" },
+  { name: "assert_organization_wall", args: "p_kind text, p_organization_id uuid, p_row jsonb", returns: "void", security: "invoker" },
+  { name: "assert_scope_door", args: "p_organization_id uuid, p_door text", returns: "void", security: "definer" },
+  { name: "assert_store_door", args: "p_organization_id uuid, p_door text", returns: "void", security: "invoker" },
+  { name: "autonumber_backfill", args: "p_organization_id uuid, p_field_id uuid", returns: "jsonb", security: "definer" },
+  { name: "barcode_symbologies", args: "", returns: "text[]", security: "invoker" },
+  { name: "booking_cancel", args: "p_booking_ref text, p_origin text DEFAULT NULL::text", returns: "TABLE(booking_ref text, record_id uuid, slot_key text, state text, message text)", security: "definer" },
+  { name: "booking_confirm", args: "p_form_id uuid, p_hold_id uuid, p_origin text, p_payload jsonb, p_bucket text, p_honeypot text DEFAULT NULL::text, p_client_key text DEFAULT NULL::text", returns: "TABLE(booking_ref text, record_id uuid, submission_id uuid, slot_key text, slot_at timestamp with time zone, state text, message text)", security: "definer" },
+  { name: "booking_declare", args: "p_organization_id uuid, p_table_id uuid, p_title text, p_questions jsonb, p_availability jsonb DEFAULT '{}'::jsonb, p_presentation jsonb DEFAULT '{}'::jsonb, p_submission_cap integer DEFAULT NULL::integer, p_quarantine_rule_id uuid DEFAULT NULL::uuid, p_notify_rule_id uuid DEFAULT NULL::uuid, p_form_id uuid DEFAULT NULL::uuid, p_slug text DEFAULT NULL::text, p_home_id uuid DEFAULT NULL::uuid", returns: "jsonb", security: "definer" },
+  { name: "booking_hold", args: "p_form_id uuid, p_slot_key text, p_origin text, p_bucket text, p_client_key text DEFAULT NULL::text", returns: "TABLE(hold_id uuid, slot_key text, expires_at timestamp with time zone, member_user_id uuid, state text, message text)", security: "definer" },
+  { name: "booking_manage", args: "p_booking_ref text, p_days integer DEFAULT NULL::integer", returns: "TABLE(booking_ref text, form_id uuid, title text, slot_key text, slot_at timestamp with time zone, status text, slots jsonb, availability jsonb, state text, message text)", security: "definer" },
+  { name: "booking_notify", args: "p_organization_id uuid, p_form_id uuid, p_record_id uuid, p_submission_id uuid, p_event text, p_when text", returns: "uuid", security: "invoker" },
+  { name: "booking_public", args: "p_form_id uuid, p_days integer DEFAULT NULL::integer", returns: "TABLE(form_id uuid, organization_id uuid, table_id uuid, title text, presentation jsonb, fields jsonb, honeypot_key text, availability jsonb, slots jsonb, state text, message text)", security: "definer" },
+  { name: "booking_reschedule", args: "p_booking_ref text, p_slot_key text, p_origin text, p_bucket text DEFAULT NULL::text", returns: "TABLE(booking_ref text, record_id uuid, slot_key text, slot_at timestamp with time zone, state text, message text)", security: "definer" },
+  { name: "bookings", args: "p_organization_id uuid, p_table_id uuid DEFAULT NULL::uuid", returns: "TABLE(form_id uuid, table_id uuid, title text, slug text, published_at timestamp with time zone, closed_at timestamp with time zone, slot_minutes integer, timezone text, slot_table_id uuid, booked bigint, cancelled bigint, upcoming bigint, held bigint, next_at timestamp with time zone, state text)", security: "definer" },
+  { name: "bump_epoch", args: "p_entity_type text, p_entity_id uuid, p_organization_id uuid DEFAULT NULL::uuid", returns: "bigint", security: "definer" },
+  { name: "cache_lookup", args: "p_container_type text, p_container_id uuid, p_item_type text, p_item_id uuid", returns: "permission_level", security: "definer" },
+  { name: "caller_role", args: "", returns: "name", security: "invoker" },
+  { name: "capture_open", args: "p_organization_id uuid, p_sheet_id uuid", returns: "TABLE(sheet_id uuid, organization_id uuid, table_id uuid, title text, presentation jsonb, fields jsonb, state text, may_capture boolean, message text)", security: "definer" },
+  { name: "capture_publish", args: "p_organization_id uuid, p_sheet_id uuid, p_open boolean DEFAULT true", returns: "timestamp with time zone", security: "definer" },
+  { name: "capture_sheet_declare", args: "p_organization_id uuid, p_table_id uuid, p_title text, p_questions jsonb, p_presentation jsonb DEFAULT '{}'::jsonb, p_sheet_id uuid DEFAULT NULL::uuid, p_notify_rule_id uuid DEFAULT NULL::uuid", returns: "uuid", security: "definer" },
+  { name: "capture_sheets", args: "p_organization_id uuid, p_table_id uuid DEFAULT NULL::uuid", returns: "TABLE(sheet_id uuid, table_id uuid, title text, slug text, state text, opened_at timestamp with time zone, captures bigint, replays bigint, last_capture_at timestamp with time zone, presentation jsonb)", security: "definer" },
+  { name: "capture_submit", args: "p_organization_id uuid, p_sheet_id uuid, p_client_key text, p_payload jsonb, p_files jsonb DEFAULT '[]'::jsonb, p_device text DEFAULT NULL::text, p_captured_at timestamp with time zone DEFAULT NULL::timestamp with time zone, p_location jsonb DEFAULT NULL::jsonb", returns: "TABLE(record_id uuid, state text, message text, replay boolean, file_ids uuid[])", security: "definer" },
+  { name: "carry_unchanged_value_stamps", args: "p_old jsonb, p_new jsonb", returns: "jsonb", security: "invoker" },
+  { name: "carrying_edges_in", args: "p_organization_id uuid", returns: "TABLE(container_type text, container_id uuid, item_type text, item_id uuid, conveys_max permission_level)", security: "definer" },
+  { name: "carrying_edges_of", args: "p_item_type text, p_item_id uuid", returns: "TABLE(container_type text, container_id uuid, conveys_max permission_level)", security: "definer" },
+  { name: "checklist_declare", args: "p_organization_id uuid, p_spec jsonb, p_template_id uuid DEFAULT NULL::uuid", returns: "jsonb", security: "definer" },
+  { name: "checklist_refusal", args: "p_spec jsonb", returns: "text", security: "invoker" },
+  { name: "checklist_run", args: "p_organization_id uuid, p_run_id uuid", returns: "TABLE(step_id uuid, step_order integer, ref text, title text, role text, assignee_name text, assignee_user_id uuid, due_on timestamp with time zone, due_state text, status text, finished boolean, requires text, requires_key text, requires_label text, requires_id uuid, evidence jsonb, blocked_by text[], may_complete boolean, refusal text)", security: "definer" },
+  { name: "checklist_runs", args: "p_organization_id uuid, p_about_table_id uuid DEFAULT NULL::uuid, p_about_record_id uuid DEFAULT NULL::uuid, p_include_closed boolean DEFAULT true, p_limit integer DEFAULT 100", returns: "TABLE(run_id uuid, name text, template_id uuid, template text, about_record_id uuid, about text, about_table_id uuid, started_at timestamp with time zone, started_by uuid, origin text, step_count integer, done integer, overdue integer, next_step text, next_due timestamp with time zone, closed_at timestamp with time zone)", security: "definer" },
+  { name: "checklist_start", args: "p_organization_id uuid, p_template_id uuid, p_about_record_id uuid DEFAULT NULL::uuid, p_roles jsonb DEFAULT '{}'::jsonb, p_starting_at timestamp with time zone DEFAULT NULL::timestamp with time zone", returns: "jsonb", security: "definer" },
+  { name: "checklist_step_complete", args: "p_organization_id uuid, p_step_id uuid, p_evidence jsonb DEFAULT '{}'::jsonb", returns: "jsonb", security: "definer" },
+  { name: "checklist_step_refusal", args: "p_organization_id uuid, p_step_id uuid", returns: "text", security: "definer" },
+  { name: "checklist_steps_table", args: "p_organization_id uuid", returns: "uuid", security: "definer" },
+  { name: "checklist_template_shape", args: "p_organization_id uuid, p_template_id uuid", returns: "jsonb", security: "definer" },
+  { name: "checklist_templates", args: "p_organization_id uuid, p_about_table_id uuid DEFAULT NULL::uuid, p_limit integer DEFAULT 100", returns: "TABLE(template_id uuid, name text, about_table_id uuid, about_table text, steps integer, roles integer, trigger_kind text, trigger_status text, open_runs integer, total_runs integer, updated_at timestamp with time zone)", security: "definer" },
+  { name: "checklist_templates_archived", args: "p_organization_id uuid, p_about_table_id uuid DEFAULT NULL::uuid, p_limit integer DEFAULT 100", returns: "TABLE(template_id uuid, name text, about_table_id uuid, about_table text, steps integer, archived_at timestamp with time zone, archived_by uuid, table_archived boolean)", security: "definer" },
+  { name: "choice_census", args: "p_organization_id uuid, p_table_id uuid DEFAULT NULL::uuid", returns: "jsonb", security: "definer" },
+  { name: "choice_field_map", args: "p_organization_id uuid, p_table_id uuid", returns: "jsonb", security: "invoker" },
+  { name: "choice_filter_normalize", args: "p_map jsonb, p_filter jsonb", returns: "jsonb", security: "invoker" },
+  { name: "choice_key_for", args: "p_organization_id uuid, p_options_table_id uuid, p_title text, p_exclude uuid DEFAULT NULL::uuid", returns: "text", security: "invoker" },
+  { name: "choice_key_of", args: "p_field jsonb, p_token text", returns: "text", security: "invoker" },
+  { name: "choice_nudge", args: "p_organization_id uuid", returns: "text", security: "definer" },
+  { name: "choice_options", args: "p_organization_id uuid, p_options_table_id uuid", returns: "jsonb", security: "invoker" },
+  { name: "choice_render", args: "p_organization_id uuid, p_table_id uuid, p_doc jsonb", returns: "jsonb", security: "invoker" },
+  { name: "choice_render_groups", args: "p_map jsonb, p_groups jsonb", returns: "jsonb", security: "invoker" },
+  { name: "choice_render_note", args: "p_field jsonb, p_value jsonb", returns: "jsonb", security: "invoker" },
+  { name: "choice_render_plan", args: "p_organization_id uuid, p_table_id uuid", returns: "jsonb", security: "invoker" },
+  { name: "choice_render_value", args: "p_field jsonb, p_value jsonb", returns: "jsonb", security: "invoker" },
+  { name: "choice_render_with", args: "p_organization_id uuid, p_table_id uuid, p_doc jsonb, p_plan jsonb", returns: "jsonb", security: "invoker" },
+  { name: "choice_slug", args: "p_word text", returns: "text", security: "invoker" },
+  { name: "choice_synonyms", args: "p_organization_id uuid, p_table_id uuid, p_token text", returns: "text[]", security: "invoker" },
+  { name: "choice_synonyms_in", args: "p_map jsonb, p_token text", returns: "text[]", security: "invoker" },
+  { name: "choice_words", args: "p_field jsonb", returns: "text", security: "invoker" },
+  { name: "client_write_grants", args: "", returns: "TABLE(role_name text, object_name text, privilege text)", security: "invoker" },
+  { name: "comment_mention_deliver", args: "p_organization_id uuid, p_record_id uuid, p_table_id uuid, p_comment_id uuid, p_recipient uuid, p_author_name text, p_record_title text, p_body text", returns: "uuid", security: "definer" },
+  { name: "comment_thread", args: "p_organization_id uuid, p_record_id uuid, p_include_resolved boolean DEFAULT false", returns: "jsonb", security: "definer" },
+  { name: "comment_write", args: "p_organization_id uuid, p_record_id uuid, p_body text, p_anchor jsonb DEFAULT '{}'::jsonb, p_parent_comment_id uuid DEFAULT NULL::uuid, p_mentions uuid[] DEFAULT NULL::uuid[]", returns: "jsonb", security: "definer" },
+  { name: "computed_block", args: "p_block jsonb", returns: "jsonb", security: "invoker" },
+  { name: "computed_provenance", args: "p_organization_id uuid, p_record_id uuid", returns: "TABLE(field_key text, field_id uuid, value jsonb, rule_id uuid, rule_version integer, computed_at timestamp with time zone)", security: "definer" },
+  { name: "confidential_anchor", args: "p_id uuid", returns: "uuid", security: "definer" },
+  { name: "confidential_answer", args: "p_user uuid, p_id uuid, p_required permission_level DEFAULT 'viewer'::permission_level", returns: "boolean", security: "definer" },
+  { name: "confidential_header", args: "p_user uuid, p_id uuid", returns: "jsonb", security: "invoker" },
+  { name: "confidential_names", args: "p_organization_id uuid, p_value jsonb, p_user uuid", returns: "boolean", security: "definer" },
+  { name: "containment_chain", args: "p_organization_id uuid, p_record_id uuid", returns: "TABLE(ancestor_id uuid, depth integer)", security: "invoker" },
+  { name: "containment_depth_ceiling", args: "p_organization_id uuid DEFAULT NULL::uuid", returns: "integer", security: "invoker" },
+  { name: "containment_edges", args: "p_organization_id uuid", returns: "TABLE(parent_id uuid, child_id uuid, via text)", security: "invoker" },
+  { name: "containment_parent", args: "p_data jsonb", returns: "uuid", security: "invoker" },
+  { name: "context_archived_types", args: "p_organization_id uuid", returns: "jsonb", security: "definer" },
+  { name: "context_class_for_checkout", args: "p_scope_id uuid", returns: "jsonb", security: "definer" },
+  { name: "context_compare_facts", args: "p_user_id uuid, p_record_ids uuid[], p_item_ids uuid[] DEFAULT NULL::uuid[], p_cells jsonb DEFAULT NULL::jsonb", returns: "jsonb", security: "definer" },
+  { name: "context_item_archive", args: "p_item_id uuid", returns: "jsonb", security: "definer" },
+  { name: "context_item_restore", args: "p_item_id uuid", returns: "jsonb", security: "definer" },
+  { name: "context_item_row_of", args: "p_field custom.record", returns: "jsonb", security: "invoker" },
+  { name: "context_item_write", args: "p_item_id uuid, p_scope_type_id uuid, p_spec jsonb", returns: "jsonb", security: "definer" },
+  { name: "context_items", args: "p_scope_type_ids uuid[]", returns: "jsonb", security: "definer" },
+  { name: "context_policy_rank", args: "p_policy text", returns: "integer", security: "invoker" },
+  { name: "context_resolve", args: "p_bindings jsonb", returns: "jsonb", security: "definer" },
+  { name: "context_scope_archive", args: "p_scope_id uuid", returns: "jsonb", security: "definer" },
+  { name: "context_scope_restore", args: "p_scope_id uuid", returns: "jsonb", security: "definer" },
+  { name: "context_scope_write", args: "p_organization_id uuid, p_scope_id uuid, p_type_id uuid, p_spec jsonb", returns: "jsonb", security: "definer" },
+  { name: "context_scopes", args: "p_scope_ids uuid[]", returns: "jsonb", security: "definer" },
+  { name: "context_system_items", args: "", returns: "jsonb", security: "definer" },
+  { name: "context_tags_set", args: "p_entity_type text, p_entity_id uuid, p_scope_ids uuid[]", returns: "jsonb", security: "definer" },
+  { name: "context_template_define", args: "p_organization_id uuid, p_definition jsonb", returns: "jsonb", security: "invoker" },
+  { name: "context_templates", args: "", returns: "SETOF jsonb", security: "invoker" },
+  { name: "context_tree", args: "p_organization_ids uuid[]", returns: "jsonb", security: "definer" },
+  { name: "context_tree_search", args: "p_organization_ids uuid[], p_query text, p_limit integer DEFAULT 100", returns: "jsonb", security: "definer" },
+  { name: "context_tree_type_scopes", args: "p_scope_type_id uuid, p_offset integer DEFAULT 0, p_limit integer DEFAULT 200", returns: "jsonb", security: "definer" },
+  { name: "context_tree_types", args: "p_organization_ids uuid[], p_with_counts boolean DEFAULT true", returns: "jsonb", security: "definer" },
+  { name: "context_type_archive", args: "p_type_id uuid", returns: "jsonb", security: "definer" },
+  { name: "context_type_restore", args: "p_type_id uuid", returns: "jsonb", security: "definer" },
+  { name: "context_type_write", args: "p_organization_id uuid, p_type_id uuid, p_spec jsonb", returns: "jsonb", security: "definer" },
+  { name: "context_value_write", args: "p_payload jsonb", returns: "jsonb", security: "invoker" },
+  { name: "context_values", args: "p_scope_ids uuid[]", returns: "jsonb", security: "definer" },
+  { name: "context_writer", args: "p_organization_id uuid", returns: "text", security: "definer" },
+  { name: "conversation_scope", args: "p_organization_id uuid, p_conversation_id uuid", returns: "jsonb", security: "definer" },
+  { name: "conversation_scope_bind", args: "p_organization_id uuid, p_conversation_id uuid, p_record_id uuid", returns: "jsonb", security: "definer" },
+  { name: "conversation_scope_context", args: "p_organization_id uuid, p_conversation_id uuid, p_relations integer DEFAULT 12, p_history integer DEFAULT 15, p_siblings integer DEFAULT 8", returns: "jsonb", security: "definer" },
+  { name: "conversation_scope_unbind", args: "p_organization_id uuid, p_conversation_id uuid", returns: "jsonb", security: "definer" },
+  { name: "count_records_archived", args: "p_organization_id uuid, p_table_ids uuid[], p_lane text DEFAULT 'org'::text", returns: "TABLE(table_id uuid, n integer)", security: "definer" },
+  { name: "cross_organization_links_open", args: "p_source_organization_id uuid, p_target_organization_id uuid", returns: "boolean", security: "invoker" },
+  { name: "custom_fields_tables", args: "", returns: "TABLE(token text, schema_name text, table_name text)", security: "invoker" },
+  { name: "dashboard_block_normalize", args: "p_organization_id uuid, p_subject_table_id uuid, p_block jsonb", returns: "jsonb", security: "definer" },
+  { name: "dashboard_class", args: "", returns: "text", security: "invoker" },
+  { name: "dashboard_declare", args: "p_organization_id uuid, p_table_id uuid, p_name text, p_blocks jsonb DEFAULT '[]'::jsonb, p_presentation jsonb DEFAULT '{}'::jsonb, p_dashboard_id uuid DEFAULT NULL::uuid", returns: "uuid", security: "definer" },
+  { name: "dashboard_delete", args: "p_organization_id uuid, p_dashboard_id uuid", returns: "boolean", security: "definer" },
+  { name: "dashboard_field_keys", args: "p_organization_id uuid, p_table_id uuid", returns: "text[]", security: "definer" },
+  { name: "dashboard_kinds", args: "", returns: "text[]", security: "invoker" },
+  { name: "dashboard_moment_sql", args: "p_key text", returns: "text", security: "invoker" },
+  { name: "dashboard_restore", args: "p_organization_id uuid, p_dashboard_id uuid", returns: "boolean", security: "definer" },
+  { name: "dashboard_run", args: "p_organization_id uuid, p_dashboard_id uuid, p_filter jsonb DEFAULT '{}'::jsonb, p_compare jsonb DEFAULT NULL::jsonb, p_grain text DEFAULT NULL::text", returns: "jsonb", security: "definer" },
+  { name: "dashboard_stuck", args: "p_organization_id uuid, p_table_id uuid, p_state_key text, p_days integer DEFAULT 14, p_filter jsonb DEFAULT '{}'::jsonb, p_limit integer DEFAULT 50, p_required text DEFAULT 'viewer'::text", returns: "TABLE(record_id uuid, title text, state text, last_changed_at timestamp with time zone, days_unchanged numeric, measured_from text)", security: "definer" },
+  { name: "dashboard_target_field_assert", args: "p_organization_id uuid, p_table_id uuid, p_field_key text", returns: "void", security: "invoker" },
+  { name: "dashboard_window_sql", args: "p_key text, p_window jsonb", returns: "text", security: "invoker" },
+  { name: "dashboards", args: "p_organization_id uuid, p_table_id uuid DEFAULT NULL::uuid", returns: "TABLE(dashboard_id uuid, table_id uuid, name text, blocks jsonb, presentation jsonb, block_count integer, version integer, created_at timestamp with time zone, updated_at timestamp with time zone)", security: "definer" },
+  { name: "data_home", args: "p_organization_id uuid DEFAULT NULL::uuid, p_search text DEFAULT NULL::text, p_include_app_tables boolean DEFAULT false", returns: "jsonb", security: "definer" },
+  { name: "data_home_changed_by", args: "p_asks jsonb", returns: "TABLE(organization_id uuid, id uuid, at timestamp with time zone, who text)", security: "definer" },
+  { name: "data_home_items", args: "p_organization_id uuid DEFAULT NULL::uuid", returns: "TABLE(kind text, organization_id uuid, organization_name text, item_id uuid, table_id uuid, table_name text, item_row jsonb)", security: "definer" },
+  { name: "data_home_tables", args: "p_organization_id uuid DEFAULT NULL::uuid", returns: "TABLE(table_id uuid, table_name text, organization_id uuid, organization_name text, member boolean, visibility text, updated_at timestamp with time zone, mine boolean, shared_with_me boolean, kept_by_the_app boolean, kind text, team boolean, system boolean, created_by uuid)", security: "definer" },
+  { name: "data_home_tables", args: "p_organization_id uuid, p_include_app_tables boolean", returns: "TABLE(table_id uuid, table_name text, organization_id uuid, organization_name text, member boolean, visibility text, updated_at timestamp with time zone, mine boolean, shared_with_me boolean, kept_by_the_app boolean, kind text, team boolean, system boolean, created_by uuid)", security: "invoker" },
+  { name: "declared_conversation", args: "", returns: "uuid", security: "invoker" },
+  { name: "decoration_colors", args: "", returns: "text[]", security: "invoker" },
+  { name: "decoration_rule_ops", args: "", returns: "TABLE(op text, takes_value boolean, label text)", security: "invoker" },
+  { name: "delete_cascade_closure", args: "p_organization_id uuid, p_record_id uuid", returns: "uuid[]", security: "invoker" },
+  { name: "delete_preview", args: "p_organization_id uuid, p_record_id uuid", returns: "jsonb", security: "definer" },
+  { name: "delete_rule", args: "p_organization_id uuid, p_record_id uuid, p_apply boolean DEFAULT true", returns: "jsonb", security: "definer" },
+  { name: "dependency_cycle", args: "p_organization_id uuid, p_row custom.record", returns: "text[]", security: "invoker" },
+  { name: "dependency_label", args: "p_organization_id uuid, p_node text", returns: "text", security: "invoker" },
+  { name: "derive_visibility", args: "p_container_type text, p_container_id uuid", returns: "TABLE(item_type text, item_id uuid, depth integer, max_level permission_level)", security: "definer" },
+  { name: "derived_value", args: "p_organization_id uuid, p_record_id uuid, p_field_data jsonb, p_values jsonb DEFAULT NULL::jsonb", returns: "jsonb", security: "invoker" },
+  { name: "derived_values", args: "p_organization_id uuid, p_record_id uuid", returns: "jsonb", security: "invoker" },
+  { name: "derived_values_of", args: "v_rec custom.record", returns: "jsonb", security: "invoker" },
+  { name: "display_format_ids", args: "", returns: "text[]", security: "invoker" },
+  { name: "doc_content_hash", args: "p_body text", returns: "text", security: "invoker" },
+  { name: "doc_format_value", args: "p_field_data jsonb, p_value jsonb", returns: "text", security: "invoker" },
+  { name: "doc_letterhead", args: "p_organization_id uuid", returns: "jsonb", security: "definer" },
+  { name: "doc_name_token_pattern", args: "", returns: "text", security: "invoker" },
+  { name: "doc_name_tokens", args: "p_body text", returns: "TABLE(ordinal integer, raw text)", security: "invoker" },
+  { name: "doc_render_body", args: "p_organization_id uuid, p_template_id uuid, p_record_id uuid", returns: "text", security: "invoker" },
+  { name: "doc_render_document", args: "p_organization_id uuid, p_template_id uuid, p_record_id uuid", returns: "uuid", security: "definer" },
+  { name: "doc_render_read", args: "p_organization_id uuid, p_render_id uuid", returns: "jsonb", security: "definer" },
+  { name: "doc_render_write", args: "p_organization_id uuid, p_template_id uuid, p_record_id uuid, p_table_id uuid, p_template_version integer, p_body text, p_content_hash text", returns: "uuid", security: "definer" },
+  { name: "doc_renders", args: "p_organization_id uuid, p_record_id uuid", returns: "TABLE(render_id uuid, template_id uuid, record_id uuid, table_id uuid, template_version integer, body text, content_hash text, rendered_at timestamp with time zone)", security: "definer" },
+  { name: "doc_sign", args: "p_organization_id uuid, p_render_id uuid, p_field_key text, p_signer_name text, p_signer_user_id uuid DEFAULT NULL::uuid", returns: "uuid", security: "definer" },
+  { name: "doc_signature_field_ok", args: "p_field_data jsonb", returns: "boolean", security: "invoker" },
+  { name: "doc_signature_intact", args: "p_organization_id uuid, p_signature_id uuid", returns: "jsonb", security: "invoker" },
+  { name: "doc_signature_read", args: "p_organization_id uuid, p_signature_id uuid", returns: "jsonb", security: "definer" },
+  { name: "doc_signature_write", args: "p_organization_id uuid, p_render_id uuid, p_record_id uuid, p_field_key text, p_signer_name text, p_signer_user_id uuid, p_document_hash text, p_document_version integer", returns: "uuid", security: "definer" },
+  { name: "doc_signatures", args: "p_organization_id uuid, p_record_id uuid", returns: "TABLE(signature_id uuid, render_id uuid, record_id uuid, field_key text, signer_name text, signer_user_id uuid, signed_at timestamp with time zone, document_hash text, document_version integer)", security: "definer" },
+  { name: "doc_template_delete", args: "p_organization_id uuid, p_template_id uuid", returns: "boolean", security: "definer" },
+  { name: "doc_template_read", args: "p_organization_id uuid, p_template_id uuid", returns: "jsonb", security: "definer" },
+  { name: "doc_template_restore", args: "p_organization_id uuid, p_template_id uuid", returns: "boolean", security: "definer" },
+  { name: "doc_template_save", args: "p_organization_id uuid, p_table_id uuid, p_name text, p_body text, p_template_id uuid DEFAULT NULL::uuid", returns: "uuid", security: "definer" },
+  { name: "doc_templates", args: "p_organization_id uuid, p_table_id uuid", returns: "TABLE(template_id uuid, renders_table_id uuid, name text, body text, template_version integer, token_count bigint, updated_at timestamp with time zone)", security: "definer" },
+  { name: "doc_token_pattern", args: "", returns: "text", security: "invoker" },
+  { name: "doc_tokens", args: "p_body text", returns: "TABLE(ordinal integer, raw text, field_id uuid)", security: "invoker" },
+  { name: "doc_unresolved_tokens", args: "p_organization_id uuid, p_table_id uuid, p_body text", returns: "TABLE(raw text, field_id uuid, why text)", security: "invoker" },
+  { name: "doors_not_deciding_the_caller", args: "", returns: "TABLE(function_name text, identity_args text)", security: "invoker" },
+  { name: "doors_not_deciding_the_record", args: "", returns: "TABLE(function_name text, identity_args text, why text)", security: "invoker" },
+  { name: "doors_not_masking_fields", args: "", returns: "TABLE(function_name text, identity_args text, why text)", security: "invoker" },
+  { name: "doors_not_on_one_ladder", args: "", returns: "TABLE(function_name text, identity_args text, why text)", security: "invoker" },
+  { name: "doors_refusing_in_another_doors_name", args: "", returns: "TABLE(function_name text, identity_args text, why text)", security: "invoker" },
+  { name: "drill_resolve", args: "p_organization_id uuid, p_table_id uuid, p_group_by jsonb, p_measures jsonb, p_bucket jsonb", returns: "jsonb", security: "invoker" },
+  { name: "effective_level", args: "p_user_id uuid, p_organization_id uuid, p_id uuid, p_type text DEFAULT 'record'::text", returns: "permission_level", security: "definer" },
+  { name: "enrich_cells", args: "p_organization_id uuid, p_table_id uuid, p_field_keys text[] DEFAULT NULL::text[], p_record_ids uuid[] DEFAULT NULL::uuid[]", returns: "TABLE(record_id uuid, field_key text, agent_owned boolean, value jsonb, value_version integer, actor text, on_behalf_of text, written_at timestamp with time zone, source jsonb, absent_reason text, alternates jsonb, pinned boolean, stale boolean, due_at timestamp with time zone)", security: "definer" },
+  { name: "enrich_declare", args: "p_organization_id uuid, p_field_id uuid, p_spec jsonb", returns: "jsonb", security: "definer" },
+  { name: "enrich_due", args: "p_organization_id uuid, p_field_id uuid, p_limit integer DEFAULT 50, p_include_fresh boolean DEFAULT false, p_record_ids uuid[] DEFAULT NULL::uuid[]", returns: "TABLE(record_id uuid, title text, inputs jsonb, current_value jsonb, written_at timestamp with time zone, reason text, trimmed_to integer)", security: "definer" },
+  { name: "enrich_land", args: "p_organization_id uuid, p_field_id uuid, p_results jsonb, p_run jsonb DEFAULT '{}'::jsonb", returns: "jsonb", security: "definer" },
+  { name: "enrich_normalize", args: "p_organization_id uuid, p_table_id uuid, p_field_key text, p_spec jsonb", returns: "jsonb", security: "definer" },
+  { name: "enrich_pin", args: "p_organization_id uuid, p_record_id uuid, p_field_key text, p_pinned boolean DEFAULT true", returns: "jsonb", security: "definer" },
+  { name: "enrich_run_class", args: "", returns: "text", security: "invoker" },
+  { name: "enrich_runs", args: "p_organization_id uuid, p_field_id uuid DEFAULT NULL::uuid, p_limit integer DEFAULT 50", returns: "TABLE(run_id uuid, field_id uuid, field_key text, model text, trigger_word text, rows_seen integer, rows_written integer, rows_absent integer, rows_below_floor integer, rows_pinned integer, rows_refused integer, cost_cents numeric, cost_per_row_cents numeric, ran_at timestamp with time zone)", security: "definer" },
+  { name: "enrich_sensitivity_rank", args: "p_word text", returns: "integer", security: "invoker" },
+  { name: "enrich_triggers", args: "", returns: "text[]", security: "invoker" },
+  { name: "enrichments", args: "p_organization_id uuid, p_table_id uuid DEFAULT NULL::uuid", returns: "TABLE(field_id uuid, table_id uuid, field_key text, label text, enrichment jsonb, enabled boolean, review_interval_days integer, rows_total integer, rows_filled integer, rows_stale integer, rows_pinned integer, rows_absent integer, runs integer, cost_cents numeric, cost_per_row_cents numeric, last_run_at timestamp with time zone, last_run jsonb)", security: "definer" },
+  { name: "entity_field_declare", args: "p_organization_id uuid, p_token text, p_spec jsonb", returns: "uuid", security: "definer" },
+  { name: "entity_field_protect_arman_explicitly_approved", args: "p_field_id uuid, p_readers jsonb, p_arman_words text, p_approved_on date", returns: "jsonb", security: "definer" },
+  { name: "entity_field_retire", args: "p_organization_id uuid, p_field_id uuid", returns: "uuid", security: "definer" },
+  { name: "entity_field_rights", args: "p_organization_id uuid, p_token text", returns: "jsonb", security: "definer" },
+  { name: "entity_field_update", args: "p_organization_id uuid, p_field_id uuid, p_patch jsonb", returns: "uuid", security: "definer" },
+  { name: "entity_fields", args: "p_organization_id uuid, p_token text", returns: "SETOF custom.record", security: "definer" },
+  { name: "entity_fields_across", args: "p_token text, p_organization_ids uuid[]", returns: "jsonb", security: "definer" },
+  { name: "entity_read_mask", args: "p_organization_id uuid, p_token text, p_level permission_level, p_action text DEFAULT 'read'::text", returns: "jsonb", security: "definer" },
+  { name: "entity_record_home", args: "p_token text, p_record_id uuid", returns: "jsonb", security: "invoker" },
+  { name: "entity_record_read", args: "p_organization_id uuid, p_token text, p_record_id uuid", returns: "jsonb", security: "invoker" },
+  { name: "entity_records_find", args: "p_organization_id uuid, p_token text, p_key text, p_value jsonb DEFAULT NULL::jsonb, p_limit integer DEFAULT 50, p_offset integer DEFAULT 0", returns: "jsonb", security: "invoker" },
+  { name: "entity_reference_fields", args: "p_organization_id uuid, p_table_id uuid", returns: "jsonb", security: "invoker" },
+  { name: "entity_reference_kinds", args: "", returns: "TABLE(token text, label text, category text)", security: "definer" },
+  { name: "entity_reference_render", args: "p_organization_id uuid, p_table_id uuid, p_doc jsonb", returns: "jsonb", security: "invoker" },
+  { name: "entity_reference_render_with", args: "p_organization_id uuid, p_table_id uuid, p_doc jsonb, p_fields jsonb", returns: "jsonb", security: "invoker" },
+  { name: "entity_reference_rows", args: "p_organization_id uuid, p_token text, p_ids uuid[]", returns: "jsonb", security: "invoker" },
+  { name: "entity_reference_search", args: "p_organization_id uuid, p_tokens text[], p_search text DEFAULT NULL::text, p_limit integer DEFAULT 20", returns: "jsonb", security: "definer" },
+  { name: "entity_reference_target", args: "p_token text", returns: "jsonb", security: "definer" },
+  { name: "entity_reference_words", args: "p_organization_id uuid, p_refs jsonb", returns: "jsonb", security: "definer" },
+  { name: "entity_row_propose", args: "p_organization_id uuid, p_token text, p_record_id uuid, p_columns jsonb DEFAULT '{}'::jsonb, p_custom jsonb DEFAULT '{}'::jsonb, p_expected_version integer DEFAULT NULL::integer, p_archive boolean DEFAULT NULL::boolean, p_note text DEFAULT NULL::text, p_conversation_id uuid DEFAULT NULL::uuid", returns: "jsonb", security: "invoker" },
+  { name: "entity_row_write", args: "p_organization_id uuid, p_token text, p_record_id uuid, p_columns jsonb DEFAULT '{}'::jsonb, p_custom jsonb DEFAULT '{}'::jsonb, p_expected_version integer DEFAULT NULL::integer, p_archive boolean DEFAULT NULL::boolean", returns: "jsonb", security: "invoker" },
+  { name: "entity_seat_level", args: "p_organization_id uuid, p_token text, p_record_id uuid", returns: "permission_level", security: "invoker" },
+  { name: "entity_table", args: "p_token text", returns: "TABLE(token text, schema_name text, table_name text, type text, title_column text, label text, has_organization boolean, has_deleted_at boolean)", security: "definer" },
+  { name: "entity_value_write", args: "p_organization_id uuid, p_token text, p_record_id uuid, p_patch jsonb", returns: "jsonb", security: "invoker" },
+  { name: "export_ceiling", args: "p_organization_id uuid DEFAULT NULL::uuid", returns: "integer", security: "invoker" },
+  { name: "export_records", args: "p_organization_id uuid, p_table_id uuid, p_limit integer DEFAULT 1000", returns: "TABLE(id uuid, document jsonb)", security: "invoker" },
+  { name: "external_foreign_table_findings", args: "", returns: "SETOF text", security: "definer" },
+  { name: "external_history_event", args: "p_organization_id uuid, p_link_id uuid, p_operation text", returns: "bigint", security: "definer" },
+  { name: "external_rows", args: "p_organization_id uuid, p_source_id uuid", returns: "SETOF jsonb", security: "definer" },
+  { name: "external_source_declare", args: "p_organization_id uuid, p_tier text, p_connection_token text, p_external_schema text, p_external_table text, p_link_template text", returns: "uuid", security: "definer" },
+  { name: "external_stub_upsert", args: "p_organization_id uuid, p_source_id uuid, p_table_id uuid, p_external_key text, p_link_url text, p_cached_title text", returns: "uuid", security: "definer" },
+  { name: "external_tier_contract", args: "", returns: "jsonb", security: "definer" },
+  { name: "external_write_through", args: "p_organization_id uuid, p_record_id uuid, p_patch jsonb", returns: "void", security: "definer" },
+  { name: "external_writes_set", args: "p_organization_id uuid, p_source_id uuid, p_enabled boolean", returns: "boolean", security: "definer" },
+  { name: "far_value", args: "p_organization_id uuid, p_record_id uuid, p_key text, p_reader jsonb", returns: "jsonb", security: "invoker" },
+  { name: "field_access", args: "p_user uuid, p_field_id uuid, p_token text, p_row_id uuid, p_action text, p_audit boolean DEFAULT true", returns: "jsonb", security: "definer" },
+  { name: "field_add_rung", args: "p_organization_id uuid, p_table_id uuid", returns: "permission_level", security: "invoker" },
+  { name: "field_behaviour", args: "p_field_data jsonb", returns: "text", security: "invoker" },
+  { name: "field_choice_usage", args: "p_organization_id uuid, p_field_id uuid", returns: "jsonb", security: "definer" },
+  { name: "field_context_policy_floor", args: "p_organization_id uuid, p_field_data jsonb, p_self uuid DEFAULT NULL::uuid", returns: "TABLE(context_policy text, reads jsonb)", security: "definer" },
+  { name: "field_cycle", args: "p_organization_id uuid, p_field_data jsonb, p_self uuid", returns: "text[]", security: "definer" },
+  { name: "field_declare", args: "p_organization_id uuid, p_table_id uuid, p_spec jsonb", returns: "uuid", security: "definer" },
+  { name: "field_dependants", args: "p_organization_id uuid, p_field_id uuid", returns: "TABLE(kind text, dependant_id uuid, label text, how text)", security: "definer" },
+  { name: "field_history", args: "p_organization_id uuid, p_table_id uuid, p_field_key text, p_limit integer DEFAULT 100, p_offset integer DEFAULT 0, p_record_id uuid DEFAULT NULL::uuid", returns: "TABLE(record_id uuid, record_title text, version integer, occurred_at timestamp with time zone, operation_label text, actor jsonb, before jsonb, after jsonb)", security: "definer" },
+  { name: "field_input_closure", args: "p_organization_id uuid, p_field_data jsonb, p_self uuid DEFAULT NULL::uuid", returns: "TABLE(input_id uuid, input_key text, input_label text, input_table uuid, sensitivity text, retired boolean, depth integer)", security: "definer" },
+  { name: "field_inputs_of", args: "p_organization_id uuid, p_field_data jsonb", returns: "TABLE(input_id uuid, input_key text, input_label text, input_table uuid, sensitivity text, retired boolean, how text)", security: "definer" },
+  { name: "field_is_protected", args: "p_data jsonb", returns: "boolean", security: "invoker" },
+  { name: "field_kernel_id", args: "", returns: "uuid", security: "invoker" },
+  { name: "field_kind_of", args: "p_field_data jsonb", returns: "text", security: "invoker" },
+  { name: "field_kinds", args: "", returns: "TABLE(kind text, behavior text, parity boolean, made_of text)", security: "invoker" },
+  { name: "field_options", args: "p_organization_id uuid, p_field_id uuid", returns: "SETOF custom.record", security: "definer" },
+  { name: "field_protection_refusal", args: "p_op text, p_old jsonb, p_new jsonb, p_field_id uuid", returns: "text", security: "invoker" },
+  { name: "field_restore", args: "p_organization_id uuid, p_field_id uuid", returns: "boolean", security: "definer" },
+  { name: "field_retire", args: "p_organization_id uuid, p_field_id uuid", returns: "boolean", security: "definer" },
+  { name: "field_rules", args: "p_field_data jsonb", returns: "TABLE(kind text, spec jsonb)", security: "invoker" },
+  { name: "field_sensitivity_floor", args: "p_organization_id uuid, p_field_data jsonb, p_self uuid DEFAULT NULL::uuid", returns: "TABLE(sensitivity text, reads jsonb)", security: "definer" },
+  { name: "field_source_archived", args: "p_organization_id uuid, p_field_id uuid", returns: "jsonb", security: "definer" },
+  { name: "field_update", args: "p_organization_id uuid, p_field_id uuid, p_patch jsonb", returns: "uuid", security: "definer" },
+  { name: "field_update_rehoming_choices", args: "p_organization_id uuid, p_field_id uuid, p_patch jsonb, p_rehome jsonb DEFAULT NULL::jsonb, p_cells_back jsonb DEFAULT NULL::jsonb", returns: "jsonb", security: "definer" },
+  { name: "field_value_convert", args: "p_to jsonb, p_value jsonb", returns: "jsonb", security: "invoker" },
+  { name: "field_value_kind", args: "p_organization_id uuid, p_field_data jsonb", returns: "text", security: "invoker" },
+  { name: "field_words", args: "p_organization_id uuid, p_field_id uuid, p_value jsonb", returns: "text", security: "invoker" },
+  { name: "file_kernel_id", args: "", returns: "uuid", security: "invoker" },
+  { name: "filter_is_rule", args: "p_filter jsonb", returns: "boolean", security: "invoker" },
+  { name: "form_archive", args: "p_organization_id uuid, p_form_id uuid", returns: "jsonb", security: "definer" },
+  { name: "form_declare", args: "p_organization_id uuid, p_table_id uuid, p_title text, p_questions jsonb, p_presentation jsonb DEFAULT '{}'::jsonb, p_submission_cap integer DEFAULT NULL::integer, p_quarantine_rule_id uuid DEFAULT NULL::uuid, p_notify_rule_id uuid DEFAULT NULL::uuid, p_form_id uuid DEFAULT NULL::uuid, p_slug text DEFAULT NULL::text", returns: "uuid", security: "definer" },
+  { name: "form_draft_read", args: "p_form_id uuid, p_secret text", returns: "TABLE(answers jsonb, saved_at timestamp with time zone, expires_at timestamp with time zone, state text, message text)", security: "definer" },
+  { name: "form_draft_save", args: "p_form_id uuid, p_answers jsonb, p_secret text DEFAULT NULL::text, p_bucket text DEFAULT NULL::text, p_origin text DEFAULT NULL::text", returns: "TABLE(draft_secret text, saved_at timestamp with time zone, expires_at timestamp with time zone, state text, message text)", security: "definer" },
+  { name: "form_look_options", args: "p_organization_id uuid, p_presentation jsonb DEFAULT '{}'::jsonb", returns: "jsonb", security: "definer" },
+  { name: "form_notify", args: "p_organization_id uuid, p_form_id uuid, p_record_id uuid, p_submission_id uuid", returns: "uuid", security: "invoker" },
+  { name: "form_preview_asks", args: "p_organization_id uuid, p_table_id uuid, p_questions jsonb, p_values jsonb", returns: "TABLE(field_key text, asked boolean, decided boolean, said text)", security: "definer" },
+  { name: "form_public", args: "p_form_id uuid", returns: "TABLE(form_id uuid, organization_id uuid, table_id uuid, title text, presentation jsonb, fields jsonb, honeypot_key text, state text, message text)", security: "definer" },
+  { name: "form_public_asks", args: "p_form_id uuid, p_values jsonb, p_secret text DEFAULT NULL::text, p_origin text DEFAULT NULL::text", returns: "TABLE(field_key text, asked boolean, decided boolean, said text)", security: "definer" },
+  { name: "form_redirect_domains", args: "p_organization_id uuid", returns: "text[]", security: "invoker" },
+  { name: "form_redirect_refusal", args: "p_organization_id uuid, p_url text", returns: "text", security: "invoker" },
+  { name: "form_restore", args: "p_organization_id uuid, p_form_id uuid", returns: "jsonb", security: "definer" },
+  { name: "form_slug", args: "p_organization_id uuid, p_title text, p_form_id uuid DEFAULT NULL::uuid", returns: "text", security: "invoker" },
+  { name: "form_submit", args: "p_form_id uuid, p_origin text, p_payload jsonb, p_bucket text, p_honeypot text DEFAULT NULL::text, p_client_key text DEFAULT NULL::text", returns: "TABLE(submission_id uuid, record_id uuid, state text, message text)", security: "definer" },
+  { name: "forms", args: "p_organization_id uuid, p_table_id uuid DEFAULT NULL::uuid", returns: "TABLE(form_id uuid, table_id uuid, title text, slug text, published_at timestamp with time zone, closed_at timestamp with time zone, submission_cap integer, responses bigint, in_table bigint, held bigint, rejected bigint, state text, quarantine_rule_id uuid, notify_rule_id uuid, presentation jsonb)", security: "definer" },
+  { name: "forms_archived", args: "p_organization_id uuid, p_table_id uuid DEFAULT NULL::uuid, p_limit integer DEFAULT 100", returns: "TABLE(form_id uuid, table_id uuid, table_name text, kind text, title text, slug text, archived_at timestamp with time zone, archived_by uuid, table_archived boolean, can_restore boolean)", security: "definer" },
+  { name: "formula_compile_sql", args: "p_organization_id uuid, p_expr jsonb, p_values_sql text", returns: "text", security: "invoker" },
+  { name: "formula_eval", args: "p_organization_id uuid, p_expr jsonb, p_values jsonb, p_context jsonb DEFAULT '{}'::jsonb", returns: "jsonb", security: "invoker" },
+  { name: "formula_field_keys", args: "p_organization_id uuid, p_expr jsonb", returns: "text[]", security: "invoker" },
+  { name: "formula_node_kinds", args: "", returns: "TABLE(node text, min_args integer, max_args integer, result text, signature text, says text)", security: "invoker" },
+  { name: "formula_parse", args: "p_organization_id uuid, p_table_id uuid, p_text text", returns: "jsonb", security: "definer" },
+  { name: "formula_result_kind", args: "p_organization_id uuid, p_expr jsonb", returns: "text", security: "invoker" },
+  { name: "formula_value", args: "p_organization_id uuid, p_record_id uuid, p_field_data jsonb, p_values jsonb DEFAULT NULL::jsonb", returns: "jsonb", security: "invoker" },
+  { name: "freshness_verdict", args: "p_written_at timestamp with time zone, p_ceiling_seconds numeric", returns: "jsonb", security: "definer" },
+  { name: "grid_layout", args: "p_organization_id uuid, p_table_id uuid, p_view_id uuid DEFAULT NULL::uuid", returns: "jsonb", security: "definer" },
+  { name: "grid_layout_check", args: "p_layout jsonb, p_scope text DEFAULT 'view'::text", returns: "jsonb", security: "invoker" },
+  { name: "guard_refusals_are_complete", args: "", returns: "TABLE(guard text, said text)", security: "invoker" },
+  { name: "has_visibility", args: "p_user_id uuid, p_type text, p_id uuid, p_required permission_level DEFAULT 'viewer'::permission_level", returns: "boolean", security: "definer" },
+  { name: "has_visibility_at", args: "p_user_id uuid, p_type text, p_id uuid, p_required permission_level DEFAULT 'viewer'::permission_level, p_organization_id uuid DEFAULT NULL::uuid, p_min_version bigint DEFAULT NULL::bigint", returns: "boolean", security: "definer" },
+  { name: "hidden_field_notice", args: "p_field custom.record, p_action text DEFAULT 'read'::text", returns: "jsonb", security: "invoker" },
+  { name: "history_actor", args: "p_tier text, p_document jsonb, p_actor_id uuid, p_people jsonb", returns: "jsonb", security: "invoker" },
+  { name: "history_changes", args: "p_organization_id uuid, p_table_id uuid, p_old jsonb, p_new jsonb", returns: "jsonb", security: "invoker" },
+  { name: "history_people", args: "p_organization_id uuid, p_ids uuid[]", returns: "jsonb", security: "definer" },
+  { name: "history_prune", args: "p_organization_id uuid, p_scope text DEFAULT 'values'::text, p_table_id uuid DEFAULT NULL::uuid, p_dry_run boolean DEFAULT true", returns: "jsonb", security: "definer" },
+  { name: "history_restore_body", args: "p_current jsonb, p_target jsonb, p_field_key text DEFAULT NULL::text", returns: "jsonb", security: "invoker" },
+  { name: "history_restore_body", args: "p_current jsonb, p_target jsonb, p_field_key text, p_author jsonb", returns: "jsonb", security: "invoker" },
+  { name: "history_retention", args: "p_organization_id uuid, p_table_id uuid DEFAULT NULL::uuid", returns: "jsonb", security: "definer" },
+  { name: "history_retention_floor_raise", args: "p_organization_id uuid, p_days integer", returns: "integer", security: "definer" },
+  { name: "history_retention_set", args: "p_organization_id uuid, p_table_id uuid, p_days integer", returns: "integer", security: "definer" },
+  { name: "home_add", args: "p_organization_id uuid, p_table_id uuid, p_home_record_id uuid", returns: "uuid", security: "definer" },
+  { name: "home_relations", args: "", returns: "TABLE(table_id uuid, home_record_id uuid, organization_id uuid, relation_id uuid)", security: "invoker" },
+  { name: "hub_changed_by", args: "p_organization_id uuid, p_kind text, p_ids uuid[]", returns: "TABLE(id uuid, at timestamp with time zone, who text)", security: "definer" },
+  { name: "inbound_addresses", args: "p_organization_id uuid, p_table_id uuid DEFAULT NULL::uuid", returns: "jsonb", security: "definer" },
+  { name: "inbound_declare", args: "p_organization_id uuid, p_table_id uuid, p_label text DEFAULT NULL::text", returns: "jsonb", security: "definer" },
+  { name: "inbound_domain", args: "p_organization_id uuid", returns: "text", security: "invoker" },
+  { name: "inbound_mail_land", args: "p_address text, p_mail jsonb, p_secret text DEFAULT NULL::text", returns: "jsonb", security: "definer" },
+  { name: "inbound_mail_map", args: "p_organization_id uuid, p_table_id uuid, p_mail jsonb", returns: "jsonb", security: "invoker" },
+  { name: "inbound_set", args: "p_organization_id uuid, p_inbound_id uuid, p_enabled boolean", returns: "jsonb", security: "definer" },
+  { name: "inbox_clear", args: "p_organization_id uuid, p_item_id uuid", returns: "jsonb", security: "definer" },
+  { name: "inbox_counts", args: "p_organization_id uuid DEFAULT NULL::uuid", returns: "TABLE(organization_id uuid, organization_name text, waiting integer, snoozed integer, cleared integer, overdue integer, oldest_waiting_at timestamp with time zone)", security: "definer" },
+  { name: "inbox_remind_tick", args: "", returns: "jsonb", security: "invoker" },
+  { name: "inbox_snooze", args: "p_organization_id uuid, p_item_id uuid, p_until timestamp with time zone", returns: "jsonb", security: "definer" },
+  { name: "inbox_unclear", args: "p_organization_id uuid, p_item_id uuid", returns: "jsonb", security: "definer" },
+  { name: "inbox_unsnooze", args: "p_organization_id uuid, p_item_id uuid", returns: "jsonb", security: "definer" },
+  { name: "index_payload", args: "p_organization_id uuid, p_table_id uuid, p_limit integer DEFAULT 1000", returns: "TABLE(id uuid, searchable text)", security: "invoker" },
+  { name: "intern_provenance", args: "p_data jsonb", returns: "jsonb", security: "invoker" },
+  { name: "io_cell", args: "p_organization_id uuid, p_field jsonb, p_word text, p_date_order text DEFAULT 'mdy'::text", returns: "jsonb", security: "invoker" },
+  { name: "io_change_actor", args: "", returns: "jsonb", security: "invoker" },
+  { name: "io_change_fields", args: "p_keys text[], p_old jsonb, p_new jsonb", returns: "jsonb", security: "invoker" },
+  { name: "io_change_via", args: "", returns: "text", security: "invoker" },
+  { name: "io_changed_field_ids", args: "p_organization_id uuid, p_table_id uuid, p_old jsonb, p_new jsonb", returns: "jsonb", security: "invoker" },
+  { name: "io_changed_keys", args: "p_old jsonb, p_new jsonb", returns: "text[]", security: "invoker" },
+  { name: "io_comment_resolve", args: "p_organization_id uuid, p_comment_id uuid, p_resolved boolean DEFAULT true", returns: "boolean", security: "definer" },
+  { name: "io_comment_write", args: "p_organization_id uuid, p_record_id uuid, p_body text, p_anchor jsonb DEFAULT '{}'::jsonb, p_parent_comment_id uuid DEFAULT NULL::uuid", returns: "uuid", security: "definer" },
+  { name: "io_comments", args: "p_organization_id uuid, p_record_id uuid, p_include_resolved boolean DEFAULT false", returns: "TABLE(id uuid, body text, anchor jsonb, parent_comment_id uuid, created_by uuid, created_at timestamp with time zone, resolved_at timestamp with time zone, resolved_by uuid)", security: "definer" },
+  { name: "io_csv_escape", args: "p_value text, p_delimiter text DEFAULT ','::text", returns: "text", security: "invoker" },
+  { name: "io_csv_parse", args: "p_text text, p_delimiter text DEFAULT NULL::text", returns: "TABLE(row_number integer, cells text[])", security: "invoker" },
+  { name: "io_export", args: "p_organization_id uuid, p_table_id uuid, p_columns text[] DEFAULT NULL::text[], p_limit integer DEFAULT 10000, p_required text DEFAULT 'viewer'::text", returns: "jsonb", security: "definer" },
+  { name: "io_export_csv", args: "p_organization_id uuid, p_table_id uuid, p_columns text[] DEFAULT NULL::text[], p_limit integer DEFAULT 10000, p_delimiter text DEFAULT chr(44), p_required text DEFAULT 'viewer'::text", returns: "text", security: "definer" },
+  { name: "io_import_begin", args: "p_organization_id uuid, p_table_id uuid, p_format text DEFAULT 'csv'::text, p_source_name text DEFAULT NULL::text, p_source_columns jsonb DEFAULT '[]'::jsonb, p_file_hash text DEFAULT NULL::text, p_policy jsonb DEFAULT '{}'::jsonb, p_dedupe_key text DEFAULT NULL::text, p_file_bytes bigint DEFAULT NULL::bigint, p_force boolean DEFAULT false", returns: "jsonb", security: "definer" },
+  { name: "io_import_declare_columns", args: "p_organization_id uuid, p_table_id uuid, p_rows jsonb, p_mapping jsonb DEFAULT '{}'::jsonb", returns: "jsonb", security: "definer" },
+  { name: "io_import_finish", args: "p_organization_id uuid, p_import_id uuid, p_unmapped text DEFAULT NULL::text", returns: "jsonb", security: "definer" },
+  { name: "io_import_forget", args: "p_organization_id uuid, p_import_id uuid", returns: "boolean", security: "definer" },
+  { name: "io_import_open", args: "p_organization_id uuid, p_table_id uuid, p_format text DEFAULT 'csv'::text, p_source_name text DEFAULT NULL::text, p_source_columns jsonb DEFAULT '[]'::jsonb", returns: "uuid", security: "definer" },
+  { name: "io_import_plan", args: "p_organization_id uuid, p_table_id uuid, p_columns jsonb DEFAULT '[]'::jsonb", returns: "jsonb", security: "definer" },
+  { name: "io_import_report", args: "p_organization_id uuid, p_import_id uuid, p_state text DEFAULT NULL::text, p_limit integer DEFAULT 100, p_offset integer DEFAULT 0", returns: "jsonb", security: "definer" },
+  { name: "io_import_rows", args: "p_organization_id uuid, p_import_id uuid, p_rows jsonb, p_mapping jsonb DEFAULT '{}'::jsonb", returns: "jsonb", security: "definer" },
+  { name: "io_imports", args: "p_organization_id uuid, p_table_id uuid DEFAULT NULL::uuid, p_limit integer DEFAULT 25", returns: "jsonb", security: "definer" },
+  { name: "io_infer_column", args: "p_organization_id uuid, p_table_id uuid, p_header text, p_samples jsonb DEFAULT '[]'::jsonb", returns: "jsonb", security: "definer" },
+  { name: "io_infer_type", args: "p_samples jsonb", returns: "text", security: "invoker" },
+  { name: "io_money_unit", args: "p_word text", returns: "text", security: "invoker" },
+  { name: "io_outbox_announce", args: "", returns: "trigger", security: "definer" },
+  { name: "io_outbox_backlog", args: "p_consumer text, p_event_key text, p_older_than interval DEFAULT '00:00:00'::interval", returns: "TABLE(organization_id uuid, waiting bigint, oldest timestamp with time zone, last_carried timestamp with time zone)", security: "definer" },
+  { name: "io_outbox_broadcast_stmt", args: "", returns: "trigger", security: "definer" },
+  { name: "io_outbox_consumed_by", args: "p_event_id uuid, p_consumer text, p_consumed_at timestamp with time zone", returns: "boolean", security: "invoker" },
+  { name: "io_outbox_drain", args: "p_organization_id uuid, p_consumer text, p_limit integer DEFAULT 100, p_event_key text DEFAULT 'records.changed'::text", returns: "TABLE(outbox_id uuid, record_id uuid, table_id uuid, operation text, changed_field_ids jsonb, actor jsonb, occurred_at timestamp with time zone)", security: "definer" },
+  { name: "io_outbox_last_consumed", args: "p_consumer text, p_event_key text, p_organization_id uuid", returns: "timestamp with time zone", security: "invoker" },
+  { name: "io_outbox_pending_organizations", args: "p_consumer text, p_event_key text", returns: "SETOF uuid", security: "definer" },
+  { name: "io_outbox_per_consumer", args: "", returns: "boolean", security: "invoker" },
+  { name: "io_outbox_rearm", args: "p_organization_id uuid, p_dedupe_key text", returns: "void", security: "definer" },
+  { name: "io_outbox_release", args: "p_organization_id uuid, p_consumer text, p_older_than interval DEFAULT '00:15:00'::interval", returns: "integer", security: "definer" },
+  { name: "io_outbox_release_claimed", args: "p_organization_id uuid, p_consumer text, p_ids uuid[]", returns: "integer", security: "definer" },
+  { name: "io_outbox_subscribe", args: "p_consumer text, p_event_key text", returns: "timestamp with time zone", security: "definer" },
+  { name: "io_proposal_accept", args: "p_organization_id uuid, p_import_id uuid, p_column text, p_type text DEFAULT NULL::text, p_label text DEFAULT NULL::text", returns: "uuid", security: "definer" },
+  { name: "io_proposal_reject", args: "p_organization_id uuid, p_import_id uuid, p_column text", returns: "boolean", security: "definer" },
+  { name: "io_proposal_spec", args: "p_proposal jsonb", returns: "jsonb", security: "invoker" },
+  { name: "io_record_changed", args: "", returns: "trigger", security: "definer" },
+  { name: "io_record_changed_stmt_delete", args: "", returns: "trigger", security: "definer" },
+  { name: "io_record_changed_stmt_insert", args: "", returns: "trigger", security: "definer" },
+  { name: "io_record_changed_stmt_update", args: "", returns: "trigger", security: "definer" },
+  { name: "io_relation_candidate", args: "p_organization_id uuid, p_table_id uuid, p_words text[]", returns: "uuid", security: "invoker" },
+  { name: "io_restore", args: "p_organization_id uuid, p_record_id uuid, p_version integer", returns: "integer", security: "definer" },
+  { name: "io_restore", args: "p_organization_id uuid, p_record_id uuid, p_version integer, p_author jsonb", returns: "integer", security: "definer" },
+  { name: "io_revisions", args: "p_organization_id uuid, p_record_id uuid", returns: "TABLE(version integer, changed_at timestamp with time zone, changed_by uuid, summary text, operation text, changed_fields jsonb)", security: "definer" },
+  { name: "io_sample_words", args: "p_samples jsonb", returns: "TABLE(word text)", security: "invoker" },
+  { name: "io_value_shape", args: "p_envelope jsonb", returns: "jsonb", security: "invoker" },
+  { name: "io_workflow_chain", args: "", returns: "jsonb", security: "invoker" },
+  { name: "is_a_retirement", args: "p_old_deleted timestamp with time zone, p_new_deleted timestamp with time zone, p_old_data jsonb, p_new_data jsonb, p_old_table uuid, p_new_table uuid, p_old_org uuid, p_new_org uuid, p_old_class text, p_new_class text", returns: "boolean", security: "invoker" },
+  { name: "ladder_replanners", args: "p_roots text[] DEFAULT ARRAY['custom.has_visibility'::text, 'custom.effective_level'::text, 'custom.reaches_directly'::text, 'custom.visible_set'::text]", returns: "TABLE(fn text, lang text, why text, remedy text)", security: "definer" },
+  { name: "level_floor", args: "", returns: "permission_level", security: "definer" },
+  { name: "levels_of", args: "p_user_id uuid, p_ids uuid[]", returns: "jsonb", security: "definer" },
+  { name: "levels_raised_by_a_less_specific_rung", args: "", returns: "TABLE(organization_id uuid, organization_name text, member_id uuid, member_email text, record_id uuid, addressed_level permission_level, answered_level permission_level)", security: "definer" },
+  { name: "list_door_disagreements", args: "p_pretend text DEFAULT NULL::text, p_only_organization uuid DEFAULT NULL::uuid, p_sample integer DEFAULT 200", returns: "TABLE(organization_id uuid, organization_name text, member_id uuid, table_id uuid, record_id uuid, door text, why text)", security: "invoker" },
+  { name: "list_door_disagreements", args: "p_pretend text, p_only_organization uuid, p_sample integer, p_exhaustive boolean", returns: "TABLE(organization_id uuid, organization_name text, member_id uuid, table_id uuid, record_id uuid, door text, why text)", security: "invoker" },
+  { name: "list_portals", args: "p_organization_id uuid, p_archived text DEFAULT 'active'::text", returns: "TABLE(portal_id uuid, title text, slug text, client_table_id uuid, client_table text, is_active boolean, tables integer, invited integer, signed_in integer, sign_in_method text, opened_at timestamp with time zone)", security: "definer" },
+  { name: "list_portals_everywhere", args: "p_archived text DEFAULT 'active'::text", returns: "jsonb", security: "invoker" },
+  { name: "listed_predicate_sql", args: "p_user uuid, p_organization_id uuid, p_table_id uuid, p_required permission_level DEFAULT 'viewer'::permission_level, p_alias text DEFAULT 'r'::text", returns: "text", security: "invoker" },
+  { name: "lookup_value", args: "p_organization_id uuid, p_record_id uuid, p_field_data jsonb", returns: "jsonb", security: "invoker" },
+  { name: "mask_document", args: "p_document jsonb, p_visible_keys text[], p_notices jsonb, p_by_id boolean DEFAULT false, p_key_ids jsonb DEFAULT '{}'::jsonb", returns: "jsonb", security: "invoker" },
+  { name: "mask_document", args: "p_document jsonb, p_visible_keys text[], p_notices jsonb, p_by_id boolean DEFAULT false, p_key_ids jsonb DEFAULT '{}'::jsonb, p_declared_keys text[] DEFAULT NULL::text[]", returns: "jsonb", security: "invoker" },
+  { name: "mask_history_data", args: "p_data jsonb, p_mask jsonb", returns: "jsonb", security: "invoker" },
+  { name: "mask_says_withheld", args: "p_mask jsonb, p_key text", returns: "boolean", security: "invoker" },
+  { name: "may_invite_outside", args: "p_organization_id uuid, p_table_id uuid", returns: "boolean", security: "definer" },
+  { name: "member_personal_tables", args: "p_organization_id uuid, p_person uuid", returns: "jsonb", security: "definer" },
+  { name: "member_records_take_over", args: "p_organization_id uuid, p_from uuid, p_to uuid, p_reason text", returns: "jsonb", security: "definer" },
+  { name: "merge_field_kernel_id", args: "", returns: "uuid", security: "invoker" },
+  { name: "migrate_choice_keys", args: "p_organization_id uuid, p_table_id uuid, p_dry_run boolean DEFAULT false", returns: "jsonb", security: "definer" },
+  { name: "migrate_delete", args: "p_organization_id uuid, p_record_id uuid, p_note text DEFAULT NULL::text", returns: "jsonb", security: "definer" },
+  { name: "migrate_demote", args: "p_organization_id uuid, p_table_id uuid, p_note text DEFAULT NULL::text", returns: "jsonb", security: "definer" },
+  { name: "migrate_extract_parent", args: "p_organization_id uuid, p_id uuid, p_parent_table_id uuid, p_moved_keys text[], p_note text DEFAULT NULL::text", returns: "jsonb", security: "definer" },
+  { name: "migrate_merge", args: "p_organization_id uuid, p_winner_id uuid, p_loser_id uuid, p_note text DEFAULT NULL::text", returns: "jsonb", security: "definer" },
+  { name: "migrate_promote", args: "p_organization_id uuid, p_table_id uuid, p_note text DEFAULT NULL::text", returns: "jsonb", security: "definer" },
+  { name: "migrate_purge", args: "p_organization_id uuid, p_table_id uuid DEFAULT NULL::uuid, p_dry_run boolean DEFAULT true", returns: "jsonb", security: "definer" },
+  { name: "migrate_purge_hard", args: "p_organization_id uuid, p_table_id uuid DEFAULT NULL::uuid, p_compliance_reason text DEFAULT NULL::text, p_chunk integer DEFAULT 200, p_dry_run boolean DEFAULT true", returns: "jsonb", security: "definer" },
+  { name: "migrate_purge_hard_request", args: "p_organization_id uuid, p_table_id uuid, p_compliance_reason text", returns: "void", security: "definer" },
+  { name: "migrate_reclass", args: "p_organization_id uuid, p_id uuid, p_to text DEFAULT 'field'::text, p_note text DEFAULT NULL::text", returns: "jsonb", security: "definer" },
+  { name: "migrate_rename", args: "p_organization_id uuid, p_id uuid, p_to text, p_note text DEFAULT NULL::text", returns: "jsonb", security: "definer" },
+  { name: "migrate_reparent", args: "p_organization_id uuid, p_id uuid, p_parent_id uuid, p_note text DEFAULT NULL::text", returns: "jsonb", security: "definer" },
+  { name: "migrate_retype", args: "p_organization_id uuid, p_id uuid, p_to text, p_note text DEFAULT NULL::text", returns: "jsonb", security: "definer" },
+  { name: "migrate_split", args: "p_organization_id uuid, p_record_id uuid, p_moved_keys text[], p_note text DEFAULT NULL::text", returns: "jsonb", security: "definer" },
+  { name: "migrate_undo", args: "p_organization_id uuid, p_log_id uuid", returns: "jsonb", security: "definer" },
+  { name: "migrations", args: "p_organization_id uuid, p_target_id uuid DEFAULT NULL::uuid, p_limit integer DEFAULT 100", returns: "TABLE(id uuid, verb text, target_kind text, target_id uuid, note text, applied_at timestamp with time zone, applied_by uuid, undone_at timestamp with time zone)", security: "definer" },
+  { name: "mirror_asks_the_whole_database", args: "", returns: "TABLE(schema_name text, table_name text, policy_name text, why text)", security: "invoker" },
+  { name: "my_level", args: "p_organization_id uuid, p_id uuid, p_type text DEFAULT 'record'::text", returns: "permission_level", security: "definer" },
+  { name: "my_levels", args: "p_organization_id uuid, p_ids jsonb, p_type text DEFAULT 'record'::text", returns: "TABLE(id uuid, level permission_level)", security: "definer" },
+  { name: "organization_clear", args: "p_organization_id uuid, p_confirm text, p_and_destroy boolean DEFAULT false", returns: "jsonb", security: "definer" },
+  { name: "organization_contents", args: "p_organization_id uuid", returns: "jsonb", security: "definer" },
+  { name: "organization_home_id", args: "p_organization_id uuid", returns: "uuid", security: "invoker" },
+  { name: "organization_kernel_id", args: "", returns: "uuid", security: "invoker" },
+  { name: "organization_pick_lists", args: "p_organization_id uuid", returns: "TABLE(id uuid, list_name text, description text, updated_at timestamp with time zone, lives_in text)", security: "definer" },
+  { name: "organization_references", args: "p_kind text, p_organization_id uuid, p_row jsonb", returns: "TABLE(site text, what text, ref_id uuid, openable boolean)", security: "invoker" },
+  { name: "owning_table", args: "p_organization_id uuid, p_record_id uuid", returns: "uuid", security: "invoker" },
+  { name: "owning_table_gone", args: "p_organization_id uuid, p_record_id uuid", returns: "boolean", security: "invoker" },
+  { name: "page_ceiling", args: "p_organization_id uuid DEFAULT NULL::uuid", returns: "integer", security: "invoker" },
+  { name: "page_contract", args: "p_organization_id uuid", returns: "jsonb", security: "definer" },
+  { name: "page_size", args: "p_organization_id uuid, p_door text, p_limit integer, p_default integer DEFAULT NULL::integer, p_ceiling integer DEFAULT NULL::integer", returns: "integer", security: "invoker" },
+  { name: "parity_field_types", args: "", returns: "TABLE(parity_type text, behavior text, made_of text)", security: "invoker" },
+  { name: "parity_type", args: "p_field_data jsonb", returns: "text", security: "invoker" },
+  { name: "parity_values", args: "p_organization_id uuid, p_record_id uuid", returns: "TABLE(field_key text, field_id uuid, parity_type text, behavior text, unit text, format text, value jsonb, value_version integer, actor text, written_at timestamp with time zone)", security: "invoker" },
+  { name: "per_value_access_words", args: "", returns: "text[]", security: "invoker" },
+  { name: "person_kernel_id", args: "", returns: "uuid", security: "invoker" },
+  { name: "phone_canonical", args: "p_text text", returns: "text", security: "invoker" },
+  { name: "phone_display", args: "p_text text", returns: "text", security: "invoker" },
+  { name: "phone_pattern", args: "", returns: "text", security: "invoker" },
+  { name: "pick_list_create", args: "p_organization_id uuid, p_list_name text, p_description text DEFAULT NULL::text, p_items jsonb DEFAULT '[]'::jsonb", returns: "jsonb", security: "definer" },
+  { name: "pick_list_index", args: "p_organization_id uuid", returns: "jsonb", security: "definer" },
+  { name: "pick_list_index_everywhere", args: "", returns: "jsonb", security: "definer" },
+  { name: "pin_agent_cells", args: "p_new jsonb, p_old jsonb, p_agent_keys text[]", returns: "jsonb", security: "invoker" },
+  { name: "pipeline_board", args: "p_organization_id uuid, p_table_id uuid, p_measure text DEFAULT NULL::text", returns: "TABLE(stage_key text, stage_label text, stage_position integer, cards bigint, total numeric, wip_limit integer, over_limit boolean)", security: "definer" },
+  { name: "pipeline_board", args: "p_organization_id uuid, p_table_id uuid, p_measure text, p_filter jsonb", returns: "TABLE(stage_key text, stage_label text, stage_position integer, cards bigint, total numeric, wip_limit integer, over_limit boolean)", security: "definer" },
+  { name: "pipeline_declare", args: "p_organization_id uuid, p_table_id uuid, p_spec jsonb", returns: "jsonb", security: "definer" },
+  { name: "pipeline_gate_preview", args: "p_organization_id uuid, p_table_id uuid, p_stage text, p_gate jsonb", returns: "jsonb", security: "definer" },
+  { name: "pipeline_move", args: "p_organization_id uuid, p_record_id uuid, p_to text, p_also jsonb DEFAULT '{}'::jsonb, p_expected_version integer DEFAULT NULL::integer", returns: "jsonb", security: "definer" },
+  { name: "pipeline_move_many", args: "p_organization_id uuid, p_moves jsonb", returns: "jsonb", security: "definer" },
+  { name: "pipeline_pending", args: "p_organization_id uuid, p_table_id uuid", returns: "jsonb", security: "definer" },
+  { name: "pipeline_read", args: "p_organization_id uuid, p_table_id uuid", returns: "jsonb", security: "definer" },
+  { name: "pipeline_transition_refusal", args: "p_organization_id uuid, p_record_id uuid, p_to text", returns: "jsonb", security: "definer" },
+  { name: "pipelines", args: "p_organization_id uuid", returns: "TABLE(table_id uuid, table_name text, stage_field text, stage_label text, stages integer, rules integer, broken text, updated_at timestamp with time zone, updated_by uuid)", security: "definer" },
+  { name: "plural_of", args: "p_word text", returns: "text", security: "invoker" },
+  { name: "portal_accents", args: "", returns: "text[]", security: "invoker" },
+  { name: "portal_admits", args: "p_organization_id uuid, p_user_id uuid DEFAULT NULL::uuid", returns: "boolean", security: "definer" },
+  { name: "portal_archive", args: "p_organization_id uuid, p_portal_id uuid, p_confirm_title text, p_reason text DEFAULT NULL::text", returns: "jsonb", security: "definer" },
+  { name: "portal_card", args: "p_organization_id uuid, p_portal_id uuid", returns: "jsonb", security: "definer" },
+  { name: "portal_declare", args: "p_organization_id uuid, p_title text, p_client_table_id uuid, p_tables jsonb, p_portal_id uuid DEFAULT NULL::uuid, p_slug text DEFAULT NULL::text, p_sign_in_method text DEFAULT 'magic_link'::text, p_config jsonb DEFAULT NULL::jsonb", returns: "uuid", security: "definer" },
+  { name: "portal_field_map", args: "p_organization_id uuid, p_table_id uuid", returns: "TABLE(field_id uuid, field_key text, field_type text, points_at uuid)", security: "definer" },
+  { name: "portal_form", args: "p_organization_id uuid, p_portal_id uuid, p_form_id uuid", returns: "jsonb", security: "definer" },
+  { name: "portal_form_submit", args: "p_organization_id uuid, p_portal_id uuid, p_form_id uuid, p_payload jsonb, p_client_key text DEFAULT NULL::text", returns: "jsonb", security: "definer" },
+  { name: "portal_invitation", args: "p_slug text, p_email text", returns: "jsonb", security: "definer" },
+  { name: "portal_invite", args: "p_organization_id uuid, p_portal_id uuid, p_client_record_id uuid, p_email text, p_user_id uuid DEFAULT NULL::uuid", returns: "jsonb", security: "definer" },
+  { name: "portal_invite_accept", args: "p_token text", returns: "jsonb", security: "definer" },
+  { name: "portal_me", args: "", returns: "jsonb", security: "definer" },
+  { name: "portal_preview", args: "p_organization_id uuid, p_portal_id uuid, p_principal_id uuid, p_table_id uuid", returns: "TABLE(record_id uuid, title text)", security: "definer" },
+  { name: "portal_principal_bind", args: "p_organization_id uuid, p_principal_id uuid, p_user_id uuid", returns: "jsonb", security: "definer" },
+  { name: "portal_public", args: "p_slug text", returns: "jsonb", security: "definer" },
+  { name: "portal_record_title", args: "p_organization_id uuid, p_record_id uuid", returns: "text", security: "definer" },
+  { name: "portal_restore", args: "p_organization_id uuid, p_portal_id uuid, p_confirm_title text", returns: "jsonb", security: "definer" },
+  { name: "portal_revoke", args: "p_organization_id uuid, p_portal_id uuid, p_principal_id uuid", returns: "jsonb", security: "definer" },
+  { name: "portal_slug", args: "p_organization_id uuid, p_title text, p_portal_id uuid DEFAULT NULL::uuid", returns: "text", security: "definer" },
+  { name: "portal_tables", args: "p_organization_id uuid", returns: "TABLE(portal_id uuid, table_id uuid, name text)", security: "definer" },
+  { name: "portals", args: "p_organization_id uuid", returns: "TABLE(portal_id uuid, title text, slug text, client_table_id uuid, client_table text, is_active boolean, tables integer, invited integer, signed_in integer, sign_in_method text, opened_at timestamp with time zone)", security: "definer" },
+  { name: "presentation_kernel_id", args: "", returns: "uuid", security: "invoker" },
+  { name: "promote_field", args: "p_organization_id uuid, p_table_id uuid, p_field_id uuid", returns: "jsonb", security: "invoker" },
+  { name: "promote_table", args: "p_organization_id uuid, p_table_id uuid", returns: "jsonb", security: "definer" },
+  { name: "promoted_field_cap", args: "", returns: "integer", security: "invoker" },
+  { name: "promoted_fields", args: "p_organization_id uuid, p_table_id uuid", returns: "TABLE(field_id uuid, field_key text, parity_type text, is_unique boolean, value_path text, index_arm text, index_expr text, index_name text, indexable boolean, why_not text)", security: "invoker" },
+  { name: "promoted_index_arm", args: "p_field_data jsonb", returns: "text", security: "invoker" },
+  { name: "promoted_index_ddl", args: "p_organization_id uuid, p_table_id uuid", returns: "TABLE(step integer, purpose text, statement text)", security: "invoker" },
+  { name: "promoted_index_expr", args: "p_field_data jsonb", returns: "text", security: "invoker" },
+  { name: "promoted_index_name", args: "p_table_id uuid, p_field_key text, p_unique boolean", returns: "text", security: "invoker" },
+  { name: "promoted_query_sql", args: "p_organization_id uuid, p_table_id uuid, p_field_key text", returns: "text", security: "invoker" },
+  { name: "promoted_read", args: "p_organization_id uuid, p_table_id uuid, p_field_key text, p_value text", returns: "SETOF uuid", security: "invoker" },
+  { name: "promoted_value_path", args: "p_field_data jsonb", returns: "text", security: "invoker" },
+  { name: "promotion_inline_ceiling", args: "", returns: "integer", security: "invoker" },
+  { name: "protected_field_notice", args: "p_field custom.record", returns: "jsonb", security: "invoker" },
+  { name: "protected_field_query_refusal", args: "p_field_id uuid, p_verb text", returns: "text", security: "definer" },
+  { name: "protected_field_rule", args: "p_token text", returns: "jsonb", security: "invoker" },
+  { name: "protected_matches", args: "p_field_id uuid, p_value jsonb DEFAULT NULL::jsonb", returns: "TABLE(row_id uuid, value jsonb)", security: "definer" },
+  { name: "protected_readers_problem", args: "p_token text, p_readers jsonb", returns: "text", security: "invoker" },
+  { name: "protected_value", args: "p_token text, p_row_id uuid, p_field_id uuid", returns: "jsonb", security: "definer" },
+  { name: "protected_value_leaks", args: "p_field_id uuid DEFAULT NULL::uuid", returns: "TABLE(place text, table_token text, field_key text, row_id uuid, ref text)", security: "definer" },
+  { name: "protected_values", args: "p_organization_id uuid, p_token text, p_row_id uuid", returns: "jsonb", security: "definer" },
+  { name: "provenance_prune", args: "p_organization_id uuid DEFAULT NULL::uuid, p_dry_run boolean DEFAULT true, p_limit integer DEFAULT 200000", returns: "jsonb", security: "definer" },
+  { name: "provenance_retention_days", args: "p_organization_id uuid", returns: "integer", security: "definer" },
+  { name: "provenance_write", args: "p_organization_id uuid, p_conversation_id uuid, p_turn_id text, p_rows jsonb", returns: "integer", security: "definer" },
+  { name: "publish_bind", args: "p_organization_id uuid, p_kind text, p_resource_id uuid, p_slug text, p_render_mode text DEFAULT 'page'::text", returns: "jsonb", security: "definer" },
+  { name: "query_access_ids", args: "p_organization_id uuid, p_required text DEFAULT 'viewer'::text", returns: "uuid[]", security: "invoker" },
+  { name: "query_across_homes", args: "p_organization_id uuid, p_table_id uuid, p_limit integer DEFAULT 50, p_offset integer DEFAULT 0, p_required text DEFAULT 'viewer'::text", returns: "TABLE(record_id uuid, home_record_id uuid, data jsonb, created_at timestamp with time zone)", security: "definer" },
+  { name: "query_by_coordinates", args: "p_organization_id uuid, p_table_id uuid DEFAULT NULL::uuid, p_coordinates jsonb DEFAULT '[]'::jsonb, p_limit integer DEFAULT 50, p_offset integer DEFAULT 0, p_required text DEFAULT 'viewer'::text", returns: "TABLE(record_id uuid, table_id uuid, data jsonb, coordinates_matched integer)", security: "definer" },
+  { name: "query_can_see", args: "p_organization_id uuid, p_record_id uuid, p_required text DEFAULT 'viewer'::text", returns: "boolean", security: "definer" },
+  { name: "query_hot_paths", args: "", returns: "TABLE(name text, statement text)", security: "invoker" },
+  { name: "query_hot_paths_prepared", args: "", returns: "TABLE(name text, prepared boolean, generic_plans bigint)", security: "invoker" },
+  { name: "query_is_store_owner", args: "", returns: "boolean", security: "invoker" },
+  { name: "query_prepare_hot", args: "", returns: "integer", security: "invoker" },
+  { name: "query_principal", args: "", returns: "uuid", security: "invoker" },
+  { name: "query_record_as_of", args: "p_organization_id uuid, p_record_id uuid, p_recorded_at timestamp with time zone DEFAULT NULL::timestamp with time zone, p_world_on date DEFAULT NULL::date, p_required text DEFAULT 'viewer'::text", returns: "jsonb", security: "definer" },
+  { name: "query_record_document", args: "p_principal uuid, p_row custom.record", returns: "jsonb", security: "invoker" },
+  { name: "query_relation_edges", args: "p_organization_id uuid, p_flavor text DEFAULT NULL::text, p_role text DEFAULT NULL::text", returns: "TABLE(parent_id uuid, child_id uuid, role text, flavor text)", security: "definer" },
+  { name: "query_rollup", args: "p_organization_id uuid, p_roots uuid[], p_flavor text DEFAULT NULL::text, p_role text DEFAULT NULL::text, p_max_depth integer DEFAULT 33, p_required text DEFAULT 'viewer'::text", returns: "TABLE(record_id uuid, depth integer)", security: "definer" },
+  { name: "query_rollup_sum", args: "p_organization_id uuid, p_roots uuid[], p_field_key text, p_flavor text DEFAULT NULL::text, p_role text DEFAULT NULL::text, p_max_depth integer DEFAULT 33, p_required text DEFAULT 'viewer'::text", returns: "numeric", security: "definer" },
+  { name: "query_table_as_of", args: "p_organization_id uuid, p_table_id uuid, p_recorded_at timestamp with time zone DEFAULT NULL::timestamp with time zone, p_world_on date DEFAULT NULL::date, p_limit integer DEFAULT 50, p_offset integer DEFAULT 0, p_required text DEFAULT 'viewer'::text", returns: "TABLE(record_id uuid, data jsonb)", security: "definer" },
+  { name: "query_table_homes", args: "p_organization_id uuid, p_table_id uuid", returns: "SETOF uuid", security: "definer" },
+  { name: "query_visibility_parity", args: "p_organization_id uuid", returns: "TABLE(side text, container_type text, container_id uuid, item_type text, item_id uuid, stored_level permission_level, derived_level permission_level, reason text)", security: "definer" },
+  { name: "query_visible_ids", args: "p_organization_id uuid, p_table_id uuid DEFAULT NULL::uuid, p_required text DEFAULT 'viewer'::text", returns: "SETOF uuid", security: "definer" },
+  { name: "reachable_from", args: "p_organization_id uuid, p_roots uuid[]", returns: "TABLE(record_id uuid, depth integer, via text)", security: "invoker" },
+  { name: "reaches_directly", args: "p_user_id uuid, p_type text, p_id uuid, p_required permission_level DEFAULT 'viewer'::permission_level", returns: "boolean", security: "definer" },
+  { name: "read_door_carried_ids", args: "p_user uuid, p_organization_id uuid, p_table_id uuid, p_required permission_level, OUT o_ids uuid[], OUT o_containers integer", returns: "record", security: "definer" },
+  { name: "read_door_granted_ids", args: "p_organization_id uuid, p_table_id uuid", returns: "uuid[]", security: "definer" },
+  { name: "read_door_ladder_ceiling", args: "", returns: "integer", security: "invoker" },
+  { name: "read_door_parity", args: "p_organization_id uuid, p_table_id uuid, p_user uuid, p_required permission_level, p_sample integer", returns: "TABLE(record_id uuid, set_based boolean, per_row boolean, verdict text)", security: "definer" },
+  { name: "read_mask", args: "p_organization_id uuid, p_record_id uuid, p_action text DEFAULT 'read'::text", returns: "jsonb", security: "definer" },
+  { name: "read_mask_at", args: "p_record_id uuid, p_level_given boolean, p_level permission_level, p_action text DEFAULT 'read'::text", returns: "jsonb", security: "definer" },
+  { name: "read_mask_for", args: "p_user_id uuid, p_organization_id uuid, p_table_id uuid, p_level permission_level, p_action text DEFAULT 'read'::text", returns: "jsonb", security: "definer" },
+  { name: "read_paths_outside_the_door", args: "", returns: "TABLE(object_name text, why text)", security: "invoker" },
+  { name: "read_record", args: "p_organization_id uuid, p_record_id uuid, p_by_id boolean DEFAULT false", returns: "jsonb", security: "definer" },
+  { name: "read_records", args: "p_organization_id uuid, p_table_id uuid, p_by_id boolean DEFAULT false, p_limit integer DEFAULT 200, p_offset integer DEFAULT 0", returns: "TABLE(id uuid, document jsonb, level permission_level)", security: "definer" },
+  { name: "read_records_archived", args: "p_organization_id uuid, p_table_id uuid, p_lane text DEFAULT 'org'::text, p_by_id boolean DEFAULT false, p_limit integer DEFAULT 200, p_offset integer DEFAULT 0", returns: "TABLE(id uuid, document jsonb, level permission_level, archived_at timestamp with time zone, archived_by uuid, archived_by_name text)", security: "definer" },
+  { name: "read_records_by_ids", args: "p_organization_id uuid, p_table_id uuid, p_record_ids uuid[], p_by_id boolean DEFAULT false", returns: "TABLE(id uuid, document jsonb, level permission_level)", security: "definer" },
+  { name: "read_records_in_view_order", args: "p_organization_id uuid, p_view_id uuid, p_by_id boolean DEFAULT false, p_limit integer DEFAULT 200, p_offset integer DEFAULT 0, p_filter jsonb DEFAULT NULL::jsonb", returns: 'TABLE(id uuid, document jsonb, level permission_level, "position" numeric)', security: "definer" },
+  { name: "read_records_matching", args: "p_organization_id uuid, p_table_id uuid, p_filter jsonb DEFAULT '{}'::jsonb, p_by_id boolean DEFAULT false, p_limit integer DEFAULT 200, p_offset integer DEFAULT 0", returns: "TABLE(id uuid, document jsonb, level permission_level)", security: "definer" },
+  { name: "read_records_page", args: "p_organization_id uuid, p_table_id uuid, p_filter jsonb DEFAULT '{}'::jsonb, p_search text DEFAULT NULL::text, p_sort jsonb DEFAULT '[]'::jsonb, p_view_id uuid DEFAULT NULL::uuid, p_by_id boolean DEFAULT false, p_limit integer DEFAULT 50, p_offset integer DEFAULT 0, p_time_zone text DEFAULT NULL::text", returns: "jsonb", security: "definer" },
+  { name: "realtime_topic_admits", args: "p_topic text", returns: "boolean", security: "definer" },
+  { name: "record_aggregate", args: "p_organization_id uuid, p_table_id uuid, p_group_by jsonb DEFAULT '[]'::jsonb, p_measures jsonb DEFAULT '[]'::jsonb, p_bucket jsonb DEFAULT NULL::jsonb, p_filter jsonb DEFAULT '{}'::jsonb, p_limit integer DEFAULT 200, p_required text DEFAULT 'viewer'::text, p_compare jsonb DEFAULT NULL::jsonb, p_search text DEFAULT NULL::text, p_time_zone text DEFAULT NULL::text", returns: "TABLE(groups jsonb, measures jsonb, row_count bigint, prior_groups jsonb, prior_measures jsonb, prior_row_count bigint, delta jsonb, compare jsonb)", security: "definer" },
+  { name: "record_aggregate_as_of", args: "p_organization_id uuid, p_table_id uuid, p_recorded_at timestamp with time zone, p_measure text DEFAULT 'count'::text, p_field_key text DEFAULT NULL::text, p_group_by text DEFAULT NULL::text, p_match jsonb DEFAULT '{}'::jsonb", returns: "TABLE(bucket text, result numeric, row_count bigint, not_numbers bigint, a_non_number text)", security: "definer" },
+  { name: "record_applicability", args: "p_organization_id uuid, p_record_id uuid", returns: "TABLE(rule_id uuid, rule_name text, rule_version integer, applies boolean, answer jsonb)", security: "invoker" },
+  { name: "record_archiver", args: "p_organization_id uuid, p_record_id uuid", returns: "uuid", security: "definer" },
+  { name: "record_as_of", args: "p_organization_id uuid, p_record_id uuid, p_at timestamp with time zone", returns: "TABLE(state jsonb, replayed boolean)", security: "definer" },
+  { name: "record_card", args: "p_viewer uuid, p_organization_id uuid, p_record_id uuid", returns: "jsonb", security: "definer" },
+  { name: "record_carrying_edges", args: "p_id uuid, p_data_class text, p_data jsonb, p_deleted_at timestamp with time zone", returns: "TABLE(container_id uuid, item_id uuid, edge_role text)", security: "invoker" },
+  { name: "record_change_actions", args: "p_organization_id uuid, p_table_id uuid", returns: "jsonb", security: "definer" },
+  { name: "record_change_many", args: "p_organization_id uuid, p_table_id uuid, p_changes jsonb", returns: "jsonb", security: "definer" },
+  { name: "record_changes_drain", args: "p_organization_id uuid, p_consumer text, p_limit integer DEFAULT 100", returns: "TABLE(event_id uuid, organization_id uuid, table_id uuid, record_id uuid, kind text, operation text, version integer, fields jsonb, changed_field_ids jsonb, actor jsonb, chain jsonb, op_id uuid, occurred_at timestamp with time zone, via text)", security: "definer" },
+  { name: "record_delete", args: "p_organization_id uuid, p_record_id uuid", returns: "timestamp with time zone", security: "definer" },
+  { name: "record_entity_edges", args: "p_organization_id uuid, p_id uuid, p_table_id uuid, p_data_class text, p_data jsonb, p_deleted_at timestamp with time zone", returns: "TABLE(target_type text, target_id uuid, edge_role text, field_id uuid, ord integer)", security: "invoker" },
+  { name: "record_filter_sql", args: "p_filter jsonb", returns: "text", security: "invoker" },
+  { name: "record_filter_sql", args: "p_organization_id uuid, p_table_id uuid, p_filter jsonb", returns: "text", security: "invoker" },
+  { name: "record_headers", args: "p_organization_id uuid, p_ids uuid[]", returns: "TABLE(id uuid, table_id uuid, created_at timestamp with time zone, updated_at timestamp with time zone, version integer, deleted_at timestamp with time zone, mine boolean, created_by uuid)", security: "definer" },
+  { name: "record_history", args: "p_organization_id uuid, p_record_id uuid, p_limit integer DEFAULT 200, p_offset integer DEFAULT 0", returns: "TABLE(version integer, occurred_at timestamp with time zone, operation text, operation_label text, actor jsonb, changes jsonb, migration_id uuid, undoable boolean)", security: "definer" },
+  { name: "record_platform_keys", args: "", returns: "text[]", security: "invoker" },
+  { name: "record_relation_edges", args: "p_organization_id uuid, p_id uuid, p_table_id uuid, p_data_class text, p_data jsonb, p_deleted_at timestamp with time zone", returns: "TABLE(target_id uuid, edge_role text, field_id uuid, ord integer)", security: "invoker" },
+  { name: "record_reparent", args: "p_organization_id uuid, p_record_id uuid, p_parent_id uuid", returns: "void", security: "definer" },
+  { name: "record_resolve", args: "p_organization_id uuid, p_id uuid", returns: "jsonb", security: "definer" },
+  { name: "record_restore", args: "p_organization_id uuid, p_record_id uuid", returns: "void", security: "definer" },
+  { name: "record_restore_preview", args: "p_organization_id uuid, p_record_id uuid, p_version integer, p_field_key text DEFAULT NULL::text", returns: "jsonb", security: "definer" },
+  { name: "record_restore_version", args: "p_organization_id uuid, p_record_id uuid, p_version integer", returns: "jsonb", security: "definer" },
+  { name: "record_restore_version", args: "p_organization_id uuid, p_record_id uuid, p_version integer, p_author jsonb", returns: "jsonb", security: "definer" },
+  { name: "record_row_controls", args: "p_organization_id uuid, p_record_id uuid", returns: "jsonb", security: "definer" },
+  { name: "record_row_controls_set", args: "p_organization_id uuid, p_record_id uuid, p_controls jsonb", returns: "jsonb", security: "definer" },
+  { name: "record_runs", args: "p_organization_id uuid, p_record_id uuid, p_limit integer DEFAULT 50", returns: "TABLE(run_id uuid, kind text, name text, trigger_name text, status text, started_at timestamp with time zone, finished_at timestamp with time zone, steps integer, says text, ran_by uuid)", security: "definer" },
+  { name: "record_scope_context", args: "p_organization_id uuid, p_record_id uuid, p_relations integer DEFAULT 12, p_history integer DEFAULT 15, p_siblings integer DEFAULT 8", returns: "jsonb", security: "definer" },
+  { name: "record_search_sql", args: "p_organization_id uuid, p_table_id uuid, p_search text, p_alias text DEFAULT 'r'::text, p_time_zone text DEFAULT NULL::text", returns: "text", security: "invoker" },
+  { name: "record_source_key", args: "p_table_id uuid", returns: "text", security: "invoker" },
+  { name: "record_source_keys", args: "p_table_id uuid", returns: "text[]", security: "invoker" },
+  { name: "record_source_table", args: "p_key text", returns: "uuid", security: "invoker" },
+  { name: "record_stage_pending", args: "p_organization_id uuid, p_record_id uuid", returns: "jsonb", security: "definer" },
+  { name: "record_state_as_of", args: "p_record_id uuid, p_at timestamp with time zone", returns: "TABLE(state jsonb, replayed boolean)", security: "definer" },
+  { name: "record_table", args: "p_organization_id uuid, p_record_id uuid", returns: "uuid", security: "definer" },
+  { name: "record_triggers", args: "p_organization_id uuid, p_table_id uuid DEFAULT NULL::uuid", returns: "TABLE(trigger_id uuid, name text, definition_id uuid, definition_name text, table_id uuid, event text, operations jsonb, field_ids jsonb, via jsonb, is_active boolean, last_fired_at timestamp with time zone, fire_count integer, updated_at timestamp with time zone)", security: "definer" },
+  { name: "record_update", args: "p_organization_id uuid, p_record_id uuid, p_patch jsonb, p_expected_version integer DEFAULT NULL::integer", returns: "integer", security: "definer" },
+  { name: "record_update_adding_choices", args: "p_organization_id uuid, p_record_id uuid, p_patch jsonb, p_add jsonb, p_expected_version integer DEFAULT NULL::integer", returns: "integer", security: "definer" },
+  { name: "record_upsert", args: "p_organization_id uuid, p_table_id uuid, p_key text[], p_data jsonb, p_expected_version integer DEFAULT NULL::integer", returns: "uuid", security: "definer" },
+  { name: "record_value_one", args: "p_organization_id uuid, p_record_id uuid, p_key text", returns: "jsonb", security: "invoker" },
+  { name: "record_values", args: "p_organization_id uuid, p_record_id uuid", returns: "jsonb", security: "invoker" },
+  { name: "record_values_of", args: "p_row custom.record", returns: "jsonb", security: "invoker" },
+  { name: "record_values_step", args: "p_row custom.record, p_cache jsonb DEFAULT '{}'::jsonb, OUT o_doc jsonb, OUT o_cache jsonb", returns: "record", security: "invoker" },
+  { name: "record_values_versioned", args: "p_organization_id uuid, p_record_id uuid", returns: "TABLE(field_key text, field_id uuid, value jsonb, value_version integer, source jsonb, absent_reason text, actor text, on_behalf_of text, written_at timestamp with time zone, alternates jsonb)", security: "definer" },
+  { name: "record_words", args: "p_organization_id uuid, p_record_id uuid, p_noun text DEFAULT NULL::text", returns: "text", security: "definer" },
+  { name: "record_write", args: "p_organization_id uuid, p_table_id uuid, p_data jsonb", returns: "uuid", security: "definer" },
+  { name: "record_write_graph", args: "p_organization_id uuid, p_table_id uuid, p_parent jsonb, p_edges jsonb DEFAULT '[]'::jsonb, p_children jsonb DEFAULT '[]'::jsonb", returns: "jsonb", security: "definer" },
+  { name: "record_write_graph_superseding", args: `p_organization_id uuid, p_table_id uuid, p_lock_key text, p_idempotence jsonb DEFAULT NULL::jsonb, p_parent jsonb DEFAULT NULL::jsonb, p_edges jsonb DEFAULT '[]'::jsonb, p_children jsonb DEFAULT '[]'::jsonb, p_chain jsonb DEFAULT '{"mode": "first"}'::jsonb, p_rows_state jsonb DEFAULT NULL::jsonb`, returns: "jsonb", security: "definer" },
+  { name: "record_write_many", args: "p_organization_id uuid, p_table_id uuid, p_rows jsonb[], p_ids uuid[] DEFAULT NULL::uuid[]", returns: "uuid[]", security: "definer" },
+  { name: "records_search", args: "p_search text, p_limit integer DEFAULT 50, p_offset integer DEFAULT 0, p_table_ids uuid[] DEFAULT NULL::uuid[], p_organization_ids uuid[] DEFAULT NULL::uuid[], p_include_app_tables boolean DEFAULT false", returns: "TABLE(record_id uuid, table_id uuid, table_name text, name text, organization_id uuid, updated_at timestamp with time zone)", security: "definer" },
+  { name: "refusals_claiming_a_level_never_asked", args: "", returns: "TABLE(function_name text, identity_args text, why text)", security: "invoker" },
+  { name: "relation_carry", args: "p_organization_id uuid, p_container_id uuid, p_item_id uuid", returns: "uuid", security: "definer" },
+  { name: "relation_edges_withdraw", args: "p_organization_id uuid, p_field_ids uuid[], p_why text", returns: "integer", security: "definer" },
+  { name: "relation_halves_disagreements", args: "p_organization_id uuid DEFAULT NULL::uuid, p_record_id uuid DEFAULT NULL::uuid", returns: "TABLE(organization_id uuid, record_id uuid, field_key text, field_id uuid, target_id uuid, direction text, remedy text, why text)", security: "definer" },
+  { name: "relation_halves_repair", args: "p_organization_id uuid, p_record_id uuid", returns: "jsonb", security: "definer" },
+  { name: "relation_kernel_record", args: "p_organization_id uuid, p_kernel_table_id uuid, p_id uuid", returns: "uuid", security: "definer" },
+  { name: "relation_name_key", args: "p_text text", returns: "text", security: "invoker" },
+  { name: "relation_names_match", args: "p_organization_id uuid, p_table_id uuid, p_names text[]", returns: "jsonb", security: "definer" },
+  { name: "relation_own", args: "p_organization_id uuid, p_owner_id uuid, p_target_id uuid", returns: "uuid", security: "definer" },
+  { name: "relation_restore", args: "p_organization_id uuid, p_relation_id uuid", returns: "boolean", security: "definer" },
+  { name: "relation_target_card", args: "p_organization_id uuid, p_record_id uuid, p_via_key text DEFAULT NULL::text", returns: "TABLE(target_id uuid, target_organization_id uuid, is_foreign boolean, masked boolean, reader_level permission_level, card jsonb, why text)", security: "definer" },
+  { name: "relation_target_external", args: "p_connection_token text, p_external_table text, p_external_key text", returns: "jsonb", security: "definer" },
+  { name: "relation_target_ours", args: "p_entity_token text, p_row_id uuid", returns: "jsonb", security: "definer" },
+  { name: "relation_targets", args: "p_organization_id uuid, p_record_id uuid, p_via_key text", returns: "SETOF uuid", security: "definer" },
+  { name: "relation_uncarry", args: "p_organization_id uuid, p_container_id uuid, p_item_id uuid", returns: "integer", security: "definer" },
+  { name: "relation_value_target_ok", args: "p_organization_id uuid, p_field_id uuid, p_field_data jsonb, p_target_id uuid", returns: "boolean", security: "invoker" },
+  { name: "relation_words", args: "p_organization_id uuid, p_field_id uuid, p_value text", returns: "text", security: "definer" },
+  { name: "relation_words_many", args: "p_organization_id uuid, p_field_id uuid, p_record_ids uuid[]", returns: "TABLE(record_id uuid, words text, archived boolean)", security: "definer" },
+  { name: "reopen_declared_doors", args: "", returns: "TABLE(reopened text)", security: "definer" },
+  { name: "required_epoch", args: "p_container_type text, p_container_id uuid, p_item_type text, p_item_id uuid", returns: "bigint", security: "definer" },
+  { name: "resolve_context", args: "p_entity_type text, p_entity_id uuid, p_record_ids uuid[] DEFAULT NULL::uuid[], p_table_ids uuid[] DEFAULT NULL::uuid[], p_system_item_refs text[] DEFAULT NULL::text[]", returns: "jsonb", security: "definer" },
+  { name: "resolve_first_match", args: "p_organization_id uuid, p_record_id uuid", returns: "jsonb", security: "invoker" },
+  { name: "resolve_id", args: "p_organization_id uuid, p_id uuid", returns: "uuid", security: "invoker" },
+  { name: "retired_actor_words", args: "", returns: "jsonb", security: "invoker" },
+  { name: "reverse_columns", args: "p_organization_id uuid, p_table_id uuid", returns: "TABLE(key text, label text, source_field_id uuid, source_field_key text, source_field_label text, source_table_id uuid, source_table_name text, cardinality text, read_only boolean)", security: "definer" },
+  { name: "reverse_links_many", args: "p_organization_id uuid, p_table_id uuid, p_field_id uuid, p_record_ids uuid[], p_limit integer DEFAULT 10, p_offset integer DEFAULT 0", returns: "TABLE(record_id uuid, total integer, links jsonb)", security: "definer" },
+  { name: "rollup_value", args: "p_organization_id uuid, p_record_id uuid, p_field_data jsonb", returns: "jsonb", security: "invoker" },
+  { name: "row_actions", args: "p_organization_id uuid, p_table_id uuid", returns: "jsonb", security: "definer" },
+  { name: "row_sits_in_a_personal_table", args: "p_type text, p_organization_id uuid, p_id uuid", returns: "boolean", security: "invoker" },
+  { name: "row_template_declare", args: "p_organization_id uuid, p_table_id uuid, p_spec jsonb", returns: "uuid", security: "definer" },
+  { name: "row_templates", args: "p_organization_id uuid, p_table_id uuid", returns: 'TABLE(template_id uuid, name text, table_id uuid, "values" jsonb, created_at timestamp with time zone, updated_at timestamp with time zone)', security: "definer" },
+  { name: "rule_applies", args: "p_organization_id uuid, p_rule_id uuid, p_record_id uuid", returns: "jsonb", security: "invoker" },
+  { name: "rule_context", args: "p_organization_id uuid, p_record_id uuid", returns: "jsonb", security: "invoker" },
+  { name: "rule_declare", args: "p_organization_id uuid, p_spec jsonb, p_rule_id uuid DEFAULT NULL::uuid", returns: "uuid", security: "definer" },
+  { name: "rule_dependency_edges", args: "p_organization_id uuid, p_row custom.record DEFAULT NULL::custom.record", returns: "TABLE(needs text, needed text)", security: "invoker" },
+  { name: "rule_eval", args: "p_organization_id uuid, p_expr jsonb, p_values jsonb, p_context jsonb DEFAULT '{}'::jsonb", returns: "jsonb", security: "invoker" },
+  { name: "rule_field_key", args: "p_organization_id uuid, p_field_id uuid", returns: "text", security: "invoker" },
+  { name: "rule_field_label", args: "p_organization_id uuid, p_field_id uuid", returns: "text", security: "invoker" },
+  { name: "rule_filter_node_sql", args: "p_organization_id uuid, p_table_id uuid, p_node jsonb, p_map jsonb, p_visible text[]", returns: "text", security: "invoker" },
+  { name: "rule_kernel_id", args: "", returns: "uuid", security: "invoker" },
+  { name: "rule_members", args: "p_organization_id uuid, p_rule_id uuid", returns: "SETOF custom.record", security: "invoker" },
+  { name: "rule_members_visible", args: "p_organization_id uuid, p_rule_id uuid, p_limit integer DEFAULT 200, p_offset integer DEFAULT 0", returns: "TABLE(id uuid, document jsonb, level permission_level)", security: "definer" },
+  { name: "rule_membership", args: "p_organization_id uuid, p_rule_id uuid, p_record_id uuid", returns: "jsonb", security: "invoker" },
+  { name: "rule_node_kinds", args: "", returns: "TABLE(node text, evaluated_by text, note text)", security: "invoker" },
+  { name: "rule_restore", args: "p_organization_id uuid, p_rule_id uuid", returns: "boolean", security: "definer" },
+  { name: "rule_run", args: "p_organization_id uuid, p_rule_id uuid, p_values jsonb, p_context jsonb DEFAULT '{}'::jsonb", returns: "jsonb", security: "invoker" },
+  { name: "rule_sql_op", args: "p_op text, p_a jsonb, p_b jsonb DEFAULT NULL::jsonb", returns: "jsonb", security: "invoker" },
+  { name: "rule_truth", args: "p_answer jsonb", returns: "boolean", security: "invoker" },
+  { name: "rule_uses", args: "", returns: "text[]", security: "invoker" },
+  { name: "rule_version", args: "p_organization_id uuid, p_rule_id uuid", returns: "integer", security: "invoker" },
+  { name: "said", args: "p_value text, p_when_there_is_none text", returns: "text", security: "invoker" },
+  { name: "scope_item_row_of", args: "p_field custom.record", returns: "jsonb", security: "invoker" },
+  { name: "scope_item_value_type", args: "p_field jsonb, p_carried jsonb", returns: "text", security: "invoker" },
+  { name: "scope_items_of", args: "p_org uuid, p_table uuid", returns: "SETOF custom.record", security: "invoker" },
+  { name: "scope_member_reaches", args: "p_user_id uuid, p_record_id uuid, p_required permission_level DEFAULT 'viewer'::permission_level", returns: "boolean", security: "invoker" },
+  { name: "scope_row_of", args: "p_rec custom.record", returns: "jsonb", security: "invoker" },
+  { name: "scope_rows_of", args: "p_org uuid, p_types uuid[] DEFAULT NULL::uuid[]", returns: "TABLE(id uuid, table_id uuid, type_sort integer, sort_order integer, name text, type_doc jsonb, row_doc jsonb)", security: "invoker" },
+  { name: "scope_setting_back", args: "p_value jsonb, p_behavior text", returns: "jsonb", security: "invoker" },
+  { name: "scope_table_provision", args: "p_organization_id uuid, p_item_id uuid, p_scope_id uuid, p_home_id uuid DEFAULT NULL::uuid", returns: "uuid", security: "definer" },
+  { name: "scope_type_row_of", args: "p_table custom.record", returns: "jsonb", security: "invoker" },
+  { name: "scope_value_columns", args: "p_org uuid, p_field jsonb, p_value_type text, p_value jsonb", returns: "jsonb", security: "invoker" },
+  { name: "seen_among", args: "p_user_id uuid, p_ids uuid[]", returns: "uuid[]", security: "definer" },
+  { name: "sensitivity_rank", args: "p_sensitivity text", returns: "integer", security: "invoker" },
+  { name: "set_table_confidential_arman_explicitly_approved", args: "p_table_id uuid, p_readers jsonb, p_arman_words text, p_approved_on date, p_maker_is_reader boolean DEFAULT NULL::boolean", returns: "jsonb", security: "definer" },
+  { name: "share_access", args: "p_organization_id uuid, p_subject_id uuid", returns: "TABLE(principal_kind text, principal_id uuid, principal_label text, level permission_level, reason text, reason_detail text, via_type text, via_id uuid, revocable boolean)", security: "definer" },
+  { name: "share_grant", args: "p_organization_id uuid, p_subject_id uuid, p_principal_kind text, p_principal_id uuid, p_level permission_level DEFAULT 'viewer'::permission_level", returns: "jsonb", security: "definer" },
+  { name: "share_lane_set", args: "p_organization_id uuid, p_subject_id uuid, p_choice text, p_level permission_level DEFAULT NULL::permission_level", returns: "jsonb", security: "definer" },
+  { name: "share_lanes", args: "", returns: "TABLE(choice text, lane text, discoverable boolean, label text, means text)", security: "definer" },
+  { name: "share_levels", args: "", returns: "TABLE(level permission_level, ordinal integer, label text, means text)", security: "definer" },
+  { name: "share_people", args: "p_organization_id uuid, p_subject_id uuid DEFAULT NULL::uuid, p_query text DEFAULT NULL::text, p_limit integer DEFAULT 25", returns: "TABLE(user_id uuid, email text, display_name text, membership text, already_at permission_level, already_why text)", security: "definer" },
+  { name: "share_revoke", args: "p_organization_id uuid, p_subject_id uuid, p_principal_kind text, p_principal_id uuid", returns: "jsonb", security: "definer" },
+  { name: "share_subject_name", args: "p_organization_id uuid, p_type text, p_id uuid", returns: "text", security: "definer" },
+  { name: "shared_only_disagreements", args: "p_pretend text DEFAULT NULL::text", returns: "TABLE(organization_id uuid, organization_name text, member_id uuid, record_id uuid, table_id uuid, ladder boolean, read_door boolean, rls_mirror boolean, why text)", security: "invoker" },
+  { name: "shares_outside", args: "p_organization_id uuid", returns: "TABLE(invitation_id uuid, table_id uuid, table_name text, email text, level text, level_label text, status text, joined boolean, expired boolean, invited_at timestamp with time zone, expires_at timestamp with time zone, say text)", security: "definer" },
+  { name: "sign_request_cancel", args: "p_organization_id uuid, p_request_id uuid, p_reason text DEFAULT NULL::text", returns: "jsonb", security: "definer" },
+  { name: "sign_request_create", args: "p_organization_id uuid, p_render_id uuid, p_field_key text, p_signer_email text, p_signer_name text, p_expires_in interval DEFAULT '14 days'::interval", returns: "jsonb", security: "definer" },
+  { name: "sign_request_decline", args: "p_token text, p_reason text DEFAULT NULL::text, p_ip text DEFAULT NULL::text, p_user_agent text DEFAULT NULL::text", returns: "jsonb", security: "definer" },
+  { name: "sign_request_public", args: "p_token text, p_origin text DEFAULT NULL::text", returns: "jsonb", security: "definer" },
+  { name: "sign_request_remind", args: "p_organization_id uuid, p_request_id uuid", returns: "jsonb", security: "definer" },
+  { name: "sign_request_sentence", args: "p_data jsonb", returns: "text", security: "invoker" },
+  { name: "sign_request_sign", args: "p_token text, p_signed_name text, p_mark text, p_image text DEFAULT NULL::text, p_ip text DEFAULT NULL::text, p_user_agent text DEFAULT NULL::text, p_origin text DEFAULT NULL::text", returns: "jsonb", security: "definer" },
+  { name: "sign_request_state", args: "p_data jsonb", returns: "text", security: "invoker" },
+  { name: "sign_request_unchanged", args: "p_organization_id uuid, p_request_id uuid", returns: "boolean", security: "definer" },
+  { name: "sign_requests", args: "p_organization_id uuid, p_record_id uuid", returns: "TABLE(request_id uuid, render_id uuid, record_id uuid, field_key text, document_title text, signer_name text, signer_email text, signer_has_account boolean, state text, sentence text, document_version integer, document_hash text, sent_at timestamp with time zone, expires_at timestamp with time zone, viewed_at timestamp with time zone, signed_at timestamp with time zone, declined_at timestamp with time zone, invalidated_at timestamp with time zone, signature_id uuid, signature_mark text, reminder_count integer)", security: "definer" },
+  { name: "sign_token_decode", args: "p_token text", returns: "bytea", security: "invoker" },
+  { name: "sign_token_encode", args: "p_bytes bytea", returns: "text", security: "invoker" },
+  { name: "silent_page_doors", args: "", returns: "TABLE(door text, why text)", security: "definer" },
+  { name: "size_refusal", args: "p_organization_id uuid, p_data jsonb", returns: "text", security: "invoker" },
+  { name: "source_next_pointer", args: "p_sources jsonb", returns: "text", security: "invoker" },
+  { name: "source_pointer", args: "p_sources jsonb, p_source jsonb", returns: "text", security: "invoker" },
+  { name: "stage_rule_enforcement", args: "p_organization_id uuid", returns: "text", security: "invoker" },
+  { name: "stage_rule_on_fail_kinds", args: "", returns: "TABLE(behaviour text, note text)", security: "invoker" },
+  { name: "stamp_value_envelopes", args: "p_data jsonb, p_actor text, p_on_behalf_of text, p_at timestamp with time zone", returns: "jsonb", security: "invoker" },
+  { name: "status_groups_keyed", args: "p_organization_id uuid, p_options_table_id uuid, p_groups jsonb, p_kept jsonb, p_label text", returns: "jsonb", security: "invoker" },
+  { name: "status_groups_of", args: "p_groups jsonb", returns: "jsonb", security: "invoker" },
+  { name: "storage_modes", args: "", returns: "text[]", security: "invoker" },
+  { name: "store_census_pair_ceiling", args: "", returns: "integer", security: "invoker" },
+  { name: "store_is_open", args: "p_organization_id uuid DEFAULT NULL::uuid", returns: "boolean", security: "invoker" },
+  { name: "store_off_sentence", args: "p_organization_id uuid", returns: "text", security: "invoker" },
+  { name: "subscription_cadences", args: "p_organization_id uuid", returns: "text[]", security: "definer" },
+  { name: "subscription_declare", args: "p_organization_id uuid, p_table_id uuid, p_spec jsonb", returns: "uuid", security: "definer" },
+  { name: "subscription_mute", args: "p_organization_id uuid, p_rule_id uuid, p_muted boolean DEFAULT true", returns: "boolean", security: "definer" },
+  { name: "subscription_preview", args: "p_organization_id uuid, p_rule_id uuid", returns: "jsonb", security: "definer" },
+  { name: "subscriptions", args: "p_organization_id uuid, p_table_id uuid DEFAULT NULL::uuid", returns: "TABLE(rule_id uuid, name text, table_id uuid, saved_view_id uuid, cadence text, schedule text, quiet_hours jsonb, channel text, recipient_user_id uuid, event_key text, muted boolean, mine boolean, i_may_mute boolean, last_sent_at timestamp with time zone, next_digest_at timestamp with time zone)", security: "definer" },
+  { name: "table_add_rung", args: "p_organization_id uuid, p_table_id uuid", returns: "permission_level", security: "invoker" },
+  { name: "table_archive", args: "p_organization_id uuid, p_table_id uuid, p_chunk integer DEFAULT 50, p_include_table boolean DEFAULT true", returns: "jsonb", security: "definer" },
+  { name: "table_archive_deliberately", args: "p_organization_id uuid, p_table_id uuid, p_typed_slug text, p_reason text", returns: "jsonb", security: "definer" },
+  { name: "table_capacity", args: "p_organization_id uuid, p_table_id uuid", returns: "jsonb", security: "definer" },
+  { name: "table_carries_its_rows", args: "p_user_id uuid, p_table_id uuid, p_required permission_level DEFAULT 'viewer'::permission_level", returns: "boolean", security: "definer" },
+  { name: "table_column_source", args: "p_organization_id uuid, p_table_id uuid", returns: "text", security: "invoker" },
+  { name: "table_contents", args: "p_organization_id uuid, p_table_id uuid", returns: "TABLE(record_id uuid, kind text, goes_at integer)", security: "invoker" },
+  { name: "table_copies_in_progress", args: "", returns: "jsonb", security: "definer" },
+  { name: "table_declare", args: "p_organization_id uuid, p_spec jsonb", returns: "uuid", security: "definer" },
+  { name: "table_decorate", args: "p_organization_id uuid, p_table_id uuid, p_path text[], p_value jsonb DEFAULT NULL::jsonb", returns: "jsonb", security: "definer" },
+  { name: "table_decorations", args: "p_organization_id uuid, p_table_id uuid", returns: "jsonb", security: "definer" },
+  { name: "table_dimensions", args: "p_organization_id uuid, p_table_id uuid", returns: "jsonb", security: "definer" },
+  { name: "table_dimensions_set", args: "p_organization_id uuid, p_table_id uuid, p_overrides jsonb", returns: "jsonb", security: "definer" },
+  { name: "table_duplicate", args: "p_table_id uuid, p_with_records boolean DEFAULT false, p_name text DEFAULT NULL::text, p_organization_id uuid DEFAULT NULL::uuid", returns: "jsonb", security: "definer" },
+  { name: "table_duplicate_continue", args: "p_table_id uuid", returns: "jsonb", security: "definer" },
+  { name: "table_ensure", args: "p_organization_id uuid, p_spec jsonb", returns: "jsonb", security: "definer" },
+  { name: "table_facts", args: "p_organization_id uuid DEFAULT NULL::uuid", returns: "TABLE(table_id uuid, visibility text, mine boolean, kept_by_the_app boolean, kept_for text, offered_as_context boolean, keeper_group text, keeper_says text, used_in_kind text, used_in_id uuid, used_in_table_id uuid, foundation boolean)", security: "definer" },
+  { name: "table_find", args: "p_organization_id uuid, p_slug text DEFAULT NULL::text, p_name text DEFAULT NULL::text, p_kept_for text DEFAULT NULL::text", returns: "jsonb", security: "definer" },
+  { name: "table_from_example", args: "p_organization_id uuid, p_home_id uuid, p_example jsonb", returns: "jsonb", security: "definer" },
+  { name: "table_has_a_visible_record", args: "p_user uuid, p_organization_id uuid, p_table_id uuid", returns: "boolean", security: "definer" },
+  { name: "table_home", args: "p_table_id uuid, p_to_organization_id uuid DEFAULT NULL::uuid", returns: "jsonb", security: "definer" },
+  { name: "table_is_foundation", args: "p_data jsonb", returns: "boolean", security: "invoker" },
+  { name: "table_is_live", args: "p_organization_id uuid, p_table_id uuid", returns: "boolean", security: "invoker" },
+  { name: "table_is_options_table", args: "p_organization_id uuid, p_table_id uuid", returns: "boolean", security: "invoker" },
+  { name: "table_is_platform_context", args: "p_organization_id uuid, p_table_id uuid", returns: "boolean", security: "invoker" },
+  { name: "table_kept_for_derived", args: "p_data jsonb, p_is_kernel boolean, p_is_options boolean", returns: "text", security: "invoker" },
+  { name: "table_kept_out_of_lists", args: "p_kept_for text", returns: "boolean", security: "invoker" },
+  { name: "table_kernel_id", args: "", returns: "uuid", security: "invoker" },
+  { name: "table_kind_facts", args: "p_table_id uuid", returns: "jsonb", security: "definer" },
+  { name: "table_list_everywhere", args: "p_organization_id uuid DEFAULT NULL::uuid", returns: "jsonb", security: "definer" },
+  { name: "table_list_everywhere", args: "p_organization_id uuid, p_include_app_tables boolean", returns: "jsonb", security: "invoker" },
+  { name: "table_move", args: "p_table_id uuid, p_to_organization_id uuid, p_expected_version integer DEFAULT NULL::integer", returns: "jsonb", security: "definer" },
+  { name: "table_placement", args: "p_organization_id uuid, p_table_id uuid, p_data jsonb, p_is_kernel boolean DEFAULT false", returns: "jsonb", security: "invoker" },
+  { name: "table_record_ceiling", args: "", returns: "integer", security: "invoker" },
+  { name: "table_record_ceiling", args: "p_organization_id uuid", returns: "integer", security: "invoker" },
+  { name: "table_restore", args: "p_organization_id uuid, p_table_id uuid, p_chunk integer DEFAULT 20", returns: "jsonb", security: "definer" },
+  { name: "table_row_counts", args: "p_organization_id uuid, p_table_ids uuid[]", returns: "TABLE(table_id uuid, visible_rows bigint)", security: "definer" },
+  { name: "table_row_defaults", args: "p_organization_id uuid, p_table_id uuid", returns: "jsonb", security: "definer" },
+  { name: "table_row_defaults_apply", args: "p_organization_id uuid, p_table_id uuid, p_after uuid DEFAULT NULL::uuid, p_budget_ms integer DEFAULT 4000", returns: "jsonb", security: "definer" },
+  { name: "table_row_defaults_set", args: "p_organization_id uuid, p_table_id uuid, p_defaults jsonb", returns: "jsonb", security: "definer" },
+  { name: "table_rules", args: "p_organization_id uuid, p_table_id uuid, p_use text, p_record_type text DEFAULT NULL::text", returns: "SETOF custom.record", security: "invoker" },
+  { name: "table_share_outside", args: "p_organization_id uuid, p_table_id uuid", returns: "jsonb", security: "definer" },
+  { name: "table_share_outside_accept", args: "p_token text", returns: "jsonb", security: "definer" },
+  { name: "table_share_outside_for_me", args: "", returns: "TABLE(invitation_id uuid, organization_id uuid, organization text, table_id uuid, table_name text, level text, level_label text, token text, expires_at timestamp with time zone, say text)", security: "definer" },
+  { name: "table_share_outside_grant", args: "p_organization_id uuid, p_table_id uuid, p_person text, p_level permission_level DEFAULT 'viewer'::permission_level", returns: "jsonb", security: "definer" },
+  { name: "table_share_outside_invite", args: "p_organization_id uuid, p_table_id uuid, p_email text, p_level permission_level DEFAULT 'viewer'::permission_level", returns: "jsonb", security: "definer" },
+  { name: "table_share_outside_resend", args: "p_organization_id uuid, p_invitation_id uuid", returns: "jsonb", security: "definer" },
+  { name: "table_share_outside_revoke", args: "p_organization_id uuid, p_invitation_id uuid", returns: "jsonb", security: "definer" },
+  { name: "table_stage_field", args: "p_organization_id uuid, p_table_id uuid", returns: "text", security: "definer" },
+  { name: "table_storage", args: "p_organization_id uuid, p_table_id uuid", returns: "text", security: "invoker" },
+  { name: "table_sync", args: "p_organization_id uuid, p_home_id uuid, p_spec jsonb", returns: "jsonb", security: "definer" },
+  { name: "table_transfer_owner", args: "p_table_id uuid, p_to_person uuid, p_reason text", returns: "jsonb", security: "definer" },
+  { name: "table_type_field", args: "p_organization_id uuid, p_table_id uuid", returns: "text", security: "definer" },
+  { name: "table_unique_rule_fields", args: "p_organization_id uuid, p_table_id uuid", returns: "jsonb", security: "invoker" },
+  { name: "table_webhook_archive", args: "p_organization_id uuid, p_webhook_id uuid", returns: "boolean", security: "definer" },
+  { name: "table_webhook_declare", args: "p_organization_id uuid, p_table_id uuid, p_target_url text, p_events text[] DEFAULT NULL::text[], p_description text DEFAULT NULL::text", returns: "jsonb", security: "definer" },
+  { name: "table_webhooks", args: "p_organization_id uuid, p_table_id uuid", returns: "TABLE(webhook_id uuid, target_url text, description text, events text[], is_active boolean, last_attempt_at timestamp with time zone, last_success_at timestamp with time zone, consecutive_failures integer, owner_id uuid, created_at timestamp with time zone)", security: "definer" },
+  { name: "table_work_kind", args: "p_organization_id uuid, p_table_id uuid", returns: "text", security: "invoker" },
+  { name: "tables_at_home", args: "p_organization_id uuid, p_home_ids uuid[]", returns: "TABLE(table_id uuid, home_record_id uuid, kind text)", security: "definer" },
+  { name: "tables_described_without_asking", args: "", returns: "TABLE(function_name text, identity_args text, why text)", security: "invoker" },
+  { name: "tables_i_can_open", args: "", returns: "TABLE(table_id uuid, table_name text, organization_id uuid, organization_name text, member boolean, visibility text, updated_at timestamp with time zone)", security: "definer" },
+  { name: "tables_listed_among", args: "p_organization_id uuid, p_tables uuid[]", returns: "SETOF uuid", security: "invoker" },
+  { name: "tables_seen_among", args: "p_user_id uuid, p_organization_ids uuid[], p_among uuid[]", returns: "TABLE(organization_id uuid, id uuid, seen boolean)", security: "definer" },
+  { name: "tables_seen_once_per_group", args: "p_user_id uuid, p_organization_ids uuid[]", returns: "TABLE(organization_id uuid, id uuid, seen boolean)", security: "definer" },
+  { name: "tables_shared_with_me", args: "", returns: "TABLE(table_id uuid, organization_id uuid, organization text, table_name text, level text, level_label text, shared_at timestamp with time zone, opens boolean, say text)", security: "definer" },
+  { name: "template_declare", args: "p_scope text, p_spec jsonb", returns: "jsonb", security: "definer" },
+  { name: "template_from_tables", args: "p_organization_id uuid, p_table_ids uuid[], p_include_rows boolean DEFAULT false, p_rows_per_table integer DEFAULT 25", returns: "jsonb", security: "definer" },
+  { name: "template_install", args: "p_organization_id uuid, p_template_id uuid, p_budget_ms integer DEFAULT 4000", returns: "jsonb", security: "definer" },
+  { name: "template_install_claim", args: "p_organization_id uuid, p_install_id uuid, p_kind text, p_label text, p_source_id uuid DEFAULT NULL::uuid, p_lease_seconds integer DEFAULT NULL::integer", returns: "jsonb", security: "definer" },
+  { name: "template_install_note", args: "p_organization_id uuid, p_install_id uuid, p_kind text, p_id uuid, p_label text DEFAULT NULL::text", returns: "jsonb", security: "definer" },
+  { name: "template_restore", args: "p_organization_id uuid, p_install_id uuid, p_budget_ms integer DEFAULT 4000", returns: "jsonb", security: "definer" },
+  { name: "template_uninstall", args: "p_organization_id uuid, p_install_id uuid, p_budget_ms integer DEFAULT 4000", returns: "jsonb", security: "definer" },
+  { name: "templates", args: "p_filter jsonb DEFAULT '{}'::jsonb", returns: "jsonb", security: "definer" },
+  { name: "text_head_bytes", args: "p_text text, p_bytes bigint", returns: "text", security: "invoker" },
+  { name: "trg_associations_bump_visibility", args: "", returns: "trigger", security: "definer" },
+  { name: "undeclared_keys", args: "p_organization_id uuid, p_table_id uuid, p_data jsonb", returns: "text[]", security: "invoker" },
+  { name: "unresolved_sources_of", args: "p_sources jsonb, p_visible text[], p_by_id boolean DEFAULT false, p_key_ids jsonb DEFAULT '{}'::jsonb", returns: "jsonb", security: "invoker" },
+  { name: "validate_custom_fields", args: "p_token text, p_organization_id uuid, p_values jsonb", returns: "void", security: "invoker" },
+  { name: "validate_value_envelope", args: "p_organization_id uuid, p_fields custom.record[], p_data jsonb", returns: "void", security: "invoker" },
+  { name: "validate_values", args: "p_organization_id uuid, p_fields custom.record[], p_values jsonb, p_record_type text DEFAULT NULL::text", returns: "void", security: "invoker" },
+  { name: "value_alternate_keys", args: "", returns: "text[]", security: "invoker" },
+  { name: "value_envelope_keys", args: "", returns: "text[]", security: "invoker" },
+  { name: "value_envelope_ok", args: "p_data jsonb", returns: "boolean", security: "invoker" },
+  { name: "value_envelope_refusal", args: "p_data jsonb", returns: "text", security: "invoker" },
+  { name: "value_read", args: "p_organization_id uuid, p_record_id uuid, p_key text", returns: "TABLE(field_key text, field_id uuid, value jsonb, value_version integer, source jsonb, absent_reason text, actor text, on_behalf_of text, written_at timestamp with time zone, alternates jsonb)", security: "definer" },
+  { name: "value_restore", args: "p_organization_id uuid, p_record_id uuid, p_field_key text, p_version integer", returns: "jsonb", security: "definer" },
+  { name: "value_restore", args: "p_organization_id uuid, p_record_id uuid, p_field_key text, p_version integer, p_author jsonb", returns: "jsonb", security: "definer" },
+  { name: "value_versions", args: "p_old jsonb, p_new jsonb", returns: "jsonb", security: "invoker" },
+  { name: "view_declare", args: "p_organization_id uuid, p_table_id uuid, p_spec jsonb", returns: "uuid", security: "definer" },
+  { name: "view_designate", args: "p_organization_id uuid, p_table_id uuid, p_view_id uuid, p_layout text DEFAULT NULL::text", returns: "uuid", security: "definer" },
+  { name: "view_keys", args: "", returns: "TABLE(path text, shape text, layouts text[], writer text, sentence text)", security: "invoker" },
+  { name: "view_keys_check", args: "p_organization_id uuid, p_table_id uuid, p_set jsonb, p_old jsonb DEFAULT '{}'::jsonb", returns: "jsonb", security: "invoker" },
+  { name: "view_look_read", args: "p_organization_id uuid, p_table_id uuid", returns: "jsonb", security: "definer" },
+  { name: "view_look_set", args: "p_organization_id uuid, p_table_id uuid, p_view_id uuid, p_look jsonb", returns: "jsonb", security: "definer" },
+  { name: "view_record_order_set", args: "p_organization_id uuid, p_view_id uuid, p_record_ids uuid[]", returns: "jsonb", security: "definer" },
+  { name: "views", args: "p_organization_id uuid, p_table_id uuid DEFAULT NULL::uuid", returns: "TABLE(view_id uuid, name text, table_id uuid, filters jsonb, definition jsonb, created_at timestamp with time zone)", security: "definer" },
+  { name: "visibility_ancestors", args: "p_item_type text, p_item_id uuid", returns: "TABLE(container_type text, container_id uuid, depth integer, max_level permission_level)", security: "definer" },
+  { name: "visibility_as_of", args: "p_organization_id uuid, p_record_id uuid, p_at timestamp with time zone", returns: "TABLE(principal_kind text, principal_id uuid, level permission_level, through_kind text, through_id uuid, reason text, replayed boolean, held_from timestamp with time zone, held_to timestamp with time zone)", security: "definer" },
+  { name: "visibility_cache_rebuild", args: "", returns: "integer", security: "definer" },
+  { name: "visibility_parity", args: "", returns: "TABLE(side text, container_type text, container_id uuid, item_type text, item_id uuid, stored_level permission_level, derived_level permission_level, reason text)", security: "definer" },
+  { name: "visibility_warm", args: "p_container_type text, p_container_id uuid", returns: "integer", security: "definer" },
+  { name: "visible_predicate_sql", args: "p_user uuid, p_organization_id uuid, p_table_id uuid, p_required permission_level DEFAULT 'viewer'::permission_level, p_alias text DEFAULT 'r'::text", returns: "text", security: "definer" },
+  { name: "visible_record_ids", args: "p_user_id uuid, p_required permission_level DEFAULT 'viewer'::permission_level", returns: "TABLE(id uuid)", security: "definer" },
+  { name: "visible_set", args: "p_user uuid, p_organization_id uuid, p_table_id uuid, p_required permission_level DEFAULT 'viewer'::permission_level, OUT o_all_visible boolean, OUT o_true_visibility platform.visibility[], OUT o_granted_all uuid[], OUT o_granted_visible uuid[], OUT o_carried_visible uuid[], OUT o_ladder_calls integer, OUT o_fallback boolean, OUT o_note text", returns: "record", security: "definer" },
+  { name: "where_id_opens", args: "p_id uuid", returns: "jsonb", security: "definer" },
+  { name: "where_lists_live", args: "p_list_ids uuid[]", returns: "TABLE(list_id uuid, lives_in text, address text, why text)", security: "definer" },
+  { name: "where_tables_live", args: "p_table_ids uuid[]", returns: "TABLE(table_id uuid, lives_in text, why text)", security: "definer" },
+  { name: "whole_value_ceiling", args: "p_organization_id uuid", returns: "bigint", security: "invoker" },
+  { name: "whole_value_complete", args: "p_organization_id uuid, p_record_id uuid, p_field_key text, p_file_id uuid", returns: "jsonb", security: "definer" },
+  { name: "whole_value_head", args: "p_text text", returns: "text", security: "invoker" },
+  { name: "whole_value_park", args: "p_organization_id uuid, p_table_id uuid, p_record_id uuid, p_owner_id uuid, p_visibility platform.visibility, p_data jsonb, p_park jsonb", returns: "void", security: "invoker" },
+  { name: "whole_value_pointer_of", args: "p_values jsonb, p_sources jsonb, p_key text", returns: "jsonb", security: "invoker" },
+  { name: "whole_value_source", args: "p_text text, p_writer_src jsonb", returns: "jsonb", security: "invoker" },
+  { name: "whole_values_waiting", args: "p_organization_id uuid, p_record_ids uuid[]", returns: "TABLE(record_id uuid, field_key text, pointer text, value_version integer, sha256 text, bytes bigint, chars bigint, owner_id uuid, record_visibility text, table_id uuid, table_name text)", security: "definer" },
+  { name: "widget_kernel_id", args: "", returns: "uuid", security: "invoker" },
+  { name: "with_whole_value_pointers", args: "p_document jsonb, p_values jsonb, p_sources jsonb, p_visible text[], p_by_id boolean DEFAULT false, p_key_ids jsonb DEFAULT '{}'::jsonb", returns: "jsonb", security: "invoker" },
+  { name: "withheld_marker", args: "p_mask jsonb, p_key text", returns: "jsonb", security: "invoker" },
+  { name: "withheld_sentence", args: "p_mask jsonb, p_key text", returns: "text", security: "invoker" },
+  { name: "work_approval_approvers", args: "p_organization_id uuid, p_subject_id uuid, p_approver_id uuid DEFAULT NULL::uuid", returns: "TABLE(user_id uuid, name text, why text)", security: "definer" },
+  { name: "work_approval_decide", args: "p_organization_id uuid, p_approval_id uuid, p_approve boolean, p_note text DEFAULT NULL::text", returns: "jsonb", security: "definer" },
+  { name: "work_approval_kinds", args: "", returns: "text[]", security: "invoker" },
+  { name: "work_approval_may_decide", args: "p_organization_id uuid, p_approval_id uuid", returns: "boolean", security: "definer" },
+  { name: "work_approval_read", args: "p_organization_id uuid, p_approval_id uuid", returns: "jsonb", security: "definer" },
+  { name: "work_approval_request", args: "p_organization_id uuid, p_subject_id uuid, p_change jsonb, p_note text DEFAULT NULL::text, p_approver_id uuid DEFAULT NULL::uuid, p_origin text DEFAULT 'person'::text, p_conversation_id uuid DEFAULT NULL::uuid", returns: "jsonb", security: "definer" },
+  { name: "work_approval_withdrawal", args: "p_organization_id uuid, p_data jsonb", returns: "text", security: "invoker" },
+  { name: "work_assign", args: "p_organization_id uuid, p_record_id uuid, p_assignee_user_id uuid, p_due_date timestamp with time zone DEFAULT NULL::timestamp with time zone, p_clear_due boolean DEFAULT false", returns: "jsonb", security: "definer" },
+  { name: "work_assignment_fields", args: "p_options_table_id uuid DEFAULT NULL::uuid", returns: "TABLE(key text, label text, spec jsonb)", security: "invoker" },
+  { name: "work_decide_many", args: "p_organization_id uuid, p_decisions jsonb", returns: "jsonb", security: "definer" },
+  { name: "work_has_assignment", args: "p_organization_id uuid, p_table_id uuid", returns: "boolean", security: "definer" },
+  { name: "work_inbox", args: "p_organization_id uuid DEFAULT NULL::uuid, p_limit integer DEFAULT 50, p_offset integer DEFAULT 0, p_include_decided boolean DEFAULT false, p_view text DEFAULT 'inbox'::text", returns: "TABLE(item_id uuid, kind text, origin text, title text, subject_id uuid, subject_kind text, summary text, state text, due_on timestamp with time zone, due_state text, actionable boolean, requested_by uuid, requested_by_name text, at timestamp with time zone, table_id uuid, table_name text, decided_by uuid, decided_by_name text, decided_at timestamp with time zone, outcome text, snoozed_until timestamp with time zone, cleared_at timestamp with time zone, snoozed_count integer, cleared_count integer, undo_seconds integer, undo_refusal text)", security: "definer" },
+  { name: "work_instantiation_shape", args: "p_organization_id uuid, p_instantiation_id uuid", returns: "jsonb", security: "definer" },
+  { name: "work_list", args: "p_organization_id uuid DEFAULT NULL::uuid, p_flavour text DEFAULT 'mine'::text, p_include_finished boolean DEFAULT false, p_limit integer DEFAULT 100, p_offset integer DEFAULT 0", returns: "TABLE(record_id uuid, table_id uuid, table_name text, title text, assignee_id uuid, assignee_name text, assignee_user_id uuid, due_on timestamp with time zone, due_state text, status text, terminal boolean, assigned_by uuid, updated_at timestamp with time zone)", security: "definer" },
+  { name: "work_person", args: "p_organization_id uuid, p_user_id uuid, p_create boolean DEFAULT true", returns: "uuid", security: "definer" },
+  { name: "work_record_states", args: "p_organization_id uuid, p_record_id uuid", returns: "TABLE(state_id uuid, name text, sort integer, terminal boolean, is_current boolean, allowed boolean, refusal text)", security: "definer" },
+  { name: "work_relation_kinds", args: "", returns: "TABLE(kind text, available boolean, why text)", security: "invoker" },
+  { name: "work_set_state", args: "p_organization_id uuid, p_record_id uuid, p_state_id uuid", returns: "jsonb", security: "definer" },
+  { name: "work_slot_expire", args: "p_organization_id uuid, p_table_id uuid", returns: "integer", security: "definer" },
+  { name: "work_slot_hold", args: "p_organization_id uuid, p_table_id uuid, p_slot_key text, p_holder text, p_ttl interval DEFAULT '00:15:00'::interval", returns: "jsonb", security: "definer" },
+  { name: "work_slot_holds", args: "p_organization_id uuid, p_table_id uuid", returns: "TABLE(hold_id uuid, slot_key text, holder text, expires_at timestamp with time zone, expired boolean)", security: "definer" },
+  { name: "work_slot_index_name", args: "p_table_id uuid", returns: "text", security: "invoker" },
+  { name: "work_slot_release", args: "p_organization_id uuid, p_hold_id uuid", returns: "boolean", security: "definer" },
+  { name: "work_slots_declare", args: "p_organization_id uuid, p_name text, p_slug text, p_home_id uuid DEFAULT NULL::uuid", returns: "jsonb", security: "definer" },
+  { name: "work_state_id", args: "p_organization_id uuid, p_table_id uuid, p_value text", returns: "uuid", security: "invoker" },
+  { name: "work_states", args: "", returns: "TABLE(sort integer, name text, terminal boolean, next text[])", security: "invoker" },
+  { name: "work_take_assignment", args: "p_organization_id uuid, p_table_id uuid", returns: "jsonb", security: "definer" },
+  { name: "work_template_declare", args: "p_organization_id uuid, p_name text, p_graph jsonb", returns: "uuid", security: "definer" },
+  { name: "work_template_instantiate", args: "p_organization_id uuid, p_template_id uuid, p_overrides jsonb DEFAULT '{}'::jsonb", returns: "jsonb", security: "definer" },
+  { name: "work_template_refusal", args: "p_graph jsonb", returns: "text", security: "invoker" },
+  { name: "work_template_shape", args: "p_organization_id uuid, p_template_id uuid", returns: "jsonb", security: "definer" },
+  { name: "work_templates", args: "p_organization_id uuid, p_limit integer DEFAULT 100", returns: "TABLE(template_id uuid, name text, nodes integer, relations integer, created_at timestamp with time zone)", security: "definer" },
+  { name: "work_transition_refusal", args: "p_organization_id uuid, p_from_state_id uuid, p_to_state_id uuid", returns: "text", security: "definer" },
+  { name: "work_whose_turn", args: "p_organization_id uuid, p_table_id uuid, p_include_finished boolean DEFAULT false", returns: "TABLE(record_id uuid, title text, assignee_id uuid, turn text, due_on timestamp with time zone, state text, status text, terminal boolean)", security: "definer" }
+];
+
+// src/templates/validate.ts
+var pad = (n, w = 2) => String(n).padStart(w, "0");
+function zoneOffset(localIso, timeZone) {
+  const [d, t = "00:00"] = localIso.split("T");
+  const [y, mo, da] = (d ?? "").split("-").map(Number);
+  const [h, mi] = t.split(":").map(Number);
+  const guess = Date.UTC(y ?? 1970, (mo ?? 1) - 1, da ?? 1, h ?? 0, mi ?? 0);
+  const read = (at) => {
+    const part = new Intl.DateTimeFormat("en-US", { timeZone, timeZoneName: "longOffset" }).formatToParts(new Date(at)).find((p) => p.type === "timeZoneName")?.value;
+    const m = /GMT([+-])(\d{2}):?(\d{2})?/.exec(part ?? "");
+    return m ? (m[1] === "-" ? -1 : 1) * (Number(m[2]) * 60 + Number(m[3] ?? 0)) : 0;
+  };
+  const minutes = read(guess - read(guess) * 6e4);
+  const sign = minutes < 0 ? "-" : "+";
+  return `${sign}${pad(Math.floor(Math.abs(minutes) / 60))}:${pad(Math.abs(minutes) % 60)}`;
+}
+function addToDay(today, sign, n, unit) {
+  const [y, m, d] = today.split("-").map(Number);
+  const k = sign === "-" ? -n : n;
+  if (unit === "d" || unit === "w") {
+    const at = new Date(Date.UTC(y, m - 1, d + (unit === "w" ? 7 * k : k)));
+    return `${at.getUTCFullYear()}-${pad(at.getUTCMonth() + 1)}-${pad(at.getUTCDate())}`;
+  }
+  const months = unit === "y" ? 12 * k : k;
+  const first = new Date(Date.UTC(y, m - 1 + months, 1));
+  const last = new Date(Date.UTC(first.getUTCFullYear(), first.getUTCMonth() + 1, 0)).getUTCDate();
+  return `${first.getUTCFullYear()}-${pad(first.getUTCMonth() + 1)}-${pad(Math.min(d, last))}`;
+}
+var WEEKDAYS = ["sun", "mon", "tue", "wed", "thu", "fri", "sat"];
+var dayOfWeek = (day) => (/* @__PURE__ */ new Date(`${day}T00:00:00Z`)).getUTCDay();
+var shiftDays = (day, n) => addToDay(day, n < 0 ? "-" : "+", Math.abs(n), "d");
+function addBusinessDays(day, n) {
+  let d = day;
+  let left = Math.abs(n);
+  while (left > 0) {
+    d = shiftDays(d, n < 0 ? -1 : 1);
+    const w = dayOfWeek(d);
+    if (w !== 0 && w !== 6) left -= 1;
+  }
+  return d;
+}
+function resolveDateToken(token, today, timeZone) {
+  const m = RELATIVE_DATE.exec(token);
+  if (!m) return null;
+  let day = today;
+  const anchor = m[1] ?? "today";
+  if (anchor !== "today") {
+    const name = anchor.replace(/^(last|next)-/, "");
+    const monday = shiftDays(today, -((dayOfWeek(today) + 6) % 7));
+    day = shiftDays(monday, (WEEKDAYS.indexOf(name) + 6) % 7 + (anchor.startsWith("last-") ? -7 : anchor.startsWith("next-") ? 7 : 0));
+  }
+  if (m[2]) {
+    const n = Number(m[3]) * (m[2] === "-" ? -1 : 1);
+    day = m[4] === "b" ? addBusinessDays(day, n) : addToDay(day, m[2], Number(m[3]), m[4] ?? "d");
+  }
+  if (m[5]) {
+    const w = dayOfWeek(day);
+    if (w === 6) day = shiftDays(day, 2);
+    if (w === 0) day = shiftDays(day, 1);
+  }
+  if (m[6] === void 0) return day;
+  const local = `${day}T${m[6]}:${m[7]}`;
+  return `${local}:00${zoneOffset(local, timeZone)}`;
+}
+var BEHAVIOR_OF = new Map([
+  ...PARITY_FIELD_TYPES.map((t) => [t.parity_type, t.behavior]),
+  ...DECLARABLE_FIELD_KINDS.map((k) => [k.kind, k.behavior]),
+  ["number", "range"],
+  ["integer", "range"],
+  ["decimal", "range"],
+  ["float", "range"],
+  ["long_text", "text"],
+  ["string", "text"],
+  ["text", "text"]
+]);
+function blockTable(block, rows) {
+  const b = SHARED_BLOCKS[block];
+  return {
+    token: b.table,
+    name: b.name,
+    labelSingular: b.labelSingular,
+    labelPlural: b.labelPlural,
+    type: "entity",
+    display: "grid",
+    weight: "light",
+    ordered: false,
+    titleField: b.titleField,
+    describes: b.describes,
+    fields: b.fields.map(({ sameAs: _sameAs, ...f }) => ({ ...f })),
+    rows
+  };
+}
+function allTables(spec) {
+  return [...spec.tables ?? [], ...(spec.sharedBlocks ?? []).filter((s) => SHARED_BLOCKS[s.block]).map((s) => blockTable(s.block, s.rows ?? []))];
+}
+var STORE_DOOR_NAMES = new Set(STORE_DOORS.map((d) => d.name));
+var STORE_FIELD_KINDS = new Set(BEHAVIOR_OF.keys());
+
+// src/templates/plan.ts
+var INSTALL_PLAN_VERSION = 1;
+var ROW_BATCH = 10;
+var DERIVED = /* @__PURE__ */ new Set(["lookup", "rollup"]);
+var FILE_VALUE = /^@file:([A-Za-z0-9_.-]+)$/;
+var TOKEN_NAME = /^[A-Za-z0-9_.:-]+$/;
+var ref = (name) => {
+  if (!TOKEN_NAME.test(name)) throw new Error(`"${name}" cannot be an id name in an install plan (letters, digits, _ . : - only).`);
+  return `\${ref:${name}}`;
+};
+var minted = (name) => {
+  if (!TOKEN_NAME.test(name)) throw new Error(`"${name}" cannot be an id name in an install plan (letters, digits, _ . : - only).`);
+  return `\${new:${name}}`;
+};
+function tokenizeValues(value, attachments) {
+  const walk = (v) => {
+    if (typeof v === "string") {
+      if (RELATIVE_DATE.test(v)) return `\${date:${v}}`;
+      const f = FILE_VALUE.exec(v);
+      if (f) {
+        if (!attachments.has(f[1])) throw new Error(`A row points at the file "${f[1]}", which the template's attachments do not list.`);
+        return ref(`files.${f[1]}`);
+      }
+      return v;
+    }
+    if (Array.isArray(v)) return v.map(walk);
+    if (v && typeof v === "object") return Object.fromEntries(Object.entries(v).map(([k, x]) => [k, walk(x)]));
+    return v;
+  };
+  return walk(value);
+}
+function compileInstallPlan(written) {
+  const attachments = written.attachments ?? [];
+  const attachmentKeys = new Set(attachments.map((a) => a.key));
+  const spec = tokenizeValues({ ...written, attachments: void 0 }, attachmentKeys);
+  const bound = new Map(allTables(spec).filter((t) => t.bindsTo?.tableId).map((t) => [t.token, t.bindsTo]));
+  const has = (token, key) => bound.get(token)?.fields.includes(key) ?? false;
+  const tables = allTables(spec).map((t) => {
+    if (bound.has(t.token)) return { ...t, rows: [] };
+    const toBound = t.fields.filter((f) => f.parityType === "relation" && f.relationTarget && bound.has(f.relationTarget)).map((f) => f.key);
+    if (!toBound.length) return t;
+    return { ...t, rows: t.rows.map((r) => ({ ...r, values: Object.fromEntries(Object.entries(r.values ?? {}).filter(([k]) => !toBound.includes(k))) })) };
+  });
+  const steps = [];
+  const tableRef = (token) => {
+    if (!tables.some((t) => t.token === token)) throw new Error(`The template names a table "${token}" it does not have.`);
+    return ref(`tables.${token}`);
+  };
+  const tableTokens = Object.fromEntries(tables.map((t) => [t.token, ref(`tables.${t.token}`)]));
+  const bookingProblem = spec.extras.filter((e) => e.kind === "booking").map((b) => bookingColumnsProblem(tables, b)).find((p) => p);
+  if (bookingProblem) throw new Error(bookingProblem);
+  steps.push({ label: "home.kernel", door: "person_kernel_id", args: {}, save: { "kernel.person": [] } });
+  steps.push({
+    label: "home",
+    door: "record_write",
+    args: { p_organization_id: "${org}", p_table_id: ref("kernel.person"), p_data: { name: `${spec.business.name} Home` } },
+    save: { home: [] },
+    made: [{ kind: "record", ref: "home", title: `${spec.business.name} Home` }]
+  });
+  if (attachments.length) {
+    steps.push({ label: "files.kernel", door: "file_kernel_id", args: {}, save: { "kernel.file": [] } });
+    for (const a of attachments) {
+      steps.push({
+        label: `files.${a.key}`,
+        door: "record_write",
+        args: { p_organization_id: "${org}", p_table_id: ref("kernel.file"), p_data: { file_id: a.fileId, name: a.name, mime: a.mime, bytes: a.bytes } },
+        save: { [`files.${a.key}`]: [] },
+        made: [{ kind: "record", ref: `files.${a.key}`, title: a.name }]
+      });
+    }
+  }
+  for (const t of tables) {
+    if (bound.has(t.token)) {
+      for (const f of t.fields.filter((x) => !DERIVED.has(x.parityType) && x.parityType !== "formula" && x.parityType !== "relation" && !isSelfDeclaredField(x) && !has(t.token, x.key))) {
+        steps.push({
+          label: `bound.${t.token}.${f.key}`,
+          door: "field_declare",
+          args: { p_organization_id: "${org}", p_table_id: tableRef(t.token), p_spec: selfDeclaredFieldSpec(f) },
+          save: { [`fields.${t.token}.${f.key}`]: [] },
+          made: [{ kind: "field", ref: `fields.${t.token}.${f.key}`, table: `tables.${t.token}` }]
+        });
+      }
+      continue;
+    }
+    steps.push({
+      label: `tables.${t.token}`,
+      door: "table_from_example",
+      args: { p_organization_id: "${org}", p_home_id: ref("home"), p_example: tableShellPayload(spec, t) },
+      saveEach: { array: ["tables"], key: ["token"], value: ["table_id"], prefix: "tables." },
+      made: [{ kind: "table", ref: `tables.${t.token}`, title: t.name }]
+    });
+  }
+  steps.push(...membersAddRowsSteps(spec, tableRef));
+  for (const t of tables) {
+    for (const f of t.fields.filter((x) => x.parityType === "relation" && x.relationTarget && !has(t.token, x.key))) {
+      steps.push({
+        label: `relations.${t.token}.${f.key}`,
+        door: "field_declare",
+        args: { p_organization_id: "${org}", p_table_id: tableRef(t.token), p_spec: relationFieldSpec(f, tableRef(f.relationTarget)) },
+        save: { [`fields.${t.token}.${f.key}`]: [] },
+        made: [{ kind: "field", ref: `fields.${t.token}.${f.key}`, table: `tables.${t.token}` }]
+      });
+    }
+  }
+  for (const t of tables) {
+    for (const f of t.fields.filter((x) => isSelfDeclaredField(x) && !has(t.token, x.key))) {
+      steps.push({
+        label: `self_declared.${t.token}.${f.key}`,
+        door: "field_declare",
+        args: { p_organization_id: "${org}", p_table_id: tableRef(t.token), p_spec: selfDeclaredFieldSpec(f) },
+        save: { [`fields.${t.token}.${f.key}`]: [] },
+        made: [{ kind: "field", ref: `fields.${t.token}.${f.key}`, table: `tables.${t.token}` }]
+      });
+    }
+  }
+  const rowIds = /* @__PURE__ */ new Map();
+  for (const t of tables) for (const r of t.rows) rowIds.set(`${t.token}.${r.key}`, minted(`row.${t.token}.${r.key}`));
+  const deferred = deferredRelations(tables);
+  for (const level of rowLevels(tables)) {
+    for (const t of level) {
+      const { rows, ids } = rowsFor(t, rowIds, deferred.get(t.token));
+      for (let i = 0; i < rows.length; i += ROW_BATCH) {
+        steps.push({
+          label: `rows.${t.token}.${i / ROW_BATCH + 1}`,
+          door: "record_write_many",
+          args: { p_organization_id: "${org}", p_table_id: tableRef(t.token), p_rows: rows.slice(i, i + ROW_BATCH), p_ids: ids.slice(i, i + ROW_BATCH) }
+        });
+      }
+    }
+  }
+  for (const t of tables) {
+    const changes = relationPatches(t, rowIds, deferred.get(t.token));
+    for (let i = 0; i < changes.length; i += ROW_BATCH) {
+      steps.push({
+        label: `links.${t.token}.${i / ROW_BATCH + 1}`,
+        door: "record_change_many",
+        args: { p_organization_id: "${org}", p_table_id: tableRef(t.token), p_changes: changes.slice(i, i + ROW_BATCH) }
+      });
+    }
+  }
+  for (const t of tables) {
+    for (const f of t.fields.filter((x) => DERIVED.has(x.parityType) && !has(t.token, x.key))) {
+      steps.push({
+        label: `derived.${t.token}.${f.key}`,
+        door: "field_declare",
+        args: { p_organization_id: "${org}", p_table_id: tableRef(t.token), p_spec: derivedFieldSpec(f) },
+        save: { [`fields.${t.token}.${f.key}`]: [] },
+        made: [{ kind: "field", ref: `fields.${t.token}.${f.key}`, table: `tables.${t.token}` }]
+      });
+    }
+  }
+  for (const t of tables) {
+    for (const f of formulaOrder(t).filter((x) => !has(t.token, x.key))) {
+      steps.push({
+        label: `formula.${t.token}.${f.key}`,
+        door: "field_declare",
+        args: { p_organization_id: "${org}", p_table_id: tableRef(t.token), p_spec: formulaFieldSpec(f) },
+        save: { [`fields.${t.token}.${f.key}`]: [] },
+        made: [{ kind: "field", ref: `fields.${t.token}.${f.key}`, table: `tables.${t.token}` }]
+      });
+    }
+  }
+  const needIds = /* @__PURE__ */ new Set([
+    ...spec.extras.filter((e) => e.kind === "document" || e.kind === "row_action").map((e) => e.table),
+    ...spec.views.filter((v) => v.anyOf && Object.keys(v.anyOf).length).map((v) => v.table)
+  ]);
+  const fieldRefs = (token) => {
+    const t = tables.find((x) => x.token === token);
+    return Object.fromEntries((t?.fields ?? []).map((f) => [f.key, ref(`fields.${token}.${f.key}`)]));
+  };
+  for (const token of needIds) {
+    steps.push({
+      label: `field_ids.${token}`,
+      door: "applicable_fields",
+      args: { p_organization_id: "${org}", p_table_id: tableRef(token), p_record_type: null },
+      saveEach: { array: [], key: ["data", "key"], value: ["id"], prefix: `fields.${token}.` }
+    });
+  }
+  for (const d of spec.dimensions.filter((x) => !bound.has(x.table))) {
+    const overrides = {};
+    if (d.dimensions) overrides["dimensions"] = d.dimensions;
+    if (d.measures) overrides["measures"] = d.measures;
+    if (d.paths) overrides["paths"] = d.paths;
+    if (d.default) overrides["default"] = d.default;
+    steps.push({
+      label: `dimensions.${d.table}`,
+      door: "table_dimensions_set",
+      args: { p_organization_id: "${org}", p_table_id: tableRef(d.table), p_overrides: overrides }
+    });
+  }
+  for (const v of spec.views) {
+    steps.push({
+      label: `views.${v.token}`,
+      door: "view_declare",
+      args: { p_organization_id: "${org}", p_table_id: tableRef(v.table), p_spec: viewSpec(v, fieldRefs(v.table)) },
+      save: { [`views.${v.token}`]: [] },
+      made: [{ kind: "view", ref: `views.${v.token}`, title: v.name, table: `tables.${v.table}` }]
+    });
+  }
+  for (const f of spec.forms) {
+    steps.push({
+      label: `forms.${f.token}`,
+      door: "form_declare",
+      args: formArgs("${org}", tableRef(f.table), f),
+      save: { [`forms.${f.token}`]: [] },
+      made: [{ kind: "form", ref: `forms.${f.token}`, title: f.name, table: `tables.${f.table}` }]
+    });
+  }
+  const actionsByTable = /* @__PURE__ */ new Map();
+  const formRefs = Object.fromEntries(spec.forms.map((f) => [f.token, ref(`forms.${f.token}`)]));
+  const documentRefs = Object.fromEntries(
+    spec.extras.filter((e) => e.kind === "document").map((e) => [e.token, ref(`documents.${e.token}`)])
+  );
+  const extrasInOrder = [...spec.extras.filter((e) => e.kind === "document"), ...spec.extras.filter((e) => e.kind !== "document")];
+  for (const e of extrasInOrder) {
+    switch (e.kind) {
+      case "booking":
+        steps.push({
+          label: `bookings.${e.token}`,
+          door: "booking_declare",
+          args: bookingArgs("${org}", tableRef(e.table), e),
+          save: { [`bookings.${e.token}.form`]: ["form_id"], [`bookings.${e.token}.slots`]: ["slot_table_id"] },
+          made: [
+            { kind: "form", ref: `bookings.${e.token}.form`, title: e.title, table: `tables.${e.table}` },
+            { kind: "table", ref: `bookings.${e.token}.slots`, title: `${e.title} slots` }
+          ]
+        });
+        break;
+      case "dashboard":
+        steps.push({
+          label: `dashboards.${e.token}`,
+          door: "dashboard_declare",
+          args: { p_organization_id: "${org}", p_table_id: tableRef(e.table), p_name: e.name, p_blocks: dashboardBlocks(e, tableTokens), p_presentation: {}, p_dashboard_id: null },
+          save: { [`dashboards.${e.token}`]: [] },
+          made: [{ kind: "dashboard", ref: `dashboards.${e.token}`, title: e.name, table: `tables.${e.table}` }]
+        });
+        break;
+      case "drill_down": {
+        const d = drillDownDashboard(e, spec.dimensions);
+        steps.push({
+          label: `dashboards.${e.token}`,
+          door: "dashboard_declare",
+          args: { p_organization_id: "${org}", p_table_id: tableRef(e.table), p_name: d.name, p_blocks: d.blocks, p_presentation: {}, p_dashboard_id: null },
+          save: { [`dashboards.${e.token}`]: [] },
+          made: [{ kind: "dashboard", ref: `dashboards.${e.token}`, title: e.name, table: `tables.${e.table}` }]
+        });
+        break;
+      }
+      case "digest": {
+        const view = spec.views.find((v) => v.token === e.view);
+        if (!view) throw new Error(`The digest "${e.name}" sends the view "${e.view}", which this template does not declare.`);
+        steps.push({
+          label: `digests.${e.token}`,
+          door: "subscription_declare",
+          args: { p_organization_id: "${org}", p_table_id: tableRef(view.table), p_spec: digestSpec(e, ref(`views.${e.view}`)) },
+          save: { [`digests.${e.token}`]: [] },
+          made: [{ kind: "rule", ref: `digests.${e.token}`, title: e.name, table: `tables.${view.table}` }]
+        });
+        break;
+      }
+      case "stage_rules":
+        steps.push({
+          label: `stage_rules.${e.token}`,
+          door: "pipeline_declare",
+          args: { p_organization_id: "${org}", p_table_id: tableRef(e.table), p_spec: stageRulesSpec(e) }
+        });
+        break;
+      case "document":
+        steps.push({
+          label: `documents.${e.token}`,
+          door: "doc_template_save",
+          args: { p_organization_id: "${org}", p_table_id: tableRef(e.table), p_name: e.name, p_body: documentBody(e, fieldRefs(e.table), spec.business.name), p_template_id: null },
+          save: { [`documents.${e.token}`]: [] },
+          made: [{ kind: "document", ref: `documents.${e.token}`, title: e.name, table: `tables.${e.table}` }]
+        });
+        break;
+      case "row_action":
+        actionsByTable.set(e.table, [...actionsByTable.get(e.table) ?? [], e]);
+        break;
+      case "notification": {
+        const n = notificationParts(e, stageFieldOf(tables, e.when.table, e.when.stage));
+        steps.push({
+          label: `notifications.${e.token}.view`,
+          door: "view_declare",
+          args: { p_organization_id: "${org}", p_table_id: tableRef(e.when.table), p_spec: n.view },
+          save: { [`notifications.${e.token}.view`]: [] },
+          made: [{ kind: "view", ref: `notifications.${e.token}.view`, title: e.name, table: `tables.${e.when.table}` }]
+        });
+        steps.push({
+          label: `notifications.${e.token}`,
+          door: "subscription_declare",
+          args: { p_organization_id: "${org}", p_table_id: tableRef(e.when.table), p_spec: { ...n.subscription, saved_view_id: ref(`notifications.${e.token}.view`) } },
+          save: { [`notifications.${e.token}`]: [] },
+          made: [{ kind: "rule", ref: `notifications.${e.token}`, title: e.name, table: `tables.${e.when.table}` }]
+        });
+        break;
+      }
+      case "portal":
+        steps.push({
+          label: `portals.${e.token}`,
+          door: "portal_declare",
+          args: portalArgs("${org}", e, tableTokens),
+          save: { [`portals.${e.token}`]: [] },
+          made: [{ kind: "portal", ref: `portals.${e.token}`, title: e.title, table: `tables.${e.clientTable}` }]
+        });
+        break;
+      case "checklist":
+        for (const t of [e.aboutTable, ...e.trigger && e.trigger.kind !== "manual" ? [e.trigger.table] : []]) tableRef(t);
+        for (const st of e.steps) {
+          const r = st.requires;
+          if (r?.kind === "form" && !formRefs[r.form]) throw new Error(`The checklist "${e.name}" asks for the form "${r.form}", which this template does not declare.`);
+          if (r?.kind === "document" && !documentRefs[r.document]) throw new Error(`The checklist "${e.name}" asks for the document "${r.document}", which this template does not declare.`);
+        }
+        steps.push({
+          label: `checklists.${e.token}`,
+          door: "checklist_declare",
+          args: { p_organization_id: "${org}", p_spec: checklistSpec(e, tableTokens, formRefs, documentRefs), p_template_id: null },
+          save: { [`checklists.${e.token}`]: ["template_id"] },
+          made: [{ kind: "record", ref: `checklists.${e.token}`, title: e.name }]
+        });
+        break;
+      case "automation":
+        throw new Error(automationHeld(e));
+      default:
+        throw new Error(`The install plan has no door for a ${e.kind} yet ("${e.token ?? "?"}"), so this template cannot be declared until it does.`);
+    }
+  }
+  for (const [token, actions] of actionsByTable) {
+    steps.push({
+      label: `row_actions.${token}`,
+      door: "action_declare",
+      args: { p_organization_id: "${org}", p_table_id: tableRef(token), p_actions: rowActionList(actions, fieldRefs(token)) }
+    });
+  }
+  const host = compileHostExtras(spec);
+  const agent = spec.agent;
+  return {
+    planVersion: INSTALL_PLAN_VERSION,
+    timezone: spec.business.timezone || "UTC",
+    steps,
+    ...agent?.platformAgent ? {
+      agent: {
+        platformAgent: agent.platformAgent,
+        name: agent.name,
+        bindings: (agent.variables ?? []).map((v) => {
+          const binding = host.agentBindings.get(v.name);
+          return { variable: v.name, tableToken: v.table, describes: v.describes, ...binding ? { binding } : {} };
+        })
+      }
+    } : {},
+    ...bound.size ? { ids: Object.fromEntries([...bound].map(([token, b]) => [`ref:tables.${token}`, b.tableId])) } : {},
+    ...host.extras
+  };
+}
+
+// src/choice.ts
+import { isUuidShape } from "@ai-matrx/kit/uuid";
+function choiceSlug(word) {
+  const slug = word.trim().toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "").slice(0, 55);
+  return slug === "" ? "choice" : slug;
+}
+
+// src/memory/world.ts
+var MEMORY_KERNEL = {
+  table: "11111111-0000-4000-8000-000000000001",
+  field: "11111111-0000-4000-8000-000000000002",
+  person: "11111111-0000-4000-8000-000000000005",
+  file: "11111111-0000-4000-8000-000000000006",
+  rule: "11111111-0000-4000-8000-000000000003"
+};
+function stableId(name) {
+  const lanes = [2166136261, 16777619, 2654435769, 2246822507];
+  for (let i = 0; i < name.length; i += 1) {
+    const c = name.charCodeAt(i);
+    for (let l = 0; l < 4; l += 1) lanes[l] = Math.imul((lanes[l] ^ c) >>> 0, 16777619 + l * 2) >>> 0;
+  }
+  const hex = lanes.map((n) => n.toString(16).padStart(8, "0")).join("");
+  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-4${hex.slice(13, 16)}-${"89ab"[parseInt(hex[16], 16) % 4]}${hex.slice(17, 20)}-${hex.slice(20, 32)}`;
+}
+var COMPUTED2 = /* @__PURE__ */ new Set(["lookup", "rollup", "formula"]);
+function storedField(spec, tableId, tableToken, sort, idOf) {
+  const key = String(spec["key"]);
+  const parity = String(spec["parityType"] ?? spec["type"] ?? "text");
+  const base = {
+    key,
+    label: spec["label"] ?? key,
+    sort,
+    dated: Boolean(spec["dated"]),
+    multi: Boolean(spec["multi"]),
+    required: Boolean(spec["required"]),
+    rules: Array.isArray(spec["rules"]) ? spec["rules"] : [],
+    config: {},
+    source: COMPUTED2.has(parity) ? "formula" : "manual",
+    depends_on: [],
+    sensitivity: spec["sensitivity"] ?? "internal",
+    context_policy: spec["contextPolicy"] ?? spec["context_policy"] ?? "include",
+    applies_to_types: [],
+    entity_definition_id: tableId,
+    parity_type: parity
+  };
+  const unit = spec["unit"];
+  if (typeof unit === "string" && unit) base["unit"] = unit;
+  const display = spec["displayFormat"] ?? spec["display_format"];
+  if (display && typeof display === "object") base["display_format"] = display;
+  const config = base["config"];
+  switch (parity) {
+    case "text":
+      base["type"] = "text";
+      break;
+    case "long_text":
+      base["type"] = "text";
+      base["format"] = "long";
+      config["multiline"] = true;
+      break;
+    case "email":
+    case "phone":
+    case "url":
+    case "signature":
+      base["type"] = "text";
+      base["format"] = parity;
+      break;
+    case "number":
+    case "integer":
+    case "decimal":
+      base["type"] = "range";
+      break;
+    case "currency":
+      base["type"] = "range";
+      base["format"] = "currency";
+      if (!base["unit"]) base["unit"] = "USD";
+      break;
+    case "percent":
+      base["type"] = "range";
+      base["format"] = "percent";
+      break;
+    case "datetime": {
+      base["type"] = "range";
+      const timed = spec["kind"] === "datetime" || spec["format"] === "datetime";
+      config["kind"] = timed ? "datetime" : "date";
+      if (timed) base["format"] = "datetime";
+      break;
+    }
+    case "checkbox":
+      base["type"] = "boolean";
+      break;
+    case "select":
+    case "multi_select":
+      base["type"] = "list";
+      config["options_table_id"] = idOf(`options.${tableToken}.${key}`);
+      if (parity === "multi_select") base["multi"] = true;
+      break;
+    case "relation":
+      base["type"] = "relation";
+      base["relation_target"] = spec["relation_target"] ?? (spec["relationTarget"] ? idOf(`tables.${String(spec["relationTarget"])}`) : null);
+      if (spec["relation_max"] ?? spec["relationMax"]) base["relation_max"] = spec["relation_max"] ?? spec["relationMax"];
+      break;
+    case "member":
+      base["type"] = "relation";
+      base["relation_target"] = MEMORY_KERNEL.person;
+      break;
+    case "attachment":
+      base["type"] = "relation";
+      base["relation_target"] = MEMORY_KERNEL.file;
+      break;
+    case "lookup":
+      base["type"] = "formula";
+      config["via"] = spec["via"];
+      config["pick"] = spec["pick"];
+      break;
+    case "rollup":
+      base["type"] = "formula";
+      config["via"] = spec["via"];
+      config["agg"] = spec["agg"];
+      config["of"] = spec["of"] ?? spec["pick"];
+      if (spec["filter"]) config["filter"] = spec["filter"];
+      break;
+    case "formula":
+      base["type"] = "formula";
+      config["formula_text"] = spec["formula_text"] ?? spec["formula"];
+      break;
+    default:
+      base["type"] = "text";
+  }
+  if (parity !== "datetime" && typeof spec["format"] === "string" && !base["format"] && parity !== "lookup" && parity !== "rollup") {
+    base["format"] = spec["format"];
+  }
+  return { id: idOf(`fields.${tableToken}.${key}`), table_id: tableId, data: base };
+}
+var PLACEHOLDER = /\$\{(org|ref:[^}]+|new:[^}]+|date:[^}]+)\}/g;
+function templateWorld(spec, options = {}) {
+  const plan = compileInstallPlan(spec);
+  const today = options.today ?? (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+  const tz = plan.timezone || spec.business?.timezone || "UTC";
+  const seed = `template:${spec.id ?? spec.business?.name ?? "preview"}`;
+  const idOf = (name) => {
+    if (name === "kernel.person") return MEMORY_KERNEL.person;
+    if (name === "kernel.file") return MEMORY_KERNEL.file;
+    return plan.ids?.[`ref:${name}`] ?? stableId(`${seed}:${name}`);
+  };
+  const org = stableId(`${seed}:organization`);
+  const resolveString = (s) => {
+    const whole = /^\$\{(org|ref:[^}]+|new:[^}]+|date:[^}]+)\}$/.exec(s);
+    const one = (tok) => {
+      if (tok === "org") return org;
+      if (tok.startsWith("date:")) return resolveDateToken(tok.slice(5), today, tz) ?? tok.slice(5);
+      return idOf(tok.slice(4));
+    };
+    if (whole) return one(whole[1]);
+    return s.replace(PLACEHOLDER, (_m, tok) => one(tok));
+  };
+  const resolve = (v) => {
+    if (typeof v === "string") return resolveString(v);
+    if (Array.isArray(v)) return v.map(resolve);
+    if (v && typeof v === "object") return Object.fromEntries(Object.entries(v).map(([k, x]) => [k, resolve(x)]));
+    return v;
+  };
+  const world = {
+    organization_id: org,
+    user_id: stableId(`${seed}:viewer`),
+    timezone: tz,
+    today,
+    businessName: spec.business?.name ?? "",
+    tables: [],
+    tableById: /* @__PURE__ */ new Map(),
+    views: [],
+    forms: [],
+    dashboards: [],
+    recordTable: /* @__PURE__ */ new Map(),
+    stageField: /* @__PURE__ */ new Map()
+  };
+  const tokenOfTable = /* @__PURE__ */ new Map();
+  const addField = (table, raw) => {
+    const key = String(raw["key"]);
+    const existing = table.fields.findIndex((f) => f.data["key"] === key);
+    const field = storedField(raw, table.id, table.token, (existing >= 0 ? existing : table.fields.length) * 10 + 10, idOf);
+    if (existing >= 0) table.fields[existing] = field;
+    else table.fields.push(field);
+    const choices = raw["choices"] ?? raw["options"];
+    if (Array.isArray(choices)) {
+      const colors = /* @__PURE__ */ new Map();
+      const display = raw["displayFormat"] ?? raw["display_format"];
+      for (const c of display?.options?.choices ?? []) colors.set(c.value, c.color);
+      table.options.set(
+        key,
+        choices.map((label) => ({
+          id: idOf(`options.${table.token}.${key}.${String(label)}`),
+          key: choiceSlug(String(label)),
+          label: String(label),
+          color: colors.get(String(label)) ?? null
+        }))
+      );
+    }
+    table.document["fields"].push(key);
+  };
+  const writeRow = (table, id, data) => {
+    const doc = {};
+    for (const [k, v] of Object.entries(data)) if (!k.startsWith("_")) doc[k] = v;
+    for (const [key, opts] of table.options) {
+      const v = doc[key];
+      const toKey = (x) => opts.find((o) => o.label === x || o.key === x || o.id === x)?.key ?? x;
+      if (Array.isArray(v)) doc[key] = v.map(toKey);
+      else if (v !== void 0 && v !== null) doc[key] = toKey(v);
+    }
+    const before = table.rows.get(id);
+    if (!before) table.order.push(id);
+    table.rows.set(id, { ...before ?? {}, ...doc });
+    world.recordTable.set(id, table);
+  };
+  for (const step of plan.steps) {
+    const args = resolve(step.args);
+    const tableId = typeof args["p_table_id"] === "string" ? args["p_table_id"] : null;
+    const table = tableId ? world.tableById.get(tableId) : void 0;
+    switch (step.door) {
+      case "table_from_example":
+      case "table_declare": {
+        const example = args["p_example"] ?? { tables: [args["p_spec"]] };
+        for (const t of example.tables ?? []) {
+          const token = String(t["token"]);
+          const id = idOf(`tables.${token}`);
+          const made = {
+            id,
+            token,
+            document: {
+              name: t["name"],
+              slug: token,
+              label_singular: t["labelSingular"] ?? null,
+              label_plural: t["labelPlural"] ?? null,
+              description: t["describes"] ?? null,
+              title_field: t["titleField"] ?? null,
+              type: t["type"] ?? "entity",
+              display: t["display"] ?? "grid",
+              icon: t["icon"] ?? null,
+              fields: []
+            },
+            fields: [],
+            options: /* @__PURE__ */ new Map(),
+            rows: /* @__PURE__ */ new Map(),
+            order: []
+          };
+          world.tables.push(made);
+          world.tableById.set(id, made);
+          tokenOfTable.set(id, token);
+          for (const f of t["fields"] ?? []) addField(made, f);
+        }
+        break;
+      }
+      case "field_declare":
+        if (table) addField(table, args["p_spec"]);
+        break;
+      case "record_write":
+        if (table) writeRow(table, idOf(step.save ? Object.keys(step.save)[0] : `${step.label}`), args["p_data"]);
+        break;
+      case "record_write_many":
+        if (table) {
+          const rows = args["p_rows"] ?? [];
+          const ids = args["p_ids"] ?? [];
+          rows.forEach((r, i) => writeRow(table, ids[i] ?? idOf(`${step.label}.${i}`), r));
+        }
+        break;
+      case "record_change_many":
+        if (table) {
+          for (const change of args["p_changes"] ?? []) {
+            if (change["op"] === "update" && typeof change["record_id"] === "string") writeRow(table, change["record_id"], change["patch"]);
+          }
+        }
+        break;
+      case "view_declare": {
+        if (!tableId) break;
+        const s = args["p_spec"];
+        const token = step.label.replace(/^views\./, "");
+        world.views.push({
+          view_id: idOf(`views.${token}`),
+          token,
+          table_id: tableId,
+          name: String(s["name"] ?? token),
+          definition: { table_id: tableId, ...s["definition"] ?? {} },
+          filters: s["filters"] ?? {}
+        });
+        break;
+      }
+      case "form_declare":
+      case "booking_declare": {
+        if (!tableId) break;
+        const save = step.save ? Object.keys(step.save)[0] : step.label;
+        world.forms.push({
+          form_id: idOf(save),
+          token: step.label.replace(/^(forms|bookings|extras)\./, ""),
+          table_id: tableId,
+          title: String(args["p_title"] ?? ""),
+          questions: args["p_questions"] ?? [],
+          presentation: args["p_presentation"] ?? {},
+          booking: step.door === "booking_declare" ? args["p_availability"] ?? {} : null
+        });
+        break;
+      }
+      case "dashboard_declare": {
+        if (!tableId) break;
+        const save = step.save ? Object.keys(step.save)[0] : step.label;
+        world.dashboards.push({
+          dashboard_id: idOf(save),
+          token: step.label.replace(/^(dashboards|extras)\./, ""),
+          table_id: tableId,
+          name: String(args["p_name"] ?? ""),
+          blocks: args["p_blocks"] ?? []
+        });
+        break;
+      }
+      case "pipeline_declare": {
+        const stage = args["p_spec"]?.["stage_field"]?.["key"];
+        if (tableId && typeof stage === "string") world.stageField.set(tableId, stage);
+        break;
+      }
+      default:
+        break;
+    }
+  }
+  return world;
+}
+
+// src/memory/doors.ts
+var PREVIEW_REFUSAL = {
+  code: "42501",
+  message: "This is a preview of a template. Nothing here is saved \u2014 use the template to make it yours.",
+  details: null,
+  hint: null
+};
+var WRITE_DOOR = /(^|_)(write|writes|declare|delete|update|upsert|archive|restore|set|move|save|submit|insert|merge|retype|undo|retire|assign|claim|clear|snooze|unsnooze|publish|invite|revoke|issue|pin|duplicate|designate|bind|unbind|change|start|complete|decide|request|hold|release|expire|forget|begin|finish|rows|take|nudge|import|mute|sign|render|instantiate|ensure)(_|$)/;
+function ok(data) {
+  return { data, error: null };
+}
+function refuse(message, code = "PGRST202") {
+  return { data: null, error: { code, message, details: null, hint: null } };
+}
+function stamp(world) {
+  const at = `${world.today}T09:00:00+00:00`;
+  return { created_at: at, updated_at: at, created_by: world.user_id, updated_by: world.user_id };
+}
+function readDocument(world, table, id) {
+  const stored = table.rows.get(id) ?? {};
+  const doc = { ...stored };
+  const choices = {};
+  for (const [key, opts] of table.options) {
+    const v = stored[key];
+    if (v === void 0 || v === null) continue;
+    const one = (k) => opts.find((o) => o.key === k);
+    if (Array.isArray(v)) {
+      const picked = v.map(one).filter((o) => o !== void 0);
+      doc[key] = picked.map((o) => o.label);
+      choices[key] = picked.map((o) => ({ key: o.key, label: o.label, id: o.id, retired: false, reason: null }));
+    } else {
+      const o = one(v);
+      if (o) {
+        doc[key] = o.label;
+        choices[key] = { key: o.key, label: o.label, id: o.id, retired: false, reason: null };
+      }
+    }
+  }
+  if (Object.keys(choices).length) doc["_choices"] = choices;
+  for (const f of table.fields) {
+    if (f.data["type"] !== "formula") continue;
+    const key = String(f.data["key"]);
+    const config = f.data["config"] ?? {};
+    const parity = f.data["parity_type"];
+    if (parity === "lookup") doc[key] = lookup(world, table, stored, config);
+    else if (parity === "rollup") doc[key] = rollup(world, table, id, config);
+  }
+  return doc;
+}
+function lookup(world, table, stored, config) {
+  const via = String(config["via"] ?? "");
+  const pick = String(config["pick"] ?? "");
+  const target = stored[via];
+  const first = Array.isArray(target) ? target[0] : target;
+  if (typeof first !== "string") return null;
+  const far = world.recordTable.get(first);
+  if (!far) return null;
+  const value = readDocument(world, far, first)[pick];
+  void table;
+  return value ?? null;
+}
+function rollup(world, table, id, config) {
+  const via = String(config["via"] ?? "");
+  const [maybeTable, maybeField] = via.includes(".") ? via.split(".") : [null, via];
+  const of = config["of"] ? String(config["of"]) : null;
+  const agg = String(config["agg"] ?? "count");
+  const filter = config["filter"] ?? null;
+  const values = [];
+  let count = 0;
+  for (const other of world.tables) {
+    if (maybeTable && other.token !== maybeTable) continue;
+    const rel = other.fields.find((f) => f.data["key"] === maybeField && f.data["type"] === "relation" && f.data["relation_target"] === table.id);
+    if (!rel) continue;
+    for (const rid of other.order) {
+      const row = other.rows.get(rid);
+      const link = row[maybeField];
+      const linked = Array.isArray(link) ? link.includes(id) : link === id;
+      if (!linked) continue;
+      if (filter && !admits(world, other, rid, filter)) continue;
+      count += 1;
+      if (of) values.push(readDocument(world, other, rid)[of]);
+    }
+  }
+  const nums = values.filter((v) => typeof v === "number");
+  switch (agg) {
+    case "count":
+      return count;
+    case "sum":
+      return nums.reduce((a, b) => a + b, 0);
+    case "avg":
+      return nums.length ? nums.reduce((a, b) => a + b, 0) / nums.length : null;
+    case "min":
+      return nums.length ? Math.min(...nums) : values.filter((v) => typeof v === "string").sort()[0] ?? null;
+    case "max":
+      return nums.length ? Math.max(...nums) : values.filter((v) => typeof v === "string").sort().at(-1) ?? null;
+    default:
+      return count;
+  }
+}
+function admits(world, table, id, filter) {
+  if (!filter || typeof filter !== "object") return true;
+  const doc = readDocument(world, table, id);
+  const stored = table.rows.get(id) ?? {};
+  const f = filter;
+  if (typeof f["op"] === "string") return rule(table, doc, stored, f) !== false;
+  for (const [key, want] of Object.entries(f)) {
+    const got = doc[key];
+    const raw = stored[key];
+    if (want === null) {
+      if (!(got === null || got === void 0 || got === "")) return false;
+    } else if (typeof want === "object" && !Array.isArray(want)) {
+      const w = want;
+      if (typeof got !== "string" && typeof got !== "number") return false;
+      const g = String(got);
+      const at = new Date(g.length === 10 ? `${g}T00:00:00Z` : g).getTime();
+      if (w.to && at >= new Date(w.to).getTime()) return false;
+      if (w.from && at < new Date(w.from).getTime()) return false;
+    } else {
+      const list = Array.isArray(got) ? got : [got];
+      const rawList = Array.isArray(raw) ? raw : [raw];
+      if (!list.some((x) => x === want) && !rawList.some((x) => x === want)) return false;
+    }
+  }
+  return true;
+}
+function rule(table, doc, stored, node) {
+  if ("const" in node) return node["const"];
+  if (typeof node["field"] === "string") {
+    const field = table.fields.find((f) => f.id === node["field"] || f.data["key"] === node["field"]);
+    return field ? doc[String(field.data["key"])] ?? stored[String(field.data["key"])] ?? null : null;
+  }
+  const args = (node["args"] ?? []).map((a) => rule(table, doc, stored, a));
+  switch (node["op"]) {
+    case "and":
+    case "all":
+      return args.every((a) => a !== false);
+    case "or":
+    case "any":
+      return args.some((a) => a !== false && a !== null);
+    case "not":
+      return args[0] === false;
+    case "eq":
+      return Array.isArray(args[0]) ? args[0].includes(args[1]) : args[0] === args[1];
+    case "neq":
+      return args[0] !== args[1];
+    case "is_empty":
+      return args[0] === null || args[0] === void 0 || args[0] === "";
+    case "not_empty":
+      return !(args[0] === null || args[0] === void 0 || args[0] === "");
+    default:
+      return true;
+  }
+}
+function sortRows(world, table, ids, sort) {
+  const sorts = Array.isArray(sort) ? sort : [];
+  if (!sorts.length) return ids;
+  const docs = new Map(ids.map((id) => [id, readDocument(world, table, id)]));
+  return [...ids].sort((a, b) => {
+    for (const s of sorts) {
+      const key = s.field ?? "";
+      const x = docs.get(a)[key];
+      const y = docs.get(b)[key];
+      if (x === y) continue;
+      if (x === void 0 || x === null) return 1;
+      if (y === void 0 || y === null) return -1;
+      const c = typeof x === "number" && typeof y === "number" ? x - y : String(x).localeCompare(String(y));
+      if (c !== 0) return s.direction === "desc" ? -c : c;
+    }
+    return 0;
+  });
+}
+function matching(world, table, args) {
+  const search = typeof args["p_search"] === "string" ? args["p_search"].trim().toLowerCase() : "";
+  let ids = table.order.filter((id) => admits(world, table, id, args["p_filter"]));
+  if (search) ids = ids.filter((id) => JSON.stringify(readDocument(world, table, id)).toLowerCase().includes(search));
+  return sortRows(world, table, ids, args["p_sort"]);
+}
+var VIEWER = "viewer";
+function memoryDataSource(world) {
+  const looks = /* @__PURE__ */ new Map();
+  const tableRow = (t) => ({ id: t.id, document: { ...t.document }, level: VIEWER });
+  const row = (t, id) => ({ id, document: readDocument(world, t, id), level: VIEWER });
+  const tableOf = (args) => world.tableById.get(String(args["p_table_id"] ?? ""));
+  const fieldById = (id) => {
+    for (const t of world.tables) for (const f of t.fields) if (f.id === id) return { t, f };
+    return null;
+  };
+  const nameOf = (id) => {
+    const t = world.recordTable.get(id);
+    if (!t) return null;
+    const title = String(t.document["title_field"] ?? "");
+    const v = readDocument(world, t, id)[title];
+    return typeof v === "string" ? v : v === void 0 || v === null ? null : String(v);
+  };
+  const doors = {
+    table_kernel_id: () => ok(MEMORY_KERNEL.table),
+    field_kernel_id: () => ok(MEMORY_KERNEL.field),
+    person_kernel_id: () => ok(MEMORY_KERNEL.person),
+    file_kernel_id: () => ok(MEMORY_KERNEL.file),
+    rule_kernel_id: () => ok(MEMORY_KERNEL.rule),
+    store_is_open: () => ok(true),
+    read_records: (args) => {
+      const limit = Number(args["p_limit"] ?? 50);
+      const offset = Number(args["p_offset"] ?? 0);
+      if (args["p_table_id"] === MEMORY_KERNEL.table) return ok(world.tables.slice(offset, offset + limit).map(tableRow));
+      const t = tableOf(args);
+      if (!t) return ok([]);
+      return ok(t.order.slice(offset, offset + limit).map((id) => row(t, id)));
+    },
+    read_records_by_ids: (args) => {
+      const ids = args["p_record_ids"] ?? [];
+      if (args["p_table_id"] === MEMORY_KERNEL.table) return ok(world.tables.filter((t2) => ids.includes(t2.id)).map(tableRow));
+      const t = tableOf(args);
+      if (!t) return ok([]);
+      return ok(ids.filter((id) => t.rows.has(id)).map((id) => row(t, id)));
+    },
+    read_records_matching: (args) => {
+      const t = tableOf(args);
+      if (!t) return ok([]);
+      const limit = Number(args["p_limit"] ?? 50);
+      const offset = Number(args["p_offset"] ?? 0);
+      return ok(matching(world, t, args).slice(offset, offset + limit).map((id) => row(t, id)));
+    },
+    read_records_page: (args) => {
+      const t = tableOf(args);
+      const limit = Number(args["p_limit"] ?? 50);
+      const offset = Number(args["p_offset"] ?? 0);
+      if (!t) return ok({ rows: [], total: 0, limit, offset, sort_ignored: [] });
+      const ids = matching(world, t, args);
+      return ok({ rows: ids.slice(offset, offset + limit).map((id) => row(t, id)), total: ids.length, limit, offset, sort_ignored: [] });
+    },
+    read_record: (args) => {
+      const id = String(args["p_record_id"] ?? "");
+      const t = world.recordTable.get(id);
+      if (!t) return refuse("That record is not in this template.", "P0002");
+      return ok(readDocument(world, t, id));
+    },
+    record_headers: (args) => ok(
+      (args["p_ids"] ?? []).filter((id) => world.recordTable.has(id)).map((id) => ({ id, mine: false, version: 1, table_id: world.recordTable.get(id).id, deleted_at: null, ...stamp(world) }))
+    ),
+    applicable_fields: (args) => {
+      const t = tableOf(args);
+      if (!t) return ok([]);
+      return ok(
+        t.fields.map((f) => ({
+          id: f.id,
+          data: f.data,
+          version: 1,
+          metadata: {},
+          shown_to: null,
+          table_id: MEMORY_KERNEL.field,
+          data_class: "field",
+          deleted_at: null,
+          visibility: "internal",
+          custom_fields: {},
+          organization_id: world.organization_id,
+          ...stamp(world)
+        }))
+      );
+    },
+    field_options: (args) => {
+      const hit = fieldById(args["p_field_id"]);
+      if (!hit) return ok([]);
+      const opts = hit.t.options.get(String(hit.f.data["key"])) ?? [];
+      return ok(
+        opts.map((o, i) => ({
+          id: o.id,
+          organization_id: world.organization_id,
+          table_id: hit.f.data["config"]["options_table_id"] ?? null,
+          data_class: "record",
+          data: { name: o.label, sort: (i + 1) * 10, ...o.color ? { color: o.color } : {} },
+          version: 1,
+          metadata: { option_key: o.key },
+          custom_fields: {},
+          visibility: "internal",
+          deleted_at: null,
+          ...stamp(world)
+        }))
+      );
+    },
+    my_levels: (args) => ok((args["p_ids"] ?? []).map((id) => ({ id, level: VIEWER }))),
+    views: (args) => ok(
+      world.views.filter((v) => !args["p_table_id"] || v.table_id === args["p_table_id"]).map((v) => ({ view_id: v.view_id, name: v.name, table_id: v.table_id, filters: v.filters, definition: v.definition, created_at: `${world.today}T09:00:00Z` }))
+    ),
+    view_look_read: (args) => {
+      const out = {};
+      for (const [key, look] of looks) if (key.startsWith(`${String(args["p_table_id"])}:`)) out[key.split(":")[1]] = look;
+      return ok(out);
+    },
+    view_look_set: (args) => {
+      const key = `${String(args["p_table_id"])}:${String(args["p_view_id"])}`;
+      const look = args["p_look"] ?? null;
+      if (look) looks.set(key, { look, updated_at: (/* @__PURE__ */ new Date()).toISOString() });
+      else looks.delete(key);
+      return ok(look);
+    },
+    grid_layout: (args) => ok({
+      layout: { mode: "auto", wrap: false, row_height: "normal", fit_max_columns: 8, freeze_first_column: false },
+      source: { mode: "platform", wrap: "platform", row_height: "platform", fit_max_columns: "platform", freeze_first_column: "platform" },
+      refused: [],
+      view_id: args["p_view_id"] ?? null
+    }),
+    table_decorations: () => ok({ rows: {}, cells: {}, rules: [], stale: [], colors: ["slate", "green", "amber", "red", "blue", "violet", "teal"], columns: {}, version: 1, rule_ops: [] }),
+    row_actions: () => ok({ stale: [], actions: [] }),
+    table_stage_field: (args) => ok(world.stageField.get(String(args["p_table_id"])) ?? null),
+    pipeline_read: (args) => {
+      const t = tableOf(args);
+      const stage = t ? world.stageField.get(t.id) : void 0;
+      const field = stage ? t.fields.find((f) => f.data["key"] === stage) : void 0;
+      if (!t || !stage || !field) return ok({ is_pipeline: false, why: "This table has no stage column." });
+      const stages = (t.options.get(stage) ?? []).map((o) => ({ key: o.key, label: o.label, retired: false }));
+      return ok({ is_pipeline: true, table_id: t.id, stage_field: stage, field_id: field.id, stage_label: field.data["label"], stages, rules: [] });
+    },
+    pipeline_board: (args) => {
+      const t = tableOf(args);
+      const stage = t ? world.stageField.get(t.id) : void 0;
+      if (!t || !stage) return ok([]);
+      const measure = typeof args["p_measure"] === "string" ? args["p_measure"] : null;
+      const ids = t.order.filter((id) => admits(world, t, id, args["p_filter"]));
+      return ok(
+        (t.options.get(stage) ?? []).map((o, i) => {
+          const inIt = ids.filter((id) => t.rows.get(id)[stage] === o.key);
+          const total = measure ? inIt.reduce((sum, id) => sum + (typeof t.rows.get(id)[measure] === "number" ? t.rows.get(id)[measure] : 0), 0) : null;
+          return { stage_key: o.key, stage_label: o.label, stage_position: i + 1, cards: inIt.length, total, wip_limit: null, over_limit: false };
+        })
+      );
+    },
+    relation_words_many: (args) => ok((args["p_record_ids"] ?? []).map((id) => ({ record_id: id, words: nameOf(id), archived: false }))),
+    reverse_columns: (args) => {
+      const target = String(args["p_table_id"] ?? "");
+      const out = [];
+      for (const t of world.tables) {
+        for (const f of t.fields) {
+          if (f.data["type"] !== "relation" || f.data["relation_target"] !== target) continue;
+          out.push({
+            key: `${t.token}__${String(f.data["key"])}`,
+            label: String(t.document["name"] ?? t.token),
+            source_field_id: f.id,
+            source_field_key: f.data["key"],
+            source_field_label: f.data["label"],
+            source_table_id: t.id,
+            source_table_name: t.document["name"],
+            cardinality: "many",
+            read_only: true
+          });
+        }
+      }
+      return ok(out);
+    },
+    reverse_links_many: (args) => {
+      const hit = fieldById(args["p_field_id"]);
+      return ok(
+        (args["p_record_ids"] ?? []).map((rid) => {
+          if (!hit) return { record_id: rid, total: 0, links: [] };
+          const key = String(hit.f.data["key"]);
+          const links = hit.t.order.filter((id) => {
+            const v = hit.t.rows.get(id)[key];
+            return Array.isArray(v) ? v.includes(rid) : v === rid;
+          }).map((id) => ({ id, words: nameOf(id) ?? "" }));
+          return { record_id: rid, total: links.length, links };
+        })
+      );
+    },
+    // A template's own record has no history, comments, checklists or worked-out provenance yet:
+    // these are the answers an installed template gives on its first day.
+    record_history: () => ok([]),
+    field_history: () => ok([]),
+    computed_provenance: () => ok([]),
+    comment_thread: (args) => ok({ record_id: args["p_record_id"] ?? null, comments: [], may_comment: false, may_resolve: false }),
+    checklist_runs: () => ok([]),
+    checklist_templates: () => ok([]),
+    doc_templates: () => ok([]),
+    doc_renders: () => ok([]),
+    doc_signatures: () => ok([]),
+    record_row_controls: () => ok({
+      shown_to: { value: null, effective: "everyone", type_default: null, table_default: null, allowed: ["everyone"], is_child: false, can_change: false },
+      published_to_web: { available: false, value: false, table_default: null, can_change: false },
+      indexed: { available: false, value: null, table_default: null, effective: false, can_change: false }
+    }),
+    enrich_cells: () => ok([]),
+    enrichments: () => ok([]),
+    pipeline_pending: () => ok([]),
+    record_stage_pending: () => ok([]),
+    io_imports: () => ok([]),
+    relation_words: (args) => ok(nameOf(String(args["p_value"] ?? ""))),
+    forms: (args) => ok(
+      world.forms.filter((f) => !f.booking && (!args["p_table_id"] || f.table_id === args["p_table_id"])).map((f) => ({ form_id: f.form_id, table_id: f.table_id, title: f.title, questions: f.questions, presentation: f.presentation, published_at: null, slug: null }))
+    ),
+    bookings: (args) => ok(
+      world.forms.filter((f) => f.booking && (!args["p_table_id"] || f.table_id === args["p_table_id"])).map((f) => ({ form_id: f.form_id, table_id: f.table_id, title: f.title, questions: f.questions, availability: f.booking, presentation: f.presentation, slug: null }))
+    ),
+    dashboards: (args) => ok(
+      world.dashboards.filter((d) => !args["p_table_id"] || d.table_id === args["p_table_id"]).map((d) => ({ dashboard_id: d.dashboard_id, table_id: d.table_id, name: d.name, blocks: d.blocks, presentation: {} }))
+    )
+  };
+  const source = {
+    world,
+    rpc(fn, args) {
+      const name = fn.replace(/^custom\./, "");
+      const door = doors[name];
+      if (door) return Promise.resolve(door(args ?? {}));
+      if (WRITE_DOOR.test(name)) return Promise.resolve({ data: null, error: PREVIEW_REFUSAL });
+      return Promise.resolve(refuse(`A template preview does not answer ${name}.`));
+    },
+    schema() {
+      return {
+        from() {
+          throw new Error("A template preview reads through the store's doors, never a table.");
+        }
+      };
+    }
+  };
+  return source;
+}
+
+// src/memory/index.ts
+function templatePreview(spec, options = {}) {
+  const world = templateWorld(spec, options);
+  const config = {
+    dataSource: memoryDataSource(world),
+    actor: { actor: "user", user_id: world.user_id },
+    organizationId: world.organization_id
+  };
+  return {
+    config,
+    world,
+    tables: world.tables.map((t) => ({ id: t.id, token: t.token, name: String(t.document["name"] ?? t.token), rows: t.order.length })),
+    forms: world.forms.map((f) => ({ id: f.form_id, token: f.token, title: f.title, tableId: f.table_id, booking: f.booking !== null })),
+    dashboards: world.dashboards.map((d) => ({ id: d.dashboard_id, token: d.token, name: d.name, tableId: d.table_id }))
+  };
+}
+export {
+  MEMORY_KERNEL,
+  PREVIEW_REFUSAL,
+  memoryDataSource,
+  stableId,
+  templatePreview,
+  templateWorld
+};
+//# sourceMappingURL=index.js.map