@ai-matrx/records 0.3.0

package/dist/core/index.cjs

@@ -0,0 +1,3003 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/core/index.ts
+var core_exports = {};
+__export(core_exports, {
+  ABSENCE_REASONS: () => ABSENCE_REASONS,
+  ACTOR_VOCABULARY: () => ACTOR_VOCABULARY,
+  COMPUTE_ON: () => COMPUTE_ON,
+  CONTEXT_POLICIES: () => CONTEXT_POLICIES,
+  DEFAULT_DOCUMENT_MAX_BYTES: () => DEFAULT_DOCUMENT_MAX_BYTES,
+  DEFAULT_PAGE_SIZE: () => DEFAULT_PAGE_SIZE,
+  DEFAULT_VALUE_MAX_BYTES: () => DEFAULT_VALUE_MAX_BYTES,
+  DELIVERIES: () => DELIVERIES,
+  DOORS: () => DOORS,
+  ENTITY_TOKENS: () => ENTITY_TOKENS,
+  FIELD_SENSITIVITIES: () => FIELD_SENSITIVITIES,
+  FIELD_SOURCES: () => FIELD_SOURCES,
+  FRESHNESS: () => FRESHNESS,
+  KERNEL_TABLES: () => KERNEL_TABLES,
+  MAPPED_SQLSTATES: () => MAPPED_SQLSTATES,
+  MERGE_FIELD_MODIFIERS: () => MERGE_FIELD_MODIFIERS,
+  MERGE_FIELD_SEMANTIC_TYPES: () => MERGE_FIELD_SEMANTIC_TYPES,
+  MERGE_FIELD_SOURCES: () => MERGE_FIELD_SOURCES,
+  ON_DELETE: () => ON_DELETE,
+  OVERRIDE_POLICIES: () => OVERRIDE_POLICIES,
+  PARITY_FIELD_TYPES: () => PARITY_FIELD_TYPES,
+  PER_VALUE_ACCESS_WORDS: () => PER_VALUE_ACCESS_WORDS,
+  RELATION_BINDINGS: () => RELATION_BINDINGS,
+  RELATION_CARDINALITIES: () => RELATION_CARDINALITIES,
+  RELATION_FLAVORS: () => RELATION_FLAVORS,
+  RETIRED_ACTOR_WORDS: () => RETIRED_ACTOR_WORDS,
+  RULE_NODE_KINDS: () => RULE_NODE_KINDS,
+  RULE_USES: () => RULE_USES,
+  STORAGE_MODES: () => STORAGE_MODES,
+  STORE_DOORS: () => STORE_DOORS,
+  STORE_KNOBS: () => STORE_KNOBS,
+  STORE_REFUSAL_CODES: () => STORE_REFUSAL_CODES,
+  TABLE_DISPLAYS: () => TABLE_DISPLAYS,
+  TABLE_ORIGINS: () => TABLE_ORIGINS,
+  TABLE_TYPES: () => TABLE_TYPES,
+  VALUE_ALTERNATE_KEYS: () => VALUE_ALTERNATE_KEYS,
+  VALUE_ENVELOPE_KEYS: () => VALUE_ENVELOPE_KEYS,
+  asWriteConflict: () => asWriteConflict,
+  cellText: () => cellText,
+  createRecordsClient: () => createRecordsClient,
+  doorAbsent: () => doorAbsent,
+  doorCensus: () => doorCensus,
+  doorExists: () => doorExists,
+  err: () => err,
+  exportCsv: () => exportCsv,
+  exportXlsx: () => exportXlsx,
+  importCsv: () => importCsv,
+  importXlsx: () => importXlsx,
+  intersectIds: () => intersectIds,
+  isRecordsErr: () => isRecordsErr,
+  mapPgError: () => mapPgError,
+  measureKey: () => measureKey,
+  ok: () => ok,
+  parseCsv: () => parseCsv,
+  planQuery: () => planQuery,
+  predictEnvelopeRefusal: () => predictEnvelopeRefusal,
+  predictSizeRefusal: () => predictSizeRefusal,
+  predictValueRefusals: () => predictValueRefusals,
+  predictWriteRefusals: () => predictWriteRefusals,
+  staleWriteDetail: () => staleWriteDetail,
+  toAoa: () => toAoa
+});
+module.exports = __toCommonJS(core_exports);
+
+// src/vocabulary.ts
+var TABLE_TYPES = [
+  "entity",
+  "detail",
+  "reference",
+  "ledger",
+  "restricted",
+  "system",
+  "deprecated"
+];
+var TABLE_ORIGINS = ["standard", "custom"];
+var RELATION_FLAVORS = ["owned", "referenced"];
+var ON_DELETE = ["cascade", "set_null", "restrict"];
+var RELATION_BINDINGS = ["live", "snapshot"];
+var RELATION_CARDINALITIES = ["one", "many"];
+var FIELD_SOURCES = ["manual", "formula", "agent", "synced"];
+var COMPUTE_ON = ["read", "write"];
+var FIELD_SENSITIVITIES = ["public", "internal", "confidential", "restricted"];
+var DELIVERIES = ["inline", "on_demand", "auto"];
+var CONTEXT_POLICIES = ["include", "summarize", "exclude", "on_request"];
+var MERGE_FIELD_SOURCES = [
+  "literal",
+  "record",
+  "state",
+  "actor",
+  "platform",
+  "user_input",
+  "tool",
+  "derived"
+];
+var MERGE_FIELD_SEMANTIC_TYPES = [
+  "value",
+  "reference",
+  "resolver",
+  "computed",
+  "collection"
+];
+var MERGE_FIELD_MODIFIERS = [
+  "scoped",
+  "temporal",
+  "collection",
+  "live",
+  "fallback",
+  "formatted",
+  "required"
+];
+var OVERRIDE_POLICIES = [
+  "must_supply",
+  "shown_overridable",
+  "shown_locked",
+  "server_fixed",
+  "derived"
+];
+var FRESHNESS = ["live", "cached", "snapshot"];
+var TABLE_DISPLAYS = ["list", "grid", "board", "calendar", "timeline"];
+
+// src/aggregate.ts
+function measureKey(measure) {
+  return measure.op === "count" ? "count" : `${measure.op}_${measure.key ?? ""}`;
+}
+
+// src/results.ts
+function isRecordsErr(result) {
+  return result.ok === false;
+}
+var ok = (data) => ({ ok: true, data });
+var err = (error) => ({ ok: false, error });
+
+// src/store.generated.ts
+var ACTOR_VOCABULARY = ["user", "agent", "system"];
+var RETIRED_ACTOR_WORDS = { "ai": "agent", "code": "system", "human": "user" };
+var ABSENCE_REASONS = ["never asked", "none", "refused", "conflicting"];
+var VALUE_ENVELOPE_KEYS = ["ver", "src", "actor", "on_behalf_of", "at", "absent", "alternates", "dated"];
+var VALUE_ALTERNATE_KEYS = ["value", "src", "rank"];
+var STORAGE_MODES = ["light", "heavy"];
+var RULE_USES = ["validate", "compute", "membership", "applicability"];
+var PER_VALUE_ACCESS_WORDS = ["visibility", "access", "share", "acl", "permission", "permissions", "secret"];
+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: "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 RULE_NODE_KINDS = [
+  { node: "add", evaluated_by: "W1-RULE" },
+  { node: "and", evaluated_by: "W1-RULE" },
+  { node: "concat", evaluated_by: "W1-RULE" },
+  { node: "const", evaluated_by: "W1-RULE" },
+  { node: "div", evaluated_by: "W1-RULE" },
+  { node: "eq", evaluated_by: "W1-RULE" },
+  { node: "field", evaluated_by: "W1-RULE" },
+  { node: "gt", evaluated_by: "W1-RULE" },
+  { node: "gte", evaluated_by: "W1-RULE" },
+  { node: "length", evaluated_by: "W1-RULE" },
+  { node: "lt", evaluated_by: "W1-RULE" },
+  { node: "lte", evaluated_by: "W1-RULE" },
+  { node: "matches", evaluated_by: "W1-RULE" },
+  { node: "merge_field", evaluated_by: "W5-MERGE-B" },
+  { node: "mul", evaluated_by: "W1-RULE" },
+  { node: "ne", evaluated_by: "W1-RULE" },
+  { node: "not", evaluated_by: "W1-RULE" },
+  { node: "or", evaluated_by: "W1-RULE" },
+  { node: "parent_field", evaluated_by: "W1-RULE-APPLY" },
+  { node: "present", evaluated_by: "W1-RULE" },
+  { node: "sub", evaluated_by: "W1-RULE" }
+];
+var KERNEL_TABLES = [
+  { id: "11111111-0000-4000-8000-000000000002", name: "Field" },
+  { id: "11111111-0000-4000-8000-000000000006", name: "File" },
+  { id: "11111111-0000-4000-8000-000000000009", name: "Merge Field" },
+  { id: "11111111-0000-4000-8000-000000000004", name: "Organization" },
+  { id: "11111111-0000-4000-8000-000000000005", name: "Person" },
+  { id: "11111111-0000-4000-8000-000000000007", name: "Presentation" },
+  { id: "11111111-0000-4000-8000-000000000003", name: "Rule" },
+  { id: "11111111-0000-4000-8000-000000000001", name: "Table" },
+  { id: "11111111-0000-4000-8000-000000000008", name: "Widget" }
+];
+var STORE_DOORS = [
+  { name: "absence_reasons", args: "", returns: "text[]", security: "invoker" },
+  { name: "actor_vocabulary", args: "", returns: "text[]", security: "invoker" },
+  { name: "actor_word", args: "p_declared text", returns: "text", security: "invoker" },
+  { name: "agent_context", args: "p_organization_id uuid, p_table_id uuid, p_limit integer DEFAULT 50", returns: "jsonb", security: "invoker" },
+  { name: "agg_assert_key", args: "p_key text", returns: "text", security: "invoker" },
+  { name: "agg_buckets", args: "", returns: "text[]", 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", returns: "uuid", 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_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: "invoker" },
+  { name: "agg_operations", args: "", 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", 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_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, cadence text, schedule text, 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_view_admits", args: "p_organization_id uuid, p_saved_view_id uuid, p_record_id uuid", returns: "boolean", 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_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: "assert_client_may_reach", args: "p_organization_id uuid, p_door 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_store_door", args: "p_organization_id uuid, p_door text", returns: "void", security: "invoker" },
+  { 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: "client_write_grants", args: "", returns: "TABLE(role_name text, object_name text, privilege text)", 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: "invoker" },
+  { 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: "custom_fields_tables", args: "", returns: "TABLE(token text, schema_name text, table_name text)", security: "invoker" },
+  { 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: "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_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_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_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_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_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_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: "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: "field_dependants", args: "p_organization_id uuid, p_field_id uuid", returns: "TABLE(kind text, dependant_id uuid, label text, how text)", security: "invoker" },
+  { name: "field_kernel_id", args: "", returns: "uuid", security: "invoker" },
+  { name: "field_options", args: "p_organization_id uuid, p_field_id uuid", returns: "SETOF custom.record", security: "invoker" },
+  { name: "field_rules", args: "p_field_data jsonb", returns: "TABLE(kind text, spec jsonb)", security: "invoker" },
+  { name: "file_kernel_id", args: "", returns: "uuid", 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: "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: "home_add", args: "p_organization_id uuid, p_table_id uuid, p_home_record_id uuid", returns: "uuid", security: "invoker" },
+  { name: "home_relations", args: "", returns: "TABLE(table_id uuid, home_record_id uuid, organization_id uuid, relation_id uuid)", security: "invoker" },
+  { 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_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 ','::text, p_required text DEFAULT 'viewer'::text", returns: "text", 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_rows", args: "p_organization_id uuid, p_import_id uuid, p_rows jsonb, p_mapping jsonb DEFAULT '{}'::jsonb", returns: "jsonb", security: "definer" },
+  { name: "io_infer_type", args: "p_samples jsonb", returns: "text", security: "invoker" },
+  { name: "io_outbox_announce", args: "", returns: "trigger", security: "definer" },
+  { 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_release", args: "p_organization_id uuid, p_consumer text, p_older_than interval DEFAULT '00:15:00'::interval", returns: "integer", 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_record_changed", args: "", returns: "trigger", security: "definer" },
+  { name: "io_restore", args: "p_organization_id uuid, p_record_id uuid, p_version integer", 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)", security: "definer" },
+  { 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: "merge_field_kernel_id", args: "", returns: "uuid", security: "invoker" },
+  { name: "migrate_delete", args: "p_organization_id uuid, p_record_id uuid, p_note text DEFAULT NULL::text", returns: "jsonb", security: "invoker" },
+  { name: "migrate_demote", args: "p_organization_id uuid, p_table_id uuid, p_note text DEFAULT NULL::text", returns: "jsonb", security: "invoker" },
+  { 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: "invoker" },
+  { 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: "invoker" },
+  { name: "migrate_promote", args: "p_organization_id uuid, p_table_id uuid, p_note text DEFAULT NULL::text", returns: "jsonb", security: "invoker" },
+  { name: "migrate_purge", args: "p_organization_id uuid, p_table_id uuid DEFAULT NULL::uuid, p_dry_run boolean DEFAULT true", returns: "jsonb", security: "invoker" },
+  { name: "migrate_rename", args: "p_organization_id uuid, p_id uuid, p_to text, p_note text DEFAULT NULL::text", returns: "jsonb", security: "invoker" },
+  { name: "migrate_reparent", args: "p_organization_id uuid, p_id uuid, p_parent_id uuid, p_note text DEFAULT NULL::text", returns: "jsonb", security: "invoker" },
+  { name: "migrate_retype", args: "p_organization_id uuid, p_id uuid, p_to text, p_note text DEFAULT NULL::text", returns: "jsonb", security: "invoker" },
+  { 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: "invoker" },
+  { 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: "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: "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: "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: "invoker" },
+  { 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: "invoker" },
+  { name: "query_can_see", args: "p_organization_id uuid, p_record_id uuid, p_required text DEFAULT 'viewer'::text", returns: "boolean", security: "invoker" },
+  { 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: "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: "invoker" },
+  { 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: "invoker" },
+  { 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: "invoker" },
+  { 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: "invoker" },
+  { name: "query_table_homes", args: "p_organization_id uuid, p_table_id uuid", returns: "SETOF uuid", security: "invoker" },
+  { 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: "invoker" },
+  { name: "reachable_from", args: "p_organization_id uuid, p_roots uuid[]", returns: "TABLE(record_id uuid, depth integer, via text)", security: "invoker" },
+  { 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: "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", returns: "TABLE(groups jsonb, measures jsonb, row_count bigint)", security: "invoker" },
+  { 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_delete", args: "p_organization_id uuid, p_record_id uuid", returns: "timestamp with time zone", security: "definer" },
+  { name: "record_reparent", args: "p_organization_id uuid, p_record_id uuid, p_parent_id uuid", returns: "void", security: "invoker" },
+  { name: "record_restore", args: "p_organization_id uuid, p_record_id uuid", returns: "void", 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_values", args: "p_organization_id uuid, p_record_id uuid", returns: "jsonb", 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: "invoker" },
+  { name: "record_write", args: "p_organization_id uuid, p_table_id uuid, p_data jsonb", returns: "uuid", security: "definer" },
+  { name: "relation_own", args: "p_organization_id uuid, p_owner_id uuid, p_target_id uuid", returns: "uuid", security: "invoker" },
+  { 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: "invoker" },
+  { 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_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: "rollup_value", args: "p_organization_id uuid, p_record_id uuid, p_field_data jsonb", returns: "jsonb", security: "invoker" },
+  { 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_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_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_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_run", args: "p_organization_id uuid, p_rule_id uuid, p_values jsonb, p_context jsonb DEFAULT '{}'::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: "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: "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: "storage_modes", args: "", returns: "text[]", security: "invoker" },
+  { name: "store_is_open", args: "p_organization_id uuid DEFAULT NULL::uuid", returns: "boolean", security: "invoker" },
+  { name: "table_capacity", args: "p_organization_id uuid, p_table_id uuid", returns: "jsonb", security: "definer" },
+  { name: "table_declare", args: "p_organization_id uuid, p_spec jsonb", returns: "uuid", security: "definer" },
+  { name: "table_kernel_id", args: "", returns: "uuid", 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_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_storage", args: "p_organization_id uuid, p_table_id uuid", returns: "text", security: "invoker" },
+  { name: "table_type_field", 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: "invoker" },
+  { name: "trg_associations_bump_visibility", args: "", returns: "trigger", security: "definer" },
+  { 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: "invoker" },
+  { name: "value_versions", args: "p_old jsonb, p_new jsonb", returns: "jsonb", security: "invoker" },
+  { 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_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_record_ids", args: "p_user_id uuid, p_required permission_level DEFAULT 'viewer'::permission_level", returns: "TABLE(id uuid)", 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_has_assignment", args: "p_organization_id uuid, p_table_id uuid", returns: "boolean", security: "invoker" },
+  { name: "work_instantiation_shape", args: "p_organization_id uuid, p_instantiation_id uuid", returns: "jsonb", security: "invoker" },
+  { name: "work_relation_kinds", args: "", returns: "TABLE(kind text, available boolean, why text)", security: "invoker" },
+  { name: "work_slot_expire", args: "p_organization_id uuid, p_table_id uuid", returns: "integer", security: "invoker" },
+  { 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: "invoker" },
+  { 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: "invoker" },
+  { 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: "invoker" },
+  { 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: "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: "invoker" },
+  { name: "work_template_declare", args: "p_organization_id uuid, p_name text, p_graph jsonb", returns: "uuid", security: "invoker" },
+  { name: "work_template_instantiate", args: "p_organization_id uuid, p_template_id uuid, p_overrides jsonb DEFAULT '{}'::jsonb", returns: "jsonb", security: "invoker" },
+  { 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: "invoker" },
+  { name: "work_transition_refusal", args: "p_organization_id uuid, p_from_state_id uuid, p_to_state_id uuid", returns: "text", security: "invoker" },
+  { 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: "invoker" }
+];
+var STORE_KNOBS = [
+  { key: "accessible_entity_ids_guard", value: "false", type: "boolean" },
+  { key: "associations_guard", value: "false", type: "boolean" },
+  { key: "code_paths_enabled", value: "false", type: "boolean" },
+  { key: "containment_depth_ceiling", value: "16", type: "integer" },
+  { key: "document_max_bytes", value: "1048576", type: "integer" },
+  { key: "emergency_door_guard", value: "false", type: "boolean" },
+  { key: "emergency_door_sweep_enabled", value: "false", type: "boolean" },
+  { key: "entity_custom_fields_guard", value: "false", type: "boolean" },
+  { key: "entity_types_guard", value: "false", type: "boolean" },
+  { key: "external_principal_enabled", value: "false", type: "boolean" },
+  { key: "field_index_guard", value: "false", type: "boolean" },
+  { key: "field_sensitivity_levels", value: '{"edit": {"public": "editor", "internal": "editor", "restricted": "admin", "confidential": "admin"}, "read": {"public": "viewer", "internal": "viewer", "restricted": "admin", "confidential": "editor"}}', type: "json" },
+  { key: "member_default_level", value: '"viewer"', type: "string" },
+  { key: "row_versions_guard", value: "false", type: "boolean" },
+  { key: "sandbox_expanded_frame_height_px", value: "20000", type: "integer" },
+  { key: "sandbox_frame_height_px", value: "4000", type: "integer" },
+  { key: "sandbox_message_bytes", value: "65536", type: "integer" },
+  { key: "sandbox_org_components", value: "true", type: "boolean" },
+  { key: "signup_provisioning_guard", value: "false", type: "boolean" },
+  { key: "system_enabled", value: "false", type: "boolean" },
+  { key: "table_record_ceiling", value: "150000", type: "integer" },
+  { key: "value_max_bytes", value: "100000", type: "integer" },
+  { key: "world_publish_enabled", value: "false", type: "boolean" }
+];
+var STORE_REFUSAL_CODES = [
+  { code: "02000", raised_by: "doc_render_body,doc_render_document,doc_sign,doc_signature_intact,doc_template_save,external_history_event,external_rows,external_stub_upsert,external_writes_set,migrate_delete,migrate_extract_parent,migrate_merge,migrate_rename,migrate_reparent,migrate_retype,migrate_split,read_record,record_delete,record_restore,record_update" },
+  { code: "0A000", raised_by: "external_rows,external_source_declare,external_write_through,promote_field,promoted_index_expr,promoted_query_sql,promoted_read,rule_eval,work_slots_declare" },
+  { code: "22004", raised_by: "_value_envelope,actor_word,agg_assert_key,agg_sql,anon_capture,anon_token_issue,anon_write,assert_client_may_reach,doc_render_write,doc_sign,doc_signature_write,doc_template_save,external_history_event,external_rows,external_source_declare,external_stub_upsert,external_write_through,external_writes_set,home_add,io_comment_write,io_import_open,io_outbox_drain,io_restore,migrate_purge,migrate_split,query_across_homes,query_by_coordinates,query_rollup,record_delete,record_reparent,record_restore,record_update,record_write,relation_own,table_declare,work_template_declare" },
+  { code: "22012", raised_by: "rule_eval" },
+  { code: "22023", raised_by: "_value_envelope,_work_shape_guard,actor_word,agg_assert_key,agg_sql,anon_token_issue,containment_parent,doc_render_body,doc_render_write,doc_signature_write,external_history_event,external_source_declare,external_stub_upsert,external_write_through,io_import_open,io_proposal_accept,migrate_merge,query_by_coordinates,query_rollup,record_update,rule_eval,rule_members,table_rules,work_slot_hold" },
+  { code: "23503", raised_by: "_containment_guard,_record_rule_uses,anon_publish,anon_rate_take,anon_token_issue,anon_write,assert_organization_wall,doc_sign,doc_template_save,home_add,io_comment_write,io_import_rows,io_proposal_accept,migrate_delete,migrate_demote,migrate_promote,promote_field,promote_table,record_applicability,record_reparent,relation_own,resolve_first_match,rule_applies,rule_eval,rule_members,rule_run,work_take_assignment,work_template_instantiate" },
+  { code: "23505", raised_by: "doc_sign,doc_signature_write,home_add,io_proposal_accept,work_slot_hold" },
+  { code: "23514", raised_by: "_containment_guard,_dated_values_guard,_derived_fields,_field_shape_guard,_field_type_parity_guard,_merge_field_shape_guard,_merge_field_temporal_guard,_promoted_field_cap_guard,_record_rule_uses,_rule_shape_guard,_rule_topology_guard,_table_shape_guard,_value_envelope,_work_shape_guard,doc_sign,doc_signature_write,doc_template_save,home_add,validate_value_envelope,validate_values,work_slots_declare,work_take_assignment,work_template_instantiate" },
+  { code: "40001", raised_by: "has_visibility_at" },
+  { code: "42501", raised_by: "_doc_render_immutable,_doc_signature_immutable,_field_definition_write,_field_write_door,_rule_definition_write,_store_door,anon_capture,anon_inbound_land,anon_publish,anon_token_issue,anon_token_verify,anon_write,assert_client_may_reach,assert_store_door,external_write_through,io_comment_resolve,io_comment_write,io_restore,migrate_purge,promote_table,read_record,read_records" },
+  { code: "53400", raised_by: "anon_rate_take,promote_field" },
+  { code: "PT409", raised_by: "record_update" }
+];
+var ENTITY_TOKENS = [
+  "access_delta_probe",
+  "access_delta_run",
+  "access_request",
+  "account_addon",
+  "acquisition_block",
+  "activity",
+  "admin_audit_log",
+  "admin_email_log",
+  "admin_markdown_sample",
+  "admin_user",
+  "admission_config",
+  "agent",
+  "agent_card",
+  "agent_definition_version",
+  "agent_drift_alert",
+  "agent_exemplar",
+  "agent_mandate_note",
+  "agent_prompt_remediation",
+  "agent_provision_legacy",
+  "agent_run",
+  "agent_run_stage",
+  "agent_schedule",
+  "agent_schedule_claim",
+  "agent_shortcut",
+  "agent_surface_binding",
+  "agent_template",
+  "agent_usage",
+  "agent_user_kv",
+  "ai_api",
+  "ai_endpoint",
+  "ai_model",
+  "ai_model_alias",
+  "ai_offering",
+  "ai_provider",
+  "ai_setting",
+  "analysis_result",
+  "anon_form",
+  "anon_function_birth_grandfather",
+  "anon_hit",
+  "anon_inbound",
+  "anon_replay",
+  "anon_submission",
+  "anon_token",
+  "api_field_warning",
+  "api_request_log",
+  "app",
+  "app_config",
+  "app_config_history",
+  "app_definition_version",
+  "app_error",
+  "app_execution",
+  "app_instance",
+  "app_log",
+  "app_log_muted_pattern",
+  "app_log_norm_exception",
+  "app_rate_limit",
+  "app_setting",
+  "app_sync_status",
+  "approach",
+  "artifact",
+  "assessment",
+  "assessment_item",
+  "assessment_result",
+  "assignment_session",
+  "assist",
+  "assist_producer_policy",
+  "assist_producer_policy_history",
+  "association_type",
+  "assurance_level",
+  "attempt",
+  "audit_broken_functions",
+  "audit_canonical_findings",
+  "audit_exemption",
+  "audit_function_deps",
+  "audit_function_runtime_probe",
+  "audit_m2m_candidates",
+  "audit_refresh_log",
+  "audit_stale_registry",
+  "audit_unregistered_candidates",
+  "bak_assoc_file_processed_document_20260812",
+  "bak_assoc_type_file_processed_document_20260812",
+  "bak_organization_name_dd043",
+  "base_entity_template",
+  "batch_cost_event",
+  "batch_provider_batch",
+  "batch_work_item",
+  "billing_capability",
+  "billing_capability_limit",
+  "billing_connect_account",
+  "billing_customer",
+  "billing_plan",
+  "billing_plan_limit",
+  "billing_price",
+  "billing_product",
+  "billing_spend_guardrail",
+  "billing_stripe_event",
+  "billing_subscription",
+  "billing_usage_ledger",
+  "billing_user_plan",
+  "browser_account_binding",
+  "browser_action_event",
+  "browser_authenticator_window",
+  "browser_capture",
+  "browser_control_request",
+  "browser_handoff",
+  "browser_login_attempt",
+  "browser_login_recipe",
+  "browser_profile",
+  "browser_profile_checkpoint",
+  "browser_run",
+  "browser_site_observation",
+  "browser_site_policy",
+  "browser_stream_ticket",
+  "build_lock",
+  "calendar_event",
+  "canvas_comment",
+  "canvas_comment_like",
+  "canvas_item",
+  "canvas_item_state",
+  "canvas_like",
+  "canvas_score",
+  "canvas_view",
+  "capture_window",
+  "carrying_rule",
+  "catalog_entries_history",
+  "catalog_entry",
+  "category",
+  "change_type_default",
+  "chat_user_usage_summary",
+  "citations",
+  "class_purchase",
+  "classifier_revision_ledger",
+  "client_callable_door",
+  "client_callable_door_retirement",
+  "client_excluded_column_unregistered",
+  "cmp_entry",
+  "cmp_feedback",
+  "code_file",
+  "code_folder",
+  "code_repository",
+  "coding_session",
+  "coding_session_entry",
+  "comment",
+  "commerce_asset_allocation",
+  "commerce_asset_grading",
+  "commerce_asset_identifier",
+  "commerce_asset_lot_event",
+  "commerce_asset_mandate_result",
+  "commerce_asset_price_factor",
+  "commerce_asset_reshoot_request",
+  "commerce_asset_review",
+  "commerce_asset_unknown",
+  "commerce_certified_printer",
+  "commerce_cloud_sync_connection",
+  "commerce_ebay_business_policy",
+  "commerce_ebay_category",
+  "commerce_ebay_category_aspect",
+  "commerce_ebay_category_tree",
+  "commerce_ebay_custom_policy",
+  "commerce_ebay_inventory_item",
+  "commerce_ebay_inventory_item_group",
+  "commerce_ebay_inventory_item_group_member",
+  "commerce_ebay_inventory_location",
+  "commerce_ebay_listing",
+  "commerce_ebay_marketplace_policy",
+  "commerce_ebay_media_asset",
+  "commerce_ebay_notification_destination",
+  "commerce_ebay_notification_event",
+  "commerce_ebay_notification_subscription",
+  "commerce_ebay_notification_topic",
+  "commerce_ebay_offer",
+  "commerce_ebay_order",
+  "commerce_ebay_order_line_item",
+  "commerce_ebay_shipping_fulfillment",
+  "commerce_ebay_store_category",
+  "commerce_human_correction",
+  "commerce_intake_artifact",
+  "commerce_intake_asset",
+  "commerce_intake_batch",
+  "commerce_label_batch",
+  "commerce_label_code",
+  "commerce_marketplace_account",
+  "commerce_marketplace_account_deletion_audit",
+  "commerce_marketplace_api_call",
+  "commerce_marketplace_rate_budget",
+  "commerce_marketplace_site",
+  "commerce_marketplace_sync_run",
+  "commerce_prediction_outcome",
+  "commerce_print_order",
+  "commerce_product",
+  "commerce_product_channel_ref",
+  "commerce_product_media",
+  "commerce_product_variant",
+  "commerce_recall_audit",
+  "comparison_set",
+  "component_group",
+  "contact_medium",
+  "contact_submission",
+  "content_certification",
+  "content_ir_kind",
+  "content_ir_kind_component",
+  "content_ir_kind_component_incident",
+  "content_ir_kind_conformance",
+  "content_ir_kind_edge",
+  "content_ir_kind_example",
+  "content_ir_kind_instance",
+  "content_ir_kind_surface",
+  "context_access_log",
+  "context_item",
+  "context_item_suggestion",
+  "context_item_value",
+  "context_value_refs",
+  "conversation",
+  "conversation_value",
+  "courts",
+  "credential_attachment",
+  "credential_item",
+  "credential_mutation_receipt",
+  "crm_address",
+  "crm_affiliation",
+  "crm_blocklist_entry",
+  "crm_contact_candidate",
+  "crm_deal",
+  "crm_deal_stage_event",
+  "crm_enrichment_call",
+  "crm_interaction",
+  "crm_merge_candidate",
+  "crm_outreach_list",
+  "crm_outreach_list_member",
+  "crm_party_merge",
+  "crm_registry_ingest_run",
+  "crm_registry_source",
+  "crm_saved_view",
+  "crm_sending_event",
+  "crm_sending_identity",
+  "crm_sending_identity_check",
+  "crm_sending_policy",
+  "custom_entity_definition",
+  "custom_field_definition",
+  "custom_field_target",
+  "custom_record",
+  "cx_agent_memory",
+  "cx_agent_plan",
+  "cx_agent_task",
+  "cx_code_edit",
+  "cx_code_message_file",
+  "cx_conversation_documents",
+  "cx_media",
+  "cx_observational_memory",
+  "cx_observational_memory_event",
+  "cx_pending_injection",
+  "cx_request",
+  "cx_request_snapshot",
+  "cx_tool_trace",
+  "cx_user_request",
+  "cx_user_todo",
+  "dashboard_saved_view",
+  "data_rights_event",
+  "data_store",
+  "data_store_members",
+  "dataset",
+  "dd171_containment_baseline",
+  "dd175_cast",
+  "dd175_component_lane_baseline",
+  "ddl_guard_log",
+  "deck_suggestion",
+  "definer_class_exemption",
+  "definer_client_grant_grandfather",
+  "definer_grant_baseline",
+  "deprecated_relation",
+  "derive_run",
+  "dev_login_audit",
+  "dict_entry",
+  "dict_provider_publication",
+  "dict_setting",
+  "dm_conversation",
+  "dm_message",
+  "dm_participant",
+  "doc_render",
+  "doc_signature",
+  "dockets",
+  "domain_classification",
+  "edge_payload_kind",
+  "egress_device",
+  "egress_pairing",
+  "egress_ticket",
+  "emails",
+  "embedding_cache",
+  "embeddings_google_gemini_2_1536",
+  "embeddings_oai_3_small_1536",
+  "embeddings_voyage_4_large_1024",
+  "embeddings_voyage_code_3_1024",
+  "endpoint_family_sweep_state",
+  "engine_owner_task",
+  "entity_grant",
+  "entity_relationship",
+  "entity_type",
+  "esign_campaign",
+  "esign_campaign_member",
+  "esign_consent_disclosure",
+  "esign_envelope",
+  "esign_envelope_certificate",
+  "esign_envelope_document",
+  "esign_envelope_event",
+  "esign_envelope_external_ref",
+  "esign_envelope_signer",
+  "esign_provider",
+  "esign_provider_binding",
+  "esign_signing_key",
+  "execution_event_cursor",
+  "extension_auth_code",
+  "external_link",
+  "external_source",
+  "extract_sweep_state",
+  "fc_card",
+  "fc_detail",
+  "fc_set",
+  "feature_doc",
+  "feature_knob",
+  "feedback_comments",
+  "feedback_user_messages",
+  "field_component",
+  "file",
+  "file_analysis",
+  "file_entities",
+  "file_overrides",
+  "file_page_annotations",
+  "file_pages",
+  "file_rag_job",
+  "file_version",
+  "files_account_tier",
+  "files_machine_written_prefix",
+  "files_sync_mapping",
+  "files_user_account",
+  "flashcard_data",
+  "flashcard_history",
+  "flashcard_review",
+  "flashcard_set",
+  "flashcard_sets",
+  "flexible_data",
+  "folder",
+  "function_contract",
+  "game_badge",
+  "game_result",
+  "game_room",
+  "global_execution",
+  "global_execution_checkpoint",
+  "global_execution_control",
+  "global_execution_event",
+  "global_meter_entry",
+  "global_origin",
+  "global_request",
+  "google_document",
+  "growth_loop_event",
+  "growth_loop_run",
+  "growth_loop_stage_run",
+  "guardian_link",
+  "guest_conversion_audit",
+  "guest_execution_log",
+  "guest_executions",
+  "guided_checklist_run",
+  "heatmap_save",
+  "hindsight_enrollment",
+  "hindsight_finding",
+  "hindsight_regression_case",
+  "hindsight_replay",
+  "hindsight_replay_step",
+  "hindsight_review",
+  "hr_access_audit",
+  "hr_access_role",
+  "hr_accommodation_request",
+  "hr_ai_evidence",
+  "hr_alert_routing_rule",
+  "hr_application",
+  "hr_approval_authority",
+  "hr_approval_delegation",
+  "hr_asset",
+  "hr_asset_assignment",
+  "hr_attendance_exception",
+  "hr_auto_close_rule",
+  "hr_availability",
+  "hr_background_check",
+  "hr_benefits_event",
+  "hr_calculation_snapshot",
+  "hr_candidate",
+  "hr_candidate_conversion",
+  "hr_candidate_message",
+  "hr_careers_portal",
+  "hr_checklist_item",
+  "hr_checklist_run",
+  "hr_checklist_template",
+  "hr_checklist_template_item",
+  "hr_compensation",
+  "hr_corrective_action",
+  "hr_course",
+  "hr_course_version",
+  "hr_credential",
+  "hr_crew",
+  "hr_deduction_code",
+  "hr_department",
+  "hr_derived_grant",
+  "hr_disposition_event",
+  "hr_earning_code",
+  "hr_eeo_response",
+  "hr_emergency_contact",
+  "hr_employee",
+  "hr_employee_private",
+  "hr_employer_profile",
+  "hr_employment",
+  "hr_employment_pin",
+  "hr_engagement",
+  "hr_establishment",
+  "hr_external_identity",
+  "hr_field_policy",
+  "hr_holiday",
+  "hr_holiday_calendar",
+  "hr_i9",
+  "hr_i9_document",
+  "hr_incident",
+  "hr_incident_party",
+  "hr_interview",
+  "hr_interview_kit",
+  "hr_job_title",
+  "hr_jurisdiction",
+  "hr_jurisdiction_rule",
+  "hr_jurisdiction_rule_class",
+  "hr_jurisdiction_rule_org_decision",
+  "hr_jurisdiction_rule_test",
+  "hr_kiosk_device",
+  "hr_kiosk_session",
+  "hr_labor_target",
+  "hr_leave_case",
+  "hr_leave_enrollment",
+  "hr_leave_ledger",
+  "hr_leave_policy",
+  "hr_leave_request",
+  "hr_legal_hold",
+  "hr_legal_hold_item",
+  "hr_location",
+  "hr_new_hire_report",
+  "hr_offer",
+  "hr_opening",
+  "hr_overtime_alert",
+  "hr_overtime_alert_rule",
+  "hr_overtime_preapproval",
+  "hr_pay_group",
+  "hr_pay_period",
+  "hr_pay_period_employment",
+  "hr_payroll_export",
+  "hr_payroll_export_line",
+  "hr_position_assignment",
+  "hr_posting",
+  "hr_posting_publication",
+  "hr_provider_binding",
+  "hr_provider_event",
+  "hr_provisioning_result",
+  "hr_punch",
+  "hr_recalculation_batch",
+  "hr_record_class",
+  "hr_records_request",
+  "hr_reference_check",
+  "hr_reporting_line",
+  "hr_requisition",
+  "hr_restricted_note",
+  "hr_retention_rule",
+  "hr_role_assignment",
+  "hr_schedule",
+  "hr_schedule_change",
+  "hr_schedule_guidance",
+  "hr_schedule_template",
+  "hr_schedule_template_shift",
+  "hr_scorecard",
+  "hr_separation",
+  "hr_shift",
+  "hr_shift_claim",
+  "hr_staffing_requirement",
+  "hr_survey",
+  "hr_survey_invitation",
+  "hr_survey_question",
+  "hr_survey_response",
+  "hr_tax_registration",
+  "hr_tax_withholding",
+  "hr_time_adjustment",
+  "hr_training_assignment",
+  "hr_training_attempt",
+  "hr_transcript_entry",
+  "hr_verification_letter_request",
+  "hr_work_interval",
+  "hr_workflow_binding",
+  "hr_workflow_decision",
+  "hr_workflow_definition",
+  "hr_workflow_event",
+  "hr_workflow_failure",
+  "hr_workflow_flow_type",
+  "hr_workflow_instance",
+  "hr_workflow_step",
+  "hr_workflow_step_definition",
+  "hr_workweek",
+  "html_extraction",
+  "iam_access_audit",
+  "iam_api_key",
+  "iam_emergency_door_request",
+  "idempotency",
+  "industry",
+  "industry_curator",
+  "infra_status",
+  "ingest_runs",
+  "integration_connection",
+  "integration_connection_resource",
+  "interview_decision_interview",
+  "interview_decision_question",
+  "interview_document_revision",
+  "interview_hole",
+  "interview_question",
+  "interview_session",
+  "interview_turn",
+  "invitation",
+  "invitation_code",
+  "invitation_request",
+  "io_comment",
+  "io_contract",
+  "io_import",
+  "io_outbox",
+  "item",
+  "item_mastery",
+  "judge_verdict",
+  "jurisdiction_policy",
+  "keyword_classification_queue",
+  "kg_alert",
+  "kg_chunk_entities",
+  "kg_chunks",
+  "kg_clusters",
+  "kg_edges",
+  "kg_entities",
+  "kg_entity_aliases",
+  "kg_suggestion_ack",
+  "kg_sweep_queue",
+  "kg_sweep_run",
+  "kg_sweep_state",
+  "kg_value_match",
+  "knob_override",
+  "knob_override_audit",
+  "knob_rung_lock",
+  "knob_scope_kind",
+  "knob_write_door",
+  "league_membership",
+  "learn_doc",
+  "library_doc",
+  "lifecycle_archive",
+  "lifecycle_archive_row",
+  "lifecycle_audit",
+  "lifecycle_entity_plan",
+  "lifecycle_map_build",
+  "lifecycle_reference_map",
+  "lifecycle_run",
+  "lifecycle_tier_ledger",
+  "location",
+  "mandate",
+  "mandate_advance_batch_row",
+  "mandate_binding",
+  "mandate_binding_legacy",
+  "mandate_legacy",
+  "mandate_observation",
+  "mandate_reference",
+  "mandate_scan",
+  "mandate_treatment",
+  "marketing_initiative",
+  "masterwork_corpus_item",
+  "masterwork_run",
+  "masterwork_run_kind",
+  "masterwork_source",
+  "math_course_structure",
+  "math_problem",
+  "matrx_action_ledger",
+  "mcp_config",
+  "mcp_server",
+  "mcp_user_conn",
+  "media_capture_handoff",
+  "media_catalog_setting",
+  "media_library_item",
+  "media_selection_item",
+  "media_selection_job",
+  "media_source_library",
+  "meet_call_invite",
+  "meet_meeting",
+  "meet_note",
+  "meet_participant",
+  "meet_recording",
+  "meet_transcript_segment",
+  "membership",
+  "membership_grant",
+  "merge_field_provenance",
+  "message",
+  "message_template",
+  "meta_excluded_schema",
+  "meta_table_stats_history",
+  "metadata_reserved_keys",
+  "microservice_project",
+  "migration_log",
+  "mtx_media_heal_queue",
+  "mtx_public_url_guard",
+  "ner_shadow",
+  "note",
+  "note_folder",
+  "notification",
+  "notification_channel_preference",
+  "notification_event_override",
+  "notification_event_type",
+  "notification_preference",
+  "notify_outsider_door_baseline",
+  "oauth_handoff_claim",
+  "opinion_clusters",
+  "opinions",
+  "ops_issue_class",
+  "ops_issue_event",
+  "ops_proof_check",
+  "ops_proof_run",
+  "ops_proof_scenario",
+  "org_admin_audit",
+  "org_change_policy",
+  "org_context_ledger",
+  "org_industries",
+  "org_member_control",
+  "org_module_config",
+  "org_plan",
+  "org_repair_0253_backup",
+  "organization",
+  "organization_preferences",
+  "organization_visibility_version",
+  "output_feedback",
+  "outreach_acceptance",
+  "page_extraction_job",
+  "page_extraction_page_run",
+  "page_extraction_results",
+  "page_extraction_runs",
+  "page_intent_queue",
+  "page_mapping_queue",
+  "part_config",
+  "part_config_sub",
+  "party",
+  "party_contact_point",
+  "path_drift_repair_2026_09",
+  "pc_article",
+  "pc_episode",
+  "pc_show",
+  "pc_studio_run",
+  "pc_studio_run_asset",
+  "pdf_consolidation_log",
+  "pdf_redaction_audit",
+  "pdf_redaction_key_escrow",
+  "permission_grant",
+  "plan_cms_fill_item",
+  "plan_cms_fill_job",
+  "plan_entity",
+  "plan_node",
+  "plan_node_artifact",
+  "plan_node_step",
+  "plan_profile",
+  "platform_actor_session",
+  "platform_actor_token",
+  "platform_actor_token_event",
+  "platform_continued_access",
+  "platform_org_knob_override",
+  "platform_outcome_event",
+  "platform_outsider_consumer",
+  "platform_reachability",
+  "platform_reference_category",
+  "platform_reference_declaration",
+  "platform_repo",
+  "platform_saved_view",
+  "platform_schema",
+  "platform_share_link",
+  "platform_user_knob_override",
+  "podcast_race",
+  "policy_overlap_backup",
+  "policy_overlap_probe",
+  "processed_document",
+  "processed_document_page",
+  "product_capture_file",
+  "product_capture_item",
+  "product_capture_payload",
+  "product_capture_product",
+  "product_capture_question",
+  "profile",
+  "project",
+  "prompt",
+  "provider_account",
+  "provider_account_credential",
+  "provision",
+  "provision_generate_target",
+  "provision_grant",
+  "provision_marker",
+  "provision_rule_message",
+  "provision_schema",
+  "provision_shape_debt",
+  "provision_spec",
+  "provision_spec_grandfather",
+  "provision_vocabulary",
+  "purpose",
+  "quiz_session",
+  "rag_ingest_run",
+  "rag_library_audit_log",
+  "rate_limit_buckets",
+  "recompute_queue",
+  "record",
+  "record_alias",
+  "redaction_mapping",
+  "research_analysis",
+  "research_content",
+  "research_context_bundle",
+  "research_document",
+  "research_intent",
+  "research_keyword",
+  "research_media",
+  "research_source",
+  "research_synthesis",
+  "research_tag",
+  "research_template",
+  "research_topic",
+  "retention_policy",
+  "retrieval_audit",
+  "review_queue",
+  "route_manifest_entry",
+  "row_version",
+  "rulebook",
+  "runtime_operation_stream",
+  "runtime_operation_stream_batch",
+  "sandbox_instance",
+  "sch_agent_task",
+  "sch_run",
+  "sch_task",
+  "sch_trigger",
+  "schema_client_exposure",
+  "schema_migration_ledger",
+  "schema_migration_legacy",
+  "schema_migration_slot_grandfather",
+  "schema_templates",
+  "scope",
+  "scope_association_suggestion",
+  "scope_dataset_instance",
+  "scope_door_registry",
+  "scope_item_value_suggestion",
+  "scope_suggestion",
+  "scope_type",
+  "scrape_domain",
+  "scrape_domain_settings",
+  "scrape_failure_log",
+  "scrape_parsed_page",
+  "scrape_path_override",
+  "scrape_path_pattern",
+  "scrape_retry_queue",
+  "seo_ai_capability",
+  "seo_ai_visibility_citation",
+  "seo_ai_visibility_claim",
+  "seo_ai_visibility_panel",
+  "seo_ai_visibility_response",
+  "seo_ai_visibility_signal",
+  "seo_backlink",
+  "seo_backlink_change_event",
+  "seo_backlink_dimension_snapshot",
+  "seo_backlink_observation",
+  "seo_backlink_snapshot",
+  "seo_change_assessment",
+  "seo_change_event",
+  "seo_change_item",
+  "seo_change_metric",
+  "seo_change_set",
+  "seo_change_theory",
+  "seo_collection_run",
+  "seo_competitor",
+  "seo_competitor_observation",
+  "seo_competitor_opportunity",
+  "seo_coverage_mention",
+  "seo_coverage_tracker",
+  "seo_dimension_value_matcher",
+  "seo_engine_schedule",
+  "seo_geo_place",
+  "seo_gsc_dig_rule",
+  "seo_keyword",
+  "seo_keyword_class_rule",
+  "seo_keyword_edge",
+  "seo_keyword_facet",
+  "seo_keyword_market",
+  "seo_keyword_market_observation",
+  "seo_keyword_place",
+  "seo_keyword_saved_view",
+  "seo_keyword_topic",
+  "seo_landscape_brief",
+  "seo_link_gap_domain",
+  "seo_link_gap_match",
+  "seo_map_facet",
+  "seo_map_facet_value",
+  "seo_map_topic",
+  "seo_page_measurement_health",
+  "seo_page_performance",
+  "seo_provider_call",
+  "seo_provider_task",
+  "seo_rank_observation",
+  "seo_rank_target",
+  "seo_raw_payload",
+  "seo_referring_domain_profile",
+  "seo_reputation_case",
+  "seo_search_performance_daily",
+  "seo_serp_mention",
+  "seo_serp_opportunity",
+  "seo_serp_result",
+  "seo_serp_snapshot",
+  "seo_site_geo_area",
+  "seo_site_keyword_offering",
+  "seo_site_keyword_value",
+  "seo_site_offering_value",
+  "seo_site_topic_value",
+  "seo_site_value_combo",
+  "seo_site_value_worth",
+  "seo_site_vocabulary",
+  "seo_source_request",
+  "seo_starter_pack",
+  "seo_starter_pack_item",
+  "seo_story_angle",
+  "seo_topic",
+  "seo_topical_map",
+  "seo_web_analytics_daily",
+  "share_link",
+  "shareable_resource_registry",
+  "shared_canvas_item",
+  "short_link",
+  "shortcut_category",
+  "skill",
+  "skill_category",
+  "skill_render_definition",
+  "sms_consent",
+  "sms_conversation",
+  "sms_message",
+  "sms_message_media",
+  "sms_notification",
+  "sms_notification_preference",
+  "sms_phone_number",
+  "sms_rate_limits",
+  "sms_webhook_logs",
+  "soft_delete_edge",
+  "source_authority",
+  "stage_dockets_966c18eca7",
+  "stage_ref_kind",
+  "stamped_write_table",
+  "structure",
+  "structured_list",
+  "studio_cleaned_segments",
+  "studio_concept_items",
+  "studio_documents",
+  "studio_module_segments",
+  "studio_raw_segments",
+  "studio_recording_chunks",
+  "studio_recording_segments",
+  "studio_run",
+  "studio_session",
+  "studio_session_settings",
+  "study_attempt",
+  "study_goal",
+  "study_media",
+  "study_plan",
+  "study_plan_block",
+  "study_plan_day",
+  "study_reminder_context",
+  "study_reminder_delivery",
+  "study_session",
+  "study_source_chunk",
+  "study_streak",
+  "study_structured_section",
+  "superseded_policy",
+  "surface",
+  "system_announcement",
+  "system_context_item",
+  "system_error",
+  "system_orgs",
+  "system_personal_org_failure",
+  "system_write_failure",
+  "task",
+  "task_user_state",
+  "taxonomy_node",
+  "template_context_items",
+  "template_scope_types",
+  "templates",
+  "thread",
+  "tool",
+  "tool_binding",
+  "tool_bundle",
+  "tool_call",
+  "tool_definition_version",
+  "tool_executor",
+  "tool_surface_defaults",
+  "tool_test_sample",
+  "tool_ui",
+  "tool_ui_incident",
+  "tool_ui_version",
+  "topic_placement_queue",
+  "transcript",
+  "trigger_event",
+  "udt_dataset_fields",
+  "udt_dataset_row_versions",
+  "udt_dataset_rows",
+  "udt_dataset_template",
+  "udt_dataset_template_fields",
+  "udt_document",
+  "udt_document_snapshot",
+  "udt_structured_list_items",
+  "udt_workbook_snapshot",
+  "ui_client",
+  "ui_surface_agent_pref",
+  "ui_surface_agent_role",
+  "ui_surface_client_tool",
+  "ui_surface_config",
+  "ui_surface_value",
+  "ui_surface_write_target",
+  "unsubscribe_token",
+  "uploads_inflight",
+  "user_achievement",
+  "user_active_context",
+  "user_analysis_preference",
+  "user_bookmark",
+  "user_email_preference",
+  "user_entity_state",
+  "user_feedback",
+  "user_follows",
+  "user_form_profile",
+  "user_markdown_sample",
+  "user_memory",
+  "user_preference",
+  "user_profile",
+  "user_secret",
+  "user_secret_audit",
+  "user_secret_grant",
+  "user_stat",
+  "user_storage_usage",
+  "user_surface_state",
+  "visibility_cache",
+  "visibility_epoch",
+  "voice",
+  "war_room",
+  "wbx_capture",
+  "wbx_demo",
+  "wbx_guidance",
+  "wbx_highlight",
+  "wbx_pattern",
+  "wbx_recipe",
+  "wbx_screenshot",
+  "wbx_seo_audit",
+  "wc_claim",
+  "wc_impairment_definition",
+  "wc_injury",
+  "wc_report",
+  "web_analysis_item",
+  "web_brand",
+  "web_brand_asset",
+  "web_brand_offering",
+  "web_business_fact",
+  "web_business_location",
+  "web_channel_analytics_daily",
+  "web_crawl_event",
+  "web_crawl_preset",
+  "web_crawl_schedule",
+  "web_crawl_session",
+  "web_crawl_url",
+  "web_discovered_item",
+  "web_finding",
+  "web_gsc_page_stat",
+  "web_link_edge",
+  "web_listing_publisher",
+  "web_location_listing",
+  "web_offering_template",
+  "web_page",
+  "web_page_content",
+  "web_page_evidence",
+  "web_page_sitemap",
+  "web_property",
+  "web_provider",
+  "web_result",
+  "web_screenshot",
+  "web_site",
+  "web_site_endpoint_rule",
+  "web_site_item_config",
+  "web_site_offering",
+  "web_sitemap",
+  "web_snapshot",
+  "web_tag_manager_snapshot",
+  "web_youtube_video",
+  "webhook_deliveries",
+  "webhook_dispatch_state",
+  "webhooks",
+  "wf_node_data_slot",
+  "work_claim",
+  "work_item",
+  "workbook",
+  "worker_heartbeat",
+  "workflow",
+  "workflow_card",
+  "workflow_checkpoint",
+  "workflow_comparison",
+  "workflow_definition_version",
+  "workflow_idempotency",
+  "workflow_job",
+  "workflow_node_events",
+  "workflow_node_outcome",
+  "workflow_plan",
+  "workflow_plan_event",
+  "workflow_plan_sample",
+  "workflow_recovery_audit",
+  "workflow_run",
+  "workflow_run_log",
+  "workflow_runtime_surface",
+  "workflow_template",
+  "workflow_trigger",
+  "workflow_trigger_fire",
+  "workflow_work_item",
+  "working_document",
+  "write_guard_key",
+  "youtube_quota_day",
+  "youtube_search",
+  "youtube_video"
+];
+
+// src/core/doors.ts
+var OWED_BY = {
+  metadata_search: "W5-SRV / W5-AGENT \u2014 the agent surface's eight verbs",
+  record_aggregate: "W5-SRV / W5-AGENT \u2014 `record_aggregate` is one of the eight verbs",
+  field_propose: "W5-AGENT \u2014 AGT-4/AGT-8, the proposal and its approvers",
+  table_propose: "W5-AGENT \u2014 AGT-8, the proposal and its approvers",
+  merge_field_resolve: "W5-MERGE-B \u2014 the resolver's server half",
+  record_query: "W1-INDEX / W5-SRV \u2014 the promoted-field query path",
+  rule_declare: "W1-RULE \u2014 `custom.record_write` writes `data_class = 'record'`, so the ONE write door cannot make a Rule record; declaring a Rule (and therefore a DOOR-18 subscription) needs a door of its own"
+};
+var TRUST_SCHEMA = "iam";
+var TRUST_DOORS = {
+  /** VIS-31. A signed-in outsider: an account with no NON-personal organization. */
+  isExternalPrincipal: "is_external_principal",
+  /** The same answer with the plain-English reason attached. */
+  externalPrincipalCard: "external_principal_card",
+  /** EXACTLY the resources Visibility gave that outsider — never "their organization's". */
+  externalPrincipalReach: "external_principal_reach",
+  /** VIS-32. A record or a view bound to a public address with a declared render mode. */
+  publishBindingCreate: "publish_binding_create",
+  publishBindingRevoke: "publish_binding_revoke",
+  /** What a SIGNED-OUT visitor resolves. Returns nothing for an invented or revoked address. */
+  resolvePublishBinding: "resolve_publish_binding",
+  /** D-15. The one sentence that admits nothing was scanned — one function, so it cannot drift. */
+  worldPublishGapNotice: "world_publish_gap_notice",
+  publishToWorld: "publish_to_world",
+  worldPublishAdmit: "world_publish_admit",
+  claimWorldNamespace: "claim_world_namespace"
+};
+var DOOR_NAMES = new Set(STORE_DOORS.map((d) => d.name));
+function doorExists(name) {
+  return DOOR_NAMES.has(name);
+}
+function doorAbsent(name) {
+  const owed = OWED_BY[name];
+  return {
+    code: "door_absent",
+    message: `The record store has no door \`custom.${name}\` yet, so this call was not made. Nothing was read and nothing was written.`,
+    hint: owed ? `That door is ${owed}. Until it lands, this call refuses rather than guessing: an empty answer here would read like "there is nothing", which is a different sentence.` : `No lane in the build book claims this door. Either the name is wrong, or the door was removed from the store and this package has not been regenerated \u2014 run \`pnpm records:generate\`.`
+  };
+}
+var DOORS = {
+  // THE READ DOOR (DOOR-1). Every read of a record's values goes through these
+  // two and nothing else: they resolve the reader from the session, ask
+  // visibility once per set, and mask the fields this reader may not see with a
+  // notice under `_hidden`. Selecting `custom.record` directly is the thing
+  // they exist to replace — it returns rows and fields the store never agreed
+  // this person could see.
+  readRecord: "read_record",
+  readRecords: "read_records",
+  // DOOR-8, the two clocks. `p_recorded_at` is what the store SAID then;
+  // `p_world_on` is what was TRUE of the world on that date, read out of dated
+  // values. A client that answered either one itself would be guessing.
+  queryRecordAsOf: "query_record_as_of",
+  queryTableAsOf: "query_table_as_of",
+  recordWrite: "record_write",
+  recordUpdate: "record_update",
+  recordDelete: "record_delete",
+  recordRestore: "record_restore",
+  recordValues: "record_values",
+  recordValuesVersioned: "record_values_versioned",
+  valueRead: "value_read",
+  computedProvenance: "computed_provenance",
+  recordApplicability: "record_applicability",
+  applicableFields: "applicable_fields",
+  fieldOptions: "field_options",
+  parityValues: "parity_values",
+  tableDeclare: "table_declare",
+  tableCapacity: "table_capacity",
+  tableStorage: "table_storage",
+  promoteTable: "promote_table",
+  promoteField: "promote_field",
+  promotedFields: "promoted_fields",
+  promotedRead: "promoted_read",
+  relationTargets: "relation_targets",
+  relationOwn: "relation_own",
+  homeAdd: "home_add",
+  recordReparent: "record_reparent",
+  containmentChain: "containment_chain",
+  storeIsOpen: "store_is_open",
+  // DOOR-11. The record's own revision list. A screen that offers an optimistic
+  // save needs the version it LOADED, and the read door answers documents, not
+  // versions — so the version comes from here, once, for the one record being
+  // edited, and never for a whole list.
+  ioRevisions: "io_revisions",
+  resolveFirstMatch: "resolve_first_match",
+  // The kernels a package-owned Table needs to exist at all: a Home is a record
+  // in the person kernel, a Field is a record in the field kernel (REC-1).
+  personKernelId: "person_kernel_id",
+  fieldKernelId: "field_kernel_id",
+  ruleKernelId: "rule_kernel_id",
+  // And the Table kernel, which is how `tableList` asks the READ DOOR for this
+  // organization's Tables: a Table is a record like any other, so listing them
+  // is `read_records(org, table_kernel_id())` and never a select on a table.
+  tableKernelId: "table_kernel_id",
+  // A saved view references its membership Rule, and the STORE decides who is
+  // in it — the screen never re-implements the predicate.
+  ruleMembers: "rule_members",
+  ruleMembership: "rule_membership",
+  ruleRun: "rule_run",
+  ruleEval: "rule_eval",
+  // The eighth verb (AGT-N-8): a grouped, bucketed, filtered count/sum/avg/
+  // min/max computed INSIDE the read door's own query, so a chart shows exactly
+  // the rows this person may see and never fetches the ones they may not.
+  recordAggregate: "record_aggregate",
+  aggOperations: "agg_operations",
+  aggBuckets: "agg_buckets",
+  // DOOR-18: a subscription is a Rule record carrying a `subscription` block
+  // over a saved view. There is no subscription TABLE and no second notifier.
+  aggSubscriptions: "agg_subscriptions",
+  aggSubscriptionCadences: "agg_subscription_cadences",
+  // The doc doors: a template is saved, a render is written once and frozen,
+  // and a signature is checked against the exact bytes that were signed.
+  docTemplateSave: "doc_template_save",
+  docRenderBody: "doc_render_body",
+  docRenderDocument: "doc_render_document",
+  docTokens: "doc_tokens",
+  docUnresolvedTokens: "doc_unresolved_tokens",
+  docSign: "doc_sign",
+  docSignatureIntact: "doc_signature_intact",
+  // THE ANONYMOUS LANE (W4-ANON). It landed, and it landed as SEVEN doors
+  // rather than the one this package had guessed at: a token is issued and
+  // verified separately from the write it authorises, a form is published
+  // separately from being declared, and an offline capture by a SIGNED-IN
+  // person is a different door from a write by a stranger.
+  //
+  // This package used to name a door `anon_record_write`, which never existed —
+  // so `FormRunner` told every person that the public link was "pending" for a
+  // lane that had already shipped. A screen calling a live feature pending is
+  // the same silent failure as a screen calling a missing one live, and the fix
+  // is to name the doors the store actually has.
+  anonTokenIssue: "anon_token_issue",
+  anonTokenVerify: "anon_token_verify",
+  anonTokenRevoke: "anon_token_revoke",
+  /** The stranger's write. The TOKEN names the organization; a caller never does. */
+  anonWrite: "anon_write",
+  /** SCR-30. The signed-in OFFLINE path: the client mints the key, the store dedupes on it. */
+  anonCapture: "anon_capture",
+  anonPublish: "anon_publish",
+  // WORK (W4-WORK): a template instantiated as real records, whose turn it is,
+  // and a slot somebody is holding. `ChecklistRunner` and `BookingSlots` are
+  // screens over these and hold no state of their own.
+  workStates: "work_states",
+  workTemplateDeclare: "work_template_declare",
+  workTemplateInstantiate: "work_template_instantiate",
+  workTemplateShape: "work_template_shape",
+  /** Why a graph would be refused — asked BEFORE it is written, never after. */
+  workTemplateRefusal: "work_template_refusal",
+  workWhoseTurn: "work_whose_turn",
+  workTakeAssignment: "work_take_assignment",
+  workHasAssignment: "work_has_assignment",
+  workAssignmentFields: "work_assignment_fields",
+  workTransitionRefusal: "work_transition_refusal",
+  workInstantiationShape: "work_instantiation_shape",
+  workSlotsDeclare: "work_slots_declare",
+  workSlotHold: "work_slot_hold",
+  workSlotRelease: "work_slot_release",
+  workSlotHolds: "work_slot_holds",
+  workSlotExpire: "work_slot_expire",
+  // Declared here BECAUSE they do not exist yet: naming them is what makes the
+  // absence visible to `pnpm check:store-registry` and to the suite.
+  metadataSearch: "metadata_search",
+  ruleDeclare: "rule_declare",
+  fieldPropose: "field_propose",
+  tablePropose: "table_propose",
+  mergeFieldResolve: "merge_field_resolve"
+};
+function doorCensus() {
+  const present = [];
+  const absent = [];
+  for (const name of Object.values(DOORS)) {
+    (doorExists(name) ? present : absent).push(name);
+  }
+  return { present: present.sort(), absent: absent.sort() };
+}
+
+// src/core/pgError.ts
+var BY_SQLSTATE = {
+  PT409: "stale_write",
+  "42501": "door",
+  "23514": "refused_by_rule",
+  "22004": "invalid_argument",
+  "22023": "invalid_argument",
+  "02000": "not_found",
+  "23503": "missing_reference",
+  "23505": "already_exists",
+  "0A000": "not_supported",
+  "53400": "store_limit",
+  "22012": "store_limit",
+  // VIS: `custom.has_visibility_at` refuses to answer from a snapshot older
+  // than a write this reader has already seen, rather than returning something
+  // they just lost access to. It is retryable on a fresher connection, which is
+  // a different instruction from every other refusal here.
+  "40001": "stale_read",
+  // PostgREST's own two: the store is not being SERVED, which is a different
+  // thing from the store refusing. `custom` absent from `pgrst.db_schemas`, or
+  // the grants not copied, land here.
+  PGRST202: "store_not_served",
+  PGRST205: "store_not_served",
+  PGRST301: "door"
+};
+var MAPPED_SQLSTATES = Object.keys(BY_SQLSTATE);
+function parseDetail(details) {
+  if (!details) return void 0;
+  const trimmed = details.trim();
+  if (!trimmed.startsWith("{") && !trimmed.startsWith("[")) return details;
+  try {
+    return JSON.parse(trimmed);
+  } catch {
+    return details;
+  }
+}
+function mapPgError(error, where) {
+  const sqlstate = error.code ?? void 0;
+  const code = (sqlstate ? BY_SQLSTATE[sqlstate] : void 0) ?? "internal";
+  const mapped = {
+    code,
+    message: error.message,
+    ...error.hint ? { hint: error.hint } : {},
+    ...sqlstate ? { sqlstate } : {}
+  };
+  const detail = parseDetail(error.details);
+  if (detail !== void 0) mapped.detail = detail;
+  if (code === "internal") {
+    mapped.hint = (mapped.hint ? `${mapped.hint} ` : "") + `(@ai-matrx/records did not recognise SQLSTATE ${sqlstate ?? "(none)"} from ${where}; the message above is the store's own and is the thing to act on.)`;
+  }
+  return mapped;
+}
+function staleWriteDetail(error) {
+  if (error.code !== "stale_write") return null;
+  const detail = error.detail;
+  if (!detail || typeof detail.expected_version !== "number" || typeof detail.current_version !== "number") {
+    return null;
+  }
+  return {
+    expected_version: detail.expected_version,
+    current_version: detail.current_version,
+    contested_fields: detail.contested_fields ?? {}
+  };
+}
+
+// src/core/query.ts
+var DEFAULT_PAGE_SIZE = 50;
+function planQuery(query) {
+  const relationCalls = (query.relations ?? []).map((coordinate) => ({
+    door: "relation_targets",
+    record_id: coordinate.record_id,
+    via_key: coordinate.role ?? null
+  }));
+  const promotedCalls = (query.promoted ?? []).map((predicate) => ({
+    door: "promoted_read",
+    field_key: predicate.field_key,
+    value: predicate.equals
+  }));
+  return {
+    relationCalls,
+    promotedCalls,
+    read: {
+      table_id: query.table_id,
+      includeDeleted: query.includeDeleted ?? false,
+      recordType: query.recordType ?? null,
+      asOf: query.asOf ?? null,
+      acrossHomes: query.acrossHomes ?? false,
+      orderBy: {
+        column: query.orderBy?.column ?? "created_at",
+        ascending: query.orderBy?.ascending ?? false
+      },
+      limit: query.limit ?? DEFAULT_PAGE_SIZE,
+      offset: query.offset ?? 0
+    },
+    intersects: relationCalls.length + promotedCalls.length > 0
+  };
+}
+function intersectIds(sets) {
+  if (sets.length === 0) return [];
+  const [first, ...rest] = sets;
+  const others = rest.map((s) => new Set(s));
+  return first.filter((id) => others.every((set) => set.has(id)));
+}
+
+// src/core/client.ts
+var DEFAULT_SCHEMA = "custom";
+function sink(config) {
+  return config.onError ?? ((e) => (
+    // The defined degradation, stated: loud, with the store's own words, and
+    // naming where it happened. Never silence.
+    console.error(`[@ai-matrx/records] ${e.where}: ${e.code} \u2014 ${e.message}${e.hint ? ` (${e.hint})` : ""}`)
+  ));
+}
+function createRecordsClient(config) {
+  const schema = config.schema ?? DEFAULT_SCHEMA;
+  const org = config.organizationId;
+  const scream = sink(config);
+  async function callDoor(door, args, where) {
+    if (!doorExists(door)) {
+      const refusal = doorAbsent(door);
+      scream({ code: refusal.code, message: refusal.message, ...refusal.hint ? { hint: refusal.hint } : {}, where });
+      return err(refusal);
+    }
+    const response = await config.dataSource.rpc(`${door}`, args, { schema });
+    if (response.error) {
+      const refusal = mapPgError(response.error, where);
+      scream({ code: refusal.code, message: refusal.message, ...refusal.hint ? { hint: refusal.hint } : {}, where });
+      return err(refusal);
+    }
+    return ok(response.data);
+  }
+  async function trustDoor(door, args, where) {
+    const response = await config.dataSource.rpc(door, args, { schema: TRUST_SCHEMA });
+    if (response.error) {
+      const refusal = mapPgError(response.error, where);
+      scream({ code: refusal.code, message: refusal.message, ...refusal.hint ? { hint: refusal.hint } : {}, where });
+      return err(refusal);
+    }
+    return ok(response.data);
+  }
+  function unfold(document) {
+    const raw = document ?? {};
+    const hidden = raw._hidden ?? {};
+    const values = {};
+    for (const [key, value] of Object.entries(raw)) {
+      if (key === "_hidden") continue;
+      values[key] = value;
+    }
+    return { document: values, hidden };
+  }
+  async function readValues(recordId) {
+    return callDoor(
+      DOORS.recordValuesVersioned,
+      { p_organization_id: org, p_record_id: recordId },
+      "recordRead"
+    );
+  }
+  const client = {
+    config,
+    async recordWrite({ table_id, data }) {
+      return callDoor(
+        DOORS.recordWrite,
+        { p_organization_id: org, p_table_id: table_id, p_data: data },
+        "recordWrite"
+      );
+    },
+    async recordUpdate({ record_id, patch, expectedVersion }) {
+      const result = await callDoor(
+        DOORS.recordUpdate,
+        {
+          p_organization_id: org,
+          p_record_id: record_id,
+          p_patch: patch,
+          ...expectedVersion === void 0 ? {} : { p_expected_version: expectedVersion }
+        },
+        "recordUpdate"
+      );
+      return result;
+    },
+    async recordDelete({ record_id }) {
+      return callDoor(
+        DOORS.recordDelete,
+        { p_organization_id: org, p_record_id: record_id },
+        "recordDelete"
+      );
+    },
+    async recordRestore({ record_id }) {
+      return callDoor(
+        DOORS.recordRestore,
+        { p_organization_id: org, p_record_id: record_id },
+        "recordRestore"
+      );
+    },
+    async recordRead({ record_id, withComputed = false }) {
+      const door = await callDoor(
+        DOORS.readRecord,
+        { p_organization_id: org, p_record_id: record_id },
+        "recordRead"
+      );
+      if (!door.ok) return err(door.error);
+      const { document, hidden } = unfold(door.data);
+      let computed = [];
+      if (withComputed) {
+        const provenance = await callDoor(
+          DOORS.computedProvenance,
+          { p_organization_id: org, p_record_id: record_id },
+          "recordRead.computed"
+        );
+        if (!provenance.ok) return err(provenance.error);
+        computed = provenance.data ?? [];
+      }
+      return ok({ record_id, document, hidden, computed });
+    },
+    async list({ table_id, limit = 50, offset = 0 }) {
+      const door = await callDoor(
+        DOORS.readRecords,
+        {
+          p_organization_id: org,
+          p_table_id: table_id,
+          p_limit: limit,
+          p_offset: offset
+        },
+        "list"
+      );
+      if (!door.ok) return err(door.error);
+      const rows = (door.data ?? []).map((row) => {
+        const { document, hidden } = unfold(row.document);
+        return { id: row.id, document, level: row.level, hidden };
+      });
+      return ok({ rows, total: null });
+    },
+    async query(input) {
+      const plan = planQuery(input);
+      const sets = [];
+      for (const call of plan.relationCalls) {
+        const result = await callDoor(
+          DOORS.relationTargets,
+          { p_organization_id: org, p_record_id: call.record_id, p_via_key: call.via_key },
+          "query.relations"
+        );
+        if (!result.ok) return err(result.error);
+        sets.push(
+          (result.data ?? []).map(
+            (row) => typeof row === "string" ? row : row.relation_targets
+          )
+        );
+      }
+      for (const call of plan.promotedCalls) {
+        const result = await callDoor(
+          DOORS.promotedRead,
+          {
+            p_organization_id: org,
+            p_table_id: plan.read.table_id,
+            p_field_key: call.field_key,
+            p_value: call.value
+          },
+          "query.promoted"
+        );
+        if (!result.ok) return err(result.error);
+        sets.push(
+          (result.data ?? []).map(
+            (row) => typeof row === "string" ? row : row.promoted_read
+          )
+        );
+      }
+      const ids = plan.intersects ? intersectIds(sets) : null;
+      if (ids !== null && ids.length === 0) {
+        return ok({ rows: [], total: 0 });
+      }
+      if (plan.read.asOf) {
+        const clock = plan.read.asOf.clock === "world" ? { p_world_on: plan.read.asOf.at.slice(0, 10) } : { p_recorded_at: plan.read.asOf.at };
+        if (ids !== null) {
+          const answers = await Promise.all(
+            ids.slice(0, plan.read.limit).map(
+              (id) => callDoor(
+                DOORS.queryRecordAsOf,
+                { p_organization_id: org, p_record_id: id, ...clock },
+                "query.asOf"
+              ).then((result) => ({ id, result }))
+            )
+          );
+          const rows2 = [];
+          for (const { id, result } of answers) {
+            if (!result.ok) return err(result.error);
+            if (result.data === null) continue;
+            const { document, hidden } = unfold(result.data);
+            rows2.push({ id, document, level: "viewer", hidden });
+          }
+          return ok({ rows: rows2, total: rows2.length });
+        }
+        const page = await callDoor(
+          DOORS.queryTableAsOf,
+          {
+            p_organization_id: org,
+            p_table_id: plan.read.table_id,
+            ...clock,
+            p_limit: plan.read.limit,
+            p_offset: plan.read.offset
+          },
+          "query.asOf"
+        );
+        if (!page.ok) return err(page.error);
+        const rows = (page.data ?? []).filter((row) => row.data !== null).map((row) => {
+          const { document, hidden } = unfold(row.data);
+          return { id: row.record_id, document, level: "viewer", hidden };
+        });
+        return ok({ rows, total: null });
+      }
+      if (ids !== null) {
+        const answers = await Promise.all(
+          ids.slice(0, plan.read.limit).map(
+            (id) => callDoor(
+              DOORS.readRecord,
+              { p_organization_id: org, p_record_id: id },
+              "query"
+            ).then((result) => ({ id, result }))
+          )
+        );
+        const rows = [];
+        for (const { id, result } of answers) {
+          if (!result.ok) {
+            if (result.error.sqlstate === "02000") continue;
+            return err(result.error);
+          }
+          const { document, hidden } = unfold(result.data);
+          rows.push({ id, document, level: "viewer", hidden });
+        }
+        return ok({ rows, total: rows.length });
+      }
+      return client.list({
+        table_id: plan.read.table_id,
+        limit: plan.read.limit,
+        offset: plan.read.offset
+      });
+    },
+    async tableList() {
+      const kernel = await callDoor(DOORS.tableKernelId, {}, "tableList.kernel");
+      if (!kernel.ok) return err(kernel.error);
+      const door = await callDoor(
+        DOORS.readRecords,
+        { p_organization_id: org, p_table_id: kernel.data, p_limit: 500, p_offset: 0 },
+        "tableList"
+      );
+      if (!door.ok) return err(door.error);
+      const tables = (door.data ?? []).map((row) => {
+        const { document } = unfold(row.document);
+        return { ...document, id: row.id, organization_id: org };
+      });
+      tables.sort((a, b) => (a.name ?? "").localeCompare(b.name ?? ""));
+      return ok(tables);
+    },
+    async fields({ table_id, recordType }) {
+      const applicable = await callDoor(
+        DOORS.applicableFields,
+        {
+          p_organization_id: org,
+          p_table_id: table_id,
+          ...recordType === void 0 ? {} : { p_record_type: recordType }
+        },
+        "fields"
+      );
+      if (!applicable.ok) return err(applicable.error);
+      const rows = applicable.data ?? [];
+      return ok(
+        rows.map((row) => ({ id: row.id, ...row.data }))
+      );
+    },
+    async fieldOptions({ field_id }) {
+      return callDoor(
+        DOORS.fieldOptions,
+        { p_organization_id: org, p_field_id: field_id },
+        "fieldOptions"
+      );
+    },
+    async tableCapacity({ table_id }) {
+      return callDoor(
+        DOORS.tableCapacity,
+        { p_organization_id: org, p_table_id: table_id },
+        "tableCapacity"
+      );
+    },
+    async tableDeclare({ spec, homeId }) {
+      return callDoor(
+        DOORS.tableDeclare,
+        { p_organization_id: org, p_spec: { ...spec, parent_id: homeId } },
+        "tableDeclare"
+      );
+    },
+    async personKernelId() {
+      return callDoor(DOORS.personKernelId, {}, "personKernelId");
+    },
+    async fieldKernelId() {
+      return callDoor(DOORS.fieldKernelId, {}, "fieldKernelId");
+    },
+    async ruleKernelId() {
+      return callDoor(DOORS.ruleKernelId, {}, "ruleKernelId");
+    },
+    async ruleMembers({ rule_id }) {
+      return callDoor(
+        DOORS.ruleMembers,
+        { p_organization_id: org, p_rule_id: rule_id },
+        "ruleMembers"
+      );
+    },
+    async ruleMembership({ rule_id, record_id }) {
+      return callDoor(
+        DOORS.ruleMembership,
+        { p_organization_id: org, p_rule_id: rule_id, p_record_id: record_id },
+        "ruleMembership"
+      );
+    },
+    async ruleRun({ rule_id, values, context }) {
+      return callDoor(
+        DOORS.ruleRun,
+        {
+          p_organization_id: org,
+          p_rule_id: rule_id,
+          p_values: values,
+          ...context === void 0 ? {} : { p_context: context }
+        },
+        "ruleRun"
+      );
+    },
+    async ruleEval({ expr, values, context }) {
+      return callDoor(
+        DOORS.ruleEval,
+        {
+          p_organization_id: org,
+          p_expr: expr,
+          p_values: values,
+          ...context === void 0 ? {} : { p_context: context }
+        },
+        "ruleEval"
+      );
+    },
+    async recordAggregate({ table_id, groupBy, measures, bucket, filter, limit }) {
+      return callDoor(
+        DOORS.recordAggregate,
+        {
+          p_organization_id: org,
+          p_table_id: table_id,
+          p_group_by: groupBy ?? [],
+          p_measures: measures ?? [],
+          p_bucket: bucket ?? null,
+          p_filter: filter ?? {},
+          p_limit: limit ?? 200
+        },
+        "recordAggregate"
+      );
+    },
+    async aggOperations() {
+      return callDoor(DOORS.aggOperations, {}, "aggOperations");
+    },
+    async aggBuckets() {
+      return callDoor(DOORS.aggBuckets, {}, "aggBuckets");
+    },
+    async aggSubscriptions(args) {
+      return callDoor(
+        DOORS.aggSubscriptions,
+        {
+          p_organization_id: org,
+          p_saved_view_id: args?.saved_view_id ?? null,
+          p_cadence: args?.cadence ?? null
+        },
+        "aggSubscriptions"
+      );
+    },
+    async aggSubscriptionCadences() {
+      return callDoor(DOORS.aggSubscriptionCadences, {}, "aggSubscriptionCadences");
+    },
+    async docTemplateSave({ table_id, name, body, template_id }) {
+      return callDoor(
+        DOORS.docTemplateSave,
+        {
+          p_organization_id: org,
+          p_table_id: table_id,
+          p_name: name,
+          p_body: body,
+          p_template_id: template_id ?? null
+        },
+        "docTemplateSave"
+      );
+    },
+    async docRenderBody({ template_id, record_id }) {
+      return callDoor(
+        DOORS.docRenderBody,
+        { p_organization_id: org, p_template_id: template_id, p_record_id: record_id },
+        "docRenderBody"
+      );
+    },
+    async docRenderDocument({ template_id, record_id }) {
+      return callDoor(
+        DOORS.docRenderDocument,
+        { p_organization_id: org, p_template_id: template_id, p_record_id: record_id },
+        "docRenderDocument"
+      );
+    },
+    async docTokens({ body }) {
+      return callDoor(DOORS.docTokens, { p_body: body }, "docTokens");
+    },
+    async docUnresolvedTokens({ table_id, body }) {
+      return callDoor(
+        DOORS.docUnresolvedTokens,
+        { p_organization_id: org, p_table_id: table_id, p_body: body },
+        "docUnresolvedTokens"
+      );
+    },
+    async docSign({ render_id, field_key, signer_name, signer_user_id }) {
+      return callDoor(
+        DOORS.docSign,
+        {
+          p_organization_id: org,
+          p_render_id: render_id,
+          p_field_key: field_key,
+          p_signer_name: signer_name,
+          p_signer_user_id: signer_user_id ?? null
+        },
+        "docSign"
+      );
+    },
+    async docTemplates({ table_id }) {
+      const response = await config.dataSource.schema(schema).from("doc_template").select("*").eq("organization_id", org).eq("renders_table_id", table_id).order("name");
+      if (response.error) {
+        const refusal = mapPgError(response.error, "docTemplates");
+        scream({ code: refusal.code, message: refusal.message, ...refusal.hint ? { hint: refusal.hint } : {}, where: "docTemplates" });
+        return err(refusal);
+      }
+      return ok(response.data ?? []);
+    },
+    async docRenders({ record_id }) {
+      const response = await config.dataSource.schema(schema).from("doc_render").select("*").eq("organization_id", org).eq("record_id", record_id).is("deleted_at", null).order("rendered_at", { ascending: false });
+      if (response.error) {
+        const refusal = mapPgError(response.error, "docRenders");
+        scream({ code: refusal.code, message: refusal.message, ...refusal.hint ? { hint: refusal.hint } : {}, where: "docRenders" });
+        return err(refusal);
+      }
+      return ok(response.data ?? []);
+    },
+    async docSignatures({ record_id }) {
+      const response = await config.dataSource.schema(schema).from("doc_signature").select("*").eq("organization_id", org).eq("record_id", record_id).is("deleted_at", null).order("signed_at", { ascending: false });
+      if (response.error) {
+        const refusal = mapPgError(response.error, "docSignatures");
+        scream({ code: refusal.code, message: refusal.message, ...refusal.hint ? { hint: refusal.hint } : {}, where: "docSignatures" });
+        return err(refusal);
+      }
+      return ok(response.data ?? []);
+    },
+    async recordValuesVersioned({ record_id }) {
+      return readValues(record_id);
+    },
+    async revisions({ record_id }) {
+      return callDoor(
+        DOORS.ioRevisions,
+        { p_organization_id: org, p_record_id: record_id },
+        "revisions"
+      );
+    },
+    async docSignatureIntact({ signature_id }) {
+      return callDoor(
+        DOORS.docSignatureIntact,
+        { p_organization_id: org, p_signature_id: signature_id },
+        "docSignatureIntact"
+      );
+    },
+    // ── the anonymous lane ───────────────────────────────────────────────
+    async anonTokenIssue({ mode, allowedOrigins, formId, savedViewId, recordId, expiresAt }) {
+      const answered = await callDoor(
+        DOORS.anonTokenIssue,
+        {
+          p_organization_id: org,
+          p_mode: mode,
+          p_allowed_origins: allowedOrigins,
+          p_form_id: formId ?? null,
+          p_saved_view_id: savedViewId ?? null,
+          p_record_id: recordId ?? null,
+          p_expires_at: expiresAt ?? null
+        },
+        "anonTokenIssue"
+      );
+      if (!answered.ok) return answered;
+      const pair = answered.data[0];
+      if (!pair) {
+        return err({
+          code: "internal",
+          message: "custom.anon_token_issue returned no token, which it cannot do \u2014 it either mints one or raises.",
+          hint: "Nothing was issued. Do not retry blindly: something between this client and the store changed the answer's shape."
+        });
+      }
+      return ok(pair);
+    },
+    async anonTokenVerify({ secret, origin, requiredMode }) {
+      const answered = await callDoor(
+        DOORS.anonTokenVerify,
+        { p_secret: secret, p_origin: origin, p_required_mode: requiredMode ?? null },
+        "anonTokenVerify"
+      );
+      if (!answered.ok) return answered;
+      const binding = answered.data[0];
+      if (!binding) {
+        return err({
+          code: "internal",
+          message: "custom.anon_token_verify returned no binding, which it cannot do \u2014 it either answers or raises.",
+          hint: "Treat this as unverified. It is reported rather than read as 'not valid', because those are different sentences."
+        });
+      }
+      return ok(binding);
+    },
+    async anonTokenRevoke({ token_id }) {
+      return callDoor(
+        DOORS.anonTokenRevoke,
+        { p_organization_id: org, p_token_id: token_id },
+        "anonTokenRevoke"
+      );
+    },
+    async anonWrite({ secret, origin, payload, clientKey, rawPayload }) {
+      return callDoor(
+        DOORS.anonWrite,
+        {
+          p_secret: secret,
+          p_origin: origin,
+          p_payload: payload,
+          p_client_key: clientKey ?? null,
+          p_raw_payload: rawPayload ?? {}
+        },
+        "anonWrite"
+      );
+    },
+    async anonCapture({ table_id, clientKey, payload, device, capturedAt }) {
+      return callDoor(
+        DOORS.anonCapture,
+        {
+          p_organization_id: org,
+          p_client_key: clientKey,
+          p_table_id: table_id,
+          p_payload: payload,
+          p_device: device ?? null,
+          p_captured_at: capturedAt ?? null
+        },
+        "anonCapture"
+      );
+    },
+    async anonPublish({ form_id, published = true }) {
+      return callDoor(
+        DOORS.anonPublish,
+        { p_organization_id: org, p_form_id: form_id, p_published: published },
+        "anonPublish"
+      );
+    },
+    // ── work ─────────────────────────────────────────────────────────────
+    async workStates() {
+      return callDoor(DOORS.workStates, {}, "workStates");
+    },
+    async workTemplateRefusal({ graph }) {
+      return callDoor(DOORS.workTemplateRefusal, { p_graph: graph }, "workTemplateRefusal");
+    },
+    async workTemplateDeclare({ name, graph }) {
+      return callDoor(
+        DOORS.workTemplateDeclare,
+        { p_organization_id: org, p_name: name, p_graph: graph },
+        "workTemplateDeclare"
+      );
+    },
+    async workTemplateInstantiate({ template_id, overrides }) {
+      return callDoor(
+        DOORS.workTemplateInstantiate,
+        { p_organization_id: org, p_template_id: template_id, p_overrides: overrides ?? {} },
+        "workTemplateInstantiate"
+      );
+    },
+    async workTemplateShape({ template_id }) {
+      return callDoor(
+        DOORS.workTemplateShape,
+        { p_organization_id: org, p_template_id: template_id },
+        "workTemplateShape"
+      );
+    },
+    async workInstantiationShape({ instantiation_id }) {
+      return callDoor(
+        DOORS.workInstantiationShape,
+        { p_organization_id: org, p_instantiation_id: instantiation_id },
+        "workInstantiationShape"
+      );
+    },
+    async workWhoseTurn({ table_id, includeFinished = false }) {
+      return callDoor(
+        DOORS.workWhoseTurn,
+        { p_organization_id: org, p_table_id: table_id, p_include_finished: includeFinished },
+        "workWhoseTurn"
+      );
+    },
+    async workHasAssignment({ table_id }) {
+      return callDoor(
+        DOORS.workHasAssignment,
+        { p_organization_id: org, p_table_id: table_id },
+        "workHasAssignment"
+      );
+    },
+    async workAssignmentFields(args) {
+      return callDoor(
+        DOORS.workAssignmentFields,
+        { p_options_table_id: args?.options_table_id ?? null },
+        "workAssignmentFields"
+      );
+    },
+    async workTakeAssignment({ table_id }) {
+      return callDoor(
+        DOORS.workTakeAssignment,
+        { p_organization_id: org, p_table_id: table_id },
+        "workTakeAssignment"
+      );
+    },
+    async workTransitionRefusal({ from_state_id, to_state_id }) {
+      return callDoor(
+        DOORS.workTransitionRefusal,
+        { p_organization_id: org, p_from_state_id: from_state_id, p_to_state_id: to_state_id },
+        "workTransitionRefusal"
+      );
+    },
+    async workSlotsDeclare({ name, slug, homeId }) {
+      return callDoor(
+        DOORS.workSlotsDeclare,
+        { p_organization_id: org, p_name: name, p_slug: slug, p_home_id: homeId ?? null },
+        "workSlotsDeclare"
+      );
+    },
+    async workSlotHold({ table_id, slotKey, holder, ttl }) {
+      return callDoor(
+        DOORS.workSlotHold,
+        {
+          p_organization_id: org,
+          p_table_id: table_id,
+          p_slot_key: slotKey,
+          p_holder: holder,
+          ...ttl ? { p_ttl: ttl } : {}
+        },
+        "workSlotHold"
+      );
+    },
+    async workSlotRelease({ hold_id }) {
+      return callDoor(
+        DOORS.workSlotRelease,
+        { p_organization_id: org, p_hold_id: hold_id },
+        "workSlotRelease"
+      );
+    },
+    async workSlotHolds({ table_id }) {
+      return callDoor(
+        DOORS.workSlotHolds,
+        { p_organization_id: org, p_table_id: table_id },
+        "workSlotHolds"
+      );
+    },
+    async workSlotExpire({ table_id }) {
+      return callDoor(
+        DOORS.workSlotExpire,
+        { p_organization_id: org, p_table_id: table_id },
+        "workSlotExpire"
+      );
+    },
+    // ── the trust doors ──────────────────────────────────────────────────
+    async isExternalPrincipal(args) {
+      return trustDoor(
+        TRUST_DOORS.isExternalPrincipal,
+        { p_user_id: args?.user_id ?? null },
+        "isExternalPrincipal"
+      );
+    },
+    async externalPrincipalCard(args) {
+      return trustDoor(
+        TRUST_DOORS.externalPrincipalCard,
+        { p_user_id: args?.user_id ?? null },
+        "externalPrincipalCard"
+      );
+    },
+    async externalPrincipalReach({ resourceType, user_id }) {
+      return trustDoor(
+        TRUST_DOORS.externalPrincipalReach,
+        { p_resource_type: resourceType, p_user_id: user_id ?? null },
+        "externalPrincipalReach"
+      );
+    },
+    async publishBindingCreate({ slug, resourceType, resource_id, renderMode = "page" }) {
+      return trustDoor(
+        TRUST_DOORS.publishBindingCreate,
+        {
+          p_slug: slug,
+          p_resource_type: resourceType,
+          p_resource_id: resource_id,
+          p_organization_id: org,
+          p_render_mode: renderMode
+        },
+        "publishBindingCreate"
+      );
+    },
+    async publishBindingRevoke({ slug }) {
+      return trustDoor(TRUST_DOORS.publishBindingRevoke, { p_slug: slug }, "publishBindingRevoke");
+    },
+    async resolvePublishBinding({ slug }) {
+      return trustDoor(
+        TRUST_DOORS.resolvePublishBinding,
+        { p_slug: slug },
+        "resolvePublishBinding"
+      );
+    },
+    async worldPublishGapNotice() {
+      return trustDoor(TRUST_DOORS.worldPublishGapNotice, {}, "worldPublishGapNotice");
+    },
+    async publishToWorld({ resourceType, resource_id, discoverable = false }) {
+      return trustDoor(
+        TRUST_DOORS.publishToWorld,
+        {
+          p_resource_type: resourceType,
+          p_resource_id: resource_id,
+          p_organization_id: org,
+          p_discoverable: discoverable
+        },
+        "publishToWorld"
+      );
+    },
+    async ruleDeclare() {
+      const refusal = doorAbsent(DOORS.ruleDeclare);
+      scream({ code: refusal.code, message: refusal.message, ...refusal.hint ? { hint: refusal.hint } : {}, where: "ruleDeclare" });
+      return err(refusal);
+    },
+    async metadataSearch() {
+      const refusal = doorAbsent(DOORS.metadataSearch);
+      scream({ code: refusal.code, message: refusal.message, ...refusal.hint ? { hint: refusal.hint } : {}, where: "metadataSearch" });
+      return err(refusal);
+    },
+    async fieldPropose() {
+      const refusal = doorAbsent(DOORS.fieldPropose);
+      scream({ code: refusal.code, message: refusal.message, ...refusal.hint ? { hint: refusal.hint } : {}, where: "fieldPropose" });
+      return err(refusal);
+    },
+    async tablePropose() {
+      const refusal = doorAbsent(DOORS.tablePropose);
+      scream({ code: refusal.code, message: refusal.message, ...refusal.hint ? { hint: refusal.hint } : {}, where: "tablePropose" });
+      return err(refusal);
+    },
+    async promoteTable({ table_id }) {
+      return callDoor(
+        DOORS.promoteTable,
+        { p_organization_id: org, p_table_id: table_id },
+        "promoteTable"
+      );
+    },
+    async promoteField({ table_id, field_id }) {
+      return callDoor(
+        DOORS.promoteField,
+        { p_organization_id: org, p_table_id: table_id, p_field_id: field_id },
+        "promoteField"
+      );
+    },
+    async storeIsOpen() {
+      return callDoor(DOORS.storeIsOpen, { p_organization_id: org }, "storeIsOpen");
+    }
+  };
+  return client;
+}
+function asWriteConflict(error, recordId) {
+  const detail = staleWriteDetail(error);
+  if (!detail) return null;
+  return {
+    ...detail,
+    record_id: recordId,
+    message: error.message,
+    hint: error.hint ?? ""
+  };
+}
+
+// src/core/validation.ts
+var DEFAULT_VALUE_MAX_BYTES = 1e5;
+var DEFAULT_DOCUMENT_MAX_BYTES = 1048576;
+var jsonType = (value) => {
+  if (value === null) return "null";
+  if (Array.isArray(value)) return "array";
+  switch (typeof value) {
+    case "string":
+      return "string";
+    case "number":
+      return "number";
+    case "boolean":
+      return "boolean";
+    case "object":
+      return "object";
+    default:
+      return "null";
+  }
+};
+function pgJsonbText(value) {
+  if (value === null || value === void 0) return "null";
+  if (Array.isArray(value)) return `[${value.map(pgJsonbText).join(", ")}]`;
+  if (typeof value === "object") {
+    const parts = Object.entries(value).map(
+      ([k, v]) => `${JSON.stringify(k)}: ${pgJsonbText(v)}`
+    );
+    return `{${parts.join(", ")}}`;
+  }
+  return JSON.stringify(value);
+}
+var jsonBytes = (value) => new TextEncoder().encode(pgJsonbText(value)).length;
+var UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+function labelOf(field) {
+  return field.label && field.label.length > 0 ? field.label : field.key;
+}
+function ruleRefusal(field, rule, item, values) {
+  const label = labelOf(field);
+  const base = { sqlstate: "23514", predicted_by: "custom.validate_values", field_key: field.key };
+  const num = typeof item === "number" ? item : null;
+  switch (rule.kind) {
+    case "min":
+      if (num !== null && num < Number(rule.value)) {
+        return { ...base, message: `${label} has to be at least ${rule.value}`, hint: "FLD-3: an attached validation Rule, not a behavior." };
+      }
+      return null;
+    case "max":
+      if (num !== null && num > Number(rule.value)) {
+        return { ...base, message: `${label} cannot be more than ${rule.value}`, hint: "FLD-3: an attached validation Rule, not a behavior." };
+      }
+      return null;
+    case "length":
+      if (typeof item === "string" && item.length > Number(rule.value)) {
+        return { ...base, message: `${label} is longer than ${rule.value} characters`, hint: "FLD-3." };
+      }
+      return null;
+    case "pattern":
+      if (typeof item === "string" && !new RegExp(String(rule.value)).test(item)) {
+        return { ...base, message: `${label} is not written the way this field expects`, hint: "FLD-3." };
+      }
+      return null;
+    case "equals_field": {
+      const other = values[String(rule.value)];
+      if (other !== void 0 && other !== null && JSON.stringify(other) !== JSON.stringify(item)) {
+        return {
+          ...base,
+          message: `${label} and ${rule.value} have to be the same`,
+          hint: "FLD-3 / T8: a constraint across two fields is a Rule attached to one of them, never a behavior."
+        };
+      }
+      return null;
+    }
+    case "differs_from_field": {
+      const other = values[String(rule.value)];
+      if (other !== void 0 && JSON.stringify(other) === JSON.stringify(item)) {
+        return { ...base, message: `${label} and ${rule.value} have to be different`, hint: "FLD-3." };
+      }
+      return null;
+    }
+    default:
+      return null;
+  }
+}
+function predictValueRefusals(fields, values, recordType) {
+  const found = [];
+  for (const field of fields) {
+    const label = labelOf(field);
+    const base = { sqlstate: "23514", predicted_by: "custom.validate_values", field_key: field.key };
+    const raw = values[field.key];
+    const isEmpty = raw === void 0 || raw === null || field.multi && Array.isArray(raw) && raw.length === 0;
+    if (isEmpty) {
+      if (field.required) {
+        found.push({
+          ...base,
+          message: `${label} is required`,
+          hint: `REC-51: the field ${field.key} of this table.`
+        });
+      }
+      continue;
+    }
+    if (field.type === "formula") {
+      found.push({
+        ...base,
+        message: `${label} is worked out by the system, so it cannot be typed in`,
+        hint: `FLD-9: this formula computes on ${field.compute_on ?? "write"}.`
+      });
+      continue;
+    }
+    let items;
+    if (field.multi) {
+      if (!Array.isArray(raw)) {
+        found.push({ ...base, message: `${label} holds many values, so it takes a list`, hint: "FLD-2: the multi modifier." });
+        continue;
+      }
+      items = raw;
+    } else {
+      if (Array.isArray(raw)) {
+        found.push({ ...base, message: `${label} holds one value, and it was given a list`, hint: "FLD-2: multi is off for this field." });
+        continue;
+      }
+      items = [raw];
+    }
+    for (const item of items) {
+      if (field.type === "text" && typeof item !== "string") {
+        found.push({ ...base, message: `${label} takes words, and it was given a ${jsonType(item)}`, hint: "FLD-1: text." });
+      } else if (field.type === "range") {
+        const kind = field.config?.["kind"] ?? "number";
+        if (typeof item === "number") {
+        } else if (typeof item === "string" && (kind === "date" || kind === "datetime")) {
+          if (Number.isNaN(Date.parse(item))) {
+            found.push({ ...base, message: `${label} takes a date, and ${item} is not one`, hint: "FLD-1: range, of kind date." });
+          }
+        } else {
+          found.push({ ...base, message: `${label} takes a number, and it was given a ${jsonType(item)}`, hint: "FLD-1: range." });
+        }
+      } else if (field.type === "list") {
+        if (typeof item !== "string") {
+          found.push({
+            ...base,
+            message: `${label} takes one of its choices, and it was given a ${jsonType(item)}`,
+            hint: "FLD-5 / FLD-6: a list field stores the id of the option RECORD, because every pick-list is already a Table."
+          });
+        } else if (!UUID.test(item)) {
+          found.push({
+            ...base,
+            message: `${label} was given a choice that is not one of its choices`,
+            hint: `REC-51: option membership. ${label} stores the id of an option record, and what it was given is not an id at all.`
+          });
+        }
+      } else if (field.type === "relation") {
+        if (typeof item !== "string") {
+          found.push({ ...base, message: `${label} points at a record, and it was given a ${jsonType(item)}`, hint: "FLD-1: relation." });
+        } else if (!UUID.test(item)) {
+          found.push({
+            ...base,
+            message: `${label} points at something that is not there`,
+            hint: `REC-51: ${label} stores the id of a record, and what it was given is not an id at all.`
+          });
+        }
+      }
+      for (const rule of field.rules ?? []) {
+        const applies = !rule.applies_to_types || rule.applies_to_types.length === 0 || recordType !== void 0 && rule.applies_to_types.includes(recordType);
+        if (!applies) continue;
+        const refusal = ruleRefusal(field, rule, item, values);
+        if (refusal) found.push(refusal);
+      }
+    }
+    if (field.type === "relation" && field.multi && field.relation_max !== null) {
+      const n = items.length;
+      if (n > field.relation_max) {
+        found.push({
+          ...base,
+          message: `${label} points at ${n} things, and it can point at ${field.relation_max} at most`,
+          hint: "REC-51: relation_max."
+        });
+      }
+    }
+  }
+  return found;
+}
+function predictSizeRefusal(document, limits = {}) {
+  const valueMax = limits.value_max_bytes ?? DEFAULT_VALUE_MAX_BYTES;
+  const docMax = limits.document_max_bytes ?? DEFAULT_DOCUMENT_MAX_BYTES;
+  for (const [key, value] of Object.entries(document)) {
+    if (key.startsWith("_")) continue;
+    const bytes = jsonBytes(value);
+    if (bytes > valueMax) {
+      return {
+        field_key: key,
+        sqlstate: "23514",
+        predicted_by: "custom.size_refusal",
+        message: `${key} is ${bytes} bytes, and one value in a record holds at most ${valueMax}. Put the big thing in a file record and point the value at it - this store has a File table for exactly that.`
+      };
+    }
+  }
+  const total = jsonBytes(document);
+  if (total > docMax) {
+    return {
+      sqlstate: "23514",
+      predicted_by: "custom.size_refusal",
+      message: `this record is ${total} bytes, and one record holds at most ${docMax}. Put the big things in file records and point the values at them - this store has a File table for exactly that.`
+    };
+  }
+  return null;
+}
+function predictEnvelopeRefusal(document) {
+  const say = (message) => ({
+    message,
+    sqlstate: "23514",
+    predicted_by: "custom.value_envelope_refusal"
+  });
+  let sources = {};
+  if (Object.prototype.hasOwnProperty.call(document, "_sources")) {
+    const block2 = document._sources;
+    if (jsonType(block2) !== "object") {
+      return say(
+        `this record's provenance block (_sources) must be an object of pointer -> source, and it is a ${jsonType(block2)}.`
+      );
+    }
+    sources = block2;
+    for (const pointer of Object.keys(sources)) {
+      if (!/^s[0-9]+$/.test(pointer)) {
+        return say(
+          `"${pointer}" is not a provenance pointer. A pointer is interned by this store and looks like s1, s2, s3 \u2014 it is never a name a writer chooses.`
+        );
+      }
+      if (jsonType(sources[pointer]) !== "object") {
+        return say(
+          `the source at ${pointer} must be an object describing where the value came from, and it is a ${jsonType(sources[pointer])}.`
+        );
+      }
+    }
+    const distinct = new Set(Object.values(sources).map((v) => JSON.stringify(v)));
+    if (distinct.size !== Object.keys(sources).length) {
+      return say(
+        `the same source is written twice in this record's provenance block. A source is interned once per save and every value that came from it points at the one entry.`
+      );
+    }
+  }
+  if (!Object.prototype.hasOwnProperty.call(document, "_values")) return null;
+  const block = document._values;
+  if (jsonType(block) !== "object") {
+    return say(
+      `this record's value block (_values) must be an object of field key -> envelope, and it is a ${jsonType(block)}.`
+    );
+  }
+  for (const [key, envUnknown] of Object.entries(block)) {
+    if (jsonType(envUnknown) !== "object") {
+      return say(`the envelope for ${key} must be an object, and it is a ${jsonType(envUnknown)}.`);
+    }
+    const env = envUnknown;
+    for (const k of Object.keys(env)) {
+      if (!VALUE_ENVELOPE_KEYS.includes(k)) {
+        if (PER_VALUE_ACCESS_WORDS.includes(k)) {
+          return say(
+            `${key} cannot carry "${k}": visibility and access belong to a Field and to a Record, never to a single value. A value that must be secret goes in a contained record with its own visibility.`
+          );
+        }
+        return say(
+          `${key} carries "${k}", which is not part of a value envelope. An envelope holds ${VALUE_ENVELOPE_KEYS.join(", ")}.`
+        );
+      }
+    }
+    if ("absent" in env && env.absent !== null) {
+      const absent = String(env.absent);
+      if (!ABSENCE_REASONS.includes(absent)) {
+        return say(
+          `${key}: "${absent}" is not a reason a value can be missing. The reasons are ${ABSENCE_REASONS.join(", ")}.`
+        );
+      }
+      if (key in document && document[key] !== null) {
+        return say(`${key} both holds a value and says why it is missing ("${absent}"). It can be one or the other.`);
+      }
+    }
+    if ("src" in env && env.src !== null) {
+      if (typeof env.src !== "string") {
+        return say(
+          `${key}: its source must be a provenance pointer this store interned. Write the source itself and the store interns it; ${jsonType(env.src)} is not a pointer.`
+        );
+      }
+      if (!(env.src in sources)) {
+        return say(`${key} points at the source ${env.src}, and this record's provenance block has no such entry.`);
+      }
+    }
+    if ("alternates" in env && env.alternates !== null) {
+      if (!Array.isArray(env.alternates)) {
+        return say(`${key}: its other candidate values must be a list, and it is a ${jsonType(env.alternates)}.`);
+      }
+      const ranks = [];
+      for (const altUnknown of env.alternates) {
+        if (jsonType(altUnknown) !== "object") {
+          return say(`${key}: every other candidate is a value, a source and a rank, and one of them is a ${jsonType(altUnknown)}.`);
+        }
+        const alt = altUnknown;
+        for (const k of Object.keys(alt)) {
+          if (!VALUE_ALTERNATE_KEYS.includes(k)) {
+            if (PER_VALUE_ACCESS_WORDS.includes(k)) {
+              return say(
+                `${key}: an alternate cannot carry "${k}" \u2014 visibility and access belong to a Field and to a Record, never to a single value.`
+              );
+            }
+            return say(
+              `${key}: an alternate carries "${k}", which is not part of one. An alternate holds ${VALUE_ALTERNATE_KEYS.join(", ")} \u2014 a rank, which is the order an organization's sources are trusted in, and never a score or a confidence a machine invented.`
+            );
+          }
+        }
+        if (!("value" in alt)) {
+          return say(`${key}: an alternate with no value is not a candidate for anything.`);
+        }
+        const rank = alt["rank"];
+        if (typeof rank !== "number" || !Number.isInteger(rank) || rank < 1) {
+          return say(`${key}: every alternate carries a whole rank of 1 or more \u2014 the order its source is trusted in.`);
+        }
+        if (ranks.includes(rank)) {
+          return say(`${key}: two alternates claim rank ${rank}. A rank is an order, so it is held by one candidate.`);
+        }
+        ranks.push(rank);
+        if ("src" in alt && alt["src"] !== null) {
+          if (typeof alt["src"] !== "string") {
+            return say(`${key}: an alternate's source must be a provenance pointer this store interned, and it is a ${jsonType(alt["src"])}.`);
+          }
+          if (!(String(alt["src"]) in sources)) {
+            return say(`${key}: an alternate points at the source ${String(alt["src"])}, and this record's provenance block has no such entry.`);
+          }
+        }
+      }
+    }
+  }
+  return null;
+}
+function predictWriteRefusals(args) {
+  const { fields, document, recordType, limits } = args;
+  const values = {};
+  for (const [k, v] of Object.entries(document)) {
+    if (!k.startsWith("_")) values[k] = v;
+  }
+  const found = [];
+  const envelope = predictEnvelopeRefusal(document);
+  if (envelope) found.push(envelope);
+  const size = predictSizeRefusal(document, limits);
+  if (size) found.push(size);
+  found.push(...predictValueRefusals(fields, values, recordType));
+  return found;
+}
+
+// src/core/io.ts
+var escape = (value) => /[",\n\r]/.test(value) ? `"${value.replace(/"/g, '""')}"` : value;
+function cellText(value) {
+  if (!value) return "";
+  if (value.absent_reason) return `(${value.absent_reason})`;
+  const raw = value.value;
+  if (raw === null || raw === void 0) return "";
+  if (typeof raw === "string") return raw;
+  return JSON.stringify(raw);
+}
+function headerFor(field) {
+  return field.label && field.label.length > 0 ? field.label : field.key;
+}
+function exportCsv(fields, rows) {
+  const lines = [fields.map((f) => escape(headerFor(f))).join(",")];
+  for (const row of rows) {
+    lines.push(fields.map((f) => escape(cellText(row[f.key]))).join(","));
+  }
+  return lines.join("\n");
+}
+function toAoa(fields, rows) {
+  return [fields.map(headerFor), ...rows.map((row) => fields.map((f) => cellText(row[f.key])))];
+}
+async function exportXlsx(fields, rows, sheetLabel = "Records") {
+  const XLSX = await import("xlsx");
+  const worksheet = XLSX.utils.aoa_to_sheet(toAoa(fields, rows));
+  const workbook = XLSX.utils.book_new();
+  const name = sheetLabel.replace(/[\\/?*[\]:]/g, " ").trim().slice(0, 31) || "Data";
+  XLSX.utils.book_append_sheet(workbook, worksheet, name);
+  return XLSX.write(workbook, { type: "array", bookType: "xlsx", compression: true });
+}
+function matchField(header, fields) {
+  const wanted = header.trim().toLowerCase();
+  return fields.find((f) => f.key.toLowerCase() === wanted) ?? fields.find((f) => (f.label ?? "").toLowerCase() === wanted) ?? null;
+}
+function parseCsv(text) {
+  const rows = [];
+  let row = [];
+  let cell = "";
+  let quoted = false;
+  for (let i = 0; i < text.length; i += 1) {
+    const ch = text[i];
+    if (quoted) {
+      if (ch === '"') {
+        if (text[i + 1] === '"') {
+          cell += '"';
+          i += 1;
+        } else quoted = false;
+      } else cell += ch;
+      continue;
+    }
+    if (ch === '"') quoted = true;
+    else if (ch === ",") {
+      row.push(cell);
+      cell = "";
+    } else if (ch === "\n" || ch === "\r") {
+      if (ch === "\r" && text[i + 1] === "\n") i += 1;
+      row.push(cell);
+      rows.push(row);
+      row = [];
+      cell = "";
+    } else cell += ch;
+  }
+  if (cell.length > 0 || row.length > 0) {
+    row.push(cell);
+    rows.push(row);
+  }
+  return rows;
+}
+function importCsv(fields, text) {
+  return fromMatrix(fields, parseCsv(text));
+}
+async function importXlsx(fields, bytes) {
+  const XLSX = await import("xlsx");
+  const workbook = XLSX.read(bytes, { type: "array" });
+  const first = workbook.SheetNames[0];
+  if (!first) return { columns: [], rows: [], unmapped: [] };
+  const sheet = workbook.Sheets[first];
+  if (!sheet) return { columns: [], rows: [], unmapped: [] };
+  const matrix = XLSX.utils.sheet_to_json(sheet, { header: 1, raw: false, defval: "" });
+  return fromMatrix(fields, matrix);
+}
+function fromMatrix(fields, matrix) {
+  const [header, ...body] = matrix;
+  if (!header) return { columns: [], rows: [], unmapped: [] };
+  const columns = header.map((text) => ({ header: text, field: matchField(text, fields) }));
+  const unmapped = columns.filter((c) => c.field === null).map((c) => c.header).filter((h) => h.trim().length > 0);
+  const rows = body.filter((line) => line.some((cell) => String(cell ?? "").trim().length > 0)).map((line) => {
+    const record = {};
+    columns.forEach((column, index) => {
+      if (column.field) record[column.field.key] = String(line[index] ?? "");
+    });
+    return record;
+  });
+  return { columns, rows, unmapped };
+}
+//# sourceMappingURL=index.cjs.map