@sequenceholdings/orm 2.1.0 → 2.2.0

package/dist/index.cjs

@@ -2,8 +2,8 @@
 
 var drizzleOrm = require('drizzle-orm');
 var pgCore = require('drizzle-orm/pg-core');
-var crypto = require('crypto');
 var zod = require('zod');
+var crypto = require('crypto');
 var jiti = require('jiti');
 var promises = require('fs/promises');
 var module$1 = require('module');
@@ -40,7 +40,8 @@ var ColumnBuilder = class {
       description: void 0,
       renamedFrom: void 0,
       cast: void 0,
-      deprecated: false
+      deprecated: false,
+      cell: void 0
     };
   }
   /** Marks this column as (part of) the primary key. Implies NOT NULL. */
@@ -100,6 +101,11 @@ var ColumnBuilder = class {
     this.state.deprecated = true;
     return this;
   }
+  /** @internal System cell-metadata part of logical column `of` (generated resolved views only). */
+  cellPart(of, part) {
+    this.state.cell = { of, part };
+    return this;
+  }
   /** Whether `.primaryKey()` was called — collected into the table-level PK. */
   get isPrimaryKey() {
     return this.state.primaryKey;
@@ -128,6 +134,7 @@ var ColumnBuilder = class {
     if (this.state.description !== void 0) column.description = this.state.description;
     if (this.state.renamedFrom !== void 0) column.renamedFrom = this.state.renamedFrom;
     if (this.state.cast !== void 0) column.cast = this.state.cast;
+    if (this.state.cell !== void 0) column.cell = { ...this.state.cell };
     return column;
   }
 };
@@ -151,15 +158,15 @@ var t = {
 
 // src/constants.ts
 var NAMESPACE_PATTERN = /^[a-z][a-z0-9_]{0,40}$/;
+var ORM_DATA_TOKEN_HEADER = "x-sequence-data-token";
+var ORM_SERVICE_DATA_TOKEN_HEADER = "x-sequence-data-token-service";
 var IDENTIFIER_PATTERN = /^[a-z][a-z0-9_]*$/;
 var COLUMN_IDENTIFIER_PATTERN = /^_?[a-z][a-z0-9_]*$/;
 var MAX_IDENTIFIER_LENGTH = 63;
-var ORM_DATA_TOKEN_HEADER = "x-sequence-data-token";
-var ORM_SERVICE_DATA_TOKEN_HEADER = "x-sequence-data-token-service";
-var CAPABILITY_KEY_PATTERN = /^(?:org\/)?[a-z0-9-]{1,64}$/;
+var CAPABILITY_KEY_PATTERN = /^(?:org\/|app\/[a-z][a-z0-9-]{0,63}\/)?[a-z0-9-]{1,64}$/;
 var CLAIM_KEY_PATTERN = /^[a-z][a-z0-9_]*$/;
-var QUALIFIED_TABLE_PATTERN = /^[a-z][a-z0-9_]*\.[a-z][a-z0-9_]*$/;
-var SYNCED_SOURCE_PATTERN = /^gold\.[a-z][a-z0-9_]*$/;
+var QUALIFIED_TABLE_PATTERN = /^[a-z][a-z0-9_]{0,62}\.[a-z][a-z0-9_]{0,62}$/;
+var SYNCED_SOURCE_PATTERN = QUALIFIED_TABLE_PATTERN;
 var ORM_SCHEMA_PREFIX = "orm_";
 var CONSUMER_ROLE_SUFFIX = "_consumer";
 var ormSchemaName = (namespace) => `${ORM_SCHEMA_PREFIX}${namespace}`;
@@ -172,6 +179,27 @@ var MAX_GENERATED_SDL_BYTES = 16 * 1024 * 1024;
 var ORM_REGISTRATION_MAX_BYTES = 64 * 1024 * 1024;
 var RESERVED_TABLE_NAMES = /* @__PURE__ */ new Set(["actions", "query"]);
 var RESERVED_COLUMN_NAMES = /* @__PURE__ */ new Set(["select", "order", "limit", "offset"]);
+var CELL_PARTS = ["at", "by", "rev", "source", "conflicts"];
+var CELL_PART_SUFFIX = {
+  at: "__at",
+  by: "__by",
+  rev: "__rev",
+  source: "__src",
+  conflicts: "__lost"
+};
+var MAX_TRACKED_COLUMN_NAME = MAX_IDENTIFIER_LENGTH - 6;
+var CELLS_FIELD = "cells";
+function cellColumnName(column, part) {
+  return `${column}${CELL_PART_SUFFIX[part]}`;
+}
+var MATERIALIZE_ACTOR = "orm:materialize";
+var MATERIALIZE_CLAIMS_JSON = JSON.stringify({ sub: MATERIALIZE_ACTOR, org: null, roles: [], capabilities: [] });
+function materializedRefreshFunctionName(table) {
+  return `${table}__refresh`;
+}
+function materializeLockKey(schema, table) {
+  return `orm:materialize:${schema}.${table}`;
+}
 
 // src/errors.ts
 var OrmDefinitionError = class extends Error {
@@ -239,6 +267,9 @@ function registerNamespaceConfig(value) {
 // src/authoring/table.ts
 var TABLE_BRAND = "seq-table";
 var LINK_BRAND = "seq-link";
+function objectRef(namespace, table) {
+  return { kind: "seq-external-object", namespace, table };
+}
 function toOne(target, options) {
   return {
     kind: LINK_BRAND,
@@ -247,6 +278,8 @@ function toOne(target, options) {
     on: options.on,
     references: options.references,
     enforce: options.enforce ?? false,
+    onDelete: options.onDelete,
+    onUpdate: options.onUpdate,
     description: options.description
   };
 }
@@ -258,6 +291,8 @@ function toMany(target, options) {
     on: options.on,
     references: options.references,
     enforce: false,
+    onDelete: void 0,
+    onUpdate: void 0,
     description: options.description
   };
 }
@@ -269,6 +304,8 @@ function toPlatformUser(options) {
     on: options.on,
     references: options.references,
     enforce: false,
+    onDelete: void 0,
+    onUpdate: void 0,
     description: options.description
   };
 }
@@ -286,45 +323,51 @@ function assertIdentifier({ value, what, file, pattern = IDENTIFIER_PATTERN }) {
     );
   }
 }
-function defineTable(name, columns, config = {}) {
+function defineTable(name2, columns, config = {}) {
   const file = activeAuthoringContext()?.currentFile;
-  assertIdentifier({ value: name, what: "table name", file });
+  assertIdentifier({ value: name2, what: "table name", file });
   const entries = Object.entries(columns);
   if (entries.length === 0) {
-    throw new OrmDefinitionError(`table "${name}" declares no columns`, file);
+    throw new OrmDefinitionError(`table "${name2}" declares no columns`, file);
   }
   const seenColumnNames = /* @__PURE__ */ new Map();
   for (const [propertyName, builder] of entries) {
     if (!isColumnBuilder(builder)) {
       throw new OrmDefinitionError(
-        `table "${name}": column "${propertyName}" is not a column builder \u2014 use the t.* factories (t.uuid(), t.text(), \u2026)`,
+        `table "${name2}": column "${propertyName}" is not a column builder \u2014 use the t.* factories (t.uuid(), t.text(), \u2026)`,
         file
       );
     }
     const columnName = builder.columnNameFor(propertyName);
-    assertIdentifier({ value: columnName, what: `table "${name}": column "${propertyName}" column name`, file, pattern: COLUMN_IDENTIFIER_PATTERN });
+    assertIdentifier({ value: columnName, what: `table "${name2}": column "${propertyName}" column name`, file, pattern: COLUMN_IDENTIFIER_PATTERN });
+    if (config.materializes === void 0 && (propertyName === CELLS_FIELD || Object.values(CELL_PART_SUFFIX).some((suffix) => columnName.endsWith(suffix) || propertyName.endsWith(suffix)))) {
+      throw new OrmDefinitionError(
+        `table "${name2}": "${propertyName}" collides with the reserved cell-metadata names ('${CELLS_FIELD}', or a ${Object.values(CELL_PART_SUFFIX).join("/")} suffix)`,
+        file
+      );
+    }
     const existing = seenColumnNames.get(columnName);
     if (existing !== void 0) {
       throw new OrmDefinitionError(
-        `table "${name}": columns "${existing}" and "${propertyName}" both map to Postgres column "${columnName}"`,
+        `table "${name2}": columns "${existing}" and "${propertyName}" both map to Postgres column "${columnName}"`,
         file
       );
     }
     seenColumnNames.set(columnName, propertyName);
   }
-  const table = { kind: TABLE_BRAND, tableName: name, columns, config, source: void 0, file };
+  const table = { kind: TABLE_BRAND, tableName: name2, columns, config, source: void 0, file };
   registerTable(table);
   return table;
 }
-function defineSyncedTable(name, columnsOrConfig, maybeConfig) {
+function defineSyncedTable(name2, columnsOrConfig, maybeConfig) {
   const file = activeAuthoringContext()?.currentFile;
-  assertIdentifier({ value: name, what: "table name", file });
+  assertIdentifier({ value: name2, what: "table name", file });
   const isTyped = maybeConfig !== void 0;
   const columns = isTyped ? columnsOrConfig : {};
   const config = isTyped ? maybeConfig : columnsOrConfig;
   if (!SYNCED_SOURCE_PATTERN.test(config.source)) {
     throw new OrmDefinitionError(
-      `synced table "${name}": source "${config.source}" must match ${SYNCED_SOURCE_PATTERN} (gold layer only)`,
+      `synced table "${name2}": source "${config.source}" must be a qualified lowercase schema.table identifier`,
       file
     );
   }
@@ -334,21 +377,21 @@ function defineSyncedTable(name, columnsOrConfig, maybeConfig) {
   for (const [propertyName, builder] of entries) {
     if (!isColumnBuilder(builder)) {
       throw new OrmDefinitionError(
-        `synced table "${name}": column "${propertyName}" is not a column builder \u2014 use the t.* factories (t.uuid(), t.text(), \u2026)`,
+        `synced table "${name2}": column "${propertyName}" is not a column builder \u2014 use the t.* factories (t.uuid(), t.text(), \u2026)`,
         file
       );
     }
     const columnName = builder.columnNameFor(propertyName);
     assertIdentifier({
       value: columnName,
-      what: `synced table "${name}": column "${propertyName}" column name`,
+      what: `synced table "${name2}": column "${propertyName}" column name`,
       file,
       pattern: COLUMN_IDENTIFIER_PATTERN
     });
     const existing = seenColumnNames.get(columnName);
     if (existing !== void 0) {
       throw new OrmDefinitionError(
-        `synced table "${name}": columns "${existing}" and "${propertyName}" both map to Postgres column "${columnName}"`,
+        `synced table "${name2}": columns "${existing}" and "${propertyName}" both map to Postgres column "${columnName}"`,
         file
       );
     }
@@ -359,13 +402,13 @@ function defineSyncedTable(name, columnsOrConfig, maybeConfig) {
     const hasConfigPk = config.primaryKey !== void 0 && config.primaryKey.length > 0;
     if (columnLevelPk.length === 0 && !hasConfigPk) {
       throw new OrmDefinitionError(
-        `synced table "${name}" declares columns but no primary key \u2014 use .primaryKey() or config.primaryKey`,
+        `synced table "${name2}" declares columns but no primary key \u2014 use .primaryKey() or config.primaryKey`,
         file
       );
     }
     if (columnLevelPk.length > 0 && hasConfigPk) {
       throw new OrmDefinitionError(
-        `synced table "${name}": declare the primary key either with .primaryKey() on columns or with config.primaryKey \u2014 not both`,
+        `synced table "${name2}": declare the primary key either with .primaryKey() on columns or with config.primaryKey \u2014 not both`,
         file
       );
     }
@@ -377,7 +420,7 @@ function defineSyncedTable(name, columnsOrConfig, maybeConfig) {
   if (config.policies !== void 0) tableConfig.policies = { read: config.policies.read };
   const table = {
     kind: TABLE_BRAND,
-    tableName: name,
+    tableName: name2,
     columns,
     config: tableConfig,
     source: config.source,
@@ -386,26 +429,26 @@ function defineSyncedTable(name, columnsOrConfig, maybeConfig) {
   registerTable(table);
   return table;
 }
-function defineEnum(name, values) {
+function defineEnum(name2, values) {
   const file = activeAuthoringContext()?.currentFile;
-  assertIdentifier({ value: name, what: "enum name", file });
+  assertIdentifier({ value: name2, what: "enum name", file });
   if (values.length === 0 || values.length > 100) {
-    throw new OrmDefinitionError(`enum "${name}" must declare between 1 and 100 values`, file);
+    throw new OrmDefinitionError(`enum "${name2}" must declare between 1 and 100 values`, file);
   }
   const seen = /* @__PURE__ */ new Set();
   for (const value of values) {
     if (value.length === 0 || value.length > MAX_IDENTIFIER_LENGTH) {
       throw new OrmDefinitionError(
-        `enum "${name}": value ${JSON.stringify(value)} must be 1-${MAX_IDENTIFIER_LENGTH} characters`,
+        `enum "${name2}": value ${JSON.stringify(value)} must be 1-${MAX_IDENTIFIER_LENGTH} characters`,
         file
       );
     }
     if (seen.has(value)) {
-      throw new OrmDefinitionError(`enum "${name}" declares duplicate value "${value}"`, file);
+      throw new OrmDefinitionError(`enum "${name2}" declares duplicate value "${value}"`, file);
     }
     seen.add(value);
   }
-  const ref = { kind: ENUM_BRAND, name, values: [...values] };
+  const ref = { kind: ENUM_BRAND, name: name2, values: [...values] };
   registerEnum(ref);
   return ref;
 }
@@ -413,52 +456,52 @@ var VIEW_BRAND = "seq-view";
 function isSeqView(value) {
   return typeof value === "object" && value !== null && value.kind === VIEW_BRAND;
 }
-function defineView(name, columns, config) {
+function defineView(name2, columns, config) {
   const file = activeAuthoringContext()?.currentFile;
-  if (!IDENTIFIER_PATTERN.test(name) || name.length > MAX_IDENTIFIER_LENGTH) {
+  if (!IDENTIFIER_PATTERN.test(name2) || name2.length > MAX_IDENTIFIER_LENGTH) {
     throw new OrmDefinitionError(
-      `view name "${name}" must match ${IDENTIFIER_PATTERN} and be at most ${MAX_IDENTIFIER_LENGTH} characters`,
+      `view name "${name2}" must match ${IDENTIFIER_PATTERN} and be at most ${MAX_IDENTIFIER_LENGTH} characters`,
       file
     );
   }
   const entries = Object.entries(columns);
-  if (entries.length === 0) throw new OrmDefinitionError(`view "${name}" declares no columns`, file);
+  if (entries.length === 0) throw new OrmDefinitionError(`view "${name2}" declares no columns`, file);
   const seenColumnNames = /* @__PURE__ */ new Map();
   for (const [propertyName, builder] of entries) {
     if (!isColumnBuilder(builder)) {
       throw new OrmDefinitionError(
-        `view "${name}": column "${propertyName}" is not a column builder \u2014 use the t.* factories`,
+        `view "${name2}": column "${propertyName}" is not a column builder \u2014 use the t.* factories`,
         file
       );
     }
     const columnName = builder.columnNameFor(propertyName);
     if (!COLUMN_IDENTIFIER_PATTERN.test(columnName) || columnName.length > MAX_IDENTIFIER_LENGTH) {
-      throw new OrmDefinitionError(`view "${name}": column "${propertyName}" has invalid column name "${columnName}"`, file);
+      throw new OrmDefinitionError(`view "${name2}": column "${propertyName}" has invalid column name "${columnName}"`, file);
     }
     const existing = seenColumnNames.get(columnName);
     if (existing !== void 0) {
       throw new OrmDefinitionError(
-        `view "${name}": columns "${existing}" and "${propertyName}" both map to Postgres column "${columnName}"`,
+        `view "${name2}": columns "${existing}" and "${propertyName}" both map to Postgres column "${columnName}"`,
         file
       );
     }
     seenColumnNames.set(columnName, propertyName);
   }
-  const view = { kind: VIEW_BRAND, viewName: name, columns, config, file };
+  const view = { kind: VIEW_BRAND, viewName: name2, columns, config, file };
   registerView(view);
   return view;
 }
 var QUERY_COLUMN_FACTORIES = {
-  uuid: (name) => pgCore.uuid(name),
-  text: (name) => pgCore.text(name),
-  integer: (name) => pgCore.integer(name),
-  bigint: (name) => pgCore.bigint(name, { mode: "bigint" }),
-  numeric: (name) => pgCore.numeric(name),
-  double: (name) => pgCore.doublePrecision(name),
-  boolean: (name) => pgCore.boolean(name),
-  timestamptz: (name) => pgCore.timestamp(name, { withTimezone: true }),
-  date: (name) => pgCore.date(name),
-  jsonb: (name) => pgCore.jsonb(name)
+  uuid: (name2) => pgCore.uuid(name2),
+  text: (name2) => pgCore.text(name2),
+  integer: (name2) => pgCore.integer(name2),
+  bigint: (name2) => pgCore.bigint(name2, { mode: "bigint" }),
+  numeric: (name2) => pgCore.numeric(name2),
+  double: (name2) => pgCore.doublePrecision(name2),
+  boolean: (name2) => pgCore.boolean(name2),
+  timestamptz: (name2) => pgCore.timestamp(name2, { withTimezone: true }),
+  date: (name2) => pgCore.date(name2),
+  jsonb: (name2) => pgCore.jsonb(name2)
 };
 function compileViewQueries(input) {
   const schemaName = `orm_${input.namespace}`;
@@ -514,9 +557,9 @@ function compileViewQueries(input) {
       }
       const handle = handles.get(resolved);
       if (!handle) {
-        const name = isSeqTable(resolved) ? resolved.tableName : resolved.viewName;
+        const name2 = isSeqTable(resolved) ? resolved.tableName : resolved.viewName;
         throw new OrmDefinitionError(
-          `view "${authored.viewName}" references relation "${name}" which is not part of this namespace`,
+          `view "${authored.viewName}" references relation "${name2}" which is not part of this namespace`,
           authored.file
         );
       }
@@ -550,11 +593,11 @@ function compileViewQueries(input) {
       );
     }
     if (!config.query) throw new OrmDefinitionError(`view "${authored.viewName}" produced no query`, authored.file);
-    const tableDependencies = pgCore.extractUsedTable(config.query).map((physical) => {
-      const logical = physicalToLogical.get(physical);
+    const tableDependencies = pgCore.extractUsedTable(config.query).map((physical2) => {
+      const logical = physicalToLogical.get(physical2);
       if (!logical) {
         throw new OrmDefinitionError(
-          `view "${authored.viewName}" query references unmanaged relation "${physical}" \u2014 use relation(...) with a namespace table or view`,
+          `view "${authored.viewName}" query references unmanaged relation "${physical2}" \u2014 use relation(...) with a namespace table or view`,
           authored.file
         );
       }
@@ -707,8 +750,8 @@ function overlayWinsUnion(input) {
 // src/authoring/cow-mutations.ts
 function overrideRowMutation(input) {
   const { overlay, synced, pk } = input;
-  const name = input.name ?? `override_${overlay.tableName}`;
-  assertMutationName(name, "overrideRowMutation");
+  const name2 = input.name ?? `override_${overlay.tableName}`;
+  assertMutationName(name2, "overrideRowMutation");
   assertOverlayPairPrimaryKey({ overlay, synced, pk, helper: "overrideRowMutation" });
   const sharedProperties = sharedNonPkProperties({ overlay, synced, pk });
   const setProperties = resolveSetProperties({
@@ -727,7 +770,7 @@ function overrideRowMutation(input) {
   });
   return {
     kind: "override",
-    name,
+    name: name2,
     synced: synced.tableName,
     pk,
     copy: [pk, ...sharedProperties],
@@ -736,23 +779,23 @@ function overrideRowMutation(input) {
 }
 function revertOverlayMutation(input) {
   const { overlay, synced, pk } = input;
-  const name = input.name ?? `revert_${overlay.tableName}`;
-  assertMutationName(name, "revertOverlayMutation");
+  const name2 = input.name ?? `revert_${overlay.tableName}`;
+  assertMutationName(name2, "revertOverlayMutation");
   assertOverlayPairPrimaryKey({ overlay, synced, pk, helper: "revertOverlayMutation" });
   assertMatchingColumns({ overlay, synced, properties: [pk], helper: "revertOverlayMutation" });
   return {
     kind: "revert",
-    name,
+    name: name2,
     synced: synced.tableName,
     pk,
     copy: [],
     set: []
   };
 }
-function assertMutationName(name, helper) {
-  if (!IDENTIFIER_PATTERN.test(name) || name.length > MAX_IDENTIFIER_LENGTH) {
+function assertMutationName(name2, helper) {
+  if (!IDENTIFIER_PATTERN.test(name2) || name2.length > MAX_IDENTIFIER_LENGTH) {
     throw new OrmDefinitionError(
-      `${helper}: mutation name "${name}" must match ${IDENTIFIER_PATTERN} and be at most ${MAX_IDENTIFIER_LENGTH} characters`
+      `${helper}: mutation name "${name2}" must match ${IDENTIFIER_PATTERN} and be at most ${MAX_IDENTIFIER_LENGTH} characters`
     );
   }
 }
@@ -878,9 +921,495 @@ function scalarColumnType(table, property, helper) {
   }
   return type;
 }
+var objectRef2 = zod.z.string().max(255).regex(/^[a-z][a-z0-9_]{0,40}\/[A-Za-z_][A-Za-z0-9_]*$/, "Expected an explicit namespace/object reference (no wildcards)");
+var functionRef = zod.z.string().max(255).regex(/^[a-z][a-z0-9-]*$/, "Expected a function slug");
+var refs = (schema) => zod.z.array(schema).max(256).refine(
+  (values) => new Set(values).size === values.length,
+  "Duplicate dependency reference"
+).default([]);
+var ontologyContractSchema = zod.z.strictObject({
+  version: zod.z.literal(1),
+  read: refs(objectRef2),
+  write: refs(objectRef2),
+  produce: refs(objectRef2),
+  invoke: refs(functionRef)
+}).refine((contract) => JSON.stringify(contract).length <= 4096, "Ontology contract exceeds the 4 KiB signed-context budget");
+function readOntologyContract(manifest) {
+  if (!manifest || typeof manifest !== "object" || !("ontology" in manifest) || manifest.ontology === void 0) return void 0;
+  return ontologyContractSchema.parse(manifest.ontology);
+}
+
+// src/compiler/sql.ts
+var CLAIMS_SETTING = "request.jwt.claims";
+var CAPABILITIES_CLAIM_KEY = "capabilities";
+var ROLES_CLAIM_KEY = "roles";
+var quoteIdentifier = (name2) => `"${name2.replaceAll('"', '""')}"`;
+var quoteLiteral = (value) => `'${value.replaceAll("'", "''")}'`;
+var CLAIMS_SOURCE = `nullif(current_setting('${CLAIMS_SETTING}', true), '')::jsonb`;
+var claimExpression = (key) => `(${CLAIMS_SOURCE} ->> ${quoteLiteral(key)})`;
+var scopedClaimsSource = (namespace) => namespace ? `(CASE WHEN ${CLAIMS_SOURCE} ? 'namespaces' THEN ${CLAIMS_SOURCE} -> 'namespaces' -> ${quoteLiteral(namespace)} ELSE ${CLAIMS_SOURCE} END)` : CLAIMS_SOURCE;
+var capabilityExpression = (key, namespace) => `coalesce(${scopedClaimsSource(namespace)} -> '${CAPABILITIES_CLAIM_KEY}' ? ${quoteLiteral(key)}, false)`;
+var roleExpression = (key, namespace) => `coalesce(${scopedClaimsSource(namespace)} -> '${ROLES_CLAIM_KEY}' ? ${quoteLiteral(key)}, false)`;
+
+// src/checks/compile.ts
+function tokenize(source) {
+  const tokens = [];
+  for (let position = 0; position < source.length; ) {
+    const char = source[position];
+    if (/\s/.test(char)) {
+      position++;
+      continue;
+    }
+    if (char === "(" || char === ")" || char === ",") {
+      tokens.push({ kind: char === "(" ? "lparen" : char === ")" ? "rparen" : "comma", value: char, position });
+      position++;
+      continue;
+    }
+    if (char === "'") {
+      const start = position++;
+      let value = "";
+      let closed = false;
+      while (position < source.length) {
+        if (source[position] !== "'") {
+          value += source[position++];
+          continue;
+        }
+        if (source[position + 1] === "'") {
+          value += "'";
+          position += 2;
+          continue;
+        }
+        position++;
+        closed = true;
+        break;
+      }
+      if (!closed) throw new Error(`unterminated string at position ${start}`);
+      if (/[\x00-\x1f\x7f]/.test(value)) throw new Error(`control character in string at position ${start}`);
+      tokens.push({ kind: "string", value, position: start });
+      continue;
+    }
+    const operator = /^(<=|>=|<>|!=|!~|=|<|>|~)/.exec(source.slice(position));
+    if (operator) {
+      tokens.push({ kind: "operator", value: operator[0] === "<>" ? "!=" : operator[0], position });
+      position += operator[0].length;
+      continue;
+    }
+    const number = /^-?\d+(?:\.\d+)?/.exec(source.slice(position));
+    if (number) {
+      tokens.push({ kind: "number", value: number[0], position });
+      position += number[0].length;
+      continue;
+    }
+    const identifier3 = /^[a-zA-Z_][a-zA-Z_0-9]*/.exec(source.slice(position));
+    if (identifier3) {
+      tokens.push({ kind: "identifier", value: identifier3[0], position });
+      position += identifier3[0].length;
+      continue;
+    }
+    throw new Error(`unexpected character '${char}' at position ${position}`);
+  }
+  tokens.push({ kind: "end", value: "", position: source.length });
+  if (tokens.length > 256) throw new Error("check expression exceeds 256 tokens");
+  return tokens;
+}
+var Parser = class {
+  constructor(tokens, columns) {
+    this.tokens = tokens;
+    this.columns = /* @__PURE__ */ new Map();
+    for (const column of columns) {
+      for (const alias of [column.name, column.columnName]) {
+        const previous = this.columns.get(alias);
+        if (previous && previous.columnName !== column.columnName) {
+          throw new Error(`ambiguous check column '${alias}'`);
+        }
+        this.columns.set(alias, column);
+      }
+    }
+  }
+  index = 0;
+  depth = 0;
+  columns;
+  parse() {
+    const expression = this.parseOr();
+    this.expect("end", "end of expression");
+    return expression;
+  }
+  parseOr() {
+    let left = this.parseAnd();
+    while (this.matchKeyword("or")) left = `(${left} OR ${this.parseAnd()})`;
+    return left;
+  }
+  parseAnd() {
+    let left = this.parseNot();
+    while (this.matchKeyword("and")) left = `(${left} AND ${this.parseNot()})`;
+    return left;
+  }
+  parseNot() {
+    if (this.matchKeyword("not")) return `(NOT ${this.parseNot()})`;
+    return this.parsePrimary();
+  }
+  parsePrimary() {
+    if (this.peek().kind === "lparen") {
+      if (++this.depth > 32) throw new Error("check expression nesting exceeds 32 levels");
+      this.advance();
+      const expression = this.parseOr();
+      this.expect("rparen", "')'");
+      this.depth--;
+      return `(${expression})`;
+    }
+    return this.parseComparison();
+  }
+  parseComparison() {
+    const left = this.parseValue();
+    if (this.matchKeyword("is")) {
+      const negate = this.matchKeyword("not");
+      this.expectKeyword("null");
+      return `${left.sql} IS ${negate ? "NOT " : ""}NULL`;
+    }
+    if (this.matchKeyword("between")) {
+      const lower = this.parseValue();
+      this.expectKeyword("and");
+      const upper = this.parseValue();
+      return `${left.sql} BETWEEN ${lower.sql} AND ${upper.sql}`;
+    }
+    if (this.matchKeyword("in")) {
+      this.expect("lparen", "'(' after IN");
+      const values = [this.parseValue()];
+      while (this.peek().kind === "comma") {
+        this.advance();
+        values.push(this.parseValue());
+      }
+      this.expect("rparen", "')' after IN values");
+      if (values.some((value) => !value.literal)) throw new Error("IN values must be literals");
+      return `${left.sql} IN (${values.map((value) => value.sql).join(", ")})`;
+    }
+    const operator = this.expect("operator", "a comparison operator");
+    const right = this.parseValue();
+    if (operator.value === "~" || operator.value === "!~") {
+      if (left.column && left.column.type !== "text") throw new Error("regex checks require a text column");
+      if (!right.literal) throw new Error("regex pattern must be a literal");
+    }
+    return `${left.sql} ${operator.value} ${right.sql}`;
+  }
+  parseValue() {
+    const token = this.advance();
+    if (token.kind === "string") return { sql: quoteLiteral(token.value), literal: true };
+    if (token.kind === "number") {
+      const number = Number(token.value);
+      if (!Number.isFinite(number) || Number.isInteger(number) && !Number.isSafeInteger(number)) {
+        throw new Error(`unsafe numeric literal at position ${token.position}`);
+      }
+      return { sql: token.value, literal: true };
+    }
+    if (token.kind !== "identifier") throw new Error(`expected a column or literal at position ${token.position}`);
+    const keyword = token.value.toLowerCase();
+    if (keyword === "true" || keyword === "false" || keyword === "null") return { sql: keyword.toUpperCase(), literal: true };
+    if (keyword === "btrim") {
+      this.expect("lparen", "'(' after btrim");
+      const column2 = this.parseColumn();
+      this.expect("rparen", "')' after btrim column");
+      if (column2.type !== "text") throw new Error("btrim requires a text column");
+      return { sql: `btrim(${quoteIdentifier(column2.columnName)})`, column: column2 };
+    }
+    const column = this.columns.get(token.value);
+    if (!column) throw new Error(`unknown check column '${token.value}'`);
+    return { sql: quoteIdentifier(column.columnName), column };
+  }
+  parseColumn() {
+    const token = this.expect("identifier", "a column name");
+    const column = this.columns.get(token.value);
+    if (!column) throw new Error(`unknown check column '${token.value}'`);
+    return column;
+  }
+  peek() {
+    return this.tokens[this.index];
+  }
+  advance() {
+    const token = this.peek();
+    if (token.kind !== "end") this.index++;
+    return token;
+  }
+  matchKeyword(keyword) {
+    if (this.peek().kind !== "identifier" || this.peek().value.toLowerCase() !== keyword) return false;
+    this.advance();
+    return true;
+  }
+  expectKeyword(keyword) {
+    if (!this.matchKeyword(keyword)) throw new Error(`expected '${keyword}' at position ${this.peek().position}`);
+  }
+  expect(kind, description) {
+    const token = this.peek();
+    if (token.kind !== kind) throw new Error(`expected ${description} at position ${token.position}`);
+    return this.advance();
+  }
+};
+function compileCheckExpression(source, columns) {
+  return new Parser(tokenize(source), columns).parse();
+}
+var policyVariantSchema = zod.z.object({
+  /** Claims-only guard (capability()/role()/claim() comparisons — no columns). */
+  when: zod.z.string().min(1).max(1e3),
+  /** Exactly one of: allow-all bypass, or a row predicate. */
+  allow: zod.z.literal(true).optional(),
+  policy: zod.z.string().min(1).max(2e3).optional()
+}).refine((v) => v.allow === true !== (typeof v.policy === "string"), {
+  message: "A variant declares exactly one of allow: true or policy"
+});
+var policyExpressionSchema = zod.z.union([
+  zod.z.string().min(1).max(2e3),
+  zod.z.object({
+    default: zod.z.string().min(1).max(2e3),
+    variants: zod.z.array(policyVariantSchema).max(10).default([])
+  })
+]);
+function parseDurationMs(input) {
+  if (typeof input === "number") return Number.isInteger(input) && input > 0 ? input : void 0;
+  const match = /^(\d+(?:\.\d+)?)(ms|s|m)$/.exec(input);
+  if (!match) return void 0;
+  const factor = match[2] === "ms" ? 1 : match[2] === "s" ? 1e3 : 6e4;
+  const value = Math.round(Number(match[1]) * factor);
+  return value > 0 ? value : void 0;
+}
+var identifier = zod.z.string().min(1).max(63).regex(/^[a-z][a-z0-9_]*$/);
+var durationMs = zod.z.number().int().positive().max(24 * 60 * 60 * 1e3);
+var RESOLVED_VIEW_SYSTEM_COLUMNS = {
+  writebackStatus: { name: "writebackStatus", columnName: "_writeback_status", type: "text" },
+  writebackError: { name: "writebackError", columnName: "_writeback_error", type: "text" }
+};
+var RESOLVED_SOURCE_SYSTEM_COLUMNS = {
+  tombstoned: { name: "sysTombstoned", columnName: "_tombstoned" },
+  fetchedAt: { name: "sysFetchedAt", columnName: "_fetched_at" },
+  writebackStatus: { name: "sysWritebackStatus", columnName: "_writeback_status" },
+  writebackError: { name: "sysWritebackError", columnName: "_writeback_error" },
+  writebackAt: { name: "sysWritebackAt", columnName: "_writeback_at" }
+};
+var RESOLVED_VIEW_CELL_PARTS = ["source", "at", "by", "conflicts"];
+var RESERVED_RESOLVED_COLUMN_NAMES = /* @__PURE__ */ new Set([
+  ...Object.values(RESOLVED_VIEW_SYSTEM_COLUMNS).flatMap((c) => [c.name, c.columnName]),
+  ...Object.values(RESOLVED_SOURCE_SYSTEM_COLUMNS).flatMap((c) => [c.name, c.columnName])
+]);
+var COMPARATORS = ["latest", "highest", "lowest", "priority", "nonNullFirst", "custom"];
+var canonicalFunctionRefSchema = zod.z.object({
+  /** `managed` = a Managed Function id/slug; `native` = an in-process Atlas function (reserved). */
+  kind: zod.z.enum(["managed", "native"]),
+  id: zod.z.string().min(1).max(200)
+}).strict();
+var canonicalFetchShapeSchema = zod.z.union([
+  zod.z.object({ shape: zod.z.literal("single") }).strict(),
+  zod.z.object({ shape: zod.z.literal("batch"), maxKeys: zod.z.number().int().min(2).max(500) }).strict()
+]);
+var canonicalResolvedSourceSchema = zod.z.object({
+  name: identifier,
+  kind: zod.z.enum(["manual", "etl", "prefetch"]),
+  /** Backing relation in this namespace: an internal table (manual/prefetch) or a synced table (etl). */
+  table: identifier,
+  /** Resolved columns (logical names) this source supplies — the primary key is implicit. */
+  columns: zod.z.array(zod.z.string().min(1).max(63)).min(1).max(500),
+  /** etl: logical timestamptz/date column on the synced table used as every cell's updated_at. */
+  updatedAt: zod.z.string().min(1).max(63).optional(),
+  /** prefetch: resolved column holding the source system's key (may be the primary key). */
+  key: zod.z.string().min(1).max(63).optional(),
+  fetch: canonicalFetchShapeSchema.optional(),
+  function: canonicalFunctionRefSchema.optional(),
+  prefetchDefaults: zod.z.object({
+    maxStalenessMs: durationMs,
+    timeoutMs: durationMs,
+    onError: zod.z.enum(["fallback", "fail"])
+  }).strict().optional(),
+  writeback: zod.z.object({
+    columns: zod.z.array(zod.z.string().min(1).max(63)).min(1).max(500),
+    defaultMode: zod.z.enum(["sync", "async"]),
+    timeoutMs: durationMs,
+    /** Remove confirmed cells from the manual source so a stale edit cannot shadow the source. */
+    clearManualOnConfirm: zod.z.boolean()
+  }).strict().optional()
+}).strict();
+var canonicalResolveRuleSchema = zod.z.object({
+  column: zod.z.string().min(1).max(63),
+  comparator: zod.z.enum(COMPARATORS),
+  /** Source names, in tie-break order. */
+  candidates: zod.z.array(identifier).min(1).max(16),
+  /** custom only: SQL ORDER BY key over value / updated_at / source / actor / ord. */
+  orderBy: zod.z.string().min(1).max(2e3).optional()
+}).strict();
+var canonicalResolvedSchema = zod.z.object({
+  sources: zod.z.array(canonicalResolvedSourceSchema).min(1).max(16),
+  /** One rule per resolved (non-pk) column; documents the generated view for tooling. */
+  resolve: zod.z.array(canonicalResolveRuleSchema).max(500),
+  /** Sources whose tombstone hides the resolved row (v1: the manual source only). */
+  deletedBy: zod.z.array(identifier).max(1).default([]),
+  /**
+   * Materialized: the view reads an indexed internal table (`table`) that the
+   * data plane keeps in step with `compute`, the internal view holding the
+   * resolution query. Omitted when the view computes on read.
+   */
+  materialized: zod.z.object({ table: identifier, compute: identifier }).strict().optional(),
+  /** Write policies evaluated against the RESOLVED row (reads use the view's read policy). */
+  policies: zod.z.object({
+    write: policyExpressionSchema.optional(),
+    insert: policyExpressionSchema.optional(),
+    update: policyExpressionSchema.optional()
+  }).strict().default({})
+}).strict();
+function validateResolvedView({ view, tables, views = [] }) {
+  const resolved = view.resolved;
+  if (!resolved) return [];
+  const errors = [];
+  const fail = (message) => errors.push(`resolved table '${view.view}': ${message}`);
+  const pkColumn = view.primaryKey?.length === 1 ? view.columns.find((c) => c.columnName === view.primaryKey?.[0]) : void 0;
+  if (!pkColumn) {
+    fail("requires exactly one primary-key column");
+    return errors;
+  }
+  const systemNames = new Set(Object.values(RESOLVED_VIEW_SYSTEM_COLUMNS).map((c) => c.name));
+  const scope = {
+    view,
+    resolved,
+    pkColumn,
+    dataColumns: new Map(view.columns.filter((c) => !systemNames.has(c.name) && c.cell === void 0).map((c) => [c.name, c])),
+    sourceByName: /* @__PURE__ */ new Map(),
+    fail
+  };
+  if (resolved.sources.filter((source) => source.kind === "manual").length !== 1) fail("requires exactly one manual source");
+  const tableByName = new Map(tables.map((table) => [table.table, table]));
+  for (const source of resolved.sources) {
+    if (scope.sourceByName.has(source.name)) fail(`duplicate source '${source.name}'`);
+    scope.sourceByName.set(source.name, source);
+    const table = tableByName.get(source.table);
+    if (!table) fail(`source '${source.name}' references unknown table '${source.table}'`);
+    else validateSource({ scope, source, table });
+  }
+  validateRules(scope);
+  validateViewCells(scope);
+  if (resolved.materialized) validateMaterialized({ scope, tableByName, views });
+  for (const name2 of resolved.deletedBy) {
+    if (scope.sourceByName.get(name2)?.kind !== "manual") fail(`deletedBy '${name2}' must be the manual source`);
+  }
+  return errors;
+}
+function validateSource({ scope, source, table }) {
+  const { fail } = scope;
+  if (source.kind === "etl" && table.source === void 0) fail(`etl source '${source.name}' must reference a synced table`);
+  if (source.kind !== "etl" && (table.internal !== true || table.cellMetadata !== true)) {
+    fail(`${source.kind} source '${source.name}' must reference an internal table with cell metadata`);
+  }
+  const hasRev = table.columns.some((column) => column.cell?.part === "rev");
+  if (source.kind === "manual" && !hasRev) fail(`manual source '${source.name}' must carry '__rev' cell columns`);
+  if (source.kind === "prefetch" && hasRev) fail(`prefetch source '${source.name}' must not carry '__rev' cell columns`);
+  const byName = new Map(table.columns.map((c) => [c.name, c]));
+  validateSourceColumns({ scope, source, byName });
+  if (source.kind === "etl") {
+    const updatedAt = source.updatedAt === void 0 ? void 0 : byName.get(source.updatedAt);
+    if (source.updatedAt !== void 0 && updatedAt?.type !== "timestamptz" && updatedAt?.type !== "date") {
+      fail(`etl source '${source.name}' updatedAt must name a timestamptz/date column on '${source.table}'`);
+    }
+  }
+  validatePrefetchFields({ scope, source });
+}
+function validatePrefetchFields({ scope, source }) {
+  const { fail, pkColumn } = scope;
+  if (source.kind !== "prefetch") {
+    if (source.key || source.fetch || source.function || source.prefetchDefaults || source.writeback) {
+      fail(`only prefetch sources may declare key/fetch/function/prefetchDefaults/writeback ('${source.name}')`);
+    }
+    return;
+  }
+  if (!source.key || !source.fetch || !source.function || !source.prefetchDefaults) {
+    fail(`prefetch source '${source.name}' requires key, fetch, function and prefetchDefaults`);
+  } else if (source.key !== pkColumn.name && !source.columns.includes(source.key)) {
+    fail(`prefetch source '${source.name}' key '${source.key}' must be the primary key or one of its columns`);
+  }
+  for (const column of source.writeback?.columns ?? []) {
+    if (!source.columns.includes(column)) fail(`prefetch source '${source.name}' writes back '${column}', which it does not supply`);
+  }
+}
+function validateSourceColumns({ scope, source, byName }) {
+  const { fail, pkColumn, dataColumns } = scope;
+  for (const column of [pkColumn.name, ...source.columns]) {
+    const own = column === pkColumn.name ? pkColumn : dataColumns.get(column);
+    const theirs = byName.get(column);
+    if (!own) fail(`source '${source.name}' supplies unknown column '${column}'`);
+    else if (!theirs) fail(`source '${source.name}' table '${source.table}' has no column '${column}'`);
+    else if (JSON.stringify(theirs.type) !== JSON.stringify(own.type)) fail(`column '${column}' has a different type on source '${source.name}'`);
+  }
+}
+function validateRules({ resolved, pkColumn, dataColumns, sourceByName, fail }) {
+  const ruled = /* @__PURE__ */ new Set();
+  for (const rule of resolved.resolve) {
+    if (!dataColumns.has(rule.column) || rule.column === pkColumn.name) {
+      fail(`resolve rule targets unknown column '${rule.column}'`);
+      continue;
+    }
+    if (ruled.has(rule.column)) fail(`column '${rule.column}' has more than one resolve rule`);
+    ruled.add(rule.column);
+    if (rule.comparator === "custom" !== (rule.orderBy !== void 0)) {
+      fail(`column '${rule.column}': orderBy is required for custom comparators and only allowed there`);
+    }
+    if (new Set(rule.candidates).size !== rule.candidates.length) fail(`column '${rule.column}' repeats a candidate`);
+    for (const candidate of rule.candidates) {
+      const source = sourceByName.get(candidate);
+      if (!source) fail(`column '${rule.column}' names unknown candidate source '${candidate}'`);
+      else if (!source.columns.includes(rule.column)) fail(`column '${rule.column}' candidate '${candidate}' does not supply it`);
+    }
+  }
+  for (const column of dataColumns.keys()) {
+    if (column !== pkColumn.name && !ruled.has(column)) fail(`column '${column}' has no resolve rule`);
+  }
+}
+var VIEW_CELL_TYPES = {
+  source: "text",
+  at: "timestamptz",
+  by: "text",
+  conflicts: "jsonb"
+};
+function validateViewCells({ view, dataColumns, pkColumn, fail }) {
+  const expected = /* @__PURE__ */ new Map();
+  for (const column of dataColumns.values()) {
+    if (column.name === pkColumn.name) continue;
+    for (const part of RESOLVED_VIEW_CELL_PARTS) {
+      expected.set(cellColumnName(column.name, part), { part, columnName: cellColumnName(column.columnName, part) });
+    }
+  }
+  for (const column of view.columns) {
+    if (!column.cell) continue;
+    const want = expected.get(column.name);
+    if (!want || want.part !== column.cell.part || want.columnName !== column.columnName || cellColumnName(column.cell.of, column.cell.part) !== column.name) {
+      fail(`unexpected cell column '${column.name}'`);
+      continue;
+    }
+    if (column.type !== VIEW_CELL_TYPES[column.cell.part]) fail(`cell column '${column.name}' must be ${VIEW_CELL_TYPES[column.cell.part]}`);
+    expected.delete(column.name);
+  }
+  for (const name2 of expected.keys()) fail(`missing cell column '${name2}'`);
+}
+var columnSignature = (columns) => JSON.stringify(columns.map((column) => [column.name, column.columnName, column.type]));
+function validateMaterialized({ scope, tableByName, views }) {
+  const { view, resolved, fail } = scope;
+  const { table: tableName, compute: computeName } = resolved.materialized;
+  const table = tableByName.get(tableName);
+  if (!table || table.internal !== true || table.materializes !== view.view) {
+    fail(`materialized table '${tableName}' must be an internal table that materializes '${view.view}'`);
+  } else {
+    if (columnSignature(table.columns) !== columnSignature(view.columns)) fail(`materialized table '${tableName}' must have exactly the view's columns`);
+    if (JSON.stringify(table.primaryKey ?? []) !== JSON.stringify(view.primaryKey ?? [])) fail(`materialized table '${tableName}' must share the view's primary key`);
+  }
+  const compute = views.find((candidate) => candidate.view === computeName);
+  if (!compute || compute.internal !== true) fail(`compute view '${computeName}' must be an internal view`);
+  else if (columnSignature(compute.columns) !== columnSignature(view.columns)) fail(`compute view '${computeName}' must have exactly the view's columns`);
+  for (const source of resolved.sources) {
+    if (source.kind !== "etl") continue;
+    const read = tableByName.get(source.table)?.policies?.read;
+    const unconditional = typeof read === "string" ? read.trim() === "true" : read !== void 0 && read.default.trim() === "true" && read.variants.length === 0;
+    if (!unconditional) {
+      fail(`etl source '${source.name}' must have read policy 'true' to be materialized (the copy is shared by every caller)`);
+    }
+  }
+}
+
+// src/canonical/v2.ts
 var CANONICAL_FORMAT = 2;
 var IDENTIFIER_RE = /^[a-z][a-z0-9_]*$/;
-var identifier = zod.z.string().min(1).max(63).regex(IDENTIFIER_RE);
+var identifier2 = zod.z.string().min(1).max(63).regex(IDENTIFIER_RE);
 var columnIdentifier = zod.z.string().min(1).max(63).regex(COLUMN_IDENTIFIER_PATTERN);
 var COLUMN_TYPES = [
   "uuid",
@@ -896,14 +1425,14 @@ var COLUMN_TYPES = [
 ];
 var columnTypeSchema = zod.z.enum(COLUMN_TYPES);
 var canonicalEnumSchema = zod.z.object({
-  name: identifier,
+  name: identifier2,
   values: zod.z.array(zod.z.string().min(1).max(63)).min(1).max(100)
 });
 var canonicalColumnSchema = zod.z.object({
   /** Property name in TS (camelCase); columnName is the Postgres name. */
   name: zod.z.string().min(1).max(63),
   columnName: columnIdentifier,
-  type: zod.z.union([columnTypeSchema, zod.z.object({ enum: identifier })]),
+  type: zod.z.union([columnTypeSchema, zod.z.object({ enum: identifier2 })]),
   nullable: zod.z.boolean().default(true),
   unique: zod.z.boolean().default(false),
   /** Literal default, or one of the allowlisted SQL functions. */
@@ -919,7 +1448,14 @@ var canonicalColumnSchema = zod.z.object({
   /** Migration hints — same semantics as v1. */
   renamedFrom: columnIdentifier.optional(),
   cast: zod.z.string().max(200).optional(),
-  deprecated: zod.z.boolean().default(false)
+  deprecated: zod.z.boolean().default(false),
+  /**
+   * Marks a system cell-metadata column (see CELL_PARTS in constants): part
+   * `part` of the cell of logical column `of`. Synthesized by authoring,
+   * never client-writable, absent from GraphQL scalar fields. Omitted on
+   * ordinary columns so their hashes are unchanged.
+   */
+  cell: zod.z.object({ of: zod.z.string().min(1).max(63), part: zod.z.enum(CELL_PARTS) }).strict().optional()
 }).superRefine((column, ctx) => {
   if (column.onUpdateFn === void 0) return;
   if (typeof column.type !== "string" || column.type !== "timestamptz" && column.type !== "date") {
@@ -934,36 +1470,28 @@ var canonicalLinkSchema = zod.z.object({
   name: zod.z.string().min(1).max(63),
   kind: zod.z.enum(["toOne", "toMany", "toPlatformUser"]),
   /** Target table name (namespace-local). Absent for toPlatformUser. */
-  target: identifier.optional(),
+  target: identifier2.optional(),
+  /** Owning namespace of an imported target; omitted for local links. */
+  namespace: identifier2.max(41).optional(),
   /** FK column on the owning side (toOne/toPlatformUser: on this table; toMany: on the target). */
   on: columnIdentifier,
   /** Referenced column on the target (default: target's PK / platform user `sub`). */
   references: columnIdentifier.optional(),
   /** enforce: true emits a real FK constraint (same-namespace toOne only). */
   enforce: zod.z.boolean().default(false),
+  onDelete: zod.z.enum(["cascade", "restrict", "no action", "set null", "set default"]).optional(),
+  onUpdate: zod.z.enum(["cascade", "restrict", "no action", "set null", "set default"]).optional(),
   description: zod.z.string().max(500).optional()
 });
 var canonicalIndexSchema = zod.z.object({
   columns: zod.z.array(columnIdentifier).min(1),
   unique: zod.z.boolean().default(false),
-  name: identifier.optional()
-});
-var policyVariantSchema = zod.z.object({
-  /** Claims-only guard (capability()/role()/claim() comparisons — no columns). */
-  when: zod.z.string().min(1).max(1e3),
-  /** Exactly one of: allow-all bypass, or a row predicate. */
-  allow: zod.z.literal(true).optional(),
-  policy: zod.z.string().min(1).max(2e3).optional()
-}).refine((v) => v.allow === true !== (typeof v.policy === "string"), {
-  message: "A variant declares exactly one of allow: true or policy"
+  name: identifier2.optional()
 });
-var policyExpressionSchema = zod.z.union([
-  zod.z.string().min(1).max(2e3),
-  zod.z.object({
-    default: zod.z.string().min(1).max(2e3),
-    variants: zod.z.array(policyVariantSchema).max(10).default([])
-  })
-]);
+var canonicalCheckSchema = zod.z.object({
+  name: identifier2,
+  expression: zod.z.string().min(1).max(2e3)
+}).strict();
 var canonicalPoliciesSchema = zod.z.object({
   read: policyExpressionSchema.optional(),
   write: policyExpressionSchema.optional(),
@@ -1151,7 +1679,7 @@ var VIEW_QUERY_FUNCTION_ALLOWLIST = [
   "width_bucket"
 ];
 var canonicalActionSchema = zod.z.object({
-  name: identifier,
+  name: identifier2,
   requires: zod.z.string().max(1e3).optional(),
   params: zod.z.record(zod.z.string(), zod.z.object({
     type: columnTypeSchema,
@@ -1163,9 +1691,9 @@ var canonicalActionSchema = zod.z.object({
 });
 var canonicalCowMutationSchema = zod.z.object({
   kind: zod.z.enum(["override", "revert"]),
-  name: identifier,
+  name: identifier2,
   /** Synced table (same namespace) the overlay copies from / falls back to. */
-  synced: identifier,
+  synced: identifier2,
   /** Single-column primary key PROPERTY (TS camelCase, like column `name`) shared by overlay and synced. */
   pk: zod.z.string().min(1).max(63),
   /** Override: contract properties copied INSERT…SELECT from synced (pk included). Empty for revert. */
@@ -1193,23 +1721,28 @@ var canonicalCowMutationSchema = zod.z.object({
   }
 });
 var canonicalForeignKeySchema = zod.z.object({
-  name: identifier,
+  name: identifier2,
   columns: zod.z.array(columnIdentifier).min(1).max(8),
-  target: identifier,
+  target: identifier2,
   references: zod.z.array(columnIdentifier).min(1).max(8),
-  deferrable: zod.z.enum(["initially-immediate", "initially-deferred"]).optional()
+  deferrable: zod.z.enum(["initially-immediate", "initially-deferred"]).optional(),
+  onDelete: zod.z.enum(["cascade", "restrict", "no action", "set null", "set default"]).optional(),
+  onUpdate: zod.z.enum(["cascade", "restrict", "no action", "set null", "set default"]).optional()
 }).strict();
 var canonicalTableSchema = zod.z.object({
-  table: identifier,
+  table: identifier2,
+  displayName: zod.z.string().trim().min(1).max(120).optional(),
   description: zod.z.string().max(2e3).optional(),
   /** Table-level rename hint (new in v2). */
-  renamedFrom: identifier.optional(),
-  /** Synced/reflected read-only tables (`source: gold.*`) — v1 semantics. */
-  source: zod.z.string().regex(/^gold\.[a-z][a-z0-9_]*$/).optional(),
+  renamedFrom: identifier2.optional(),
+  /** Synced/reflected read-only tables (`source: schema.table`) — v1 semantics. */
+  source: zod.z.string().regex(QUALIFIED_TABLE_PATTERN).optional(),
   columns: zod.z.array(canonicalColumnSchema).default([]),
   primaryKey: zod.z.array(columnIdentifier).min(1).max(8).optional(),
   links: zod.z.array(canonicalLinkSchema).default([]),
   indexes: zod.z.array(canonicalIndexSchema).default([]),
+  /** Omitted by old definitions, preserving their existing content hashes. */
+  checks: zod.z.array(canonicalCheckSchema).max(100).optional(),
   policies: canonicalPoliciesSchema.default({}),
   /**
    * v1-conversion carry-over only. v2 has no action surface — the runtime
@@ -1220,22 +1753,55 @@ var canonicalTableSchema = zod.z.object({
   /** Optional (not defaulted) so pre-CoW canonical documents keep byte-identical hashes. */
   cowMutations: zod.z.array(canonicalCowMutationSchema).optional(),
   /** Omitted by old definitions, preserving their existing content hashes. */
-  foreignKeys: zod.z.array(canonicalForeignKeySchema).max(100).optional()
+  foreignKeys: zod.z.array(canonicalForeignKeySchema).max(100).optional(),
+  /**
+   * Per-cell edit metadata (`cellMetadata: true` in authoring): every tracked
+   * column `c` carries typed `c__at` / `c__by` system columns (plus `c__rev`
+   * on a resolved table's internal sources), listed explicitly in `columns`
+   * with a `cell` marker so DDL and migrations treat them as ordinary columns.
+   * Omitted when off so existing definitions hash unchanged.
+   */
+  cellMetadata: zod.z.literal(true).optional(),
+  /**
+   * System-owned backing table of a resolved table (its manual or prefetch
+   * source). Internal tables get DDL and IR metadata but no GraphQL surface;
+   * only the data plane writes them. Omitted when false.
+   */
+  internal: zod.z.literal(true).optional(),
+  /**
+   * The materialized copy of resolved table `materializes` (internal): the
+   * same columns as that view, including its cell parts, maintained by the
+   * data plane. Omitted otherwise.
+   */
+  materializes: identifier2.optional()
 });
+var MAX_VIEW_QUERY = 1e5;
+var MAX_RESOLVED_VIEW_QUERY = 5e6;
 var canonicalViewSchema = zod.z.object({
-  view: identifier,
+  view: identifier2,
   description: zod.z.string().max(2e3).optional(),
   columns: zod.z.array(canonicalColumnSchema).min(1),
   /** Logical identity for GraphQL only; PostgreSQL views have no PK constraint. */
   primaryKey: zod.z.array(columnIdentifier).min(1).max(8).optional(),
   links: zod.z.array(canonicalLinkSchema).default([]),
   policies: zod.z.object({ read: policyExpressionSchema }).strict(),
-  query: zod.z.string().min(1).max(1e5).refine(isSingleViewQuerySql, {
+  query: zod.z.string().min(1).max(MAX_RESOLVED_VIEW_QUERY).refine(isSingleViewQuerySql, {
     message: "view query must be one SELECT/WITH statement without comments or dollar-quoted bodies"
   }),
   /** Namespace-local logical relation names, sorted for deterministic hashing. */
-  dependencies: zod.z.array(identifier).max(500)
+  dependencies: zod.z.array(identifier2).max(500),
+  /**
+   * Present when this view is a resolved table (defineResolvedTable): the
+   * multi-source metadata behind its generated query. Omitted otherwise so
+   * existing views hash unchanged.
+   */
+  resolved: canonicalResolvedSchema.optional(),
+  /** System-owned view (a materialized resolved table's compute view): no GraphQL surface. */
+  internal: zod.z.literal(true).optional()
 }).superRefine((view, ctx) => {
+  if (view.resolved === void 0 && view.query.length > MAX_VIEW_QUERY) {
+    ctx.addIssue({ code: "custom", path: ["query"], message: `view query must be at most ${MAX_VIEW_QUERY} characters` });
+  }
   for (const [index3, column] of view.columns.entries()) {
     if (column.default !== void 0 || column.defaultFn !== void 0) {
       ctx.addIssue({ code: "custom", path: ["columns", index3], message: `view column '${column.name}' cannot declare a default` });
@@ -1250,20 +1816,91 @@ var canonicalViewSchema = zod.z.object({
       ctx.addIssue({ code: "custom", path: ["columns", index3], message: `view column '${column.name}' cannot declare migration hints` });
     }
   }
+  if (view.resolved === void 0 && view.internal !== true) {
+    for (const [index3, column] of view.columns.entries()) {
+      if (column.cell) ctx.addIssue({ code: "custom", path: ["columns", index3], message: `only resolved tables carry cell columns ('${column.name}')` });
+    }
+  }
   for (const [index3, link] of view.links.entries()) {
     if (link.enforce) {
       ctx.addIssue({ code: "custom", path: ["links", index3, "enforce"], message: `view link '${link.name}' cannot enforce a foreign key` });
     }
+    if (link.onDelete !== void 0 || link.onUpdate !== void 0) {
+      ctx.addIssue({ code: "custom", path: ["links", index3], message: `view link '${link.name}' cannot declare referential actions` });
+    }
   }
 });
-var canonicalDefinitionSchema = zod.z.object({
+var CELL_PART_TYPES = {
+  at: "timestamptz",
+  by: "text",
+  rev: "uuid",
+  source: "text",
+  conflicts: "jsonb"
+};
+function trackedCellColumns(table) {
+  const pk = new Set(table.primaryKey ?? []);
+  return table.columns.filter((column) => column.cell === void 0 && !pk.has(column.columnName) && column.onUpdateFn === void 0);
+}
+var SUFFIXES = Object.values(CELL_PART_SUFFIX);
+function validateCellMetadata(table, index3, ctx) {
+  const fail = (message, path = ["tables", index3]) => ctx.addIssue({ code: "custom", path, message });
+  const cells = table.columns.flatMap((column, position) => column.cell ? [{ column, position, cell: column.cell }] : []);
+  if (table.materializes !== void 0) return;
+  if (table.cellMetadata !== true) {
+    for (const { position } of cells) fail(`cell-metadata columns require cellMetadata on table '${table.table}'`, ["tables", index3, "columns", position]);
+    return;
+  }
+  if (table.source !== void 0) {
+    fail(`synced table '${table.table}' cannot track cell metadata`);
+    return;
+  }
+  const tracked = trackedCellColumns(table);
+  const byName = new Map(tracked.map((column) => [column.name, column]));
+  const withRev = cells.some(({ cell }) => cell.part === "rev");
+  if (withRev && table.internal !== true) fail(`only a resolved table's internal sources carry '__rev' cell columns ('${table.table}')`);
+  const seen = /* @__PURE__ */ new Set();
+  for (const { column, position, cell } of cells) {
+    const path = ["tables", index3, "columns", position];
+    const owner = byName.get(cell.of);
+    if (!owner) {
+      fail(`cell column '${column.name}' belongs to '${cell.of}', which is not a tracked column`, path);
+      continue;
+    }
+    if (cell.part !== "at" && cell.part !== "by" && cell.part !== "rev") fail(`a table cell column must be part at/by/rev, not '${cell.part}'`, path);
+    if (column.name !== cellColumnName(owner.name, cell.part) || column.columnName !== cellColumnName(owner.columnName, cell.part)) {
+      fail(`cell column for '${owner.name}' ${cell.part} must be named '${cellColumnName(owner.name, cell.part)}' / '${cellColumnName(owner.columnName, cell.part)}'`, path);
+    }
+    if (column.type !== CELL_PART_TYPES[cell.part] || !column.nullable || column.unique || column.default !== void 0 || column.defaultFn !== void 0) {
+      fail(`cell column '${column.name}' must be a nullable, default-less ${CELL_PART_TYPES[cell.part]}`, path);
+    }
+    const key = `${cell.of}:${cell.part}`;
+    if (seen.has(key)) fail(`duplicate cell column '${column.name}'`, path);
+    seen.add(key);
+  }
+  for (const column of tracked) {
+    if (column.columnName.length > MAX_TRACKED_COLUMN_NAME) {
+      fail(`column '${column.columnName}' is too long to track cell metadata (max ${MAX_TRACKED_COLUMN_NAME} characters)`);
+    }
+    if (SUFFIXES.some((suffix) => column.columnName.endsWith(suffix))) {
+      fail(`column '${column.columnName}' ends in a reserved cell-metadata suffix (${SUFFIXES.join(", ")})`);
+    }
+    for (const part of withRev ? ["at", "by", "rev"] : ["at", "by"]) {
+      if (!seen.has(`${column.name}:${part}`)) fail(`tracked column '${column.name}' is missing its '${cellColumnName(column.columnName, part)}' cell column`);
+    }
+  }
+}
+var exportGateSchema = zod.z.union([zod.z.literal(true), zod.z.object({ capability: zod.z.string().min(1) }).strict(), zod.z.object({ role: zod.z.string().min(1) }).strict()]);
+var relationExportSchema = zod.z.object({ read: exportGateSchema, write: exportGateSchema.optional() }).strict();
+var localDefinitionSchema = zod.z.object({
   definition_format: zod.z.literal(CANONICAL_FORMAT),
-  namespace: identifier.max(41),
+  namespace: identifier2.max(41),
   description: zod.z.string().max(2e3).optional(),
   enums: zod.z.array(canonicalEnumSchema).default([]),
   tables: zod.z.array(canonicalTableSchema).min(0).max(500),
   /** Optional to preserve byte-identical hashes for pre-view canonical v2 documents. */
   views: zod.z.array(canonicalViewSchema).max(500).optional(),
+  /** Target-owned cross-namespace access contract, using existing namespace grants. */
+  exports: zod.z.record(identifier2, relationExportSchema).optional(),
   /** Verbatim custom-roles grammar (@sequenceholdings/custom-roles-manifest). */
   capabilities: zod.z.object({
     roles: zod.z.unknown().optional(),
@@ -1276,6 +1913,7 @@ var canonicalDefinitionSchema = zod.z.object({
       ctx.addIssue({ code: "custom", path: ["tables", index3, "table"], message: `duplicate relation '${table.table}'` });
     }
     seen.add(table.table);
+    validateCellMetadata(table, index3, ctx);
     if (table.source !== void 0) {
       for (const [columnIndex, column] of table.columns.entries()) {
         if (column.onUpdateFn !== void 0) {
@@ -1289,12 +1927,41 @@ var canonicalDefinitionSchema = zod.z.object({
     }
   }
   const fkTables = new Map(definition.tables.map((table) => [table.table, table]));
+  const relations = /* @__PURE__ */ new Set([...fkTables.keys(), ...(definition.views ?? []).map((view) => view.view)]);
+  for (const name2 of Object.keys(definition.exports ?? {})) {
+    if (!relations.has(name2)) ctx.addIssue({ code: "custom", path: ["exports", name2], message: `export '${name2}' is not a local object` });
+  }
   for (const [tableIndex, table] of definition.tables.entries()) {
+    for (const [linkIndex, link] of table.links.entries()) {
+      if (link.enforce && link.namespace !== void 0 && link.namespace !== definition.namespace) {
+        ctx.addIssue({ code: "custom", path: ["tables", tableIndex, "links", linkIndex], message: "physical foreign keys require a local target; use an ORM link without enforce" });
+      }
+    }
     const names = /* @__PURE__ */ new Set([
       ...table.primaryKey?.length ? [`${table.table}_pkey`] : [],
       ...table.columns.filter((column) => column.unique && !(table.primaryKey?.length === 1 && table.primaryKey[0] === column.columnName)).map((column) => `${table.table}_${column.columnName}_unique`),
       ...table.links.filter((link) => link.enforce).map((link) => `fk_${table.table}_${link.name}`)
     ]);
+    for (const [index3, link] of table.links.entries()) {
+      if ((link.onDelete !== void 0 || link.onUpdate !== void 0) && (!link.enforce || link.kind !== "toOne")) {
+        ctx.addIssue({ code: "custom", path: ["tables", tableIndex, "links", index3], message: "referential actions require an enforced toOne link" });
+      }
+      if (link.onDelete === "set null" || link.onUpdate === "set null") {
+        const source = table.columns.find((column) => column.columnName === link.on);
+        if (source?.nullable === false || table.primaryKey?.includes(link.on)) ctx.addIssue({ code: "custom", path: ["tables", tableIndex, "links", index3], message: "SET NULL requires a nullable source column" });
+      }
+    }
+    for (const [index3, check] of (table.checks ?? []).entries()) {
+      const fail = (message) => ctx.addIssue({ code: "custom", path: ["tables", tableIndex, "checks", index3], message });
+      if (table.source) fail("synced tables cannot declare checks");
+      if (names.has(check.name)) fail(`duplicate constraint '${check.name}'`);
+      names.add(check.name);
+      try {
+        compileCheckExpression(check.expression, table.columns);
+      } catch (error) {
+        fail(error instanceof Error ? error.message : String(error));
+      }
+    }
     for (const [index3, fk] of (table.foreignKeys ?? []).entries()) {
       const fail = (message) => ctx.addIssue({ code: "custom", path: ["tables", tableIndex, "foreignKeys", index3], message });
       if (names.has(fk.name)) fail(`duplicate foreign key '${fk.name}'`);
@@ -1306,16 +1973,24 @@ var canonicalDefinitionSchema = zod.z.object({
       }
       if (fk.columns.length !== fk.references.length) fail("foreign key columns and references must have the same number of columns");
       if (new Set(fk.columns).size !== fk.columns.length || new Set(fk.references).size !== fk.references.length) fail("foreign key columns must not repeat");
-      for (const [position, name] of fk.columns.entries()) {
-        const sourceColumn = table.columns.find((column) => column.columnName === name);
+      for (const [position, name2] of fk.columns.entries()) {
+        const sourceColumn = table.columns.find((column) => column.columnName === name2);
         const targetColumn = target.columns.find((column) => column.columnName === fk.references[position]);
         if (!sourceColumn || !targetColumn) fail("foreign key references an unknown column");
         else if (JSON.stringify(sourceColumn.type) !== JSON.stringify(targetColumn.type)) fail("foreign key column types must match");
       }
+      if (fk.onDelete === "set null" || fk.onUpdate === "set null") {
+        if (fk.columns.some((name2) => table.columns.find((column) => column.columnName === name2)?.nullable === false || table.primaryKey?.includes(name2))) fail("SET NULL requires nullable source columns");
+      }
       const uniqueKeys = [target.primaryKey ?? [], ...target.indexes.filter((index4) => index4.unique).map((index4) => index4.columns), ...target.columns.filter((column) => column.unique).map((column) => [column.columnName])];
       if (!uniqueKeys.some((key) => key.length === fk.references.length && key.every((column) => fk.references.includes(column)))) fail("foreign key target columns must form a unique key");
     }
   }
+  for (const [viewIndex, view] of (definition.views ?? []).entries()) {
+    for (const message of validateResolvedView({ view, tables: definition.tables, views: definition.views ?? [] })) {
+      ctx.addIssue({ code: "custom", path: ["views", viewIndex, "resolved"], message });
+    }
+  }
   const tableByName = new Map(definition.tables.map((table) => [table.table, table]));
   for (const [tableIndex, table] of definition.tables.entries()) {
     const cowMutations = table.cowMutations ?? [];
@@ -1410,27 +2085,31 @@ var canonicalDefinitionSchema = zod.z.object({
   const visiting = /* @__PURE__ */ new Set();
   const visited = /* @__PURE__ */ new Set();
   let cycleReported = false;
-  const visit = (name, path) => {
-    if (visited.has(name) || cycleReported) return;
-    if (visiting.has(name)) {
+  const visit = (name2, path) => {
+    if (visited.has(name2) || cycleReported) return;
+    if (visiting.has(name2)) {
       cycleReported = true;
       ctx.addIssue({
         code: "custom",
         path: ["views"],
-        message: `view dependencies form a cycle: ${[...path, name].join(" -> ")}`
+        message: `view dependencies form a cycle: ${[...path, name2].join(" -> ")}`
       });
       return;
     }
-    visiting.add(name);
-    const view = viewByName.get(name);
+    visiting.add(name2);
+    const view = viewByName.get(name2);
     for (const dependency of view?.dependencies ?? []) {
-      if (viewByName.has(dependency)) visit(dependency, [...path, name]);
+      if (viewByName.has(dependency)) visit(dependency, [...path, name2]);
     }
-    visiting.delete(name);
-    visited.add(name);
+    visiting.delete(name2);
+    visited.add(name2);
   };
   for (const view of views) visit(view.view, []);
 });
+var canonicalDefinitionSchema = localDefinitionSchema.safeExtend({
+  /** Flattened, pinned snapshots. Imported relations never participate in this namespace's DDL. */
+  imports: zod.z.array(localDefinitionSchema).max(32).optional()
+});
 function canonicalRelations(definition) {
   const views = (definition.views ?? []).map((view) => ({
     table: view.view,
@@ -1439,8 +2118,12 @@ function canonicalRelations(definition) {
     ...view.primaryKey !== void 0 ? { primaryKey: view.primaryKey } : {},
     links: view.links,
     indexes: [],
-    policies: { read: view.policies.read },
-    actions: []
+    // A resolved table's write policies (evaluated against the resolved row)
+    // ride alongside the view's read policy.
+    policies: { read: view.policies.read, ...view.resolved?.policies ?? {} },
+    actions: [],
+    ...view.resolved !== void 0 ? { resolved: view.resolved } : {},
+    ...view.internal ? { internal: true } : {}
   }));
   return [...definition.tables, ...views].sort((a, b) => a.table.localeCompare(b.table));
 }
@@ -1450,13 +2133,14 @@ function normalizeCanonical(definition) {
     ...definition,
     enums: sortByName(definition.enums),
     tables: [...definition.tables].sort((a, b) => a.table.localeCompare(b.table)).map((t2) => {
-      const { cowMutations, foreignKeys, ...rest } = t2;
+      const { cowMutations, foreignKeys, checks, ...rest } = t2;
       return {
         ...rest,
         links: sortByName(t2.links),
         indexes: [...t2.indexes].sort((a, b) => (a.name ?? a.columns.join("_")).localeCompare(b.name ?? b.columns.join("_"))),
         actions: sortByName(t2.actions),
         ...foreignKeys?.length ? { foreignKeys: sortByName(foreignKeys) } : {},
+        ...checks?.length ? { checks: sortByName(checks) } : {},
         // Omitted entirely when absent/empty so pre-CoW documents hash unchanged.
         ...cowMutations !== void 0 && cowMutations.length > 0 ? { cowMutations: sortByName(cowMutations) } : {}
       };
@@ -1469,7 +2153,460 @@ function normalizeCanonical(definition) {
       dependencies: [...view.dependencies].sort()
     }));
   }
-  return normalized;
+  if (definition.imports?.length) {
+    normalized.imports = definition.imports.map(normalizeCanonical).sort((a, b) => a.namespace.localeCompare(b.namespace));
+  } else {
+    delete normalized.imports;
+  }
+  return normalized;
+}
+
+// src/authoring/resolved-sources.ts
+function cloneColumn({ builder, property, notNull, primaryKey: primaryKey2 }) {
+  const canonical = builder.toCanonicalColumn(property);
+  let clone = new ColumnBuilder(canonical.type, canonical.columnName);
+  if (primaryKey2) clone = clone.primaryKey();
+  if (notNull) clone = clone.notNull();
+  if (canonical.description !== void 0) clone = clone.description(canonical.description);
+  return clone;
+}
+function planSource(input) {
+  const { sourceName, input: source, fail } = input;
+  if (!IDENTIFIER_PATTERN.test(sourceName)) fail(`source name "${sourceName}" must match ${IDENTIFIER_PATTERN}`);
+  switch (source.kind) {
+    case "manual":
+      return {
+        name: sourceName,
+        kind: "manual",
+        columns: input.dataColumns,
+        table: internalTable(input, input.dataColumns, {
+          [RESOLVED_SOURCE_SYSTEM_COLUMNS.tombstoned.name]: tombstoned(),
+          [RESOLVED_SOURCE_SYSTEM_COLUMNS.writebackStatus.name]: t.text(RESOLVED_SOURCE_SYSTEM_COLUMNS.writebackStatus.columnName),
+          [RESOLVED_SOURCE_SYSTEM_COLUMNS.writebackError.name]: t.text(RESOLVED_SOURCE_SYSTEM_COLUMNS.writebackError.columnName),
+          [RESOLVED_SOURCE_SYSTEM_COLUMNS.writebackAt.name]: t.timestamptz(RESOLVED_SOURCE_SYSTEM_COLUMNS.writebackAt.columnName)
+        }, { revisions: true })
+      };
+    case "etl":
+      return planEtl(input, source);
+    case "prefetch":
+      return planPrefetch(input, source);
+  }
+}
+var tombstoned = () => t.boolean(RESOLVED_SOURCE_SYSTEM_COLUMNS.tombstoned.columnName).notNull().default(false);
+function internalTable(input, supplied, system, options = {}) {
+  const { viewName, sourceName, columns, pk, pkBuilder } = input;
+  const tableColumns = { [pk]: cloneColumn({ builder: pkBuilder, property: pk, notNull: true, primaryKey: true }) };
+  for (const property of supplied) {
+    tableColumns[property] = cloneColumn({ builder: columns[property], property, notNull: false, primaryKey: false });
+  }
+  return defineTable(`${viewName}__${sourceName}`, { ...tableColumns, ...system }, {
+    description: `Internal ${input.input.kind} source "${sourceName}" of resolved table "${viewName}". System-maintained.`,
+    cellMetadata: true,
+    // The manual source identifies each edit (`c__rev`) so an async
+    // confirmation clears only the exact edit it delivered.
+    ...options.revisions ? { cellRevisions: true } : {},
+    internal: true
+  });
+}
+function assertColumns(input, list, what) {
+  for (const column of list) if (!input.dataColumns.includes(column)) input.fail(`${what} names unknown column "${column}"`);
+}
+function planEtl(input, source) {
+  const { sourceName, pk, dataColumns, fail } = input;
+  const table = typeof source.table === "function" ? source.table() : source.table;
+  if (!isSeqTable(table) || table.source === void 0) fail(`etl source "${sourceName}" must reference a defineSyncedTable`);
+  const synced = table;
+  if (!(pk in synced.columns)) fail(`etl source "${sourceName}" table "${synced.tableName}" has no "${pk}" column`);
+  const supplied = source.columns ? [...source.columns] : dataColumns.filter((column) => column in synced.columns);
+  assertColumns(input, supplied, `etl source "${sourceName}"`);
+  if (source.updatedAt !== void 0 && !(source.updatedAt in synced.columns)) {
+    fail(`etl source "${sourceName}" updatedAt "${source.updatedAt}" is not a column of "${synced.tableName}"`);
+  }
+  return { name: sourceName, kind: "etl", table: synced, columns: supplied, ...source.updatedAt ? { updatedAt: source.updatedAt } : {} };
+}
+function planPrefetch(input, source) {
+  const { sourceName, pk, fail } = input;
+  assertColumns(input, source.columns, `prefetch source "${sourceName}"`);
+  if (source.key !== pk && !source.columns.includes(source.key)) {
+    fail(`prefetch source "${sourceName}" key "${source.key}" must be the primary key or one of its columns`);
+  }
+  for (const column of source.writeback?.columns ?? []) {
+    if (!source.columns.includes(column)) fail(`prefetch source "${sourceName}" writes back "${column}", which it does not supply`);
+  }
+  const writeback = source.writeback;
+  return {
+    name: sourceName,
+    kind: "prefetch",
+    columns: [...source.columns],
+    key: source.key,
+    function: source.function,
+    fetch: source.fetch === "single" ? { shape: "single" } : { shape: "batch", maxKeys: source.fetch.batch.maxKeys },
+    prefetchDefaults: {
+      maxStalenessMs: parseDuration(source.prefetchDefaults?.maxStaleness ?? "30s"),
+      timeoutMs: parseDuration(source.prefetchDefaults?.timeout ?? "1500ms"),
+      onError: source.prefetchDefaults?.onError ?? "fallback"
+    },
+    ...writeback ? {
+      writeback: {
+        columns: [...writeback.columns],
+        defaultMode: writeback.defaultMode ?? "sync",
+        timeoutMs: parseDuration(writeback.timeout ?? "5s"),
+        clearManualOnConfirm: writeback.clearManualOnConfirm ?? true
+      }
+    } : {},
+    table: internalTable(input, source.columns, {
+      [RESOLVED_SOURCE_SYSTEM_COLUMNS.fetchedAt.name]: t.timestamptz(RESOLVED_SOURCE_SYSTEM_COLUMNS.fetchedAt.columnName).notNull().default("now()"),
+      [RESOLVED_SOURCE_SYSTEM_COLUMNS.tombstoned.name]: tombstoned()
+    })
+  };
+}
+function parseDuration(input) {
+  const value = parseDurationMs(input);
+  if (value === void 0) throw new OrmDefinitionError(`invalid duration "${input}" \u2014 use e.g. '1500ms', '30s', '5m'`);
+  return value;
+}
+var PG_TYPE = {
+  uuid: "uuid",
+  text: "text",
+  integer: "integer",
+  bigint: "bigint",
+  numeric: "numeric",
+  double: "double precision",
+  boolean: "boolean",
+  timestamptz: "timestamptz",
+  date: "date",
+  jsonb: "jsonb"
+};
+var ident = (value) => `"${value.replace(/"/g, '""')}"`;
+var literal = (value) => `'${value.replace(/'/g, "''")}'`;
+var physical = ({ source, property }) => source.table.columns[property].columnNameFor(property);
+function candidateSql({ source, column, pk, pgType }) {
+  const a = ident(`s_${source.name}`);
+  const name2 = physical({ source, property: column });
+  const value = `CAST(${a}.${ident(name2)} AS ${pgType})`;
+  if (source.kind === "etl") {
+    return {
+      source: source.name,
+      value,
+      has: `(${a}.${ident(physical({ source, property: pk }))} IS NOT NULL)`,
+      at: source.updatedAt ? `CAST(${a}.${ident(physical({ source, property: source.updatedAt }))} AS timestamptz)` : "CAST(NULL AS timestamptz)",
+      by: "CAST(NULL AS text)"
+    };
+  }
+  const at = `${a}.${ident(cellColumnName(name2, "at"))}`;
+  const tombstoned2 = source.kind === "prefetch" ? ` AND NOT ${a}.${ident(RESOLVED_SOURCE_SYSTEM_COLUMNS.tombstoned.columnName)}` : "";
+  return { source: source.name, value, has: `(${at} IS NOT NULL${tombstoned2})`, at, by: `${a}.${ident(cellColumnName(name2, "by"))}` };
+}
+function outranks({ i, j, key, direction, inclusive }) {
+  const ki = i[key];
+  const kj = j[key];
+  const op = inclusive ? `${direction}=` : direction;
+  return inclusive ? `(${kj} IS NULL OR (${ki} IS NOT NULL AND ${ki} ${op} ${kj}))` : `(${ki} IS NOT NULL AND (${kj} IS NULL OR ${ki} ${op} ${kj}))`;
+}
+function rankedWinner({ candidates, key, direction }) {
+  const branches = candidates.map((candidate, index3) => {
+    const beats = candidates.map((other, otherIndex) => otherIndex === index3 ? null : `(NOT ${other.has} OR ${outranks({ i: candidate, j: other, key, direction, inclusive: index3 < otherIndex })})`).filter((clause) => clause !== null);
+    return `WHEN ${[candidate.has, ...beats].join(" AND ")} THEN ${index3 + 1}`;
+  });
+  return `CASE ${branches.join(" ")} END`;
+}
+function winnerIndex({ comparator, candidates }) {
+  const firstWith = (test) => candidates.map((candidate, index3) => `WHEN ${test(candidate)} THEN ${index3 + 1}`).join(" ");
+  if (candidates.length === 1 || comparator === "priority") return `CASE ${firstWith((c) => c.has)} END`;
+  switch (comparator) {
+    case "latest":
+      return rankedWinner({ candidates, key: "at", direction: ">" });
+    case "highest":
+      return rankedWinner({ candidates, key: "value", direction: ">" });
+    case "lowest":
+      return rankedWinner({ candidates, key: "value", direction: "<" });
+    case "nonNullFirst":
+      return `CASE ${firstWith((c) => `${c.has} AND ${c.value} IS NOT NULL`)} ${firstWith((c) => c.has)} END`;
+  }
+}
+function pick(winner, candidates, field) {
+  return `CASE ${winner} ${candidates.map((candidate, index3) => `WHEN ${index3 + 1} THEN ${field(candidate)}`).join(" ")} END`;
+}
+function loserSql({ loser, winner }) {
+  return `CASE WHEN ${loser.has} AND ${loser.value} IS DISTINCT FROM ${winner.value} AND ${loser.at} > ${winner.at} THEN jsonb_build_array(jsonb_build_object('source', ${literal(loser.source)}, 'value', to_jsonb(${loser.value}), 'at', ${loser.at})) ELSE '[]'::jsonb END`;
+}
+function losersAgainst({ candidates, winner, isWinner }) {
+  const losers = candidates.flatMap((loser, index3) => {
+    const excluded = isWinner(loser, index3);
+    if (excluded === true) return [];
+    const clause = loserSql({ loser, winner });
+    return [excluded === false ? clause : `CASE WHEN ${excluded} THEN '[]'::jsonb ELSE ${clause} END`];
+  });
+  return losers.length === 0 ? "CAST(NULL AS jsonb)" : `NULLIF(${losers.join(" || ")}, '[]'::jsonb)`;
+}
+function builtinCell({ comparator, candidates }) {
+  const winner = winnerIndex({ comparator, candidates });
+  const conflicts = comparator === "latest" || candidates.length < 2 ? "CAST(NULL AS jsonb)" : `CASE ${winner} ${candidates.map((known, index3) => `WHEN ${index3 + 1} THEN ${losersAgainst({ candidates, winner: known, isWinner: (_c, other) => other === index3 })}`).join(" ")} END`;
+  return {
+    value: pick(winner, candidates, (c) => c.value),
+    parts: {
+      source: pick(winner, candidates, (c) => literal(c.source)),
+      at: pick(winner, candidates, (c) => c.at),
+      by: pick(winner, candidates, (c) => c.by),
+      conflicts
+    }
+  };
+}
+function customCell({ candidates, orderBy, index: index3 }) {
+  const w = ident(`w_${index3}`);
+  const rows = candidates.map((c, ord) => `(${literal(c.source)}, ${c.has}, ${c.value}, ${c.at}, ${c.by}, ${ord})`);
+  const lateral = ` LEFT JOIN LATERAL (SELECT max(winner.source) AS source, (array_agg(winner.value))[1] AS value, max(winner.updated_at) AS updated_at, max(winner.actor) AS actor FROM (WITH cand(source, has, value, updated_at, actor, ord) AS (VALUES ${rows.join(", ")}) SELECT c.source, c.value, c.updated_at, c.actor FROM cand c WHERE c.has ORDER BY ${orderBy}, c.ord LIMIT 1) AS winner) AS ${w} ON true`;
+  const winner = { value: `${w}.value`, at: `${w}.updated_at` };
+  return {
+    value: winner.value,
+    lateral,
+    parts: {
+      source: `${w}.source`,
+      at: winner.at,
+      by: `${w}.actor`,
+      conflicts: candidates.length < 2 ? "CAST(NULL AS jsonb)" : losersAgainst({ candidates, winner, isWinner: (c) => `${w}.source = ${literal(c.source)}` })
+    }
+  };
+}
+function buildResolvedQuery({ context, plan }) {
+  const { qb, relation } = context;
+  const pkColumn = plan.columns[plan.pk].columnNameFor(plan.pk);
+  const alias = (source) => ident(`s_${source}`);
+  const tombstoned2 = RESOLVED_SOURCE_SYSTEM_COLUMNS.tombstoned.columnName;
+  const sourceByName = new Map(plan.plans.map((source) => [source.name, source]));
+  const schema = pgCore.getTableConfig(relation(plan.plans[0].table)).schema;
+  const keyBranches = plan.plans.map((source) => {
+    const where = source.kind === "prefetch" ? drizzleOrm.sql.raw(` WHERE NOT ${ident(tombstoned2)}`) : drizzleOrm.sql.raw("");
+    const sourcePk = ident(physical({ source, property: plan.pk }));
+    const selectedPk = sourcePk === ident(pkColumn) ? sourcePk : `${sourcePk} AS ${ident(pkColumn)}`;
+    return drizzleOrm.sql`SELECT ${drizzleOrm.sql.raw(selectedPk)} FROM ${relation(source.table)}${where}`;
+  });
+  const joins = plan.plans.map(
+    (source) => drizzleOrm.sql` LEFT JOIN ${relation(source.table)} AS ${drizzleOrm.sql.raw(alias(source.name))} ON ${drizzleOrm.sql.raw(`${alias(source.name)}.${ident(physical({ source, property: plan.pk }))} = "k".${ident(pkColumn)}`)}`
+  );
+  const cells = /* @__PURE__ */ new Map();
+  plan.rules.forEach((rule, index3) => {
+    const canonical = plan.columns[rule.column].toCanonicalColumn(rule.column);
+    const pgType = typeof canonical.type === "string" ? PG_TYPE[canonical.type] : `${schema === void 0 ? "" : `${ident(schema)}.`}${ident(canonical.type.enum)}`;
+    const candidates = rule.candidates.map((name2) => candidateSql({ source: sourceByName.get(name2), column: rule.column, pk: plan.pk, pgType }));
+    cells.set(rule.column, rule.comparator === "custom" ? customCell({ candidates, orderBy: rule.orderBy, index: index3 }) : builtinCell({ comparator: rule.comparator, candidates }));
+  });
+  const laterals = [...cells.values()].flatMap((cell) => cell.lateral ? [drizzleOrm.sql.raw(cell.lateral)] : []);
+  const from = drizzleOrm.sql.join([drizzleOrm.sql`(${drizzleOrm.sql.join(keyBranches, drizzleOrm.sql.raw(" UNION "))}) AS "k"`, ...joins, ...laterals], drizzleOrm.sql.raw(""));
+  const selected = {
+    [plan.pk]: drizzleOrm.sql.raw(`"k".${ident(pkColumn)}`).as(pkColumn)
+  };
+  for (const [property, builder] of Object.entries(plan.columns)) {
+    if (property === plan.pk) continue;
+    const cell = cells.get(property);
+    const columnName = builder.columnNameFor(property);
+    selected[property] = drizzleOrm.sql.raw(cell.value).as(columnName);
+    for (const [part, expression] of Object.entries(cell.parts)) {
+      selected[cellColumnName(property, part)] = drizzleOrm.sql.raw(expression).as(cellColumnName(columnName, part));
+    }
+  }
+  const manual = plan.plans.find((source) => source.kind === "manual");
+  const system = RESOLVED_VIEW_SYSTEM_COLUMNS;
+  selected[system.writebackStatus.name] = drizzleOrm.sql.raw(`${alias(manual.name)}.${ident(RESOLVED_SOURCE_SYSTEM_COLUMNS.writebackStatus.columnName)}`).as(system.writebackStatus.columnName);
+  selected[system.writebackError.name] = drizzleOrm.sql.raw(`${alias(manual.name)}.${ident(RESOLVED_SOURCE_SYSTEM_COLUMNS.writebackError.columnName)}`).as(system.writebackError.columnName);
+  const hidden = plan.deletedBy.map((name2) => `NOT COALESCE(${alias(name2)}.${ident(tombstoned2)}, false)`);
+  const query = qb.select(selected).from(from);
+  return hidden.length > 0 ? query.where(drizzleOrm.sql.raw(hidden.join(" AND "))) : query;
+}
+function managedFn(id) {
+  return { kind: "managed", id };
+}
+function manualSource() {
+  return { kind: "manual" };
+}
+function etlSource(input) {
+  return { kind: "etl", ...input };
+}
+function prefetchSource(input) {
+  return { kind: "prefetch", ...input };
+}
+var latest = (candidates) => ({ kind: "latest", candidates });
+var highest = (candidates) => ({ kind: "highest", candidates });
+var lowest = (candidates) => ({ kind: "lowest", candidates });
+var priority = (candidates) => ({ kind: "priority", candidates });
+var nonNullFirst = (candidates) => ({ kind: "nonNullFirst", candidates });
+var custom = (candidates, orderBy) => ({ kind: "custom", candidates, orderBy });
+var SYSTEM_VIEW_COLUMNS = {
+  [RESOLVED_VIEW_SYSTEM_COLUMNS.writebackStatus.name]: () => t.text(RESOLVED_VIEW_SYSTEM_COLUMNS.writebackStatus.columnName),
+  [RESOLVED_VIEW_SYSTEM_COLUMNS.writebackError.name]: () => t.text(RESOLVED_VIEW_SYSTEM_COLUMNS.writebackError.columnName)
+};
+function defineResolvedTable(name2, columns, config) {
+  const file = activeAuthoringContext()?.currentFile;
+  const fail = (message) => {
+    throw new OrmDefinitionError(`resolved table "${name2}": ${message}`, file);
+  };
+  if (!IDENTIFIER_PATTERN.test(name2)) fail(`name must match ${IDENTIFIER_PATTERN}`);
+  for (const property of Object.keys(columns)) {
+    if (RESERVED_RESOLVED_COLUMN_NAMES.has(property) || RESERVED_RESOLVED_COLUMN_NAMES.has(columns[property].columnNameFor(property))) {
+      fail(`column "${property}" collides with a reserved system column`);
+    }
+  }
+  for (const property of Object.keys(columns)) {
+    if (columns[property].columnNameFor(property).length > MAX_TRACKED_COLUMN_NAME) {
+      fail(`column "${property}" is too long for a resolved table (max ${MAX_TRACKED_COLUMN_NAME} characters, room for cell parts)`);
+    }
+  }
+  const pkEntries = Object.entries(columns).filter(([, builder]) => builder.isPrimaryKey);
+  if (pkEntries.length !== 1) fail("declare exactly one .primaryKey() column");
+  const [pk, pkBuilder] = pkEntries[0];
+  const dataColumns = Object.keys(columns).filter((property) => property !== pk);
+  if (dataColumns.length === 0) fail("declare at least one non-key column");
+  const sourceEntries = Object.entries(config.sources);
+  if (sourceEntries.filter(([, source]) => source.kind === "manual").length !== 1) fail("declare exactly one manualSource()");
+  const plans = sourceEntries.map(
+    ([sourceName, input]) => planSource({ viewName: name2, sourceName, input, columns, pk, pkBuilder, dataColumns, fail })
+  );
+  const rules = planRules({ config, plans, dataColumns, fail });
+  const deletedBy = [...config.rows?.deletedBy ?? []];
+  for (const source of deletedBy) {
+    if (plans.find((plan) => plan.name === source)?.kind !== "manual") fail(`rows.deletedBy "${source}" must be the manual source`);
+  }
+  const partType = { source: t.text, at: t.timestamptz, by: t.text, conflicts: t.jsonb };
+  const viewColumns = {};
+  for (const [property, builder] of Object.entries(columns)) {
+    viewColumns[property] = cloneColumn({ builder, property, notNull: property === pk, primaryKey: property === pk });
+    if (property === pk) continue;
+    const columnName = builder.columnNameFor(property);
+    for (const part of RESOLVED_VIEW_CELL_PARTS) {
+      viewColumns[cellColumnName(property, part)] = partType[part](cellColumnName(columnName, part)).cellPart(property, part);
+    }
+  }
+  for (const [property, make] of Object.entries(SYSTEM_VIEW_COLUMNS)) viewColumns[property] = make();
+  const { read, ...writePolicies } = config.policies;
+  const resolved = {
+    internalTables: plans.filter((plan) => plan.kind !== "etl").map((plan) => plan.table),
+    sources: plans,
+    rules,
+    deletedBy,
+    policies: writePolicies
+  };
+  const queryPlan = { columns, pk, plans, rules, deletedBy };
+  const typedColumns = viewColumns;
+  const surface = {
+    ...config.description !== void 0 ? { description: config.description } : {},
+    ...config.links !== void 0 ? { links: config.links } : {},
+    policies: { read }
+  };
+  if (!config.materialize) {
+    return defineView(name2, typedColumns, { ...surface, query: (context) => buildResolvedQuery({ context, plan: queryPlan }), resolved });
+  }
+  const materialize = config.materialize === true ? {} : config.materialize;
+  const computeName = `${name2}__compute`;
+  const tableName = `${name2}__materialized`;
+  const compute = defineView(computeName, typedColumns, {
+    policies: { read },
+    query: (context) => buildResolvedQuery({ context, plan: queryPlan }),
+    internal: true
+  });
+  const table = defineTable(tableName, viewColumns, {
+    description: `Materialized rows of resolved table "${name2}". System-maintained from "${computeName}".`,
+    internal: true,
+    materializes: name2,
+    ...materialize.indexes !== void 0 ? { indexes: materialize.indexes } : {}
+  });
+  return defineView(name2, typedColumns, {
+    ...surface,
+    query: (context) => {
+      const handle = context.relation(table);
+      const selected = Object.fromEntries(Object.entries(viewColumns).map(([property, builder]) => [
+        property,
+        drizzleOrm.sql`${handle[property]}`.as(builder.columnNameFor(property))
+      ]));
+      return context.qb.select(selected).from(context.relation(table));
+    },
+    resolved: {
+      ...resolved,
+      internalTables: [...resolved.internalTables, table],
+      internalViews: [compute],
+      materialized: { table: tableName, compute: computeName }
+    }
+  });
+}
+function planRules({ config, plans, dataColumns, fail }) {
+  const kindOrder = { manual: 0, prefetch: 1, etl: 2 };
+  const fallback = config.default ?? priority([...plans].sort((a, b) => kindOrder[a.kind] - kindOrder[b.kind]).map((plan) => plan.name));
+  for (const column of Object.keys(config.resolve ?? {})) {
+    if (!dataColumns.includes(column)) fail(`resolve names unknown column "${column}"`);
+  }
+  return dataColumns.map((column) => {
+    const explicit = config.resolve?.[column];
+    const comparator = explicit ?? fallback;
+    const candidates = explicit ? [...explicit.candidates] : comparator.candidates.filter((name2) => plans.find((plan) => plan.name === name2)?.columns.includes(column));
+    for (const candidate of candidates) {
+      const plan = plans.find((entry) => entry.name === candidate);
+      if (!plan) fail(`column "${column}" names unknown source "${candidate}"`);
+      else if (!plan.columns.includes(column)) fail(`column "${column}" candidate "${candidate}" does not supply it`);
+    }
+    if (candidates.length === 0) fail(`column "${column}" has no candidate source`);
+    if (comparator.kind === "custom") assertSafeOrderBy({ orderBy: comparator.orderBy ?? "", column, fail });
+    return {
+      column,
+      comparator: comparator.kind,
+      candidates,
+      ...comparator.kind === "custom" && comparator.orderBy !== void 0 ? { orderBy: comparator.orderBy } : {}
+    };
+  });
+}
+var ORDER_BY_KEYWORDS = /* @__PURE__ */ new Set([
+  "value",
+  "updated_at",
+  "source",
+  "actor",
+  "ord",
+  "asc",
+  "desc",
+  "nulls",
+  "first",
+  "last",
+  "case",
+  "when",
+  "then",
+  "else",
+  "end",
+  "and",
+  "or",
+  "not",
+  "is",
+  "null",
+  "true",
+  "false",
+  "in",
+  "distinct",
+  "from",
+  "coalesce",
+  "nullif",
+  "greatest",
+  "least",
+  "text",
+  "numeric",
+  "integer",
+  "bigint",
+  "boolean",
+  "timestamptz",
+  "date",
+  "jsonb",
+  "interval"
+]);
+var ALLOWED_FUNCTIONS = new Set(VIEW_QUERY_FUNCTION_ALLOWLIST);
+var ORDER_BY_TOKEN = /\s+|'(?:[^']|'')*'|\d+(?:\.\d+)?|[a-z_][a-z0-9_]*|::|<=|>=|<>|!=|[-+*/%<>=(),|]/giy;
+function assertSafeOrderBy({ orderBy, column, fail }) {
+  ORDER_BY_TOKEN.lastIndex = 0;
+  let consumed = 0;
+  for (let match = ORDER_BY_TOKEN.exec(orderBy); match; match = ORDER_BY_TOKEN.exec(orderBy)) {
+    consumed = ORDER_BY_TOKEN.lastIndex;
+    const token = match[0].toLowerCase();
+    if (/^[a-z_]/.test(token) && !ORDER_BY_KEYWORDS.has(token) && !ALLOWED_FUNCTIONS.has(token)) {
+      fail(`column "${column}" custom orderBy uses "${match[0]}" \u2014 only value, updated_at, source, actor, ord, SQL keywords and allowlisted functions`);
+    }
+  }
+  if (consumed !== orderBy.length || orderBy.trim() === "") {
+    fail(`column "${column}" custom orderBy contains an unsupported character near "${orderBy.slice(consumed, consumed + 10)}"`);
+  }
 }
 function stableJson(value) {
   if (value === null || typeof value !== "object") return JSON.stringify(value);
@@ -1501,8 +2638,8 @@ function canonicalTable(table) {
     },
     actions: emptyToNull(
       Object.fromEntries(
-        Object.entries(table.actions ?? {}).map(([name, action]) => [
-          name,
+        Object.entries(table.actions ?? {}).map(([name2, action]) => [
+          name2,
           {
             description: action.description ?? null,
             requires: action.requires?.source ?? null,
@@ -1556,6 +2693,72 @@ function computeDefinitionHash(definition) {
   return crypto.createHash("sha256").update(HASH_DOMAIN).update(stableJson(canonicalizeDefinition(definition))).digest("hex");
 }
 
+// src/canonical/composition.ts
+function localContract(definition) {
+  return normalizeCanonical(localDefinitionSchema.parse(definition));
+}
+function flattenNamespaceImports(inputs) {
+  const definitions = /* @__PURE__ */ new Map();
+  const visit = (value, depth) => {
+    if (depth > 16 || definitions.size > 32) throw new OrmDefinitionError("namespace import graph is too large");
+    const definition = localContract(localDefinitionSchema.parse(value));
+    const previous = definitions.get(definition.namespace);
+    if (previous) {
+      if (stableJson(previous) !== stableJson(definition)) throw new OrmDefinitionError(`conflicting contracts for namespace '${definition.namespace}'`);
+    }
+    definitions.set(definition.namespace, definition);
+    if (typeof value === "object" && value !== null && "imports" in value && Array.isArray(value.imports)) {
+      for (const dependency of value.imports) visit(dependency, depth + 1);
+    }
+  };
+  for (const input of inputs) visit(input, 0);
+  return [...definitions.values()].sort((a, b) => a.namespace.localeCompare(b.namespace));
+}
+function composeNamespace(definition) {
+  const all = [localContract(definition), ...definition.imports ?? []];
+  const owners = /* @__PURE__ */ new Map();
+  const namespaces = /* @__PURE__ */ new Set();
+  const enums = /* @__PURE__ */ new Map();
+  for (const owner of all) {
+    if (namespaces.has(owner.namespace)) throw new OrmDefinitionError(`duplicate imported namespace '${owner.namespace}'`);
+    namespaces.add(owner.namespace);
+    for (const value of owner.enums) {
+      const previous = enums.get(value.name);
+      if (previous && stableJson(previous) !== stableJson(value)) {
+        throw new OrmDefinitionError(`conflicting imported enum '${value.name}'`);
+      }
+      enums.set(value.name, value);
+    }
+    for (const relation of canonicalRelations(owner)) {
+      if (owners.has(relation.table)) throw new OrmDefinitionError(`ambiguous imported relation '${relation.table}'`);
+      owners.set(relation.table, owner);
+    }
+  }
+  for (const owner of definition.imports?.length ? all : []) {
+    for (const relation of canonicalRelations(owner)) {
+      for (const link of relation.links) {
+        if (link.kind === "toPlatformUser") continue;
+        const target = owners.get(link.target ?? "");
+        if (!target || target.namespace !== (link.namespace ?? owner.namespace)) {
+          throw new OrmDefinitionError(`link '${owner.namespace}/${relation.table}.${link.name}' has no matching imported target`);
+        }
+        if (target.namespace !== owner.namespace && !target.exports?.[link.target ?? ""]) {
+          throw new OrmDefinitionError(`target '${target.namespace}/${link.target}' is not exported`);
+        }
+      }
+    }
+  }
+  return {
+    owners,
+    definition: {
+      ...localContract(definition),
+      tables: all.flatMap((item) => item.tables),
+      views: all.flatMap((item) => item.views ?? []),
+      enums: [...enums.values()]
+    }
+  };
+}
+
 // src/authoring/namespace.ts
 var NAMESPACE_CONFIG_BRAND = "seq-namespace-config";
 function isSeqNamespaceConfig(value) {
@@ -1571,14 +2774,27 @@ function defineNamespace(input) {
     namespace: input.namespace,
     description: input.description,
     capabilities: input.capabilities ?? {},
+    imports: input.imports,
+    exports: input.exports,
     file
   };
   registerNamespaceConfig(config);
   return config;
 }
 function serializeNamespace(input) {
-  const { config, tables } = input;
-  const views = input.views ?? [];
+  const { config } = input;
+  const views = [...input.views ?? []];
+  const tables = [...input.tables];
+  for (const view of views) {
+    for (const internal of view.config.resolved?.internalTables ?? []) {
+      if (!tables.includes(internal)) tables.push(internal);
+    }
+  }
+  for (const view of [...views]) {
+    for (const internal of view.config.resolved?.internalViews ?? []) {
+      if (!views.includes(internal)) views.push(internal);
+    }
+  }
   const enums = input.enums ?? [];
   const tablesByName = /* @__PURE__ */ new Map();
   for (const table of tables) {
@@ -1604,15 +2820,15 @@ function serializeNamespace(input) {
   }
   const relationsByName = /* @__PURE__ */ new Map();
   for (const relation of [...tables, ...views]) {
-    const name = relationName(relation);
-    const existing = relationsByName.get(name);
+    const name2 = relationName(relation);
+    const existing = relationsByName.get(name2);
     if (existing) {
       throw new OrmDefinitionError(
-        `duplicate relation "${name}" (defined as ${relationKind(existing)} in ${describeFile(existing)} and ${relationKind(relation)} in ${describeFile(relation)})`,
+        `duplicate relation "${name2}" (defined as ${relationKind(existing)} in ${describeFile(existing)} and ${relationKind(relation)} in ${describeFile(relation)})`,
         relation.file
       );
     }
-    relationsByName.set(name, relation);
+    relationsByName.set(name2, relation);
   }
   const enumsByName = /* @__PURE__ */ new Map();
   for (const ref of enums) {
@@ -1653,6 +2869,8 @@ function serializeNamespace(input) {
   };
   if (config.description !== void 0) candidate.description = config.description;
   if (canonicalViews.length > 0) candidate.views = canonicalViews;
+  if (config.imports?.length) candidate.imports = flattenNamespaceImports(config.imports);
+  if (config.exports) candidate.exports = config.exports;
   let parsed;
   try {
     parsed = canonicalDefinitionSchema.parse(candidate);
@@ -1662,7 +2880,9 @@ function serializeNamespace(input) {
     }
     throw error;
   }
-  return normalizeCanonical(parsed);
+  const normalized = normalizeCanonical(parsed);
+  if (normalized.imports?.length) composeNamespace(normalized);
+  return normalized;
 }
 function computeCanonicalHash(definition) {
   return crypto.createHash("sha256").update(HASH_DOMAIN).update(stableJson(definition)).digest("hex");
@@ -1676,10 +2896,14 @@ function buildCanonicalTable({ table, relationsByName, enumsByName }) {
     policies: {},
     actions: []
   };
+  if (table.config.displayName !== void 0) candidate.displayName = table.config.displayName;
   if (table.config.description !== void 0) candidate.description = table.config.description;
   if (table.config.renamedFrom !== void 0) candidate.renamedFrom = table.config.renamedFrom;
   if (table.source !== void 0) candidate.source = table.source;
   if (table.source !== void 0) {
+    if (table.config.checks?.length) {
+      throw new OrmDefinitionError(`synced table "${table.tableName}" is system-owned; checks are not allowed`, table.file);
+    }
     if (table.config.indexes !== void 0 && table.config.indexes.length > 0) {
       throw new OrmDefinitionError(
         `synced table "${table.tableName}" is system-owned; indexes are not allowed`,
@@ -1717,6 +2941,11 @@ function buildCanonicalTable({ table, relationsByName, enumsByName }) {
     if (builder.isPrimaryKey) columnLevelPk.push(column.columnName);
     candidate.columns?.push(column);
   }
+  if (table.config.internal === true) candidate.internal = true;
+  if (table.config.materializes !== void 0) candidate.materializes = table.config.materializes;
+  if (table.config.cellMetadata === true && table.source !== void 0) {
+    throw new OrmDefinitionError(`synced table "${table.tableName}" cannot track cell metadata \u2014 its DDL is owned by the sync`, table.file);
+  }
   if (table.config.primaryKey !== void 0) {
     if (columnLevelPk.length > 0) {
       throw new OrmDefinitionError(
@@ -1730,9 +2959,30 @@ function buildCanonicalTable({ table, relationsByName, enumsByName }) {
   } else if (columnLevelPk.length > 0) {
     candidate.primaryKey = columnLevelPk;
   }
+  if (table.config.cellMetadata === true) {
+    candidate.cellMetadata = true;
+    const parts = table.config.cellRevisions === true ? ["at", "by", "rev"] : ["at", "by"];
+    const tracked = trackedCellColumns({ columns: candidate.columns ?? [], primaryKey: candidate.primaryKey });
+    for (const column of tracked) {
+      for (const part of parts) {
+        candidate.columns?.push({
+          name: cellColumnName(column.name, part),
+          columnName: cellColumnName(column.columnName, part),
+          type: CELL_PART_TYPES[part],
+          nullable: true,
+          unique: false,
+          deprecated: false,
+          cell: { of: column.name, part }
+        });
+      }
+    }
+  }
   if (table.config.foreignKeys?.length) {
     if (table.source) throw new OrmDefinitionError(`synced table "${table.tableName}" cannot enforce foreign keys`, table.file);
     candidate.foreignKeys = table.config.foreignKeys.map((fk) => {
+      if (typeof fk.target === "object" && fk.target.kind === "seq-external-object") {
+        throw new OrmDefinitionError("physical foreign keys require a local target; use a cross-namespace ORM link", table.file);
+      }
       const target = resolveRelationRef({ ref: fk.target, fail: (message) => {
         throw new OrmDefinitionError(message, table.file);
       } });
@@ -1742,10 +2992,15 @@ function buildCanonicalTable({ table, relationsByName, enumsByName }) {
         columns: fk.columns.map((ref) => resolveColumnRef({ relation: table, ref, role: `foreign key "${fk.name}" column` })),
         target: target.tableName,
         references: fk.references.map((ref) => resolveColumnRef({ relation: target, ref, role: `foreign key "${fk.name}" reference` })),
-        ...fk.deferrable ? { deferrable: fk.deferrable } : {}
+        ...fk.deferrable ? { deferrable: fk.deferrable } : {},
+        ...fk.onDelete ? { onDelete: fk.onDelete } : {},
+        ...fk.onUpdate ? { onUpdate: fk.onUpdate } : {}
       };
     });
   }
+  if (table.config.checks?.length) {
+    candidate.checks = table.config.checks.map((check) => ({ name: check.name, expression: check.expression }));
+  }
   for (const index3 of table.config.indexes ?? []) {
     const entry = {
       columns: index3.columns.map((ref) => resolveColumnRef({ relation: table, ref, role: "index" }))
@@ -1841,7 +3096,33 @@ function buildCanonicalView({
     columns,
     ...primaryKey2 !== void 0 ? { primaryKey: primaryKey2 } : {},
     links,
-    policies: { read: toCanonicalPolicy(view.config.policies.read) }
+    policies: { read: toCanonicalPolicy(view.config.policies.read) },
+    ...view.config.resolved !== void 0 ? { resolved: buildCanonicalResolved(view.config.resolved) } : {},
+    ...view.config.internal === true ? { internal: true } : {}
+  };
+}
+function buildCanonicalResolved(resolved) {
+  const policies = {};
+  if (resolved.policies.write !== void 0) policies.write = toCanonicalPolicy(resolved.policies.write);
+  if (resolved.policies.insert !== void 0) policies.insert = toCanonicalPolicy(resolved.policies.insert);
+  if (resolved.policies.update !== void 0) policies.update = toCanonicalPolicy(resolved.policies.update);
+  return {
+    sources: resolved.sources.map((source) => ({
+      name: source.name,
+      kind: source.kind,
+      table: source.table.tableName,
+      columns: [...source.columns],
+      ...source.updatedAt !== void 0 ? { updatedAt: source.updatedAt } : {},
+      ...source.key !== void 0 ? { key: source.key } : {},
+      ...source.fetch !== void 0 ? { fetch: source.fetch } : {},
+      ...source.function !== void 0 ? { function: { ...source.function } } : {},
+      ...source.prefetchDefaults !== void 0 ? { prefetchDefaults: { ...source.prefetchDefaults } } : {},
+      ...source.writeback !== void 0 ? { writeback: { ...source.writeback, columns: [...source.writeback.columns] } } : {}
+    })),
+    resolve: resolved.rules.map((rule) => ({ ...rule, candidates: [...rule.candidates] })),
+    deletedBy: [...resolved.deletedBy],
+    ...resolved.materialized ? { materialized: { ...resolved.materialized } } : {},
+    policies
   };
 }
 function buildCanonicalLink({
@@ -1858,6 +3139,9 @@ function buildCanonicalLink({
   if (link.enforce && link.linkKind !== "toOne") {
     return fail("sets enforce: true, which is only supported on toOne links");
   }
+  if ((link.onDelete !== void 0 || link.onUpdate !== void 0) && !link.enforce) {
+    return fail("sets a referential action without enforce: true");
+  }
   if (link.linkKind === "toPlatformUser") {
     if (link.target !== void 0) return fail("is toPlatformUser and must not declare a target table");
     return {
@@ -1869,6 +3153,19 @@ function buildCanonicalLink({
       ...link.description !== void 0 ? { description: link.description } : {}
     };
   }
+  if (typeof link.target === "object" && link.target?.kind === "seq-external-object") {
+    if (link.enforce) return fail("cannot enforce a cross-namespace physical foreign key; use an ORM link without enforce");
+    return {
+      name: linkName,
+      kind: link.linkKind,
+      namespace: link.target.namespace,
+      target: link.target.table,
+      on: link.linkKind === "toOne" ? resolveColumnRef({ relation, ref: link.on, role: "link on" }) : link.on,
+      ...link.references !== void 0 ? { references: link.linkKind === "toMany" ? resolveColumnRef({ relation, ref: link.references, role: "link references" }) : link.references } : {},
+      enforce: false,
+      ...link.description !== void 0 ? { description: link.description } : {}
+    };
+  }
   const target = resolveRelationRef({ ref: link.target, fail });
   const targetName = relationName(target);
   if (!relationsByName.has(targetName)) {
@@ -1886,6 +3183,8 @@ function buildCanonicalLink({
     on: resolveColumnRef({ relation: owningSide, ref: link.on, role: `link "${linkName}" on` }),
     ...link.references !== void 0 ? { references: resolveColumnRef({ relation: referencedSide, ref: link.references, role: `link "${linkName}" references` }) } : {},
     enforce: link.enforce,
+    ...link.onDelete !== void 0 ? { onDelete: link.onDelete } : {},
+    ...link.onUpdate !== void 0 ? { onUpdate: link.onUpdate } : {},
     ...link.description !== void 0 ? { description: link.description } : {}
   };
 }
@@ -1923,11 +3222,11 @@ function assertAcyclicViewDependencies(views) {
     views.map((view) => [view.view, new Set(view.dependencies.filter((dependency) => viewNames.has(dependency)))])
   );
   while (remaining.size > 0) {
-    const ready = [...remaining.entries()].filter(([, dependencies]) => [...dependencies].every((dependency) => !remaining.has(dependency))).map(([name]) => name);
+    const ready = [...remaining.entries()].filter(([, dependencies]) => [...dependencies].every((dependency) => !remaining.has(dependency))).map(([name2]) => name2);
     if (ready.length === 0) {
       throw new OrmDefinitionError(`view dependencies form a cycle among: ${[...remaining.keys()].sort().join(", ")}`);
     }
-    for (const name of ready) remaining.delete(name);
+    for (const name2 of ready) remaining.delete(name2);
   }
 }
 function toCanonicalPolicy(policy) {
@@ -1973,8 +3272,8 @@ function syncedContractSurface({
     namespace,
     table,
     columns: Object.fromEntries(
-      Object.entries(columns).map(([name, column]) => [
-        name,
+      Object.entries(columns).map(([name2, column]) => [
+        name2,
         { type: column.type, nullable: column.nullable, key: column.key }
       ])
     ),
@@ -1995,7 +3294,7 @@ function extractOrmSyncedTableContract({
   }
   if (table.source === void 0) {
     throw new OrmDefinitionError(
-      `table "${table.table}" is not a synced table \u2014 extractOrmSyncedTableContract requires source: gold.*`
+      `table "${table.table}" is not a synced table \u2014 extractOrmSyncedTableContract requires a qualified source`
     );
   }
   if (table.columns.length === 0) {
@@ -2142,6 +3441,53 @@ function purgeModuleCache(root) {
     if (key.startsWith(prefix)) delete require2.cache[key];
   }
 }
+var sqlScalarSchema = zod.z.enum(["text", "boolean", "integer", "bigint", "numeric", "double", "uuid", "date", "timestamptz"]);
+var name = zod.z.string().regex(/^[A-Za-z_][A-Za-z0-9_]*$/).max(63).refine((value) => !["__proto__", "prototype", "constructor"].includes(value), "reserved name");
+var base = zod.z.object({
+  name,
+  namespace: name,
+  language: zod.z.literal("sql"),
+  kind: zod.z.literal("query"),
+  requires: zod.z.object({ capability: zod.z.string().min(1).max(128) }).strict(),
+  ontology: zod.z.object({ read: zod.z.array(zod.z.string().regex(/^[A-Za-z_][A-Za-z0-9_]*\/[A-Za-z_][A-Za-z0-9_]*$/)).min(1).max(256) }).strict(),
+  maxRows: zod.z.number().int().min(1).max(1e4).default(1e3)
+});
+var fixed = base.extend({
+  parameters: zod.z.record(name, zod.z.object({ type: sqlScalarSchema, required: zod.z.boolean().default(true) }).strict()).default({}),
+  sql: zod.z.string().min(1).max(65536)
+}).strict();
+var runtime = base.extend({ mode: zod.z.literal("runtime") }).strict();
+var sqlOperationDefinitionSchema = zod.z.union([fixed, runtime]);
+function defineOperation(input) {
+  return sqlOperationDefinitionSchema.parse(input);
+}
+
+// src/authoring/catalog.ts
+var SEGMENT = /^[^./\\\s][^/\\]*[^./\\\s]$|^[^./\\\s]$/;
+function validateNamespaceCatalog(catalog, file) {
+  const paths = /* @__PURE__ */ new Set([""]);
+  function visit(folders, parent) {
+    for (const [name2, children] of Object.entries(folders)) {
+      if (!SEGMENT.test(name2) || ["__proto__", "constructor", "prototype"].includes(name2)) {
+        throw new OrmDefinitionError(`invalid catalog folder name "${name2}"`, file);
+      }
+      const path = parent ? `${parent}/${name2}` : name2;
+      paths.add(path);
+      if (children !== null) {
+        if (typeof children !== "object" || Array.isArray(children)) {
+          throw new OrmDefinitionError(`catalog folder "${path}" must contain folders or null`, file);
+        }
+        visit(children, path);
+      }
+    }
+  }
+  visit(catalog.folders, "");
+  for (const [object, path] of Object.entries(catalog.objects)) {
+    if (!object || !paths.has(path)) {
+      throw new OrmDefinitionError(`catalog object "${object}" references missing folder "${path}"`, file);
+    }
+  }
+}
 
 // src/codegen/types.ts
 var WIRE_TYPES = {
@@ -2173,9 +3519,9 @@ function generateNamespaceTypes(definition) {
       lines.push(`  /** Synced from ${table.source} \u2014 read-only typed contract. */`);
     }
     lines.push(`  ${table.table}: {`);
-    for (const [name, column] of columns) {
+    for (const [name2, column] of columns) {
       if (column.deprecated) continue;
-      lines.push(`    ${name}: ${columnWireType(column)}`);
+      lines.push(`    ${name2}: ${columnWireType(column)}`);
     }
     lines.push("  }");
   }
@@ -2186,8 +3532,8 @@ function generateNamespaceTypes(definition) {
 function actionTypeLines(definition) {
   const actions = definition.tables.flatMap((table) => Object.entries(table.actions ?? {}));
   const lines = [`export type ${actionsInterfaceName(definition.namespace)} = {`];
-  for (const [name, action] of actions.sort(([a], [b]) => a.localeCompare(b))) {
-    lines.push(`  ${name}: { params: ${actionParamsType(action)}; result: ${actionResultType(action)} }`);
+  for (const [name2, action] of actions.sort(([a], [b]) => a.localeCompare(b))) {
+    lines.push(`  ${name2}: { params: ${actionParamsType(action)}; result: ${actionResultType(action)} }`);
   }
   lines.push("}", "");
   return lines;
@@ -2195,17 +3541,17 @@ function actionTypeLines(definition) {
 function actionParamsType(action) {
   const entries = Object.entries(action.params ?? {});
   if (entries.length === 0) return "Record<never, never>";
-  const fields = entries.map(([name, param]) => {
-    const base = WIRE_TYPES[param.type];
-    return param.optional ? `${name}?: ${base} | null` : `${name}: ${base}`;
+  const fields = entries.map(([name2, param]) => {
+    const base2 = WIRE_TYPES[param.type];
+    return param.optional ? `${name2}?: ${base2} | null` : `${name2}: ${base2}`;
   });
   return `{ ${fields.join("; ")} }`;
 }
 function actionResultType(action) {
   if (!action.returns) return "{ rowsAffected: number }";
-  const columns = Object.entries(action.returns).map(([name, type]) => {
-    const base = WIRE_TYPES[type];
-    return base === "unknown" ? `${name}: ${base}` : `${name}: ${base} | null`;
+  const columns = Object.entries(action.returns).map(([name2, type]) => {
+    const base2 = WIRE_TYPES[type];
+    return base2 === "unknown" ? `${name2}: ${base2}` : `${name2}: ${base2} | null`;
   });
   return `{ rows: Array<{ ${columns.join("; ")} }> }`;
 }
@@ -2219,9 +3565,9 @@ function pascalCase(namespace) {
   return namespace.split("_").map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
 }
 function columnWireType(column) {
-  const base = WIRE_TYPES[column.type];
+  const base2 = WIRE_TYPES[column.type];
   const notNull = column.primary_key === true || column.nullable === false;
-  return notNull || base === "unknown" ? base : `${base} | null`;
+  return notNull || base2 === "unknown" ? base2 : `${base2} | null`;
 }
 
 // src/predicate/ast.ts
@@ -2339,7 +3685,7 @@ var OPERATOR_PATTERN = /^(!=|<=|>=|<>|=|<|>)/;
 var IDENTIFIER_START = /[a-z_]/;
 var IDENTIFIER_CHAR = /[a-z0-9_.-]/;
 var NUMBER_PATTERN = /^-?\d+(\.\d+)?/;
-function tokenize(source) {
+function tokenize2(source) {
   const tokens = [];
   let position = 0;
   while (position < source.length) {
@@ -2413,7 +3759,7 @@ function readString(source, start) {
   }
   throw new PredicateParseError("unterminated string literal", start);
 }
-var Parser = class {
+var Parser2 = class {
   constructor(tokens) {
     this.tokens = tokens;
   }
@@ -2545,7 +3891,7 @@ var Parser = class {
 function parsePredicate(source) {
   const trimmed = source.trim();
   if (trimmed.length === 0) throw new PredicateParseError("empty predicate", 0);
-  return { source: trimmed, ast: new Parser(tokenize(trimmed)).parse() };
+  return { source: trimmed, ast: new Parser2(tokenize2(trimmed)).parse() };
 }
 
 // src/schema/predicates.ts
@@ -2630,8 +3976,8 @@ var actionSchema = zod.z.strictObject({
     }
   }
 });
-function extractNamedParams(sql5) {
-  const withoutStrings = sql5.replace(QUOTED_STRING_PATTERN, "''");
+function extractNamedParams(sql7) {
+  const withoutStrings = sql7.replace(QUOTED_STRING_PATTERN, "''");
   const names = [...withoutStrings.matchAll(NAMED_PARAM_PATTERN)].map((match) => match[1]);
   return [...new Set(names)];
 }
@@ -2686,7 +4032,7 @@ function executesIssues(executes, declaredParams, hasReturns) {
   if (hasReturns && last && !RETURNING_PATTERN.test(last.replace(QUOTED_STRING_PATTERN, "''"))) {
     issues.push("the last executes statement must use RETURNING to populate the declared returns columns");
   }
-  const undeclared = extractNamedParams(statements.join("\n")).filter((name) => !declaredParams.has(name));
+  const undeclared = extractNamedParams(statements.join("\n")).filter((name2) => !declaredParams.has(name2));
   if (undeclared.length > 0) issues.push(`executes references undeclared params: ${undeclared.join(", ")}`);
   return issues;
 }
@@ -2698,17 +4044,6 @@ var SQL_TYPE_NAMES = {
 };
 var sqlTypeName = (type) => SQL_TYPE_NAMES[type] ?? type;
 
-// src/compiler/sql.ts
-var CLAIMS_SETTING = "request.jwt.claims";
-var CAPABILITIES_CLAIM_KEY = "capabilities";
-var ROLES_CLAIM_KEY = "roles";
-var quoteIdentifier = (name) => `"${name.replaceAll('"', '""')}"`;
-var quoteLiteral = (value) => `'${value.replaceAll("'", "''")}'`;
-var CLAIMS_SOURCE = `nullif(current_setting('${CLAIMS_SETTING}', true), '')::jsonb`;
-var claimExpression = (key) => `(${CLAIMS_SOURCE} ->> ${quoteLiteral(key)})`;
-var capabilityExpression = (key) => `coalesce(${CLAIMS_SOURCE} -> '${CAPABILITIES_CLAIM_KEY}' ? ${quoteLiteral(key)}, false)`;
-var roleExpression = (key) => `coalesce(${CLAIMS_SOURCE} -> '${ROLES_CLAIM_KEY}' ? ${quoteLiteral(key)}, false)`;
-
 // src/compiler/predicates.ts
 var SQL_COMPARE_OPS = {
   "=": "=",
@@ -2772,24 +4107,24 @@ var PARAM_SCHEMAS = {
 function buildActionParamsSchema(action) {
   const shape = {};
   const entries = Object.entries(action.params ?? {});
-  for (const [name, param] of entries) {
-    shape[name] = param.optional ? PARAM_SCHEMAS[param.type].nullish() : PARAM_SCHEMAS[param.type];
+  for (const [name2, param] of entries) {
+    shape[name2] = param.optional ? PARAM_SCHEMAS[param.type].nullish() : PARAM_SCHEMAS[param.type];
   }
   return zod.z.strictObject(shape).superRefine((obj, ctx) => {
-    for (const [name, param] of entries) {
-      if (!param.optional && param.type === "jsonb" && obj[name] === void 0) {
-        ctx.addIssue({ code: "custom", message: "Required", path: [name] });
+    for (const [name2, param] of entries) {
+      if (!param.optional && param.type === "jsonb" && obj[name2] === void 0) {
+        ctx.addIssue({ code: "custom", message: "Required", path: [name2] });
       }
     }
   });
 }
 var actionParamOrder = (action) => Object.keys(action.params ?? {});
-var actionParamArg = (name) => `p_${name}`;
+var actionParamArg = (name2) => `p_${name2}`;
 function compileActionStatements(action, renderParam = actionParamArg) {
   return actionStatementSources(action.executes).map((statement) => compileStatement(statement, renderParam));
 }
-function compileStatement(sql5, renderParam) {
-  const compiled = sql5.replace(TOKEN_PATTERN, (token, claimKey, capabilityKey, paramName) => {
+function compileStatement(sql7, renderParam) {
+  const compiled = sql7.replace(TOKEN_PATTERN, (token, claimKey, capabilityKey, paramName) => {
     if (claimKey !== void 0) {
       if (!CLAIM_KEY_PATTERN.test(claimKey)) throw new OrmDefinitionError(`invalid claim key in executes: ${token}`);
       return claimExpression(claimKey);
@@ -2835,10 +4170,12 @@ function compilePredIrToSql(pred, options = {}) {
     case "cmp":
       return compileCmp(pred.op, pred.column, pred.value, options);
     case "capability":
-      return `(${capabilityExpression(pred.key)})`;
+      return `(${capabilityExpression(pred.key, pred.namespace ?? options.namespace)})`;
     case "role":
-      return `(${roleExpression(pred.key)})`;
+      return `(${roleExpression(pred.key, pred.namespace ?? options.namespace)})`;
     case "exists":
+      if (options.exists) return options.exists(pred);
+      throw new OrmDefinitionError("synced view read policy cannot use 'exists' without a relationship resolver");
     case "aggPredicate":
     case "dynamicFilter":
       throw new OrmDefinitionError(
@@ -2854,10 +4191,11 @@ function physicalColumn(logical, options) {
   return options.columnNames?.[logical] ?? logical;
 }
 function compileCmp(op, column, value, options) {
-  const physical = physicalColumn(column, options);
-  const declared = options.columnTypes?.[physical] ?? options.columnTypes?.[column];
+  const physical2 = physicalColumn(column, options);
+  const declared = options.columnTypes?.[physical2] ?? options.columnTypes?.[column];
   const isEnum = typeof declared === "object" && declared !== null;
-  const col = isEnum ? `${quoteIdentifier(physical)}::text` : quoteIdentifier(physical);
+  const qualified = options.alias ? `${quoteIdentifier(options.alias)}.${quoteIdentifier(physical2)}` : quoteIdentifier(physical2);
+  const col = isEnum ? `${qualified}::text` : qualified;
   const columnType = isEnum ? "text" : declared;
   switch (op) {
     case "eq":
@@ -2901,11 +4239,11 @@ function compileEquality(col, value, columnType, negated, options) {
 function compileValue(value, columnType, _options) {
   switch (value.kind) {
     case "literal": {
-      const literal = value.value;
-      if (literal === null) return "NULL";
-      if (typeof literal === "string") return quoteLiteral(literal);
-      if (typeof literal === "boolean") return literal ? "TRUE" : "FALSE";
-      return String(literal);
+      const literal2 = value.value;
+      if (literal2 === null) return "NULL";
+      if (typeof literal2 === "string") return quoteLiteral(literal2);
+      if (typeof literal2 === "boolean") return literal2 ? "TRUE" : "FALSE";
+      return String(literal2);
     }
     case "claim": {
       const expression = claimExpression(value.key);
@@ -2941,22 +4279,22 @@ function returnProjection(returns, lastStatement) {
   const projection = Object.keys(returns).map(quoteIdentifier).join(", ");
   return `WITH orm_returning AS (${lastStatement}) SELECT ${projection} FROM orm_returning`;
 }
-var allActions = (definition) => definition.tables.flatMap((table) => Object.entries(table.actions ?? {}).map(([name, action]) => ({ name, action }))).sort((a, b) => a.name.localeCompare(b.name));
+var allActions = (definition) => definition.tables.flatMap((table) => Object.entries(table.actions ?? {}).map(([name2, action]) => ({ name: name2, action }))).sort((a, b) => a.name.localeCompare(b.name));
 function actionFunctionStatements(definition) {
   const schema = ormSchemaName(definition.namespace);
-  return [dropAllActionFunctions(schema), ...allActions(definition).flatMap(({ name, action }) => createActionFunction(definition, name, action))];
+  return [dropAllActionFunctions(schema), ...allActions(definition).flatMap(({ name: name2, action }) => createActionFunction(definition, name2, action))];
 }
 function actionPrepareChecks(definition) {
   const actions = allActions(definition);
   if (actions.length === 0) return [];
   const statements = [`SET LOCAL search_path TO ${quoteIdentifier(ormSchemaName(definition.namespace))}`];
-  for (const { name, action } of actions) {
+  for (const { name: name2, action } of actions) {
     const order = actionParamOrder(action);
     const signature = order.length > 0 ? ` (${order.map((param) => sqlTypeName(action.params[param].type)).join(", ")})` : "";
     const compiled = compileActionStatements(action, (param) => `$${order.indexOf(param) + 1}`);
-    compiled.forEach((sql5, index3) => {
-      const checked = action.returns && index3 === compiled.length - 1 ? returnProjection(action.returns, sql5) : sql5;
-      statements.push(`PREPARE ${quoteIdentifier(`orm_check_${name}_${index3}`)}${signature} AS ${checked}`);
+    compiled.forEach((sql7, index3) => {
+      const checked = action.returns && index3 === compiled.length - 1 ? returnProjection(action.returns, sql7) : sql7;
+      statements.push(`PREPARE ${quoteIdentifier(`orm_check_${name2}_${index3}`)}${signature} AS ${checked}`);
     });
   }
   return statements;
@@ -2977,9 +4315,9 @@ BEGIN
 END
 $orm_reconcile_actions$`;
 }
-function createActionFunction(definition, name, action) {
+function createActionFunction(definition, name2, action) {
   const schema = quoteIdentifier(ormSchemaName(definition.namespace));
-  const fn = `${schema}.${quoteIdentifier(actionFunctionName(name))}`;
+  const fn = `${schema}.${quoteIdentifier(actionFunctionName(name2))}`;
   const order = actionParamOrder(action);
   const signature = order.map((paramName) => `${quoteIdentifier(actionParamArg(paramName))} ${sqlTypeName(action.params[paramName].type)}`).join(", ");
   const argTypes = order.map((paramName) => sqlTypeName(action.params[paramName].type)).join(", ");
@@ -2999,7 +4337,7 @@ AS $orm_action$
 -- columns; resolve unqualified names to the column.
 #variable_conflict use_column
 BEGIN
-${[functionGuards(definition, name, action), ...leading, `  RETURN QUERY ${returnProjection(action.returns, last)};`].filter(Boolean).join("\n")}
+${[functionGuards(definition, name2, action), ...leading, `  RETURN QUERY ${returnProjection(action.returns, last)};`].filter(Boolean).join("\n")}
 END
 $orm_action$`
   ) : (
@@ -3013,7 +4351,7 @@ AS $orm_action$
 DECLARE
   v_count bigint;
 BEGIN
-${[functionGuards(definition, name, action), ...leading, `  ${last};`].filter(Boolean).join("\n")}
+${[functionGuards(definition, name2, action), ...leading, `  ${last};`].filter(Boolean).join("\n")}
   GET DIAGNOSTICS v_count = ROW_COUNT;
   RETURN v_count;
 END
@@ -3025,13 +4363,13 @@ $orm_action$`
     `GRANT EXECUTE ON FUNCTION ${fn}(${argTypes}) TO ${role}`
   ];
 }
-function functionGuards(definition, name, action) {
+function functionGuards(definition, name2, action) {
   const lines = [];
   const requires = compileActionRequires(action);
   if (requires) {
     lines.push(
       `  IF NOT (${requires}) THEN`,
-      `    RAISE EXCEPTION 'action ${name} requires a grant the caller does not hold' USING ERRCODE = ${quoteLiteral(ACTION_REQUIRES_DENIED_SQLSTATE)};`,
+      `    RAISE EXCEPTION 'action ${name2} requires a grant the caller does not hold' USING ERRCODE = ${quoteLiteral(ACTION_REQUIRES_DENIED_SQLSTATE)};`,
       `  END IF;`
     );
   }
@@ -3083,7 +4421,7 @@ var tableFileSchema = zod.z.strictObject({
   table: identifierSchema,
   description: zod.z.string().optional(),
   columns: zod.z.record(identifierSchema, columnSchema).optional(),
-  source: zod.z.string().regex(SYNCED_SOURCE_PATTERN, "source must reference a gold-layer table").optional(),
+  source: zod.z.string().regex(SYNCED_SOURCE_PATTERN, "source must be a qualified lowercase schema.table identifier").optional(),
   links: zod.z.record(identifierSchema, linkSchema).optional(),
   indexes: zod.z.array(indexSchema).optional(),
   policies: policiesSchema.optional(),
@@ -3092,12 +4430,12 @@ var tableFileSchema = zod.z.strictObject({
   if (RESERVED_TABLE_NAMES.has(table.table)) {
     ctx.addIssue({ code: "custom", message: `'${table.table}' is a reserved table name`, path: ["table"] });
   }
-  for (const name of Object.keys(table.columns ?? {})) {
-    if (RESERVED_COLUMN_NAMES.has(name)) {
+  for (const name2 of Object.keys(table.columns ?? {})) {
+    if (RESERVED_COLUMN_NAMES.has(name2)) {
       ctx.addIssue({
         code: "custom",
-        message: `column '${name}' collides with the Data API's reserved query parameters (select, order, limit, offset) \u2014 it could never be filtered`,
-        path: ["columns", name]
+        message: `column '${name2}' collides with the Data API's reserved query parameters (select, order, limit, offset) \u2014 it could never be filtered`,
+        path: ["columns", name2]
       });
     }
   }
@@ -3130,41 +4468,41 @@ function validateSyncedTable(table, ctx) {
   const columns = table.columns ?? {};
   const names = Object.keys(columns);
   if (names.length === 0) return;
-  const primaryKeys = names.filter((name) => columns[name]?.primary_key);
+  const primaryKeys = names.filter((name2) => columns[name2]?.primary_key);
   if (primaryKeys.length !== 1) {
     ctx.addIssue({ code: "custom", message: "exactly one column must be primary_key", path: ["columns"] });
   }
   validateRenames(columns, names, ctx);
-  for (const name of names) {
-    const column = columns[name];
+  for (const name2 of names) {
+    const column = columns[name2];
     if (!column) continue;
     const cast = column.cast ? castParts(column.cast) : null;
-    if (column.cast && cast?.column !== name) {
+    if (column.cast && cast?.column !== name2) {
       ctx.addIssue({
         code: "custom",
         message: "cast must reference the column it is declared on",
-        path: ["columns", name, "cast"]
+        path: ["columns", name2, "cast"]
       });
     }
     if (cast && cast.type !== column.type) {
       ctx.addIssue({
         code: "custom",
         message: `cast target '${cast.type}' must match the declared type '${column.type}'`,
-        path: ["columns", name, "cast"]
+        path: ["columns", name2, "cast"]
       });
     }
   }
 }
 function validateRenames(columns, names, ctx) {
   const renameSources = /* @__PURE__ */ new Map();
-  for (const name of names) {
-    const renamedFrom = columns[name]?.renamed_from;
+  for (const name2 of names) {
+    const renamedFrom = columns[name2]?.renamed_from;
     if (!renamedFrom) continue;
-    if (renamedFrom === name || names.includes(renamedFrom)) {
+    if (renamedFrom === name2 || names.includes(renamedFrom)) {
       ctx.addIssue({
         code: "custom",
         message: "renamed_from must name a column that no longer exists",
-        path: ["columns", name, "renamed_from"]
+        path: ["columns", name2, "renamed_from"]
       });
     }
     const claimed = renameSources.get(renamedFrom);
@@ -3172,10 +4510,10 @@ function validateRenames(columns, names, ctx) {
       ctx.addIssue({
         code: "custom",
         message: `renamed_from '${renamedFrom}' is already claimed by '${claimed}'`,
-        path: ["columns", name, "renamed_from"]
+        path: ["columns", name2, "renamed_from"]
       });
     }
-    renameSources.set(renamedFrom, name);
+    renameSources.set(renamedFrom, name2);
   }
 }
 function validateColumnTable(table, ctx) {
@@ -3185,27 +4523,27 @@ function validateColumnTable(table, ctx) {
     ctx.addIssue({ code: "custom", message: "a table must declare columns or a source", path: ["columns"] });
     return;
   }
-  const primaryKeys = names.filter((name) => columns[name]?.primary_key);
+  const primaryKeys = names.filter((name2) => columns[name2]?.primary_key);
   if (primaryKeys.length !== 1) {
     ctx.addIssue({ code: "custom", message: "exactly one column must be primary_key", path: ["columns"] });
   }
   validateRenames(columns, names, ctx);
-  for (const name of names) {
-    const column = columns[name];
+  for (const name2 of names) {
+    const column = columns[name2];
     if (!column) continue;
     const cast = column.cast ? castParts(column.cast) : null;
-    if (column.cast && cast?.column !== name) {
+    if (column.cast && cast?.column !== name2) {
       ctx.addIssue({
         code: "custom",
         message: "cast must reference the column it is declared on",
-        path: ["columns", name, "cast"]
+        path: ["columns", name2, "cast"]
       });
     }
     if (cast && cast.type !== column.type) {
       ctx.addIssue({
         code: "custom",
         message: `cast target '${cast.type}' must match the declared type '${column.type}'`,
-        path: ["columns", name, "cast"]
+        path: ["columns", name2, "cast"]
       });
     }
   }
@@ -3230,22 +4568,22 @@ function validateColumnTable(table, ctx) {
 }
 function validateLinks(table, ctx) {
   const columnNames = Object.keys(table.columns ?? {});
-  for (const [name, link] of Object.entries(table.links ?? {})) {
+  for (const [name2, link] of Object.entries(table.links ?? {})) {
     if (columnNames.length > 0 && !columnNames.includes(link.on)) {
-      ctx.addIssue({ code: "custom", message: `link references unknown column '${link.on}'`, path: ["links", name, "on"] });
+      ctx.addIssue({ code: "custom", message: `link references unknown column '${link.on}'`, path: ["links", name2, "on"] });
     }
     if (link.enforce && link.to.includes(".")) {
       ctx.addIssue({
         code: "custom",
         message: "enforce is only valid for links inside the namespace; cross-boundary links stay soft",
-        path: ["links", name, "enforce"]
+        path: ["links", name2, "enforce"]
       });
     }
     if (link.enforce && table.source) {
       ctx.addIssue({
         code: "custom",
         message: "a synced table cannot enforce foreign keys \u2014 its DDL is owned by the sync",
-        path: ["links", name, "enforce"]
+        path: ["links", name2, "enforce"]
       });
     }
   }
@@ -3260,32 +4598,32 @@ function validateDerivedNameLengths(table, ctx) {
     });
   }
   for (const [position, index3] of (table.indexes ?? []).entries()) {
-    const name = indexName(table.table, index3);
-    if (name.length > MAX_IDENTIFIER_LENGTH) {
+    const name2 = indexName(table.table, index3);
+    if (name2.length > MAX_IDENTIFIER_LENGTH) {
       ctx.addIssue({
         code: "custom",
-        message: `derived index name '${name}' exceeds Postgres's ${MAX_IDENTIFIER_LENGTH}-byte identifier limit \u2014 set a shorter explicit name`,
+        message: `derived index name '${name2}' exceeds Postgres's ${MAX_IDENTIFIER_LENGTH}-byte identifier limit \u2014 set a shorter explicit name`,
         path: ["indexes", position]
       });
     }
   }
-  for (const [name, link] of Object.entries(table.links ?? {})) {
-    const constraint = foreignKeyName(table.table, name);
+  for (const [name2, link] of Object.entries(table.links ?? {})) {
+    const constraint = foreignKeyName(table.table, name2);
     if (link.enforce && constraint.length > MAX_IDENTIFIER_LENGTH) {
       ctx.addIssue({
         code: "custom",
         message: `derived foreign-key name '${constraint}' exceeds Postgres's ${MAX_IDENTIFIER_LENGTH}-byte identifier limit \u2014 shorten the link or table name`,
-        path: ["links", name]
+        path: ["links", name2]
       });
     }
   }
-  for (const name of Object.keys(table.actions ?? {})) {
-    const fnName = `action_${name}`;
+  for (const name2 of Object.keys(table.actions ?? {})) {
+    const fnName = `action_${name2}`;
     if (fnName.length > MAX_IDENTIFIER_LENGTH) {
       ctx.addIssue({
         code: "custom",
         message: `derived action function name '${fnName}' exceeds Postgres's ${MAX_IDENTIFIER_LENGTH}-byte identifier limit \u2014 shorten the action name`,
-        path: ["actions", name]
+        path: ["actions", name2]
       });
     }
   }
@@ -3337,14 +4675,14 @@ function comparisonTypeIssue(left, right, columns) {
     return null;
   }
   const column = left.kind === "column" ? left : right.kind === "column" ? right : null;
-  const literal = left.kind === "literal" ? left : right.kind === "literal" ? right : null;
-  if (!column || !literal || literal.value === null) return null;
+  const literal2 = left.kind === "literal" ? left : right.kind === "literal" ? right : null;
+  if (!column || !literal2 || literal2.value === null) return null;
   const columnGroup = groupOf(column);
   if (!columnGroup) return null;
-  if (typeof literal.value === "string") return null;
-  const literalGroup = typeof literal.value === "number" ? "numeric" : "boolean";
+  if (typeof literal2.value === "string") return null;
+  const literalGroup = typeof literal2.value === "number" ? "numeric" : "boolean";
   if (literalGroup !== columnGroup) {
-    return `policy compares '${column.name}' (${columns[column.name].type}) with a ${typeof literal.value} literal \u2014 incomparable types`;
+    return `policy compares '${column.name}' (${columns[column.name].type}) with a ${typeof literal2.value} literal \u2014 incomparable types`;
   }
   return null;
 }
@@ -3378,7 +4716,7 @@ function policyStatements(schema, table) {
   const policyName2 = (suffix) => quoteIdentifier(policyName(table.table, suffix));
   const statements = POLICY_SUFFIXES.map((suffix) => `DROP POLICY IF EXISTS ${policyName2(suffix)} ON ${qualified}`);
   const columnTypes = Object.fromEntries(
-    Object.entries(table.columns ?? {}).map(([name, column]) => [name, column.type])
+    Object.entries(table.columns ?? {}).map(([name2, column]) => [name2, column.type])
   );
   const read = table.policies?.read;
   if (read) {
@@ -3430,8 +4768,8 @@ function syncedViewStatements({
     const backing = backingMap.get(table.table);
     if (!backing) continue;
     const viewName = `${schema}.${quoteIdentifier(table.table)}`;
-    const physical = splitPhysicalRelation(backing.physicalRelation);
-    const physicalTarget = `${quoteIdentifier(physical.schema)}.${quoteIdentifier(physical.table)}`;
+    const physical2 = splitPhysicalRelation(backing.physicalRelation);
+    const physicalTarget = `${quoteIdentifier(physical2.schema)}.${quoteIdentifier(physical2.table)}`;
     const columnTypes = mergeSyncedViewColumnTypes({
       table,
       canonicalColumnTypes: columnTypesByTable?.get(table.table),
@@ -3441,12 +4779,19 @@ function syncedViewStatements({
     const readPolicyIr = readPolicyIrByTable?.get(table.table);
     const readPolicy = table.policies?.read;
     const whereClause = readPolicyIr ? ` WHERE ${compilePredIrToSql(readPolicyIr, {
+      namespace: definition.namespace,
       columnTypes,
       columnNames: columnNamesByTable?.get(table.table)
     })}` : readPolicy ? ` WHERE ${compilePredicate(readPolicy.ast, narrowToV1ColumnTypes(columnTypes))}` : " WHERE false";
     if (backingPrivileges === "grant") {
-      statements.push(`GRANT USAGE ON SCHEMA ${quoteIdentifier(physical.schema)} TO ${owner}`);
+      statements.push(`GRANT USAGE ON SCHEMA ${quoteIdentifier(physical2.schema)} TO ${owner}`);
       statements.push(`GRANT SELECT ON ${physicalTarget} TO ${owner}`);
+      statements.push(`DO ${quoteLiteral(`BEGIN
+  IF NOT (pg_catalog.has_schema_privilege(${quoteLiteral(executionOwnerRole)}, ${quoteLiteral(physical2.schema)}, 'USAGE')
+    AND pg_catalog.has_table_privilege(${quoteLiteral(executionOwnerRole)}, ${quoteLiteral(physicalTarget)}, 'SELECT')) THEN
+    RAISE EXCEPTION 'Synced backing owner lacks effective USAGE/SELECT; repair managed serving reader access before ORM apply' USING ERRCODE = '42501';
+  END IF;
+END`)}`);
     }
     statements.push(
       `CREATE OR REPLACE VIEW ${viewName} AS SELECT * FROM ${physicalTarget}${whereClause}`
@@ -3462,14 +4807,14 @@ function mergeSyncedViewColumnTypes({
   columnNames
 }) {
   const fromTable = {};
-  for (const [name, def] of Object.entries(table.columns ?? {})) {
-    if (def?.type) fromTable[name] = def.type;
+  for (const [name2, def] of Object.entries(table.columns ?? {})) {
+    if (def?.type) fromTable[name2] = def.type;
   }
   if (columnNames) {
-    for (const [logical, physical] of Object.entries(columnNames)) {
-      const declared = fromTable[physical] ?? fromTable[logical];
+    for (const [logical, physical2] of Object.entries(columnNames)) {
+      const declared = fromTable[physical2] ?? fromTable[logical];
       if (!declared) continue;
-      fromTable[physical] = declared;
+      fromTable[physical2] = declared;
       fromTable[logical] = declared;
     }
   }
@@ -3508,8 +4853,8 @@ function syncedBackingRevokeStatements({
   const seen = /* @__PURE__ */ new Set();
   const statements = [];
   for (const backing of backings) {
-    const physical = splitPhysicalRelation(backing.physicalRelation);
-    const physicalTarget = `${quoteIdentifier(physical.schema)}.${quoteIdentifier(physical.table)}`;
+    const physical2 = splitPhysicalRelation(backing.physicalRelation);
+    const physicalTarget = `${quoteIdentifier(physical2.schema)}.${quoteIdentifier(physical2.table)}`;
     if (seen.has(physicalTarget)) continue;
     seen.add(physicalTarget);
     statements.push(`REVOKE SELECT ON ${physicalTarget} FROM ${owner}`);
@@ -3517,21 +4862,21 @@ function syncedBackingRevokeStatements({
   return statements;
 }
 var FACTORIES = {
-  uuid: (name) => pgCore.uuid(name),
-  text: (name) => pgCore.text(name),
-  integer: (name) => pgCore.integer(name),
+  uuid: (name2) => pgCore.uuid(name2),
+  text: (name2) => pgCore.text(name2),
+  integer: (name2) => pgCore.integer(name2),
   // Mode 'bigint' keeps int8 lossless — mode 'number' silently rounds past
   // 2^53. The read executor serializes BigInt to string for JSON.
-  bigint: (name) => pgCore.bigint(name, { mode: "bigint" }),
-  numeric: (name) => pgCore.numeric(name),
-  double: (name) => pgCore.doublePrecision(name),
-  boolean: (name) => pgCore.boolean(name),
-  timestamptz: (name) => pgCore.timestamp(name, { withTimezone: true }),
-  date: (name) => pgCore.date(name),
-  jsonb: (name) => pgCore.jsonb(name)
+  bigint: (name2) => pgCore.bigint(name2, { mode: "bigint" }),
+  numeric: (name2) => pgCore.numeric(name2),
+  double: (name2) => pgCore.doublePrecision(name2),
+  boolean: (name2) => pgCore.boolean(name2),
+  timestamptz: (name2) => pgCore.timestamp(name2, { withTimezone: true }),
+  date: (name2) => pgCore.date(name2),
+  jsonb: (name2) => pgCore.jsonb(name2)
 };
-function buildColumn(name, definition) {
-  let column = FACTORIES[definition.type](name);
+function buildColumn(name2, definition) {
+  let column = FACTORIES[definition.type](name2);
   if (definition.primary_key) column = column.primaryKey();
   if (definition.nullable === false && !definition.primary_key) column = column.notNull();
   if (definition.unique && !definition.primary_key) column = column.unique();
@@ -3562,7 +4907,7 @@ function buildDrizzleEntities(definition) {
 }
 function buildTable(schema, table, built) {
   const columns = Object.fromEntries(
-    Object.entries(table.columns ?? {}).map(([name, column]) => [name, buildColumn(name, column)])
+    Object.entries(table.columns ?? {}).map(([name2, column]) => [name2, buildColumn(name2, column)])
   );
   const drizzleTable = schema.table(table.table, columns, (self) => [
     ...buildIndexes(table, self),
@@ -3572,21 +4917,21 @@ function buildTable(schema, table, built) {
 }
 function buildIndexes(table, self) {
   return (table.indexes ?? []).map((definition) => {
-    const name = indexName(table.table, definition);
-    const factory = definition.unique ? pgCore.uniqueIndex(name) : pgCore.index(name);
+    const name2 = indexName(table.table, definition);
+    const factory = definition.unique ? pgCore.uniqueIndex(name2) : pgCore.index(name2);
     const columns = definition.columns.map((column) => self[column]);
     return factory.on(...columns);
   });
 }
 function buildForeignKeys(table, self, built) {
-  return Object.entries(table.links ?? {}).filter(([, link]) => link.enforce).map(([name, link]) => {
+  return Object.entries(table.links ?? {}).filter(([, link]) => link.enforce).map(([name2, link]) => {
     const target = link.to === table.table ? self : built.get(link.to);
     const targetColumn = target && findPrimaryKeyColumn(target);
     if (!target || !targetColumn) {
-      throw new OrmDefinitionError(`enforced link '${name}' on '${table.table}' has no built target '${link.to}'`);
+      throw new OrmDefinitionError(`enforced link '${name2}' on '${table.table}' has no built target '${link.to}'`);
     }
     return pgCore.foreignKey({
-      name: foreignKeyName(table.table, name),
+      name: foreignKeyName(table.table, name2),
       columns: [self[link.on]],
       foreignColumns: [targetColumn]
     });
@@ -3643,21 +4988,21 @@ function diffStatements(previous, current) {
 function assertUnambiguousDiff(previous, current) {
   const previousTables = tablesOf(previous);
   const currentTables = tablesOf(current);
-  const removedTables = [...previousTables.keys()].filter((name) => !currentTables.has(name));
-  const addedTables = [...currentTables.keys()].filter((name) => !previousTables.has(name));
+  const removedTables = [...previousTables.keys()].filter((name2) => !currentTables.has(name2));
+  const addedTables = [...currentTables.keys()].filter((name2) => !previousTables.has(name2));
   if (removedTables.length > 0 && addedTables.length > 0) {
     throw new OrmDefinitionError(
       `ambiguous diff: table(s) added (${addedTables.join(", ")}) and removed (${removedTables.join(", ")}) in the same change \u2014 ship the add and the drop as separate changes`
     );
   }
-  for (const [name, previousColumns] of previousTables) {
-    const currentColumns = currentTables.get(name);
+  for (const [name2, previousColumns] of previousTables) {
+    const currentColumns = currentTables.get(name2);
     if (!currentColumns) continue;
     const removed = [...previousColumns].filter((column) => !currentColumns.has(column));
     const added = [...currentColumns].filter((column) => !previousColumns.has(column));
     if (removed.length > 0 && added.length > 0) {
       throw new OrmDefinitionError(
-        `ambiguous diff on '${name}': column(s) added (${added.join(", ")}) and removed (${removed.join(", ")}) in the same change \u2014 declare \`renamed_from\` for a rename, or ship the add and the drop as separate changes`
+        `ambiguous diff on '${name2}': column(s) added (${added.join(", ")}) and removed (${removed.join(", ")}) in the same change \u2014 declare \`renamed_from\` for a rename, or ship the add and the drop as separate changes`
       );
     }
   }
@@ -3676,33 +5021,33 @@ function applyMigrationHints(previous, definition) {
   for (const table of columnTables(definition)) {
     const snapshotTable = findTable(adjusted, schemaName, table.table);
     if (!snapshotTable) continue;
-    for (const [name, column] of Object.entries(table.columns ?? {})) {
+    for (const [name2, column] of Object.entries(table.columns ?? {})) {
       if (column.renamed_from) {
         const previousColumn = snapshotTable.columns[column.renamed_from];
-        if (previousColumn && snapshotTable.columns[name]) {
+        if (previousColumn && snapshotTable.columns[name2]) {
           throw new OrmDefinitionError(
-            `'${table.table}.${name}' declares renamed_from '${column.renamed_from}', but both columns exist in the previous schema \u2014 a rename cannot overwrite a live column`
+            `'${table.table}.${name2}' declares renamed_from '${column.renamed_from}', but both columns exist in the previous schema \u2014 a rename cannot overwrite a live column`
           );
         }
         if (previousColumn) {
           statements.push(
-            `ALTER TABLE ${qualified(table.table)} RENAME COLUMN ${quoteIdentifier(column.renamed_from)} TO ${quoteIdentifier(name)}`
+            `ALTER TABLE ${qualified(table.table)} RENAME COLUMN ${quoteIdentifier(column.renamed_from)} TO ${quoteIdentifier(name2)}`
           );
           delete snapshotTable.columns[column.renamed_from];
-          snapshotTable.columns[name] = { ...previousColumn, name };
-        } else if (!snapshotTable.columns[name]) {
+          snapshotTable.columns[name2] = { ...previousColumn, name: name2 };
+        } else if (!snapshotTable.columns[name2]) {
           throw new OrmDefinitionError(
-            `'${table.table}.${name}' declares renamed_from '${column.renamed_from}', but the previous schema has neither column \u2014 check the declared source name`
+            `'${table.table}.${name2}' declares renamed_from '${column.renamed_from}', but the previous schema has neither column \u2014 check the declared source name`
           );
         }
       }
       const cast = column.cast ? castParts(column.cast) : null;
       if (cast) {
-        const current = snapshotTable.columns[name];
+        const current = snapshotTable.columns[name2];
         const targetType = sqlTypeName(column.type);
         if (current && current.type !== targetType) {
           statements.push(
-            `ALTER TABLE ${qualified(table.table)} ALTER COLUMN ${quoteIdentifier(name)} TYPE ${targetType} USING ${quoteIdentifier(name)}::${targetType}`
+            `ALTER TABLE ${qualified(table.table)} ALTER COLUMN ${quoteIdentifier(name2)} TYPE ${targetType} USING ${quoteIdentifier(name2)}::${targetType}`
           );
           current.type = targetType;
         }
@@ -3719,22 +5064,106 @@ function snapshotTableNames(snapshot, schema) {
   const tables = snapshot.tables ?? {};
   return Object.values(tables).filter((entry) => entry.schema === schema).map((entry) => entry.name);
 }
+
+// src/engine/materialized-refresh.ts
+function materializedRefreshFunctions(canonical) {
+  const schema = ormSchemaName(canonical.namespace);
+  const functions = /* @__PURE__ */ new Map();
+  for (const view of canonical.views ?? []) {
+    const materialized = view.resolved?.materialized;
+    if (!materialized) continue;
+    const table = canonical.tables.find((candidate) => candidate.table === materialized.table);
+    const pk = view.primaryKey ?? [];
+    if (!table || pk.length === 0) {
+      throw new OrmDefinitionError(`materialized resolved table '${view.view}' needs its table and primary key`);
+    }
+    functions.set(view.view, refreshFunctionSql({
+      schema,
+      name: view.view,
+      table: materialized.table,
+      compute: materialized.compute,
+      columns: table.columns.map((column) => column.columnName),
+      pk
+    }));
+  }
+  return functions;
+}
+function refreshFunctionSql({ schema, name: name2, table, compute, columns, pk }) {
+  const fn = `${quoteIdentifier(schema)}.${quoteIdentifier(materializedRefreshFunctionName(name2))}`;
+  const target = `${quoteIdentifier(schema)}.${quoteIdentifier(table)}`;
+  const source = `${quoteIdentifier(schema)}.${quoteIdentifier(compute)}`;
+  const list = columns.map(quoteIdentifier).join(", ");
+  const others = columns.filter((column) => !pk.includes(column));
+  const keys = pk.map(quoteIdentifier).join(", ");
+  const matches = pk.map((column) => `c.${quoteIdentifier(column)} = m.${quoteIdentifier(column)}`).join(" AND ");
+  const onConflict = others.length === 0 ? "DO NOTHING" : `DO UPDATE SET ${others.map((column) => `${quoteIdentifier(column)} = EXCLUDED.${quoteIdentifier(column)}`).join(", ")}
+      WHERE (${others.map((column) => `m.${quoteIdentifier(column)}`).join(", ")}) IS DISTINCT FROM (${others.map((column) => `EXCLUDED.${quoteIdentifier(column)}`).join(", ")})`;
+  const lockKey = quoteLiteral(materializeLockKey(schema, name2));
+  return `CREATE OR REPLACE FUNCTION ${fn}(wait boolean DEFAULT false)
+RETURNS TABLE(upserted bigint, deleted bigint, locked boolean)
+LANGUAGE plpgsql
+SECURITY INVOKER
+SET search_path = pg_catalog, pg_temp
+AS $orm_refresh$
+#variable_conflict use_column
+DECLARE
+  caller_claims text := current_setting('request.jwt.claims', true);
+BEGIN
+  IF wait THEN
+    PERFORM pg_advisory_xact_lock(hashtext(${lockKey}));
+  ELSIF NOT pg_try_advisory_xact_lock(hashtext(${lockKey})) THEN
+    RETURN QUERY SELECT 0::bigint, 0::bigint, false;
+    RETURN;
+  END IF;
+  PERFORM set_config('request.jwt.claims', ${quoteLiteral(MATERIALIZE_CLAIMS_JSON)}, true);
+  RETURN QUERY
+    WITH up AS (
+      INSERT INTO ${target} AS m (${list})
+      SELECT ${list} FROM ${source}
+      ON CONFLICT (${keys}) ${onConflict}
+      RETURNING 1
+    ), gone AS (
+      DELETE FROM ${target} AS m
+      WHERE NOT EXISTS (SELECT 1 FROM ${source} AS c WHERE ${matches})
+      RETURNING 1
+    )
+    SELECT (SELECT count(*) FROM up), (SELECT count(*) FROM gone), true;
+  -- NULL resets to the session value when the caller had none.
+  PERFORM set_config('request.jwt.claims', caller_claims, true);
+END
+$orm_refresh$`;
+}
+function refreshFunctionStatements({ namespace, previous, current }) {
+  const schema = quoteIdentifier(ormSchemaName(namespace));
+  const statements = [];
+  for (const name2 of Object.keys(previous).sort()) {
+    if (!current.has(name2)) statements.push(`DROP FUNCTION IF EXISTS ${schema}.${quoteIdentifier(materializedRefreshFunctionName(name2))}(boolean)`);
+  }
+  for (const [name2, create] of [...current].sort(([a], [b]) => a.localeCompare(b))) {
+    if (previous[name2] === create) continue;
+    const fn = `${schema}.${quoteIdentifier(materializedRefreshFunctionName(name2))}(boolean)`;
+    statements.push(create, `REVOKE ALL ON FUNCTION ${fn} FROM PUBLIC`);
+  }
+  return statements;
+}
+
+// src/engine/canonical2.ts
 var FACTORIES2 = {
-  uuid: (name) => pgCore.uuid(name),
-  text: (name) => pgCore.text(name),
-  integer: (name) => pgCore.integer(name),
+  uuid: (name2) => pgCore.uuid(name2),
+  text: (name2) => pgCore.text(name2),
+  integer: (name2) => pgCore.integer(name2),
   // Mode 'bigint' keeps int8 lossless — mode 'number' silently rounds past
   // 2^53. The read executor serializes BigInt to string for JSON.
-  bigint: (name) => pgCore.bigint(name, { mode: "bigint" }),
-  numeric: (name) => pgCore.numeric(name),
-  double: (name) => pgCore.doublePrecision(name),
-  boolean: (name) => pgCore.boolean(name),
-  timestamptz: (name) => pgCore.timestamp(name, { withTimezone: true }),
-  date: (name) => pgCore.date(name),
-  jsonb: (name) => pgCore.jsonb(name)
+  bigint: (name2) => pgCore.bigint(name2, { mode: "bigint" }),
+  numeric: (name2) => pgCore.numeric(name2),
+  double: (name2) => pgCore.doublePrecision(name2),
+  boolean: (name2) => pgCore.boolean(name2),
+  timestamptz: (name2) => pgCore.timestamp(name2, { withTimezone: true }),
+  date: (name2) => pgCore.date(name2),
+  jsonb: (name2) => pgCore.jsonb(name2)
 };
 var SCHEMA_IMPORT_KEY2 = "$schema";
-var enumImportKey = (name) => `$enum_${name}`;
+var enumImportKey = (name2) => `$enum_${name2}`;
 var columnTablesV2 = (definition) => definition.tables.filter((table) => !table.source);
 function buildDrizzleEntitiesV2(definition, options = {}) {
   const schemaName = ormSchemaName(definition.namespace);
@@ -3831,18 +5260,18 @@ function rewriteSyncedSourceRelationsInViewQuery({
     return rewritten;
   });
 }
-function transformSqlOutsideLiterals(sql5, transform) {
+function transformSqlOutsideLiterals(sql7, transform) {
   const out = [];
   let state = { kind: "normal" };
   let i = 0;
   let codeStart = 0;
   const emitCode = (end) => {
-    if (end > codeStart) out.push(transform(sql5.slice(codeStart, end)));
+    if (end > codeStart) out.push(transform(sql7.slice(codeStart, end)));
     codeStart = end;
   };
-  while (i < sql5.length) {
-    const c = sql5[i];
-    const next = i + 1 < sql5.length ? sql5[i + 1] : "";
+  while (i < sql7.length) {
+    const c = sql7[i];
+    const next = i + 1 < sql7.length ? sql7[i + 1] : "";
     switch (state.kind) {
       case "normal": {
         if (c === "-" && next === "-") {
@@ -3862,7 +5291,7 @@ function transformSqlOutsideLiterals(sql5, transform) {
           break;
         }
         if ((c === "E" || c === "e") && next === "'") {
-          const prev = i > 0 ? sql5[i - 1] : "";
+          const prev = i > 0 ? sql7[i - 1] : "";
           if (!/[A-Za-z0-9_]/.test(prev)) {
             emitCode(i);
             state = { kind: "e-single" };
@@ -3881,9 +5310,9 @@ function transformSqlOutsideLiterals(sql5, transform) {
           break;
         }
         if (c === "$") {
-          const prev = i > 0 ? sql5[i - 1] : "";
+          const prev = i > 0 ? sql7[i - 1] : "";
           if (!/[A-Za-z0-9_$]/.test(prev)) {
-            const tagMatch = /^\$([A-Za-z_][A-Za-z0-9_]*)?\$/.exec(sql5.slice(i));
+            const tagMatch = /^\$([A-Za-z_][A-Za-z0-9_]*)?\$/.exec(sql7.slice(i));
             if (tagMatch) {
               emitCode(i);
               state = { kind: "dollar", tag: tagMatch[1] ?? "" };
@@ -3915,8 +5344,8 @@ function transformSqlOutsideLiterals(sql5, transform) {
         break;
       }
       case "e-single": {
-        if (c === "\\" && i + 1 < sql5.length) {
-          out.push(c, sql5[i + 1]);
+        if (c === "\\" && i + 1 < sql7.length) {
+          out.push(c, sql7[i + 1]);
           i += 2;
           break;
         }
@@ -3938,7 +5367,7 @@ function transformSqlOutsideLiterals(sql5, transform) {
       }
       case "dollar": {
         const closer = `$${state.tag}$`;
-        if (sql5.startsWith(closer, i)) {
+        if (sql7.startsWith(closer, i)) {
           out.push(closer);
           state = { kind: "normal" };
           i += closer.length;
@@ -3982,15 +5411,15 @@ function transformSqlOutsideLiterals(sql5, transform) {
       }
     }
   }
-  emitCode(sql5.length);
+  emitCode(sql7.length);
   return out.join("");
 }
 function escapeRegExp(value) {
   return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
-function sqlReferencesQualifiedRelation(sql5, sourceSchema, sourceName) {
+function sqlReferencesQualifiedRelation(sql7, sourceSchema, sourceName) {
   let referenced = false;
-  transformSqlOutsideLiterals(sql5, (segment) => {
+  transformSqlOutsideLiterals(sql7, (segment) => {
     if (qualifiedRelationPattern(sourceSchema, sourceName).test(segment)) referenced = true;
     return segment;
   });
@@ -4001,16 +5430,18 @@ function qualifiedRelationPattern(sourceSchema, sourceName) {
   const namePattern = `(?:"${escapeRegExp(sourceName)}"|${escapeRegExp(sourceName)})`;
   return new RegExp(`(?<![\\w."])${schemaPattern}\\.${namePattern}(?![\\w"])`, "g");
 }
-function replaceQualifiedRelation(sql5, sourceSchema, sourceName, boundSchema, boundTable) {
-  return sql5.replace(qualifiedRelationPattern(sourceSchema, sourceName), `"${boundSchema}"."${boundTable}"`);
+function replaceQualifiedRelation(sql7, sourceSchema, sourceName, boundSchema, boundTable) {
+  return sql7.replace(qualifiedRelationPattern(sourceSchema, sourceName), `"${boundSchema}"."${boundTable}"`);
 }
 function generateSnapshotV2(definition, previousId3) {
   const { imports, schemaName } = buildDrizzleEntitiesV2(definition);
   const snapshot = api.generateDrizzleJson(imports, previousId3, [schemaName]);
   if ((definition.views?.length ?? 0) > 0 || definition.tables.some((table) => table.foreignKeys?.length)) {
     const extended = snapshot;
+    const refreshFunctions = materializedRefreshFunctions(definition);
     extended._sequenceOrm = {
       ...definition.tables.some((table) => table.foreignKeys?.length) ? { foreignKeys: Object.fromEntries(definition.tables.flatMap((table) => (table.foreignKeys ?? []).map((fk) => [`${table.table}.${fk.name}`, structuredClone(fk)]))) } : {},
+      ...refreshFunctions.size > 0 ? { refreshFunctions: Object.fromEntries(refreshFunctions) } : {},
       viewDependencies: Object.fromEntries(
         (definition.views ?? []).map((view) => [view.view, [...view.dependencies].sort()])
       )
@@ -4034,9 +5465,9 @@ function buildTable2(schema, table, built, enums, byName, introspection) {
     throw new OrmDefinitionError(`table '${table.table}' declares no primaryKey`);
   }
   const columnNames = new Set(table.columns.map((column) => column.columnName));
-  for (const name of primaryKeyColumns) {
-    if (!columnNames.has(name)) {
-      throw new OrmDefinitionError(`primaryKey of '${table.table}' references unknown column '${name}'`);
+  for (const name2 of primaryKeyColumns) {
+    if (!columnNames.has(name2)) {
+      throw new OrmDefinitionError(`primaryKey of '${table.table}' references unknown column '${name2}'`);
     }
   }
   const singlePrimaryKey = primaryKeyColumns.length === 1 ? primaryKeyColumns[0] : void 0;
@@ -4050,15 +5481,19 @@ function buildTable2(schema, table, built, enums, byName, introspection) {
   const drizzleTable = schema.table(table.table, columns, (self) => [
     ...buildCompositePrimaryKey(table, primaryKeyColumns, self),
     ...buildIndexes2(table, self),
+    ...(table.checks ?? []).map((check) => pgCore.check(check.name, drizzleOrm.sql.raw(compileCheckExpression(check.expression, table.columns)))),
     ...buildForeignKeys2(table, self, built, byName),
     ...(table.foreignKeys ?? []).map((fk) => {
       const target = fk.target === table.table ? self : built.get(fk.target);
       if (!target) throw new OrmDefinitionError(`foreign key '${fk.name}' has no target '${fk.target}'`);
-      return pgCore.foreignKey({
+      let constraint = pgCore.foreignKey({
         name: fk.name,
         columns: fk.columns.map((column) => self[column]),
         foreignColumns: fk.references.map((column) => target[column])
       });
+      if (fk.onDelete !== void 0) constraint = constraint.onDelete(fk.onDelete);
+      if (fk.onUpdate !== void 0) constraint = constraint.onUpdate(fk.onUpdate);
+      return constraint;
     })
   ]);
   return drizzleTable.enableRLS();
@@ -4118,8 +5553,8 @@ function buildIndexes2(table, self) {
         throw new OrmDefinitionError(`index on '${table.table}' references unknown column '${column}'`);
       }
     }
-    const name = indexName(table.table, definition);
-    const factory = definition.unique ? pgCore.uniqueIndex(name) : pgCore.index(name);
+    const name2 = indexName(table.table, definition);
+    const factory = definition.unique ? pgCore.uniqueIndex(name2) : pgCore.index(name2);
     const columns = definition.columns.map((column) => self[column]);
     return factory.on(...columns);
   });
@@ -4149,11 +5584,14 @@ function buildForeignKeys2(table, self, built, byName) {
         `enforced link '${link.name}' on '${table.table}' references unknown column '${targetColumn ? link.on : referencedColumn}'`
       );
     }
-    return pgCore.foreignKey({
+    let constraint = pgCore.foreignKey({
       name: foreignKeyName(table.table, link.name),
       columns: [sourceColumn],
       foreignColumns: [targetColumn]
     });
+    if (link.onDelete !== void 0) constraint = constraint.onDelete(link.onDelete);
+    if (link.onUpdate !== void 0) constraint = constraint.onUpdate(link.onUpdate);
+    return constraint;
   });
 }
 var singlePrimaryKeyOf = (table) => table.primaryKey?.length === 1 ? table.primaryKey[0] : void 0;
@@ -4195,33 +5633,33 @@ function applyMigrationHintsV2(previous, definition) {
     const snapshotTable = findTable2(adjusted, schemaName, table.table);
     if (!snapshotTable) continue;
     for (const column of table.columns) {
-      const name = column.columnName;
+      const name2 = column.columnName;
       if (column.renamedFrom) {
         const previousColumn = snapshotTable.columns[column.renamedFrom];
-        if (previousColumn && snapshotTable.columns[name]) {
+        if (previousColumn && snapshotTable.columns[name2]) {
           throw new OrmDefinitionError(
-            `'${table.table}.${name}' declares renamedFrom '${column.renamedFrom}', but both columns exist in the previous schema \u2014 a rename cannot overwrite a live column`
+            `'${table.table}.${name2}' declares renamedFrom '${column.renamedFrom}', but both columns exist in the previous schema \u2014 a rename cannot overwrite a live column`
           );
         }
         if (previousColumn) {
           statements.push(
-            `ALTER TABLE ${qualified(table.table)} RENAME COLUMN ${quoteIdentifier(column.renamedFrom)} TO ${quoteIdentifier(name)}`
+            `ALTER TABLE ${qualified(table.table)} RENAME COLUMN ${quoteIdentifier(column.renamedFrom)} TO ${quoteIdentifier(name2)}`
           );
           delete snapshotTable.columns[column.renamedFrom];
-          snapshotTable.columns[name] = { ...previousColumn, name };
-        } else if (!snapshotTable.columns[name]) {
+          snapshotTable.columns[name2] = { ...previousColumn, name: name2 };
+        } else if (!snapshotTable.columns[name2]) {
           throw new OrmDefinitionError(
-            `'${table.table}.${name}' declares renamedFrom '${column.renamedFrom}', but the previous schema has neither column \u2014 check the declared source name`
+            `'${table.table}.${name2}' declares renamedFrom '${column.renamedFrom}', but the previous schema has neither column \u2014 check the declared source name`
           );
         }
       }
       const cast = column.cast ? castParts(column.cast) : null;
       if (cast) {
-        const current = snapshotTable.columns[name];
+        const current = snapshotTable.columns[name2];
         const { snapshotType, sqlType } = castTargetTypes(column, enumsByName, schemaName, table.table);
         if (current && current.type !== snapshotType) {
           statements.push(
-            `ALTER TABLE ${qualified(table.table)} ALTER COLUMN ${quoteIdentifier(name)} TYPE ${sqlType} USING ${quoteIdentifier(name)}::${sqlType}`
+            `ALTER TABLE ${qualified(table.table)} ALTER COLUMN ${quoteIdentifier(name2)} TYPE ${sqlType} USING ${quoteIdentifier(name2)}::${sqlType}`
           );
           current.type = snapshotType;
         }
@@ -4232,8 +5670,8 @@ function applyMigrationHintsV2(previous, definition) {
 }
 function castTargetTypes(column, enums, schemaName, table) {
   if (typeof column.type === "string") {
-    const name = sqlTypeName(column.type);
-    return { snapshotType: name, sqlType: name };
+    const name2 = sqlTypeName(column.type);
+    return { snapshotType: name2, sqlType: name2 };
   }
   const enumName = column.type.enum;
   if (!enums.has(enumName)) {
@@ -4274,9 +5712,23 @@ function findTable2(snapshot, schema, table) {
   const tables = snapshot.tables ?? {};
   return Object.values(tables).find((entry) => entry.schema === schema && entry.name === table);
 }
-async function planMigrationV2({
+function planMigrationV2(input) {
+  return planWithViewRecreation({ ...input, viewRecreation: "affected" });
+}
+async function planCommittedMigrationV2({
   canonical,
-  previousSnapshot
+  previousSnapshot,
+  reproduces
+}) {
+  const current = await planMigrationV2({ canonical, previousSnapshot });
+  if (reproduces(current)) return { plan: current, reproduced: true };
+  const legacy = await planWithViewRecreation({ canonical, previousSnapshot, viewRecreation: "all-on-base-change" });
+  return reproduces(legacy) ? { plan: legacy, reproduced: true } : { plan: current, reproduced: false };
+}
+async function planWithViewRecreation({
+  canonical,
+  previousSnapshot,
+  viewRecreation
 }) {
   const schema = ormSchemaName(canonical.namespace);
   const previous = previousSnapshot ? normalizeSnapshot(previousSnapshot) : emptySnapshot(canonical.namespace);
@@ -4294,14 +5746,21 @@ async function planMigrationV2({
     currentViews,
     previousDependencies,
     currentDependencies,
-    baseChanged: hints.statements.length > 0 || baseDdl.length > 0
+    reach: viewReach({
+      viewRecreation,
+      hintStatements: hints.statements,
+      baseDdl,
+      previous,
+      adjusted: hints.adjusted,
+      current: snapshot
+    })
   });
   const dropOrder = topologicalViewNames(
-    new Set([...affected].filter((name) => previousViews.has(name))),
+    new Set([...affected].filter((name2) => previousViews.has(name2))),
     previousDependencies
   ).reverse();
   const createOrder = topologicalViewNames(
-    new Set([...affected].filter((name) => currentViews.has(name))),
+    new Set([...affected].filter((name2) => currentViews.has(name2))),
     currentDependencies
   );
   const dropDdl = await generatedViewStatements({
@@ -4318,16 +5777,21 @@ async function planMigrationV2({
   });
   const currentViewDefinitions = new Map((canonical.views ?? []).map((view) => [view.view, view]));
   const statements = [
-    ...dropOrder.map((name) => ({ kind: "ddl", sql: requiredViewStatement(dropDdl, name, schema, "DROP") })),
+    ...dropOrder.map((name2) => ({ kind: "ddl", sql: requiredViewStatement(dropDdl, name2, schema, "DROP") })),
     ...hints.statements.map((statement) => ({ kind: "hint", sql: statement })),
     ...baseDdl.map((statement) => ({ kind: "ddl", sql: statement.replace(/;\s*$/, "") })),
-    ...foreignKeyTimingStatements(canonical, previous, baseDdl).map((sql5) => ({ kind: "ddl", sql: sql5 })),
-    ...createOrder.map((name) => ({ kind: "ddl", sql: requiredViewStatement(createDdl, name, schema, "CREATE") })),
-    ...createOrder.map((name) => {
-      const view = currentViewDefinitions.get(name);
-      if (!view) throw new OrmDefinitionError(`missing canonical definition for view '${name}'`);
+    ...foreignKeyTimingStatements(canonical, previous, baseDdl).map((sql7) => ({ kind: "ddl", sql: sql7 })),
+    ...createOrder.map((name2) => ({ kind: "ddl", sql: requiredViewStatement(createDdl, name2, schema, "CREATE") })),
+    ...createOrder.map((name2) => {
+      const view = currentViewDefinitions.get(name2);
+      if (!view) throw new OrmDefinitionError(`missing canonical definition for view '${name2}'`);
       return { kind: "ddl", sql: validateViewCatalogStatement({ canonical, view, schema }) };
-    })
+    }),
+    ...refreshFunctionStatements({
+      namespace: canonical.namespace,
+      previous: previous._sequenceOrm?.refreshFunctions ?? {},
+      current: materializedRefreshFunctions(canonical)
+    }).map((sql7) => ({ kind: "ddl", sql: sql7 }))
   ];
   return { namespace: canonical.namespace, schema, statements, snapshot };
 }
@@ -4350,9 +5814,9 @@ function foreignKeyTimingStatements(canonical, previous, baseDdl) {
   }
   return result;
 }
-function foreignKeyTimingSql(schema, table, name, timing) {
+function foreignKeyTimingSql(schema, table, name2, timing) {
   const clause = timing === void 0 ? "NOT DEFERRABLE" : timing === "initially-deferred" ? "DEFERRABLE INITIALLY DEFERRED" : "DEFERRABLE INITIALLY IMMEDIATE";
-  return `ALTER TABLE ${quoteIdentifier(schema)}.${quoteIdentifier(table)} ALTER CONSTRAINT ${quoteIdentifier(name)} ${clause}`;
+  return `ALTER TABLE ${quoteIdentifier(schema)}.${quoteIdentifier(table)} ALTER CONSTRAINT ${quoteIdentifier(name2)} ${clause}`;
 }
 function validateViewCatalogStatement({
   canonical,
@@ -4371,9 +5835,9 @@ function validateViewCatalogStatement({
   }
   const expectedDependencies = sqlTextArray(
     view.dependencies.map((dependency) => {
-      const physical = relationIdentity.get(dependency);
-      if (!physical) throw new OrmDefinitionError(`view '${view.view}' depends on unknown relation '${dependency}'`);
-      return physical;
+      const physical2 = relationIdentity.get(dependency);
+      if (!physical2) throw new OrmDefinitionError(`view '${view.view}' depends on unknown relation '${dependency}'`);
+      return physical2;
     }).sort()
   );
   const allowedFunctions = sqlTextArray(VIEW_QUERY_FUNCTION_ALLOWLIST);
@@ -4481,30 +5945,111 @@ function withoutViews(snapshot) {
   delete clone._sequenceOrm;
   return clone;
 }
+var DROPS_TYPE = /^\s*DROP\s+TYPE\b/i;
+function viewReach({
+  viewRecreation,
+  hintStatements,
+  baseDdl,
+  previous,
+  adjusted,
+  current
+}) {
+  if (hintStatements.length === 0 && baseDdl.length === 0) return /* @__PURE__ */ new Set();
+  if (viewRecreation === "all-on-base-change") return "all";
+  if (baseDdl.some((statement) => DROPS_TYPE.test(statement))) return "all";
+  const dependencies = snapshotViewDependencies(adjusted);
+  if ([...snapshotViews(adjusted).keys()].some((name2) => dependencies[name2] === void 0)) return "all";
+  return baseChangesReachingViews({ previous, adjusted, current });
+}
+var SNAPSHOT_BOOKKEEPING = /* @__PURE__ */ new Set(["id", "prevId", "version", "dialect", "_meta", "views", "_sequenceOrm", "enums"]);
+var VIEW_SAFE_TABLE_FIELDS = /* @__PURE__ */ new Set([
+  "indexes",
+  "foreignKeys",
+  "uniqueConstraints",
+  "checkConstraints",
+  "policies",
+  "isRLSEnabled"
+]);
+var VIEW_SAFE_COLUMN_FIELDS = /* @__PURE__ */ new Set(["notNull", "default", "isUnique", "uniqueName", "nullsNotDistinct"]);
+function baseChangesReachingViews({
+  previous,
+  adjusted,
+  current
+}) {
+  const before = adjusted;
+  const after = current;
+  for (const section of /* @__PURE__ */ new Set([...Object.keys(before), ...Object.keys(after)])) {
+    if (SNAPSHOT_BOOKKEEPING.has(section) || section === "tables") continue;
+    if (stableJson(before[section]) !== stableJson(after[section])) return "all";
+  }
+  const relations = /* @__PURE__ */ new Set();
+  const previousTables = snapshotTables(previous);
+  const adjustedTables = snapshotTables(adjusted);
+  for (const key of changedEntryKeys(previousTables, adjustedTables)) {
+    const table = previousTables[key] ?? adjustedTables[key];
+    if (table) relations.add(table.name);
+  }
+  const currentTables = snapshotTables(current);
+  for (const key of /* @__PURE__ */ new Set([...Object.keys(adjustedTables), ...Object.keys(currentTables)])) {
+    const was = adjustedTables[key];
+    const is2 = currentTables[key];
+    if (!was || !is2) {
+      const table = was ?? is2;
+      if (table) relations.add(table.name);
+    } else if (tableChangeReachesViews({ was, is: is2 })) {
+      relations.add(is2.name);
+    }
+  }
+  return relations;
+}
+function tableChangeReachesViews({ was, is: is2 }) {
+  for (const field of /* @__PURE__ */ new Set([...Object.keys(was), ...Object.keys(is2)])) {
+    if (field === "columns" || VIEW_SAFE_TABLE_FIELDS.has(field)) continue;
+    if (stableJson(was[field]) !== stableJson(is2[field])) return true;
+  }
+  return Object.entries(was.columns).some(([name2, column]) => {
+    const next = is2.columns[name2];
+    if (!next) return true;
+    return [.../* @__PURE__ */ new Set([...Object.keys(column), ...Object.keys(next)])].some(
+      (field) => !VIEW_SAFE_COLUMN_FIELDS.has(field) && stableJson(column[field]) !== stableJson(next[field])
+    );
+  });
+}
+function changedEntryKeys(before, after) {
+  return new Set(
+    [.../* @__PURE__ */ new Set([...Object.keys(before), ...Object.keys(after)])].filter(
+      (key) => stableJson(before[key]) !== stableJson(after[key])
+    )
+  );
+}
+function snapshotTables(snapshot) {
+  return snapshot.tables ?? {};
+}
 function affectedViewNames({
   previousViews,
   currentViews,
   previousDependencies,
   currentDependencies,
-  baseChanged
+  reach
 }) {
   const allNames = /* @__PURE__ */ new Set([...previousViews.keys(), ...currentViews.keys()]);
-  if (baseChanged) return allNames;
+  if (reach === "all") return allNames;
+  const dependenciesOf = (name2) => /* @__PURE__ */ new Set([...previousDependencies[name2] ?? [], ...currentDependencies[name2] ?? []]);
   const affected = new Set(
-    [...allNames].filter((name) => {
-      const before = previousViews.get(name);
-      const after = currentViews.get(name);
-      return before === void 0 || after === void 0 || stableJson(before) !== stableJson(after);
+    [...allNames].filter((name2) => {
+      const before = previousViews.get(name2);
+      const after = currentViews.get(name2);
+      if (before === void 0 || after === void 0 || stableJson(before) !== stableJson(after)) return true;
+      return [...dependenciesOf(name2)].some((dependency) => reach.has(dependency));
     })
   );
   let grew = true;
   while (grew) {
     grew = false;
-    for (const name of allNames) {
-      if (affected.has(name)) continue;
-      const dependencies = /* @__PURE__ */ new Set([...previousDependencies[name] ?? [], ...currentDependencies[name] ?? []]);
-      if ([...dependencies].some((dependency) => affected.has(dependency))) {
-        affected.add(name);
+    for (const name2 of allNames) {
+      if (affected.has(name2)) continue;
+      if ([...dependenciesOf(name2)].some((dependency) => affected.has(dependency))) {
+        affected.add(name2);
         grew = true;
       }
     }
@@ -4515,13 +6060,13 @@ function topologicalViewNames(names, dependencies) {
   const remaining = new Set(names);
   const ordered = [];
   while (remaining.size > 0) {
-    const ready = [...remaining].filter((name) => (dependencies[name] ?? []).every((dependency) => !remaining.has(dependency))).sort();
+    const ready = [...remaining].filter((name2) => (dependencies[name2] ?? []).every((dependency) => !remaining.has(dependency))).sort();
     if (ready.length === 0) {
       throw new OrmDefinitionError(`view dependencies form a cycle among: ${[...remaining].sort().join(", ")}`);
     }
-    for (const name of ready) {
-      ordered.push(name);
-      remaining.delete(name);
+    for (const name2 of ready) {
+      ordered.push(name2);
+      remaining.delete(name2);
     }
   }
   return ordered;
@@ -4539,18 +6084,18 @@ async function generatedViewStatements({
   holder.views = Object.fromEntries(Object.entries(views).filter(([, view]) => !names.has(view.name)));
   const generated = mode === "drop" ? await diffStatements(snapshot, without) : await diffStatements(without, snapshot);
   const statements = /* @__PURE__ */ new Map();
-  for (const name of names) {
-    const qualified = `${quoteIdentifier(schema)}.${quoteIdentifier(name)}`;
+  for (const name2 of names) {
+    const qualified = `${quoteIdentifier(schema)}.${quoteIdentifier(name2)}`;
     const prefix = mode === "drop" ? "DROP VIEW" : "CREATE VIEW";
     const statement = generated.find((candidate) => candidate.trimStart().startsWith(`${prefix} ${qualified}`));
-    if (statement) statements.set(name, statement.replace(/;\s*$/, ""));
+    if (statement) statements.set(name2, statement.replace(/;\s*$/, ""));
   }
   return statements;
 }
-function requiredViewStatement(statements, name, schema, operation) {
-  const statement = statements.get(name);
+function requiredViewStatement(statements, name2, schema, operation) {
+  const statement = statements.get(name2);
   if (!statement) {
-    throw new OrmDefinitionError(`drizzle-kit did not generate ${operation} VIEW for '${schema}.${name}'`);
+    throw new OrmDefinitionError(`drizzle-kit did not generate ${operation} VIEW for '${schema}.${name2}'`);
   }
   return statement;
 }
@@ -4741,15 +6286,15 @@ async function planMigration({
   const ddl = await diffStatements(hints.adjusted, snapshot);
   const policyDrops = policyDropStatements(schema, snapshotTableNames(previous, schema));
   const statements = [
-    ...policyDrops.map((sql5) => ({ kind: "security", sql: sql5 })),
-    ...hints.statements.map((sql5) => ({ kind: "hint", sql: sql5 })),
-    ...ddl.map((sql5) => ({ kind: "ddl", sql: sql5.replace(/;\s*$/, "") })),
-    ...securityStatements(definition).map((sql5) => ({ kind: "security", sql: sql5 })),
+    ...policyDrops.map((sql7) => ({ kind: "security", sql: sql7 })),
+    ...hints.statements.map((sql7) => ({ kind: "hint", sql: sql7 })),
+    ...ddl.map((sql7) => ({ kind: "ddl", sql: sql7.replace(/;\s*$/, "") })),
+    ...securityStatements(definition).map((sql7) => ({ kind: "security", sql: sql7 })),
     // PREPARE each action's executes first (plpgsql bodies don't check columns
     // at CREATE), then create the functions. Both reference the tables the DDL
     // above creates, so they close the plan.
-    ...actionPrepareChecks(definition).map((sql5) => ({ kind: "function", sql: sql5 })),
-    ...actionFunctionStatements(definition).map((sql5) => ({ kind: "function", sql: sql5 }))
+    ...actionPrepareChecks(definition).map((sql7) => ({ kind: "function", sql: sql7 })),
+    ...actionFunctionStatements(definition).map((sql7) => ({ kind: "function", sql: sql7 }))
   ];
   return { namespace: definition.namespace, schema, statements, snapshot };
 }
@@ -4796,9 +6341,13 @@ function renderOrmMigrationExport(exported) {
   if (Buffer.byteLength(text4, "utf8") > ORM_MIGRATION_EXPORT_MAX_BYTES) throw new Error("ORM migration export exceeds the size limit");
   return text4;
 }
-var IR_VERSION = 2;
+var IR_VERSION = 5;
 var LEGACY_IR_VERSION = 1;
-var irVersionSchema = zod.z.union([zod.z.literal(LEGACY_IR_VERSION), zod.z.literal(IR_VERSION)]);
+var GUARDED_IR_VERSION = 2;
+var COMPOSED_IR_VERSION = 3;
+var SQL_IR_VERSION = 4;
+var RUNTIME_SQL_IR_VERSION = 5;
+var irVersionSchema = zod.z.union([zod.z.literal(LEGACY_IR_VERSION), zod.z.literal(GUARDED_IR_VERSION), zod.z.literal(COMPOSED_IR_VERSION), zod.z.literal(SQL_IR_VERSION), zod.z.literal(RUNTIME_SQL_IR_VERSION)]);
 var operationVersionSchema = zod.z.object({ irVersion: irVersionSchema });
 function requiredArtifactIrVersion(operations) {
   let required = LEGACY_IR_VERSION;
@@ -4850,8 +6399,8 @@ var predIrSchema = zod.z.lazy(
       value: zod.z.number(),
       where: predIrSchema.optional()
     }),
-    zod.z.object({ kind: zod.z.literal("capability"), key: zod.z.string() }),
-    zod.z.object({ kind: zod.z.literal("role"), key: zod.z.string() }),
+    zod.z.object({ kind: zod.z.literal("capability"), key: zod.z.string(), namespace: zod.z.string().optional() }),
+    zod.z.object({ kind: zod.z.literal("role"), key: zod.z.string(), namespace: zod.z.string().optional() }),
     zod.z.object({ kind: zod.z.literal("dynamicFilter"), slot: zod.z.string() }),
     zod.z.object({ kind: zod.z.literal("const"), value: zod.z.boolean() })
   ])
@@ -4879,6 +6428,21 @@ var selectionIrSchema = zod.z.lazy(
   () => zod.z.object({
     typename: zod.z.string(),
     columns: zod.z.array(zod.z.object({ alias: zod.z.string(), column: zod.z.string() })),
+    cells: zod.z.object({
+      alias: zod.z.string(),
+      typename: zod.z.string(),
+      fields: zod.z.array(zod.z.object({
+        alias: zod.z.string(),
+        column: zod.z.string(),
+        typename: zod.z.string(),
+        parts: zod.z.array(zod.z.object({
+          alias: zod.z.string(),
+          part: zod.z.enum(["source", "at", "by", "conflicts"]),
+          fields: zod.z.array(zod.z.object({ alias: zod.z.string(), field: zod.z.enum(["source", "at", "value"]) })).optional(),
+          typename: zod.z.string().optional()
+        }))
+      }))
+    }).optional(),
     relations: zod.z.array(zod.z.object({
       alias: zod.z.string(),
       link: zod.z.string(),
@@ -4900,6 +6464,11 @@ var selectionIrSchema = zod.z.lazy(
   })
 );
 var includeIfSchema = zod.z.object({ variable: zod.z.string(), negated: zod.z.boolean() });
+var prefetchPlanIrSchema = zod.z.object({
+  source: zod.z.string(),
+  maxStalenessMs: zod.z.number().int().positive().optional(),
+  key: zod.z.union([zod.z.object({ one: valueIrSchema }), zod.z.object({ many: valueIrSchema })])
+});
 var selectRootSchema = zod.z.object({
   kind: zod.z.literal("select"),
   alias: zod.z.string(),
@@ -4911,7 +6480,8 @@ var selectRootSchema = zod.z.object({
   distinctOn: zod.z.union([zod.z.array(zod.z.string()), zod.z.object({ slot: zod.z.string() })]).optional(),
   limit: limitIrSchema,
   offset: zod.z.object({ variable: zod.z.string().optional(), value: zod.z.number().int().optional() }).optional(),
-  includeIf: includeIfSchema.optional()
+  includeIf: includeIfSchema.optional(),
+  prefetch: zod.z.array(prefetchPlanIrSchema).optional()
 });
 var byPkRootSchema = zod.z.object({
   kind: zod.z.literal("byPk"),
@@ -4921,7 +6491,8 @@ var byPkRootSchema = zod.z.object({
   pk: zod.z.array(zod.z.object({ column: zod.z.string(), value: valueIrSchema })).min(1),
   /** Policy predicate — ANDed with the PK match. */
   where: predIrSchema,
-  includeIf: includeIfSchema.optional()
+  includeIf: includeIfSchema.optional(),
+  prefetch: zod.z.array(prefetchPlanIrSchema).optional()
 });
 var aggregateRootSchema = zod.z.object({
   kind: zod.z.literal("aggregate"),
@@ -4979,7 +6550,20 @@ var mutationRootSchema = zod.z.object({
    * coalesce view falls back to synced. Both are gated on a matching synced
    * row and carry the write policy in `where` like update/delete.
    */
-  op: zod.z.enum(["insert", "insertOne", "update", "updateByPk", "delete", "deleteByPk", "cowOverride", "cowRevert"]),
+  op: zod.z.enum(["insert", "insertOne", "update", "updateByPk", "delete", "deleteByPk", "cowOverride", "cowRevert", "resolvedWrite"]),
+  /**
+   * resolvedWrite: a write to a resolved table (`table` is its view). The
+   * executor gates on the resolved row (write policy in `where`), writes only
+   * the touched cells into the manual source, then re-checks `insertCheck`
+   * against the resolved row. `revert` clears `revertColumns` from the manual
+   * source; `delete` tombstones the row there.
+   */
+  resolvedAction: zod.z.enum(["insert", "update", "delete", "revert"]).optional(),
+  revertColumns: zod.z.array(zod.z.string()).optional(),
+  /** `@writeback(source:, mode:)` directives on this root. */
+  writeback: zod.z.array(zod.z.object({ source: zod.z.string(), mode: zod.z.enum(["sync", "async"]) })).optional(),
+  /** `@localOnly(source:)` — writeback columns deliberately kept local for these sources. */
+  localOnly: zod.z.array(zod.z.string()).optional(),
   alias: zod.z.string(),
   table: zod.z.string(),
   /** CoW ops: logical name of the synced twin (read through its policy-filtered view). */
@@ -5043,7 +6627,31 @@ var variableIrSchema = zod.z.object({
   /** Absent = no default declared; see {@link variableDefaultIrSchema}. */
   defaultValue: variableDefaultIrSchema.optional()
 });
+var sqlColumnSchema = zod.z.object({ name: zod.z.string(), type: zod.z.enum(["text", "boolean", "integer", "bigint", "numeric", "double", "uuid", "date", "timestamptz"]), nullable: zod.z.boolean() });
 var compiledOperationSchema = zod.z.object({
+  language: zod.z.literal("sql").optional(),
+  /** Server-compiled object catalog and permission ceiling, never caller SQL. */
+  sqlQuery: zod.z.object({
+    catalog: zod.z.object({
+      identity: zod.z.string(),
+      objects: zod.z.array(zod.z.object({
+        ref: zod.z.string(),
+        table: zod.z.string(),
+        columns: zod.z.array(sqlColumnSchema.extend({ type: zod.z.string() })).min(1),
+        scan: zod.z.string().min(1),
+        read: zod.z.array(zod.z.string()).min(1)
+      }).strict()).min(1).max(256)
+    }).strict(),
+    read: zod.z.array(zod.z.string()).min(1).max(256),
+    maxRows: zod.z.number().int().min(1).max(1e4)
+  }).strict().optional(),
+  sql: zod.z.object({
+    text: zod.z.string().min(1).max(1048576),
+    columns: zod.z.array(sqlColumnSchema).min(1).max(256),
+    parameters: zod.z.array(zod.z.string()).max(128),
+    read: zod.z.array(zod.z.string()).min(1).max(256),
+    maxRows: zod.z.number().int().min(1).max(1e4)
+  }).strict().optional(),
   irVersion: irVersionSchema,
   name: zod.z.string(),
   opHash: zod.z.string().regex(/^sha256:[0-9a-f]{64}$/),
@@ -5055,8 +6663,16 @@ var compiledOperationSchema = zod.z.object({
   variables: zod.z.array(variableIrSchema),
   /** Every table the op touches — data-token scoping + audit. */
   tableSet: zod.z.array(zod.z.string()).min(1),
-  roots: zod.z.array(rootIrSchema).min(1)
+  roots: zod.z.array(rootIrSchema)
 }).superRefine((operation, ctx) => {
+  if (operation.language === "sql") {
+    const validPlan = operation.sqlQuery ? !operation.sql && operation.irVersion === RUNTIME_SQL_IR_VERSION : !!operation.sql && operation.irVersion === SQL_IR_VERSION;
+    if (!validPlan || operation.kind !== "query" || operation.roots.length !== 0 || !operation.requires?.capability) {
+      ctx.addIssue({ code: "custom", message: "SQL operations require a query-only v4 plan or v5 runtime contract, capability, and no GraphQL roots" });
+    }
+  } else if (operation.sql || operation.sqlQuery || operation.roots.length === 0) {
+    ctx.addIssue({ code: "custom", message: "GraphQL operations require roots and cannot carry SQL" });
+  }
   for (const [index3, root] of operation.roots.entries()) {
     if (root.kind !== "mutation" || root.assertAffectedRows === void 0) continue;
     if (operation.irVersion < 2 || operation.kind !== "mutation" || root.includeIf !== void 0) {
@@ -5064,13 +6680,55 @@ var compiledOperationSchema = zod.z.object({
     }
   }
 });
+var resolvedSourceIrSchema = zod.z.object({
+  name: zod.z.string(),
+  kind: zod.z.enum(["manual", "etl", "prefetch"]),
+  /** Logical table key of the backing relation. */
+  table: zod.z.string(),
+  columns: zod.z.array(zod.z.string()),
+  key: zod.z.string().optional(),
+  fetch: zod.z.union([
+    zod.z.object({ shape: zod.z.literal("single") }),
+    zod.z.object({ shape: zod.z.literal("batch"), maxKeys: zod.z.number().int().positive() })
+  ]).optional(),
+  function: zod.z.object({ kind: zod.z.enum(["managed", "native"]), id: zod.z.string() }).optional(),
+  prefetchDefaults: zod.z.object({
+    maxStalenessMs: zod.z.number().int().positive(),
+    timeoutMs: zod.z.number().int().positive(),
+    onError: zod.z.enum(["fallback", "fail"])
+  }).optional(),
+  writeback: zod.z.object({
+    columns: zod.z.array(zod.z.string()),
+    defaultMode: zod.z.enum(["sync", "async"]),
+    timeoutMs: zod.z.number().int().positive(),
+    clearManualOnConfirm: zod.z.boolean()
+  }).optional()
+});
+var resolvedMetaIrSchema = zod.z.object({
+  /** Logical pk column of the resolved view (single-column). */
+  pk: zod.z.string(),
+  /** Source name of the manual source. */
+  manual: zod.z.string(),
+  sources: zod.z.array(resolvedSourceIrSchema),
+  deletedBy: zod.z.array(zod.z.string()),
+  /**
+   * Materialized: the view reads `table`, which the data plane refreshes from
+   * the `compute` view (claims-gated) whenever it writes a source row.
+   */
+  materialized: zod.z.object({ table: zod.z.string(), compute: zod.z.string() }).optional()
+});
 var tableMetaIrSchema = zod.z.object({
   table: zod.z.string(),
+  namespace: zod.z.string().optional(),
+  dependencies: zod.z.array(zod.z.string()).optional(),
+  foreignReferences: zod.z.array(zod.z.object({ column: zod.z.string(), target: zod.z.string(), targetColumn: zod.z.string() })).optional(),
+  exportRead: zod.z.union([zod.z.literal(true), zod.z.object({ capability: zod.z.string() }), zod.z.object({ role: zod.z.string() })]).optional(),
+  exportWrite: zod.z.union([zod.z.literal(true), zod.z.object({ capability: zod.z.string() }), zod.z.object({ role: zod.z.string() })]).optional(),
   schema: zod.z.string(),
   typename: zod.z.string(),
   /**
    * True when statements over this relation evaluate a claims-gated synced
-   * view: synced twins (`source: gold.*`) materialize as views whose baked
+   * view: synced twins (`source: schema.table`) materialize as views whose baked
    * policy reads `current_setting('request.jwt.claims')`, and namespace views
    * inherit the gate transitively through their declared dependencies. The
    * executor must stamp that GUC (transaction-scoped) before any statement
@@ -5104,6 +6762,22 @@ var tableMetaIrSchema = zod.z.object({
    * `onUpdateFn`). Omitted when empty so pre-onUpdate artifacts still parse.
    */
   touchOnUpdate: zod.z.array(zod.z.string()).optional(),
+  /**
+   * Per-cell metadata: logical column → the logical names of its cell-part
+   * columns (which are listed in `columns`, but never filterable, orderable or
+   * writable). Tables stamp `at`/`by` (and a manual source `rev`) on every
+   * write; resolved views expose `source`/`at`/`by`/`conflicts`. Omitted when
+   * the relation tracks no cells.
+   */
+  cells: zod.z.record(zod.z.string(), zod.z.object({
+    at: zod.z.string().optional(),
+    by: zod.z.string().optional(),
+    rev: zod.z.string().optional(),
+    source: zod.z.string().optional(),
+    conflicts: zod.z.string().optional()
+  }).strict()).optional(),
+  /** Resolved-table view metadata (sources, prefetch/writeback config) for the data plane. */
+  resolved: resolvedMetaIrSchema.optional(),
   constraints: zod.z.array(zod.z.object({ name: zod.z.string(), columns: zod.z.array(zod.z.string()) })),
   /** Depth/node caps for dynamic filter trees on this table. */
   dynamicFilterMaxDepth: zod.z.number().int().positive().default(6),
@@ -5113,13 +6787,21 @@ var compiledArtifactSchema = zod.z.object({
   irVersion: irVersionSchema,
   namespace: zod.z.string(),
   schemaHash: zod.z.string(),
+  ownSchemaHash: zod.z.string().optional(),
+  dependencies: zod.z.record(zod.z.string(), zod.z.string()).optional(),
+  readPolicies: zod.z.record(zod.z.string(), predIrSchema).optional(),
   opsHash: zod.z.string(),
+  /** Apply-observed synced objects without a serving backing; not part of the authored schema hash. */
+  unbackedTables: zod.z.array(zod.z.string()).optional(),
   tables: zod.z.record(zod.z.string(), tableMetaIrSchema),
   operations: zod.z.record(zod.z.string(), compiledOperationSchema)
 }).superRefine((artifact, ctx) => {
-  for (const [name, operation] of Object.entries(artifact.operations)) {
+  if (Object.keys(artifact.dependencies ?? {}).length > 0 && artifact.irVersion < COMPOSED_IR_VERSION) {
+    ctx.addIssue({ code: "custom", path: ["irVersion"], message: "cross-namespace dependencies require IR v3" });
+  }
+  for (const [name2, operation] of Object.entries(artifact.operations)) {
     if (operation.irVersion > artifact.irVersion) {
-      ctx.addIssue({ code: "custom", path: ["operations", name, "irVersion"], message: "operation requires a newer IR version than its artifact" });
+      ctx.addIssue({ code: "custom", path: ["operations", name2, "irVersion"], message: "operation requires a newer IR version than its artifact" });
     }
   }
 });
@@ -5132,7 +6814,7 @@ var IrVersionError = class extends Error {
 function normalizeIr(raw) {
   if (!raw || typeof raw !== "object") throw new IrVersionError(void 0);
   const version = raw.irVersion;
-  if (version !== LEGACY_IR_VERSION && version !== IR_VERSION) throw new IrVersionError(version);
+  if (!irVersionSchema.safeParse(version).success) throw new IrVersionError(version);
   return compiledArtifactSchema.parse(raw);
 }
 function indexByHash(artifact) {
@@ -5165,10 +6847,10 @@ function buildNamespaceDefinition(files, config) {
   }
   const actionsSeen = /* @__PURE__ */ new Map();
   for (const { file, table } of files) {
-    for (const name of Object.keys(table.actions ?? {})) {
-      const existing = actionsSeen.get(name);
-      if (existing) throw new OrmDefinitionError(`action '${name}' is already defined in ${existing}`, file);
-      actionsSeen.set(name, file);
+    for (const name2 of Object.keys(table.actions ?? {})) {
+      const existing = actionsSeen.get(name2);
+      if (existing) throw new OrmDefinitionError(`action '${name2}' is already defined in ${existing}`, file);
+      actionsSeen.set(name2, file);
     }
   }
   const capabilities = config?.capabilities ? { roles: config.capabilities.roles ?? EMPTY_CAPABILITIES.roles, uses: config.capabilities.uses ?? [] } : EMPTY_CAPABILITIES;
@@ -5211,12 +6893,12 @@ function validateActionValidates(files, byName) {
 }
 function validateIndexNames(files) {
   const seen = /* @__PURE__ */ new Map();
-  const claim = (name, label, file) => {
-    const existing = seen.get(name);
+  const claim = (name2, label, file) => {
+    const existing = seen.get(name2);
     if (existing) {
-      throw new OrmDefinitionError(`relation name '${name}' (${label}) collides with ${existing}`, file);
+      throw new OrmDefinitionError(`relation name '${name2}' (${label}) collides with ${existing}`, file);
     }
-    seen.set(name, `${label} (${file})`);
+    seen.set(name2, `${label} (${file})`);
   };
   for (const { file, table } of files) {
     claim(table.table, `table '${table.table}'`, file);
@@ -5224,9 +6906,9 @@ function validateIndexNames(files) {
   for (const { file, table } of files) {
     if (table.source) continue;
     claim(`${table.table}_pkey`, `implicit primary-key index of '${table.table}'`, file);
-    for (const [name, column] of Object.entries(table.columns ?? {})) {
+    for (const [name2, column] of Object.entries(table.columns ?? {})) {
       if (column.unique && !column.primary_key) {
-        claim(`${table.table}_${name}_unique`, `implicit unique constraint of '${table.table}.${name}'`, file);
+        claim(`${table.table}_${name2}_unique`, `implicit unique constraint of '${table.table}.${name2}'`, file);
       }
     }
   }
@@ -5238,20 +6920,20 @@ function validateIndexNames(files) {
 }
 function validateLocalLinks(files, byName) {
   for (const { file, table } of files) {
-    for (const [name, link] of Object.entries(table.links ?? {})) {
+    for (const [name2, link] of Object.entries(table.links ?? {})) {
       if (isQualifiedReference(link.to)) continue;
       const target = byName.get(link.to);
       if (!target) {
-        throw new OrmDefinitionError(`link '${name}' references unknown table '${link.to}'`, file);
+        throw new OrmDefinitionError(`link '${name2}' references unknown table '${link.to}'`, file);
       }
       if (link.enforce && target.source) {
-        throw new OrmDefinitionError(`link '${name}' cannot enforce a foreign key onto a synced table`, file);
+        throw new OrmDefinitionError(`link '${name2}' cannot enforce a foreign key onto a synced table`, file);
       }
       const sourceType = table.columns?.[link.on]?.type;
       const targetPrimaryKey = Object.values(target.columns ?? {}).find((column) => column.primary_key);
       if (sourceType && targetPrimaryKey && columnTypeGroup(sourceType) !== columnTypeGroup(targetPrimaryKey.type)) {
         throw new OrmDefinitionError(
-          `link '${name}' can never join: '${link.on}' is ${sourceType} but '${link.to}' has a ${targetPrimaryKey.type} primary key`,
+          `link '${name2}' can never join: '${link.on}' is ${sourceType} but '${link.to}' has a ${targetPrimaryKey.type} primary key`,
           file
         );
       }
@@ -5331,7 +7013,7 @@ function parseYaml(file, contents) {
     throw new OrmDefinitionError(error instanceof Error ? error.message : "invalid YAML", file);
   }
 }
-var isDefinitionFile = (name) => DEFINITION_FILE_EXTENSIONS.some((extension) => path.extname(name) === extension);
+var isDefinitionFile = (name2) => DEFINITION_FILE_EXTENSIONS.some((extension) => path.extname(name2) === extension);
 async function listDefinitionFiles(dir) {
   const entries = await promises.readdir(dir, { withFileTypes: true });
   return entries.filter((entry) => entry.isFile() && isDefinitionFile(entry.name)).map((entry) => entry.name).sort();
@@ -5425,13 +7107,13 @@ async function readMigrationSql(dir, entry) {
 var checksumOf = (text4) => crypto.createHash("sha256").update(text4).digest("hex");
 var migrationName = (ordinal, contentHash) => `${pad(ordinal)}_${contentHash.slice(0, 12)}`;
 function renderMigrationSql({
-  name,
+  name: name2,
   namespace,
   contentHash,
   plan
 }) {
   const header = [
-    `-- ${name}`,
+    `-- ${name2}`,
     `-- namespace: ${namespace}`,
     `-- content hash: ${contentHash}`,
     "-- generated by `seq-studio orm diff` \u2014 review and commit, do not edit"
@@ -5447,13 +7129,13 @@ async function writeMigration({
 }) {
   const tip = workspace.journal.entries.at(-1);
   const ordinal = (tip?.ordinal ?? 0) + 1;
-  const name = migrationName(ordinal, contentHash);
-  const sql5 = renderMigrationSql({ name, namespace: workspace.journal.namespace, contentHash, plan });
+  const name2 = migrationName(ordinal, contentHash);
+  const sql7 = renderMigrationSql({ name: name2, namespace: workspace.journal.namespace, contentHash, plan });
   const metaDir = path.join(dir, MIGRATIONS_DIRNAME, META_DIRNAME);
   await promises.mkdir(metaDir, { recursive: true });
   const snapshotText = `${JSON.stringify(plan.snapshot, null, 2)}
 `;
-  await promises.writeFile(path.join(dir, MIGRATIONS_DIRNAME, `${name}.sql`), sql5);
+  await promises.writeFile(path.join(dir, MIGRATIONS_DIRNAME, `${name2}.sql`), sql7);
   await promises.writeFile(path.join(metaDir, `${pad(ordinal)}.snapshot.json`), snapshotText);
   const journal = {
     ...workspace.journal,
@@ -5461,10 +7143,10 @@ async function writeMigration({
       ...workspace.journal.entries,
       {
         ordinal,
-        name,
+        name: name2,
         content_hash: contentHash,
         previous_content_hash: tip?.content_hash ?? null,
-        checksum: checksumOf(sql5),
+        checksum: checksumOf(sql7),
         snapshot_checksum: checksumOf(snapshotText),
         destructive
       }
@@ -5472,7 +7154,7 @@ async function writeMigration({
   };
   await promises.writeFile(path.join(metaDir, JOURNAL_FILENAME), `${JSON.stringify(journal, null, 2)}
 `);
-  return { name, ordinal, destructive };
+  return { name: name2, ordinal, destructive };
 }
 var pad = (ordinal) => String(ordinal).padStart(4, "0");
 function parseJson(path, raw) {
@@ -5579,8 +7261,8 @@ async function checkWorkspace({
   let previousId3;
   let previousHash = null;
   for (const entry of workspace.journal.entries) {
-    const sql5 = await readMigrationSql(dir, entry);
-    if (checksumOf(sql5) !== entry.checksum) {
+    const sql7 = await readMigrationSql(dir, entry);
+    if (checksumOf(sql7) !== entry.checksum) {
       log(`${MIGRATIONS_DIRNAME}/${entry.name}.sql does not match its journal checksum \u2014 committed migrations must not be edited`);
       return 1;
     }
@@ -5620,7 +7302,7 @@ async function checkWorkspace({
   log(`migrations in sync \u2014 ${workspace.journal.entries.length} committed, tip ${tip.name}`);
   return 0;
 }
-var firstLine = (sql5) => sql5.split("\n")[0] ?? sql5;
+var firstLine = (sql7) => sql7.split("\n")[0] ?? sql7;
 
 // src/migrations/from-yaml.ts
 function convertV1DefinitionToCanonical(definition) {
@@ -5646,15 +7328,15 @@ function convertV1DefinitionToCanonical(definition) {
 }
 function convertTable(table) {
   const columns = Object.entries(table.columns ?? {});
-  const primaryKey2 = columns.filter(([, column]) => column.primary_key).map(([name]) => name);
+  const primaryKey2 = columns.filter(([, column]) => column.primary_key).map(([name2]) => name2);
   return {
     table: table.table,
     description: table.description,
     source: table.source,
-    columns: columns.map(([name, column]) => convertColumn(name, column)),
+    columns: columns.map(([name2, column]) => convertColumn(name2, column)),
     // Synced tables may declare a typed column/PK contract; untyped remain empty.
     primaryKey: primaryKey2.length > 0 ? primaryKey2 : void 0,
-    links: Object.entries(table.links ?? {}).map(([name, link]) => convertLink(table.table, name, link)),
+    links: Object.entries(table.links ?? {}).map(([name2, link]) => convertLink(table.table, name2, link)),
     indexes: (table.indexes ?? []).map((index3) => ({
       columns: [...index3.columns],
       unique: index3.unique ?? false,
@@ -5671,11 +7353,11 @@ function convertTable(table) {
     actions: []
   };
 }
-function convertColumn(name, column) {
+function convertColumn(name2, column) {
   const isDefaultFn = column.default !== void 0 && isFunctionDefault(column.default, column.type);
   return {
-    name,
-    columnName: name,
+    name: name2,
+    columnName: name2,
     type: column.type,
     nullable: column.primary_key ? false : column.nullable !== false,
     unique: column.unique === true,
@@ -5689,14 +7371,14 @@ function convertColumn(name, column) {
     deprecated: column.deprecated === true
   };
 }
-function convertLink(table, name, link) {
+function convertLink(table, name2, link) {
   if (link.to.includes(".")) {
     throw new OrmDefinitionError(
-      `link '${name}' on '${table}' targets '${link.to}' \u2014 cross-namespace links have no canonical v2 representation (links are namespace-local in v2)`
+      `link '${name2}' on '${table}' targets '${link.to}' \u2014 cross-namespace links have no canonical v2 representation (links are namespace-local in v2)`
     );
   }
   return {
-    name,
+    name: name2,
     kind: "toOne",
     target: link.to,
     on: link.on,
@@ -5725,29 +7407,29 @@ function buildRebaseJournalEntry({ namespace, previousHash, newHash, ordinal, sn
   if (!Number.isInteger(ordinal) || ordinal < 2) {
     throw new OrmDefinitionError(`rebase ordinal must be an integer \u2265 2 (a rebase sits on an existing journal tip); got ${ordinal}`);
   }
-  const name = migrationName(ordinal, newHash);
-  const sql5 = renderRebaseMigrationSql({ name, namespace, previousHash, newHash });
+  const name2 = migrationName(ordinal, newHash);
+  const sql7 = renderRebaseMigrationSql({ name: name2, namespace, previousHash, newHash });
   const snapshotText = `${JSON.stringify(snapshot, null, 2)}
 `;
   const entry = {
     ordinal,
-    name,
+    name: name2,
     content_hash: newHash,
     previous_content_hash: previousHash,
-    checksum: checksumOf(sql5),
+    checksum: checksumOf(sql7),
     snapshot_checksum: checksumOf(snapshotText),
     destructive: false
   };
-  return { name, entry, sql: sql5, snapshotText };
+  return { name: name2, entry, sql: sql7, snapshotText };
 }
 function renderRebaseMigrationSql({
-  name,
+  name: name2,
   namespace,
   previousHash,
   newHash
 }) {
   return [
-    `-- ${name}`,
+    `-- ${name2}`,
     `-- namespace: ${namespace}`,
     `-- content hash: ${newHash}`,
     `-- rebase: v1 definitions (${previousHash}) converted to canonical v2 \u2014 verified no-op, zero statements`,
@@ -5821,8 +7503,8 @@ function canonicalActions(value) {
   const entries = Object.entries(value);
   if (entries.length === 0) return void 0;
   return Object.fromEntries(
-    entries.map(([name, action]) => [
-      name,
+    entries.map(([name2, action]) => [
+      name2,
       {
         description: action["description"] ?? void 0,
         requires: action["requires"] ?? void 0,
@@ -5835,6 +7517,526 @@ function canonicalActions(value) {
     ])
   );
 }
+var IMPORT_CONFLICT_MODES = ["error", "skip", "update"];
+var columnMapSchema = zod.z.object({
+  /** ORM property name or Postgres column name. */
+  target: zod.z.string().min(1).max(63),
+  /** Column on the source relation. Identifiers only — never an expression. */
+  source: zod.z.string().min(1).max(63),
+  /**
+   * Used when the source value is NULL. Required columns without a database
+   * default fail the load if the source contains nulls and this is omitted.
+   */
+  nullDefault: zod.z.union([zod.z.string().max(1e4), zod.z.number(), zod.z.boolean()]).optional()
+}).strict();
+var importSpecSchema = zod.z.object({
+  table: zod.z.string().min(1).max(63),
+  from: zod.z.string().regex(QUALIFIED_TABLE_PATTERN),
+  columns: zod.z.array(columnMapSchema).min(1).max(500),
+  onConflict: zod.z.enum(IMPORT_CONFLICT_MODES).default("skip"),
+  batchSize: zod.z.number().int().min(1).max(2e4).default(5e3)
+}).strict();
+var UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+var DATE_RE = /^\d{4}-\d{2}-\d{2}$/;
+var TIMESTAMPTZ_RE = /^\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}:\d{2}(\.\d+)?(Z|[+-]\d{2}:?\d{2})$/;
+var INTEGER_RE = /^-?\d+$/;
+var NUMERIC_RE = /^-?\d+(\.\d+)?$/;
+function sourceSchemaAllowed(schema) {
+  return schema !== "information_schema" && !schema.startsWith("pg_");
+}
+function isRelationIdentifier(value) {
+  return value.length <= 63 && IDENTIFIER_PATTERN.test(value);
+}
+function isSourceColumn(value) {
+  return value.length <= 63 && COLUMN_IDENTIFIER_PATTERN.test(value);
+}
+function splitQualifiedRelation(from) {
+  const dot = from.indexOf(".");
+  if (dot <= 0 || dot !== from.lastIndexOf(".")) return null;
+  const schema = from.slice(0, dot);
+  const table = from.slice(dot + 1);
+  if (!isRelationIdentifier(schema) || !isRelationIdentifier(table)) return null;
+  return { schema, table };
+}
+function postgresTypeName(type) {
+  if (type === "double") return "double precision";
+  if (type === "timestamptz") return "timestamp with time zone";
+  return type;
+}
+function columnPostgresType(column, schemaName, enums) {
+  if (typeof column.type === "string") return postgresTypeName(column.type);
+  if (!enums.has(column.type.enum)) return null;
+  return `${quoteIdentifier(schemaName)}.${quoteIdentifier(column.type.enum)}`;
+}
+function quoteQualified(schema, table) {
+  return `${quoteIdentifier(schema)}.${quoteIdentifier(table)}`;
+}
+var INT4_MIN = -2147483648;
+var INT4_MAX = 2147483647;
+function resumeLiteralSql({
+  column,
+  after,
+  schemaName,
+  enums
+}) {
+  const coerced = coerceResumeValue(column, after);
+  if (!coerced.ok) return coerced;
+  return literalSql({ column, value: coerced.value, schemaName, enums });
+}
+function coerceResumeValue(column, after) {
+  const type = typeof column.type === "string" ? column.type : null;
+  if (type === "integer") {
+    if (!INTEGER_RE.test(after)) return { ok: false, error: `${column.name}: after must be an integer` };
+    const parsed = Number(after);
+    if (!Number.isSafeInteger(parsed) || parsed < INT4_MIN || parsed > INT4_MAX) {
+      return { ok: false, error: `${column.name}: after must be an integer` };
+    }
+    return { ok: true, value: parsed };
+  }
+  if (type === "boolean") {
+    if (after !== "true" && after !== "false") return { ok: false, error: `${column.name}: after must be true or false` };
+    return { ok: true, value: after === "true" };
+  }
+  return { ok: true, value: after };
+}
+function literalSql({
+  column,
+  value,
+  schemaName,
+  enums
+}) {
+  const label = column.name;
+  if (typeof value === "string" && value.includes("\0")) {
+    return { ok: false, error: `${label}: null default contains a NUL character` };
+  }
+  if (typeof column.type !== "string") {
+    const enumDef = enums.get(column.type.enum);
+    if (!enumDef) return { ok: false, error: `${label}: enum '${column.type.enum}' is not declared` };
+    if (typeof value !== "string" || !enumDef.values.includes(value)) {
+      return { ok: false, error: `${label}: null default must be one of ${enumDef.values.join(", ")}` };
+    }
+    const typeName = columnPostgresType(column, schemaName, enums);
+    return { ok: true, sql: `${quoteLiteral(value)}::${typeName}` };
+  }
+  return scalarLiteral2({ column, type: column.type, value, label });
+}
+var SCALAR_LITERALS = {
+  text: (value, label) => typeof value === "string" ? { ok: true, sql: quoteLiteral(value) } : { ok: false, error: `${label}: null default must be a string` },
+  uuid: (value, label) => typeof value === "string" && UUID_RE.test(value) ? { ok: true, sql: `${quoteLiteral(value)}::uuid` } : { ok: false, error: `${label}: null default must be a UUID` },
+  boolean: (value, label) => typeof value === "boolean" ? { ok: true, sql: value ? "TRUE" : "FALSE" } : { ok: false, error: `${label}: null default must be true or false` },
+  integer: (value, label) => typeof value === "number" && Number.isSafeInteger(value) ? { ok: true, sql: String(value) } : { ok: false, error: `${label}: null default must be an integer` },
+  bigint: (value, label) => typeof value === "string" && INTEGER_RE.test(value) ? { ok: true, sql: `${value}::bigint` } : { ok: false, error: `${label}: null default must be a base-10 integer string` },
+  numeric: numericLiteral,
+  double: numericLiteral,
+  date: (value, label) => typeof value === "string" && DATE_RE.test(value) ? { ok: true, sql: `${quoteLiteral(value)}::date` } : { ok: false, error: `${label}: null default must be a YYYY-MM-DD date` },
+  timestamptz: (value, label) => typeof value === "string" && TIMESTAMPTZ_RE.test(value) ? { ok: true, sql: `${quoteLiteral(value)}::${postgresTypeName("timestamptz")}` } : { ok: false, error: `${label}: null default must be an ISO-8601 timestamp` },
+  jsonb: jsonbLiteral
+};
+function numericLiteral(value, label) {
+  if (typeof value === "number" && Number.isFinite(value)) return { ok: true, sql: String(value) };
+  if (typeof value === "string" && NUMERIC_RE.test(value)) return { ok: true, sql: value };
+  return { ok: false, error: `${label}: null default must be a finite number` };
+}
+function scalarLiteral2({
+  column,
+  type,
+  value,
+  label
+}) {
+  const encode = SCALAR_LITERALS[type];
+  if (!encode) return { ok: false, error: `${column.name}: unsupported type '${type}'` };
+  return encode(value, label);
+}
+function jsonbLiteral(value, label) {
+  if (typeof value !== "string") return { ok: false, error: `${label}: null default must be a JSON string` };
+  try {
+    JSON.parse(value);
+  } catch {
+    return { ok: false, error: `${label}: null default must be valid JSON` };
+  }
+  return { ok: true, sql: `${quoteLiteral(value)}::jsonb` };
+}
+function dollarQuote(body) {
+  const digest = crypto.createHash("sha256").update(body).digest("hex");
+  const candidates = ["seq_orm_import", `seq_orm_${digest.slice(0, 16)}`, `seq_orm_${digest}`];
+  const tag = candidates.find((candidate) => !body.includes(`$${candidate}$`)) ?? `seq_orm_${digest}_body`;
+  return `$${tag}$${body}$${tag}$`;
+}
+
+// src/import/script.ts
+function renderImportScript({
+  namespace,
+  schemaName,
+  table,
+  source,
+  mapped,
+  primaryKey: primaryKey2,
+  onConflict,
+  batchSize,
+  omitted,
+  resume
+}) {
+  const sourceSql = `${quoteQualified(source.schema, source.table)} AS src`;
+  const targetSql = quoteQualified(schemaName, table.table);
+  const keys = primaryKey2.map((name2) => mapped.find((column) => column.column.columnName === name2)).filter((column) => column !== void 0);
+  const probeSql = renderProbe({ sourceSql, keys, mapped });
+  const procedure = renderProcedure({ targetSql, sourceSql, mapped, keys, onConflict, batchSize });
+  const call = `CALL pg_temp.seq_orm_import(${resume.join(", ")});`;
+  const omittedLine = omitted.length > 0 ? `-- Omitted columns keep their database default or NULL: ${omitted.join(", ")}` : "-- Every column is mapped.";
+  const text4 = [
+    "-- Sequence ORM data import",
+    `-- namespace: ${namespace}`,
+    `-- target: ${schemaName}.${table.table}`,
+    `-- source: ${source.schema}.${source.table}`,
+    `-- conflict: ${onConflict}`,
+    `-- batch size: ${batchSize}`,
+    "--",
+    "-- Runs as the namespace owner. Does not evaluate insert or update policies,",
+    "-- capability gates, or the operation journal. Sync the warehouse table into",
+    "-- this Postgres relation first, review the probe, then run the load.",
+    "-- skip and update are safe to re-run from the start after a failure. error stops on an existing key.",
+    "-- Each batch commits. Do not resume from the maximum key in the target:",
+    "-- a higher key that was already there would skip source rows this run never copied.",
+    "-- --after is only the last key this procedure committed. This script does not print it.",
+    omittedLine,
+    "-- cast_* columns force every mapped value through the target type. An invalid value aborts before any insert.",
+    "",
+    probeSql,
+    "",
+    procedure,
+    call,
+    ""
+  ].join("\n");
+  return { probeSql, text: text4 };
+}
+function renderProbe({
+  sourceSql,
+  keys,
+  mapped
+}) {
+  const nullKey = keys.map((key) => `${key.expression} IS NULL`).join(" OR ");
+  const distinct = keys.length === 1 ? keys[0].expression : `(${keys.map((key) => key.expression).join(", ")})`;
+  const requiredNulls = nullChecked(mapped, keys).map((column) => `count(*) FILTER (WHERE src.${quoteIdentifier(column.source)} IS NULL) AS ${quoteIdentifier(`null_${column.column.columnName}`)}`);
+  const selects = [
+    "count(*) AS source_rows",
+    `count(*) FILTER (WHERE ${nullKey}) AS null_primary_key`,
+    `count(*) FILTER (WHERE NOT (${nullKey})) - count(DISTINCT ${distinct}) AS duplicate_primary_key`,
+    ...requiredNulls,
+    ...mapped.map((column) => `count(${column.expression}) AS ${quoteIdentifier(`cast_${column.column.columnName}`)}`)
+  ];
+  return `SELECT
+  ${selects.join(",\n  ")}
+FROM ${sourceSql};`;
+}
+function renderProcedure({
+  targetSql,
+  sourceSql,
+  mapped,
+  keys,
+  onConflict,
+  batchSize
+}) {
+  const args = keys.map((key, index3) => `IN start_${index3} ${key.pgType} DEFAULT NULL`).join(", ");
+  const declarations = [
+    "DECLARE",
+    "  batch_scanned integer;",
+    "  batch_affected integer;",
+    "  total_rows bigint;",
+    "  null_keys bigint;",
+    "  distinct_keys bigint;",
+    ...keys.map((key, index3) => `  watermark_${index3} ${key.pgType};`),
+    ...requiredNullDeclarations(mapped, keys),
+    ...mapped.map((column) => `  cast_${column.column.columnName} bigint;`)
+  ];
+  const body = [
+    "BEGIN",
+    ...keys.map((_, index3) => `  watermark_${index3} := start_${index3};`),
+    `  ${renderGuard({ sourceSql, keys, mapped })}`,
+    "  LOOP",
+    `    ${renderPage({ targetSql, sourceSql, mapped, keys, onConflict, batchSize })}`,
+    "    EXIT WHEN batch_scanned = 0;",
+    "    RAISE NOTICE 'orm import scanned % affected %', batch_scanned, batch_affected;",
+    "    COMMIT;",
+    "  END LOOP;",
+    "END"
+  ].join("\n");
+  return [
+    `CREATE OR REPLACE PROCEDURE pg_temp.seq_orm_import(${args})`,
+    "LANGUAGE plpgsql",
+    `AS ${dollarQuote(`
+${declarations.join("\n")}
+${body}
+`)}`,
+    ";",
+    ""
+  ].join("\n");
+}
+function nullChecked(mapped, keys) {
+  return mapped.filter((column) => !column.fillsNull && column.column.nullable === false && !keys.includes(column));
+}
+function requiredNullDeclarations(mapped, keys) {
+  return nullChecked(mapped, keys).map((column) => `  null_${column.column.columnName} bigint;`);
+}
+function renderGuard({
+  sourceSql,
+  keys,
+  mapped
+}) {
+  const nullKey = keys.map((key) => `${key.expression} IS NULL`).join(" OR ");
+  const distinct = keys.length === 1 ? keys[0].expression : `(${keys.map((key) => key.expression).join(", ")})`;
+  const nullColumns = nullChecked(mapped, keys);
+  const into = [
+    "total_rows",
+    "null_keys",
+    "distinct_keys",
+    ...nullColumns.map((column) => `null_${column.column.columnName}`),
+    ...mapped.map((column) => `cast_${column.column.columnName}`)
+  ];
+  const selects = [
+    "count(*)::bigint",
+    `count(*) FILTER (WHERE ${nullKey})::bigint`,
+    `count(DISTINCT ${distinct})::bigint`,
+    ...nullColumns.map((column) => `count(*) FILTER (WHERE src.${quoteIdentifier(column.source)} IS NULL)::bigint`),
+    ...mapped.map((column) => `count(${column.expression})::bigint`)
+  ];
+  const checks = [
+    "IF null_keys > 0 THEN RAISE EXCEPTION 'import refused: source primary key has % null values', null_keys; END IF;",
+    "IF total_rows <> distinct_keys THEN RAISE EXCEPTION 'import refused: source primary key has % duplicate values', total_rows - distinct_keys; END IF;",
+    ...nullColumns.map(
+      (column) => `IF null_${column.column.columnName} > 0 THEN RAISE EXCEPTION 'import refused: source column ${column.source} is null on % rows and ${column.column.columnName} is required', null_${column.column.columnName}; END IF;`
+    )
+  ];
+  return [`SELECT ${selects.join(", ")}`, `    INTO ${into.join(", ")}`, `    FROM ${sourceSql};`, ...checks.map((check) => `  ${check}`)].join("\n");
+}
+function renderPage({
+  targetSql,
+  sourceSql,
+  mapped,
+  keys,
+  onConflict,
+  batchSize
+}) {
+  const keyExprs = keys.map((key) => key.expression);
+  const where = `watermark_0 IS NULL OR (${keyExprs.join(", ")}) > (${keys.map((_, index3) => `watermark_${index3}`).join(", ")})`;
+  const order = keyExprs.join(", ");
+  const pageColumns = mapped.map((column) => `${column.expression} AS ${quoteIdentifier(column.column.columnName)}`);
+  const insertColumns = mapped.map((column) => quoteIdentifier(column.column.columnName)).join(", ");
+  const conflict = conflictClause(onConflict, keys, mapped);
+  const keyOrder = keys.map((key) => `${quoteIdentifier(key.column.columnName)} DESC`).join(", ");
+  const lastKeys = keys.map((key) => `(SELECT ${quoteIdentifier(key.column.columnName)} FROM page ORDER BY ${keyOrder} LIMIT 1)`).join(", ");
+  const watermarkTargets = keys.map((_, index3) => `watermark_${index3}`).join(", ");
+  return [
+    "WITH page AS (",
+    `      SELECT ${pageColumns.join(", ")}`,
+    `      FROM ${sourceSql}`,
+    `      WHERE ${where}`,
+    `      ORDER BY ${order}`,
+    `      LIMIT ${batchSize}`,
+    "    ),",
+    "    ins AS (",
+    `      INSERT INTO ${targetSql} (${insertColumns})`,
+    `      SELECT ${insertColumns} FROM page`,
+    `      ${conflict}`,
+    "      RETURNING 1",
+    "    )",
+    `    SELECT (SELECT count(*)::int FROM page), (SELECT count(*)::int FROM ins), ${lastKeys}`,
+    `    INTO batch_scanned, batch_affected, ${watermarkTargets};`
+  ].join("\n");
+}
+function conflictClause(onConflict, keys, mapped) {
+  if (onConflict === "error") return "";
+  const target = keys.map((key) => quoteIdentifier(key.column.columnName)).join(", ");
+  if (onConflict === "skip") return `ON CONFLICT (${target}) DO NOTHING`;
+  const assignments = mapped.filter((column) => !keys.includes(column)).map((column) => `${quoteIdentifier(column.column.columnName)} = EXCLUDED.${quoteIdentifier(column.column.columnName)}`);
+  return `ON CONFLICT (${target}) DO UPDATE SET ${assignments.join(", ")}`;
+}
+
+// src/import/plan.ts
+function planTableImport({
+  definition,
+  spec,
+  after
+}) {
+  const parsedDefinition = canonicalDefinitionSchema.safeParse(definition);
+  if (!parsedDefinition.success) return { ok: false, errors: ["namespace definition is not canonical ORM v2"] };
+  const parsedSpec = importSpecSchema.safeParse(spec);
+  if (!parsedSpec.success) {
+    return { ok: false, errors: parsedSpec.error.issues.map((issue) => `${issue.path.join(".") || "spec"}: ${issue.message}`) };
+  }
+  return planParsed({ definition: parsedDefinition.data, spec: parsedSpec.data, after });
+}
+function planParsed({
+  definition,
+  spec,
+  after
+}) {
+  const source = splitQualifiedRelation(spec.from);
+  const target = resolveTarget(definition, spec.table);
+  const errors = [];
+  if (!source) errors.push(`from '${spec.from}' is not a schema.table identifier`);
+  else if (!sourceSchemaAllowed(source.schema)) errors.push(`from schema '${source.schema}' is not a warehouse relation`);
+  if (!target.table) errors.push(...target.errors);
+  if (!source || !target.table) return { ok: false, errors };
+  const schemaName = ormSchemaName(definition.namespace);
+  if (source.schema === schemaName && source.table === target.table.table) {
+    errors.push(`from '${spec.from}' is the import target`);
+  }
+  const enums = new Map(definition.enums.map((entry) => [entry.name, entry]));
+  const mapped = mapColumns({ table: target.table, spec, schemaName, enums, errors });
+  const primaryKey2 = target.table.primaryKey ?? [];
+  if (primaryKey2.length === 0) errors.push(`table '${target.table.table}' needs a primary key`);
+  for (const key of primaryKey2) {
+    if (!mapped.some((column) => column.column.columnName === key)) {
+      errors.push(`primary key column '${key}' must be mapped so existing identities are preserved`);
+    }
+  }
+  collectUnmapped({ table: target.table, mapped, errors });
+  if (spec.onConflict === "update" && mapped.every((column) => primaryKey2.includes(column.column.columnName))) {
+    errors.push('onConflict "update" needs a mapped column that is not part of the primary key');
+  }
+  const resume = resumeArguments({ mapped, primaryKey: primaryKey2, after, schemaName, enums, errors });
+  if (errors.length > 0) return { ok: false, errors };
+  const omitted = omittedColumns(target.table, mapped);
+  const script = renderImportScript({
+    namespace: definition.namespace,
+    schemaName,
+    table: target.table,
+    source,
+    mapped,
+    primaryKey: primaryKey2,
+    onConflict: spec.onConflict,
+    batchSize: spec.batchSize,
+    omitted,
+    resume
+  });
+  const warnings = [
+    "This load runs as the namespace owner. It does not evaluate insert or update policies.",
+    ...spec.onConflict === "error" ? ['onConflict "error" is not safe to re-run: the first existing key aborts the batch.'] : []
+  ];
+  return {
+    ok: true,
+    plan: { probeSql: script.probeSql, script: script.text, batchSize: spec.batchSize, onConflict: spec.onConflict, warnings }
+  };
+}
+function resolveTarget(definition, name2) {
+  const table = definition.tables.find((candidate) => candidate.table === name2);
+  if (!table) {
+    const view = definition.views?.find((candidate) => candidate.view === name2);
+    return { table: null, errors: [view ? `'${name2}' is a view, not an owned table` : `table '${name2}' is not in this namespace`] };
+  }
+  if (table.source !== void 0) return { table: null, errors: [`'${name2}' is a synced reflection and cannot be imported into`] };
+  if (table.internal || table.materializes !== void 0) {
+    return { table: null, errors: [`'${name2}' is an internal relation, not an import target`] };
+  }
+  return { table, errors: [] };
+}
+function mapColumns({
+  table,
+  spec,
+  schemaName,
+  enums,
+  errors
+}) {
+  const mapped = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const entry of spec.columns) {
+    const column = findColumn(table, entry.target);
+    if (column === "ambiguous") {
+      errors.push(`target '${entry.target}' matches more than one column`);
+      continue;
+    }
+    if (!column) {
+      errors.push(`target '${entry.target}' is not a column of '${table.table}'`);
+      continue;
+    }
+    if (column.cell !== void 0) {
+      errors.push(`target '${entry.target}' is cell metadata and cannot be imported`);
+      continue;
+    }
+    if (seen.has(column.columnName)) {
+      errors.push(`column '${column.columnName}' is mapped more than once`);
+      continue;
+    }
+    if (!isSourceColumn(entry.source)) {
+      errors.push(`source '${entry.source}' is not a column identifier`);
+      continue;
+    }
+    seen.add(column.columnName);
+    const pgType = columnPostgresType(column, schemaName, enums);
+    if (!pgType) {
+      errors.push(`column '${column.name}' references undeclared enum '${typeof column.type === "string" ? column.type : column.type.enum}'`);
+      continue;
+    }
+    const expression = valueExpression({ column, source: entry.source, pgType, nullDefault: entry.nullDefault, schemaName, enums, errors });
+    if (expression) mapped.push({ column, source: entry.source, expression, pgType, fillsNull: entry.nullDefault !== void 0 });
+  }
+  return mapped;
+}
+function findColumn(table, target) {
+  const matches = table.columns.filter((column) => column.name === target || column.columnName === target);
+  if (matches.length > 1) return "ambiguous";
+  return matches[0];
+}
+function valueExpression({
+  column,
+  source,
+  pgType,
+  nullDefault,
+  schemaName,
+  enums,
+  errors
+}) {
+  const cast = `CAST(src.${quoteIdentifier(source)} AS ${pgType})`;
+  if (nullDefault === void 0) return cast;
+  const literal2 = literalSql({ column, value: nullDefault, schemaName, enums });
+  if (!literal2.ok) {
+    errors.push(literal2.error);
+    return null;
+  }
+  return `COALESCE(${cast}, ${literal2.sql})`;
+}
+function collectUnmapped({
+  table,
+  mapped,
+  errors
+}) {
+  const mappedNames = new Set(mapped.map((column) => column.column.columnName));
+  const primaryKey2 = new Set(table.primaryKey ?? []);
+  for (const column of table.columns) {
+    if (mappedNames.has(column.columnName) || column.cell !== void 0) continue;
+    const hasDefault = column.default !== void 0 && column.default !== null || column.defaultFn !== void 0;
+    const required = column.nullable === false && !hasDefault && !primaryKey2.has(column.columnName);
+    if (required) {
+      errors.push(`column '${column.name}' is required and has no default \u2014 map it or set a database default before importing`);
+    }
+  }
+}
+function omittedColumns(table, mapped) {
+  const mappedNames = new Set(mapped.map((column) => column.column.columnName));
+  return table.columns.filter((column) => column.cell === void 0 && !mappedNames.has(column.columnName)).map((column) => column.columnName);
+}
+function resumeArguments({
+  mapped,
+  primaryKey: primaryKey2,
+  after,
+  schemaName,
+  enums,
+  errors
+}) {
+  if (after === void 0) return primaryKey2.map(() => "NULL");
+  if (primaryKey2.length !== 1) {
+    errors.push("after resumes a single-column primary key; re-run from the start for a composite key (skip and update are idempotent)");
+    return [];
+  }
+  const key = mapped.find((column) => column.column.columnName === primaryKey2[0]);
+  if (!key) return [];
+  const literal2 = resumeLiteralSql({ column: key.column, after, schemaName, enums });
+  if (!literal2.ok) {
+    errors.push(`after: ${literal2.error}`);
+    return [];
+  }
+  return [literal2.sql];
+}
 
 Object.defineProperty(exports, "capabilityPinsSchema", {
   enumerable: true,
@@ -5862,6 +8064,9 @@ exports.AUDIT_ACTIONS = AUDIT_ACTIONS;
 exports.CANONICAL_FORMAT = CANONICAL_FORMAT;
 exports.CAPABILITIES_CLAIM_KEY = CAPABILITIES_CLAIM_KEY;
 exports.CAPABILITY_KEY_PATTERN = CAPABILITY_KEY_PATTERN;
+exports.CELLS_FIELD = CELLS_FIELD;
+exports.CELL_PARTS = CELL_PARTS;
+exports.CELL_PART_SUFFIX = CELL_PART_SUFFIX;
 exports.CLAIMS_CONTRACT = CLAIMS_CONTRACT;
 exports.CLAIMS_SETTING = CLAIMS_SETTING;
 exports.CLAIM_KEY_PATTERN = CLAIM_KEY_PATTERN;
@@ -5871,22 +8076,28 @@ exports.COLUMN_DEFAULT_FNS = COLUMN_DEFAULT_FNS;
 exports.COLUMN_IDENTIFIER_PATTERN = COLUMN_IDENTIFIER_PATTERN;
 exports.COLUMN_TYPES = COLUMN_TYPES2;
 exports.COMPARE_OPS = COMPARE_OPS;
+exports.COMPOSED_IR_VERSION = COMPOSED_IR_VERSION;
 exports.CONSUMER_ROLE_SUFFIX = CONSUMER_ROLE_SUFFIX;
 exports.ColumnBuilder = ColumnBuilder;
 exports.DATE_BUCKETS = DATE_BUCKETS;
 exports.DEFINITION_FILE_EXTENSIONS = DEFINITION_FILE_EXTENSIONS;
 exports.ENUM_BRAND = ENUM_BRAND;
+exports.GUARDED_IR_VERSION = GUARDED_IR_VERSION;
 exports.HASH_DOMAIN = HASH_DOMAIN;
 exports.IDENTIFIER_PATTERN = IDENTIFIER_PATTERN;
 exports.IDENTIFIER_RE = IDENTIFIER_RE;
+exports.IMPORT_CONFLICT_MODES = IMPORT_CONFLICT_MODES;
 exports.INPUT_REF_KINDS = INPUT_REF_KINDS;
 exports.IR_VERSION = IR_VERSION;
 exports.IrVersionError = IrVersionError;
 exports.LEGACY_IR_VERSION = LEGACY_IR_VERSION;
 exports.LINK_BRAND = LINK_BRAND;
+exports.MATERIALIZE_ACTOR = MATERIALIZE_ACTOR;
+exports.MATERIALIZE_CLAIMS_JSON = MATERIALIZE_CLAIMS_JSON;
 exports.MAX_DEFINITION_FILE_BYTES = MAX_DEFINITION_FILE_BYTES;
 exports.MAX_GENERATED_SDL_BYTES = MAX_GENERATED_SDL_BYTES;
 exports.MAX_IDENTIFIER_LENGTH = MAX_IDENTIFIER_LENGTH;
+exports.MAX_TRACKED_COLUMN_NAME = MAX_TRACKED_COLUMN_NAME;
 exports.MIGRATIONS_DIRNAME = MIGRATIONS_DIRNAME;
 exports.NAMESPACE_CONFIG_BRAND = NAMESPACE_CONFIG_BRAND;
 exports.NAMESPACE_CONFIG_FILE = NAMESPACE_CONFIG_FILE;
@@ -5905,7 +8116,9 @@ exports.QUALIFIED_TABLE_PATTERN = QUALIFIED_TABLE_PATTERN;
 exports.RESERVED_COLUMN_NAMES = RESERVED_COLUMN_NAMES;
 exports.RESERVED_TABLE_NAMES = RESERVED_TABLE_NAMES;
 exports.ROLES_CLAIM_KEY = ROLES_CLAIM_KEY;
+exports.RUNTIME_SQL_IR_VERSION = RUNTIME_SQL_IR_VERSION;
 exports.SCHEMA_DIR = SCHEMA_DIR;
+exports.SQL_IR_VERSION = SQL_IR_VERSION;
 exports.STATEMENT_KINDS = STATEMENT_KINDS;
 exports.SYNCED_CONTRACT_HASH_DOMAIN = SYNCED_CONTRACT_HASH_DOMAIN;
 exports.SYNCED_SOURCE_PATTERN = SYNCED_SOURCE_PATTERN;
@@ -5943,6 +8156,7 @@ exports.canonicalViewSchema = canonicalViewSchema;
 exports.canonicalizeDefinition = canonicalizeDefinition;
 exports.capabilityExpression = capabilityExpression;
 exports.castParts = castParts;
+exports.cellColumnName = cellColumnName;
 exports.checksumOf = checksumOf;
 exports.claimExpression = claimExpression;
 exports.classifyDestructive = classifyDestructive;
@@ -5961,9 +8175,12 @@ exports.computeSyncedContractHash = computeSyncedContractHash;
 exports.consumerRoleName = consumerRoleName;
 exports.convertV1DefinitionToCanonical = convertV1DefinitionToCanonical;
 exports.createOrmMigrationExport = createOrmMigrationExport;
+exports.custom = custom;
 exports.declaredCapabilityKeys = declaredCapabilityKeys;
 exports.defineEnum = defineEnum;
 exports.defineNamespace = defineNamespace;
+exports.defineOperation = defineOperation;
+exports.defineResolvedTable = defineResolvedTable;
 exports.defineSyncedTable = defineSyncedTable;
 exports.defineTable = defineTable;
 exports.defineView = defineView;
@@ -5973,12 +8190,15 @@ exports.diffStatements = diffStatements;
 exports.emptyJournal = emptyJournal;
 exports.emptySnapshot = emptySnapshot;
 exports.endAuthoringContext = endAuthoringContext;
+exports.etlSource = etlSource;
 exports.extractNamedParams = extractNamedParams;
 exports.extractOrmSyncedTableContract = extractOrmSyncedTableContract;
 exports.generateNamespaceTypes = generateNamespaceTypes;
 exports.generateSnapshot = generateSnapshot;
 exports.generateSnapshotV2 = generateSnapshotV2;
+exports.highest = highest;
 exports.identifierSchema = identifierSchema;
+exports.importSpecSchema = importSpecSchema;
 exports.indexByHash = indexByHash;
 exports.isColumnBuilder = isColumnBuilder;
 exports.isEnumRef = isEnumRef;
@@ -5990,17 +8210,26 @@ exports.isSeqLink = isSeqLink;
 exports.isSeqNamespaceConfig = isSeqNamespaceConfig;
 exports.isSeqTable = isSeqTable;
 exports.isSeqView = isSeqView;
+exports.latest = latest;
 exports.limitIrSchema = limitIrSchema;
 exports.loadCommittedMigrations = loadCommittedMigrations;
 exports.loadCommittedTipMigration = loadCommittedTipMigration;
 exports.loadNamespaceDefinition = loadNamespaceDefinition;
 exports.loadNamespaceFromDir = loadNamespaceFromDir;
+exports.lowest = lowest;
+exports.managedFn = managedFn;
+exports.manualSource = manualSource;
+exports.materializeLockKey = materializeLockKey;
+exports.materializedRefreshFunctionName = materializedRefreshFunctionName;
 exports.migrationName = migrationName;
 exports.namespaceConfigSchema = namespaceConfigSchema;
 exports.namespaceSchema = namespaceSchema;
+exports.nonNullFirst = nonNullFirst;
 exports.normalizeCanonical = normalizeCanonical;
 exports.normalizeIr = normalizeIr;
 exports.normalizeSnapshot = normalizeSnapshot;
+exports.objectRef = objectRef;
+exports.ontologyContractSchema = ontologyContractSchema;
 exports.orderIrSchema = orderIrSchema;
 exports.ormMigrationExportSchema = ormMigrationExportSchema;
 exports.ormSchemaName = ormSchemaName;
@@ -6014,16 +8243,22 @@ exports.parseTableFile = parseTableFile;
 exports.parsedPredicateSchema = parsedPredicateSchema;
 exports.pendingKitStatements = pendingKitStatements;
 exports.pendingKitStatementsV2 = pendingKitStatementsV2;
+exports.planCommittedMigrationV2 = planCommittedMigrationV2;
 exports.planMigration = planMigration;
 exports.planMigrationV2 = planMigrationV2;
+exports.planTableImport = planTableImport;
 exports.policyExpressionSchema = policyExpressionSchema;
 exports.policyVariantSchema = policyVariantSchema;
 exports.predIrSchema = predIrSchema;
 exports.predicateOperands = predicateOperands;
+exports.prefetchPlanIrSchema = prefetchPlanIrSchema;
+exports.prefetchSource = prefetchSource;
+exports.priority = priority;
 exports.quoteIdentifier = quoteIdentifier;
 exports.quoteLiteral = quoteLiteral;
 exports.readMigrationSql = readMigrationSql;
 exports.readMigrationWorkspace = readMigrationWorkspace;
+exports.readOntologyContract = readOntologyContract;
 exports.readSnapshot = readSnapshot;
 exports.rebaseViolations = rebaseViolations;
 exports.referencedCapabilities = referencedCapabilities;
@@ -6031,6 +8266,8 @@ exports.referencedColumns = referencedColumns;
 exports.renderMigrationSql = renderMigrationSql;
 exports.renderOrmMigrationExport = renderOrmMigrationExport;
 exports.requiredArtifactIrVersion = requiredArtifactIrVersion;
+exports.resolvedMetaIrSchema = resolvedMetaIrSchema;
+exports.resolvedSourceIrSchema = resolvedSourceIrSchema;
 exports.revertOverlayMutation = revertOverlayMutation;
 exports.rewriteSyncedSourceRelationsInViewQuery = rewriteSyncedSourceRelationsInViewQuery;
 exports.roleExpression = roleExpression;
@@ -6053,6 +8290,7 @@ exports.toMany = toMany;
 exports.toOne = toOne;
 exports.toPlatformUser = toPlatformUser;
 exports.typesInterfaceName = typesInterfaceName;
+exports.validateNamespaceCatalog = validateNamespaceCatalog;
 exports.validateViewCatalogStatement = validateViewCatalogStatement;
 exports.valueIrSchema = valueIrSchema;
 exports.variableDefaultIrSchema = variableDefaultIrSchema;