@sequenceholdings/orm 2.1.0 → 2.2.0

package/dist/index.js

@@ -1,7 +1,7 @@
 import { sql, eq, notExists, is, SQL } from 'drizzle-orm';
-import { pgSchema, uniqueIndex, index, foreignKey, primaryKey, PgDialect, QueryBuilder, getViewConfig, extractUsedTable, jsonb, date, timestamp, boolean, doublePrecision, numeric, bigint, integer, text, uuid } from 'drizzle-orm/pg-core';
-import { createHash } from 'crypto';
+import { pgSchema, uniqueIndex, index, foreignKey, check, primaryKey, getTableConfig, PgDialect, QueryBuilder, getViewConfig, extractUsedTable, jsonb, date, timestamp, boolean, doublePrecision, numeric, bigint, integer, text, uuid } from 'drizzle-orm/pg-core';
 import { z } from 'zod';
+import { createHash } from 'crypto';
 import { createJiti } from 'jiti';
 import { realpath, stat, readdir, readFile, mkdir, writeFile } from 'fs/promises';
 import { createRequire } from 'module';
@@ -38,7 +38,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. */
@@ -98,6 +99,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;
@@ -126,6 +132,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;
   }
 };
@@ -149,15 +156,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}`;
@@ -170,6 +177,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 {
@@ -237,6 +265,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,
@@ -245,6 +276,8 @@ function toOne(target, options) {
     on: options.on,
     references: options.references,
     enforce: options.enforce ?? false,
+    onDelete: options.onDelete,
+    onUpdate: options.onUpdate,
     description: options.description
   };
 }
@@ -256,6 +289,8 @@ function toMany(target, options) {
     on: options.on,
     references: options.references,
     enforce: false,
+    onDelete: void 0,
+    onUpdate: void 0,
     description: options.description
   };
 }
@@ -267,6 +302,8 @@ function toPlatformUser(options) {
     on: options.on,
     references: options.references,
     enforce: false,
+    onDelete: void 0,
+    onUpdate: void 0,
     description: options.description
   };
 }
@@ -284,45 +321,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
     );
   }
@@ -332,21 +375,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
       );
     }
@@ -357,13 +400,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
       );
     }
@@ -375,7 +418,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,
@@ -384,26 +427,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;
 }
@@ -411,52 +454,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) => uuid(name),
-  text: (name) => text(name),
-  integer: (name) => integer(name),
-  bigint: (name) => bigint(name, { mode: "bigint" }),
-  numeric: (name) => numeric(name),
-  double: (name) => doublePrecision(name),
-  boolean: (name) => boolean(name),
-  timestamptz: (name) => timestamp(name, { withTimezone: true }),
-  date: (name) => date(name),
-  jsonb: (name) => jsonb(name)
+  uuid: (name2) => uuid(name2),
+  text: (name2) => text(name2),
+  integer: (name2) => integer(name2),
+  bigint: (name2) => bigint(name2, { mode: "bigint" }),
+  numeric: (name2) => numeric(name2),
+  double: (name2) => doublePrecision(name2),
+  boolean: (name2) => boolean(name2),
+  timestamptz: (name2) => timestamp(name2, { withTimezone: true }),
+  date: (name2) => date(name2),
+  jsonb: (name2) => jsonb(name2)
 };
 function compileViewQueries(input) {
   const schemaName = `orm_${input.namespace}`;
@@ -512,9 +555,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
         );
       }
@@ -548,11 +591,11 @@ function compileViewQueries(input) {
       );
     }
     if (!config.query) throw new OrmDefinitionError(`view "${authored.viewName}" produced no query`, authored.file);
-    const tableDependencies = extractUsedTable(config.query).map((physical) => {
-      const logical = physicalToLogical.get(physical);
+    const tableDependencies = 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
         );
       }
@@ -705,8 +748,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({
@@ -725,7 +768,7 @@ function overrideRowMutation(input) {
   });
   return {
     kind: "override",
-    name,
+    name: name2,
     synced: synced.tableName,
     pk,
     copy: [pk, ...sharedProperties],
@@ -734,23 +777,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`
     );
   }
 }
@@ -876,9 +919,495 @@ function scalarColumnType(table, property, helper) {
   }
   return type;
 }
+var objectRef2 = 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 = z.string().max(255).regex(/^[a-z][a-z0-9-]*$/, "Expected a function slug");
+var refs = (schema) => z.array(schema).max(256).refine(
+  (values) => new Set(values).size === values.length,
+  "Duplicate dependency reference"
+).default([]);
+var ontologyContractSchema = z.strictObject({
+  version: 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 = z.object({
+  /** Claims-only guard (capability()/role()/claim() comparisons — no columns). */
+  when: z.string().min(1).max(1e3),
+  /** Exactly one of: allow-all bypass, or a row predicate. */
+  allow: z.literal(true).optional(),
+  policy: 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 = z.union([
+  z.string().min(1).max(2e3),
+  z.object({
+    default: z.string().min(1).max(2e3),
+    variants: 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 = z.string().min(1).max(63).regex(/^[a-z][a-z0-9_]*$/);
+var durationMs = 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 = z.object({
+  /** `managed` = a Managed Function id/slug; `native` = an in-process Atlas function (reserved). */
+  kind: z.enum(["managed", "native"]),
+  id: z.string().min(1).max(200)
+}).strict();
+var canonicalFetchShapeSchema = z.union([
+  z.object({ shape: z.literal("single") }).strict(),
+  z.object({ shape: z.literal("batch"), maxKeys: z.number().int().min(2).max(500) }).strict()
+]);
+var canonicalResolvedSourceSchema = z.object({
+  name: identifier,
+  kind: 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: z.array(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: z.string().min(1).max(63).optional(),
+  /** prefetch: resolved column holding the source system's key (may be the primary key). */
+  key: z.string().min(1).max(63).optional(),
+  fetch: canonicalFetchShapeSchema.optional(),
+  function: canonicalFunctionRefSchema.optional(),
+  prefetchDefaults: z.object({
+    maxStalenessMs: durationMs,
+    timeoutMs: durationMs,
+    onError: z.enum(["fallback", "fail"])
+  }).strict().optional(),
+  writeback: z.object({
+    columns: z.array(z.string().min(1).max(63)).min(1).max(500),
+    defaultMode: z.enum(["sync", "async"]),
+    timeoutMs: durationMs,
+    /** Remove confirmed cells from the manual source so a stale edit cannot shadow the source. */
+    clearManualOnConfirm: z.boolean()
+  }).strict().optional()
+}).strict();
+var canonicalResolveRuleSchema = z.object({
+  column: z.string().min(1).max(63),
+  comparator: z.enum(COMPARATORS),
+  /** Source names, in tie-break order. */
+  candidates: z.array(identifier).min(1).max(16),
+  /** custom only: SQL ORDER BY key over value / updated_at / source / actor / ord. */
+  orderBy: z.string().min(1).max(2e3).optional()
+}).strict();
+var canonicalResolvedSchema = z.object({
+  sources: z.array(canonicalResolvedSourceSchema).min(1).max(16),
+  /** One rule per resolved (non-pk) column; documents the generated view for tooling. */
+  resolve: z.array(canonicalResolveRuleSchema).max(500),
+  /** Sources whose tombstone hides the resolved row (v1: the manual source only). */
+  deletedBy: 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: z.object({ table: identifier, compute: identifier }).strict().optional(),
+  /** Write policies evaluated against the RESOLVED row (reads use the view's read policy). */
+  policies: 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 = z.string().min(1).max(63).regex(IDENTIFIER_RE);
+var identifier2 = z.string().min(1).max(63).regex(IDENTIFIER_RE);
 var columnIdentifier = z.string().min(1).max(63).regex(COLUMN_IDENTIFIER_PATTERN);
 var COLUMN_TYPES = [
   "uuid",
@@ -894,14 +1423,14 @@ var COLUMN_TYPES = [
 ];
 var columnTypeSchema = z.enum(COLUMN_TYPES);
 var canonicalEnumSchema = z.object({
-  name: identifier,
+  name: identifier2,
   values: z.array(z.string().min(1).max(63)).min(1).max(100)
 });
 var canonicalColumnSchema = z.object({
   /** Property name in TS (camelCase); columnName is the Postgres name. */
   name: z.string().min(1).max(63),
   columnName: columnIdentifier,
-  type: z.union([columnTypeSchema, z.object({ enum: identifier })]),
+  type: z.union([columnTypeSchema, z.object({ enum: identifier2 })]),
   nullable: z.boolean().default(true),
   unique: z.boolean().default(false),
   /** Literal default, or one of the allowlisted SQL functions. */
@@ -917,7 +1446,14 @@ var canonicalColumnSchema = z.object({
   /** Migration hints — same semantics as v1. */
   renamedFrom: columnIdentifier.optional(),
   cast: z.string().max(200).optional(),
-  deprecated: z.boolean().default(false)
+  deprecated: 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: z.object({ of: z.string().min(1).max(63), part: 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") {
@@ -932,36 +1468,28 @@ var canonicalLinkSchema = z.object({
   name: z.string().min(1).max(63),
   kind: 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: z.boolean().default(false),
+  onDelete: z.enum(["cascade", "restrict", "no action", "set null", "set default"]).optional(),
+  onUpdate: z.enum(["cascade", "restrict", "no action", "set null", "set default"]).optional(),
   description: z.string().max(500).optional()
 });
 var canonicalIndexSchema = z.object({
   columns: z.array(columnIdentifier).min(1),
   unique: z.boolean().default(false),
-  name: identifier.optional()
-});
-var policyVariantSchema = z.object({
-  /** Claims-only guard (capability()/role()/claim() comparisons — no columns). */
-  when: z.string().min(1).max(1e3),
-  /** Exactly one of: allow-all bypass, or a row predicate. */
-  allow: z.literal(true).optional(),
-  policy: 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 = z.union([
-  z.string().min(1).max(2e3),
-  z.object({
-    default: z.string().min(1).max(2e3),
-    variants: z.array(policyVariantSchema).max(10).default([])
-  })
-]);
+var canonicalCheckSchema = z.object({
+  name: identifier2,
+  expression: z.string().min(1).max(2e3)
+}).strict();
 var canonicalPoliciesSchema = z.object({
   read: policyExpressionSchema.optional(),
   write: policyExpressionSchema.optional(),
@@ -1149,7 +1677,7 @@ var VIEW_QUERY_FUNCTION_ALLOWLIST = [
   "width_bucket"
 ];
 var canonicalActionSchema = z.object({
-  name: identifier,
+  name: identifier2,
   requires: z.string().max(1e3).optional(),
   params: z.record(z.string(), z.object({
     type: columnTypeSchema,
@@ -1161,9 +1689,9 @@ var canonicalActionSchema = z.object({
 });
 var canonicalCowMutationSchema = z.object({
   kind: 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: z.string().min(1).max(63),
   /** Override: contract properties copied INSERT…SELECT from synced (pk included). Empty for revert. */
@@ -1191,23 +1719,28 @@ var canonicalCowMutationSchema = z.object({
   }
 });
 var canonicalForeignKeySchema = z.object({
-  name: identifier,
+  name: identifier2,
   columns: z.array(columnIdentifier).min(1).max(8),
-  target: identifier,
+  target: identifier2,
   references: z.array(columnIdentifier).min(1).max(8),
-  deferrable: z.enum(["initially-immediate", "initially-deferred"]).optional()
+  deferrable: z.enum(["initially-immediate", "initially-deferred"]).optional(),
+  onDelete: z.enum(["cascade", "restrict", "no action", "set null", "set default"]).optional(),
+  onUpdate: z.enum(["cascade", "restrict", "no action", "set null", "set default"]).optional()
 }).strict();
 var canonicalTableSchema = z.object({
-  table: identifier,
+  table: identifier2,
+  displayName: z.string().trim().min(1).max(120).optional(),
   description: 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: z.string().regex(/^gold\.[a-z][a-z0-9_]*$/).optional(),
+  renamedFrom: identifier2.optional(),
+  /** Synced/reflected read-only tables (`source: schema.table`) — v1 semantics. */
+  source: z.string().regex(QUALIFIED_TABLE_PATTERN).optional(),
   columns: z.array(canonicalColumnSchema).default([]),
   primaryKey: z.array(columnIdentifier).min(1).max(8).optional(),
   links: z.array(canonicalLinkSchema).default([]),
   indexes: z.array(canonicalIndexSchema).default([]),
+  /** Omitted by old definitions, preserving their existing content hashes. */
+  checks: z.array(canonicalCheckSchema).max(100).optional(),
   policies: canonicalPoliciesSchema.default({}),
   /**
    * v1-conversion carry-over only. v2 has no action surface — the runtime
@@ -1218,22 +1751,55 @@ var canonicalTableSchema = z.object({
   /** Optional (not defaulted) so pre-CoW canonical documents keep byte-identical hashes. */
   cowMutations: z.array(canonicalCowMutationSchema).optional(),
   /** Omitted by old definitions, preserving their existing content hashes. */
-  foreignKeys: z.array(canonicalForeignKeySchema).max(100).optional()
+  foreignKeys: 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: 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: 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 = z.object({
-  view: identifier,
+  view: identifier2,
   description: z.string().max(2e3).optional(),
   columns: z.array(canonicalColumnSchema).min(1),
   /** Logical identity for GraphQL only; PostgreSQL views have no PK constraint. */
   primaryKey: z.array(columnIdentifier).min(1).max(8).optional(),
   links: z.array(canonicalLinkSchema).default([]),
   policies: z.object({ read: policyExpressionSchema }).strict(),
-  query: z.string().min(1).max(1e5).refine(isSingleViewQuerySql, {
+  query: 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: z.array(identifier).max(500)
+  dependencies: 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: 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` });
@@ -1248,20 +1814,91 @@ var canonicalViewSchema = 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 = 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 = z.union([z.literal(true), z.object({ capability: z.string().min(1) }).strict(), z.object({ role: z.string().min(1) }).strict()]);
+var relationExportSchema = z.object({ read: exportGateSchema, write: exportGateSchema.optional() }).strict();
+var localDefinitionSchema = z.object({
   definition_format: z.literal(CANONICAL_FORMAT),
-  namespace: identifier.max(41),
+  namespace: identifier2.max(41),
   description: z.string().max(2e3).optional(),
   enums: z.array(canonicalEnumSchema).default([]),
   tables: z.array(canonicalTableSchema).min(0).max(500),
   /** Optional to preserve byte-identical hashes for pre-view canonical v2 documents. */
   views: z.array(canonicalViewSchema).max(500).optional(),
+  /** Target-owned cross-namespace access contract, using existing namespace grants. */
+  exports: z.record(identifier2, relationExportSchema).optional(),
   /** Verbatim custom-roles grammar (@sequenceholdings/custom-roles-manifest). */
   capabilities: z.object({
     roles: z.unknown().optional(),
@@ -1274,6 +1911,7 @@ var canonicalDefinitionSchema = 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) {
@@ -1287,12 +1925,41 @@ var canonicalDefinitionSchema = 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}'`);
@@ -1304,16 +1971,24 @@ var canonicalDefinitionSchema = 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 ?? [];
@@ -1408,27 +2083,31 @@ var canonicalDefinitionSchema = 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: z.array(localDefinitionSchema).max(32).optional()
+});
 function canonicalRelations(definition) {
   const views = (definition.views ?? []).map((view) => ({
     table: view.view,
@@ -1437,8 +2116,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));
 }
@@ -1448,13 +2131,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) } : {}
       };
@@ -1467,7 +2151,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 = getTableConfig(relation(plan.plans[0].table)).schema;
+  const keyBranches = plan.plans.map((source) => {
+    const where = source.kind === "prefetch" ? sql.raw(` WHERE NOT ${ident(tombstoned2)}`) : sql.raw("");
+    const sourcePk = ident(physical({ source, property: plan.pk }));
+    const selectedPk = sourcePk === ident(pkColumn) ? sourcePk : `${sourcePk} AS ${ident(pkColumn)}`;
+    return sql`SELECT ${sql.raw(selectedPk)} FROM ${relation(source.table)}${where}`;
+  });
+  const joins = plan.plans.map(
+    (source) => sql` LEFT JOIN ${relation(source.table)} AS ${sql.raw(alias(source.name))} ON ${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 ? [sql.raw(cell.lateral)] : []);
+  const from = sql.join([sql`(${sql.join(keyBranches, sql.raw(" UNION "))}) AS "k"`, ...joins, ...laterals], sql.raw(""));
+  const selected = {
+    [plan.pk]: 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] = sql.raw(cell.value).as(columnName);
+    for (const [part, expression] of Object.entries(cell.parts)) {
+      selected[cellColumnName(property, part)] = 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] = sql.raw(`${alias(manual.name)}.${ident(RESOLVED_SOURCE_SYSTEM_COLUMNS.writebackStatus.columnName)}`).as(system.writebackStatus.columnName);
+  selected[system.writebackError.name] = 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(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,
+        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);
@@ -1499,8 +2636,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,
@@ -1554,6 +2691,72 @@ function computeDefinitionHash(definition) {
   return 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) {
@@ -1569,14 +2772,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) {
@@ -1602,15 +2818,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) {
@@ -1651,6 +2867,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);
@@ -1660,7 +2878,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 createHash("sha256").update(HASH_DOMAIN).update(stableJson(definition)).digest("hex");
@@ -1674,10 +2894,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`,
@@ -1715,6 +2939,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(
@@ -1728,9 +2957,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);
       } });
@@ -1740,10 +2990,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" }))
@@ -1839,7 +3094,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({
@@ -1856,6 +3137,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 {
@@ -1867,6 +3151,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)) {
@@ -1884,6 +3181,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 } : {}
   };
 }
@@ -1921,11 +3220,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) {
@@ -1971,8 +3270,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 }
       ])
     ),
@@ -1993,7 +3292,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) {
@@ -2140,6 +3439,53 @@ function purgeModuleCache(root) {
     if (key.startsWith(prefix)) delete require2.cache[key];
   }
 }
+var sqlScalarSchema = z.enum(["text", "boolean", "integer", "bigint", "numeric", "double", "uuid", "date", "timestamptz"]);
+var name = z.string().regex(/^[A-Za-z_][A-Za-z0-9_]*$/).max(63).refine((value) => !["__proto__", "prototype", "constructor"].includes(value), "reserved name");
+var base = z.object({
+  name,
+  namespace: name,
+  language: z.literal("sql"),
+  kind: z.literal("query"),
+  requires: z.object({ capability: z.string().min(1).max(128) }).strict(),
+  ontology: z.object({ read: z.array(z.string().regex(/^[A-Za-z_][A-Za-z0-9_]*\/[A-Za-z_][A-Za-z0-9_]*$/)).min(1).max(256) }).strict(),
+  maxRows: z.number().int().min(1).max(1e4).default(1e3)
+});
+var fixed = base.extend({
+  parameters: z.record(name, z.object({ type: sqlScalarSchema, required: z.boolean().default(true) }).strict()).default({}),
+  sql: z.string().min(1).max(65536)
+}).strict();
+var runtime = base.extend({ mode: z.literal("runtime") }).strict();
+var sqlOperationDefinitionSchema = 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 = {
@@ -2171,9 +3517,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("  }");
   }
@@ -2184,8 +3530,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;
@@ -2193,17 +3539,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("; ")} }> }`;
 }
@@ -2217,9 +3563,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
@@ -2337,7 +3683,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) {
@@ -2411,7 +3757,7 @@ function readString(source, start) {
   }
   throw new PredicateParseError("unterminated string literal", start);
 }
-var Parser = class {
+var Parser2 = class {
   constructor(tokens) {
     this.tokens = tokens;
   }
@@ -2543,7 +3889,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
@@ -2628,8 +3974,8 @@ var actionSchema = 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)];
 }
@@ -2684,7 +4030,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;
 }
@@ -2696,17 +4042,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 = {
   "=": "=",
@@ -2770,24 +4105,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 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);
@@ -2833,10 +4168,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(
@@ -2852,10 +4189,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":
@@ -2899,11 +4237,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);
@@ -2939,22 +4277,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;
@@ -2975,9 +4313,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(", ");
@@ -2997,7 +4335,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$`
   ) : (
@@ -3011,7 +4349,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
@@ -3023,13 +4361,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;`
     );
   }
@@ -3081,7 +4419,7 @@ var tableFileSchema = z.strictObject({
   table: identifierSchema,
   description: z.string().optional(),
   columns: z.record(identifierSchema, columnSchema).optional(),
-  source: z.string().regex(SYNCED_SOURCE_PATTERN, "source must reference a gold-layer table").optional(),
+  source: z.string().regex(SYNCED_SOURCE_PATTERN, "source must be a qualified lowercase schema.table identifier").optional(),
   links: z.record(identifierSchema, linkSchema).optional(),
   indexes: z.array(indexSchema).optional(),
   policies: policiesSchema.optional(),
@@ -3090,12 +4428,12 @@ var tableFileSchema = 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]
       });
     }
   }
@@ -3128,41 +4466,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);
@@ -3170,10 +4508,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) {
@@ -3183,27 +4521,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"]
       });
     }
   }
@@ -3228,22 +4566,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"]
       });
     }
   }
@@ -3258,32 +4596,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]
       });
     }
   }
@@ -3335,14 +4673,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;
 }
@@ -3376,7 +4714,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) {
@@ -3428,8 +4766,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),
@@ -3439,12 +4777,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}`
@@ -3460,14 +4805,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;
     }
   }
@@ -3506,8 +4851,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}`);
@@ -3515,21 +4860,21 @@ function syncedBackingRevokeStatements({
   return statements;
 }
 var FACTORIES = {
-  uuid: (name) => uuid(name),
-  text: (name) => text(name),
-  integer: (name) => integer(name),
+  uuid: (name2) => uuid(name2),
+  text: (name2) => text(name2),
+  integer: (name2) => 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) => bigint(name, { mode: "bigint" }),
-  numeric: (name) => numeric(name),
-  double: (name) => doublePrecision(name),
-  boolean: (name) => boolean(name),
-  timestamptz: (name) => timestamp(name, { withTimezone: true }),
-  date: (name) => date(name),
-  jsonb: (name) => jsonb(name)
+  bigint: (name2) => bigint(name2, { mode: "bigint" }),
+  numeric: (name2) => numeric(name2),
+  double: (name2) => doublePrecision(name2),
+  boolean: (name2) => boolean(name2),
+  timestamptz: (name2) => timestamp(name2, { withTimezone: true }),
+  date: (name2) => date(name2),
+  jsonb: (name2) => 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();
@@ -3560,7 +4905,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),
@@ -3570,21 +4915,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 ? uniqueIndex(name) : index(name);
+    const name2 = indexName(table.table, definition);
+    const factory = definition.unique ? uniqueIndex(name2) : 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 foreignKey({
-      name: foreignKeyName(table.table, name),
+      name: foreignKeyName(table.table, name2),
       columns: [self[link.on]],
       foreignColumns: [targetColumn]
     });
@@ -3641,21 +4986,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`
       );
     }
   }
@@ -3674,33 +5019,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;
         }
@@ -3717,22 +5062,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) => uuid(name),
-  text: (name) => text(name),
-  integer: (name) => integer(name),
+  uuid: (name2) => uuid(name2),
+  text: (name2) => text(name2),
+  integer: (name2) => 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) => bigint(name, { mode: "bigint" }),
-  numeric: (name) => numeric(name),
-  double: (name) => doublePrecision(name),
-  boolean: (name) => boolean(name),
-  timestamptz: (name) => timestamp(name, { withTimezone: true }),
-  date: (name) => date(name),
-  jsonb: (name) => jsonb(name)
+  bigint: (name2) => bigint(name2, { mode: "bigint" }),
+  numeric: (name2) => numeric(name2),
+  double: (name2) => doublePrecision(name2),
+  boolean: (name2) => boolean(name2),
+  timestamptz: (name2) => timestamp(name2, { withTimezone: true }),
+  date: (name2) => date(name2),
+  jsonb: (name2) => 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);
@@ -3829,18 +5258,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 === "-") {
@@ -3860,7 +5289,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" };
@@ -3879,9 +5308,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] ?? "" };
@@ -3913,8 +5342,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;
         }
@@ -3936,7 +5365,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;
@@ -3980,15 +5409,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;
   });
@@ -3999,16 +5428,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 = 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()])
       )
@@ -4032,9 +5463,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;
@@ -4048,15 +5479,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$1) => check(check$1.name, sql.raw(compileCheckExpression(check$1.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 foreignKey({
+      let constraint = 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();
@@ -4116,8 +5551,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 ? uniqueIndex(name) : index(name);
+    const name2 = indexName(table.table, definition);
+    const factory = definition.unique ? uniqueIndex(name2) : index(name2);
     const columns = definition.columns.map((column) => self[column]);
     return factory.on(...columns);
   });
@@ -4147,11 +5582,14 @@ function buildForeignKeys2(table, self, built, byName) {
         `enforced link '${link.name}' on '${table.table}' references unknown column '${targetColumn ? link.on : referencedColumn}'`
       );
     }
-    return foreignKey({
+    let constraint = 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;
@@ -4193,33 +5631,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;
         }
@@ -4230,8 +5668,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)) {
@@ -4272,9 +5710,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);
@@ -4292,14 +5744,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({
@@ -4316,16 +5775,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 };
 }
@@ -4348,9 +5812,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,
@@ -4369,9 +5833,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);
@@ -4479,30 +5943,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;
       }
     }
@@ -4513,13 +6058,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;
@@ -4537,18 +6082,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;
 }
@@ -4739,15 +6284,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 };
 }
@@ -4794,9 +6339,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 = z.union([z.literal(LEGACY_IR_VERSION), 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 = z.union([z.literal(LEGACY_IR_VERSION), z.literal(GUARDED_IR_VERSION), z.literal(COMPOSED_IR_VERSION), z.literal(SQL_IR_VERSION), z.literal(RUNTIME_SQL_IR_VERSION)]);
 var operationVersionSchema = z.object({ irVersion: irVersionSchema });
 function requiredArtifactIrVersion(operations) {
   let required = LEGACY_IR_VERSION;
@@ -4848,8 +6397,8 @@ var predIrSchema = z.lazy(
       value: z.number(),
       where: predIrSchema.optional()
     }),
-    z.object({ kind: z.literal("capability"), key: z.string() }),
-    z.object({ kind: z.literal("role"), key: z.string() }),
+    z.object({ kind: z.literal("capability"), key: z.string(), namespace: z.string().optional() }),
+    z.object({ kind: z.literal("role"), key: z.string(), namespace: z.string().optional() }),
     z.object({ kind: z.literal("dynamicFilter"), slot: z.string() }),
     z.object({ kind: z.literal("const"), value: z.boolean() })
   ])
@@ -4877,6 +6426,21 @@ var selectionIrSchema = z.lazy(
   () => z.object({
     typename: z.string(),
     columns: z.array(z.object({ alias: z.string(), column: z.string() })),
+    cells: z.object({
+      alias: z.string(),
+      typename: z.string(),
+      fields: z.array(z.object({
+        alias: z.string(),
+        column: z.string(),
+        typename: z.string(),
+        parts: z.array(z.object({
+          alias: z.string(),
+          part: z.enum(["source", "at", "by", "conflicts"]),
+          fields: z.array(z.object({ alias: z.string(), field: z.enum(["source", "at", "value"]) })).optional(),
+          typename: z.string().optional()
+        }))
+      }))
+    }).optional(),
     relations: z.array(z.object({
       alias: z.string(),
       link: z.string(),
@@ -4898,6 +6462,11 @@ var selectionIrSchema = z.lazy(
   })
 );
 var includeIfSchema = z.object({ variable: z.string(), negated: z.boolean() });
+var prefetchPlanIrSchema = z.object({
+  source: z.string(),
+  maxStalenessMs: z.number().int().positive().optional(),
+  key: z.union([z.object({ one: valueIrSchema }), z.object({ many: valueIrSchema })])
+});
 var selectRootSchema = z.object({
   kind: z.literal("select"),
   alias: z.string(),
@@ -4909,7 +6478,8 @@ var selectRootSchema = z.object({
   distinctOn: z.union([z.array(z.string()), z.object({ slot: z.string() })]).optional(),
   limit: limitIrSchema,
   offset: z.object({ variable: z.string().optional(), value: z.number().int().optional() }).optional(),
-  includeIf: includeIfSchema.optional()
+  includeIf: includeIfSchema.optional(),
+  prefetch: z.array(prefetchPlanIrSchema).optional()
 });
 var byPkRootSchema = z.object({
   kind: z.literal("byPk"),
@@ -4919,7 +6489,8 @@ var byPkRootSchema = z.object({
   pk: z.array(z.object({ column: z.string(), value: valueIrSchema })).min(1),
   /** Policy predicate — ANDed with the PK match. */
   where: predIrSchema,
-  includeIf: includeIfSchema.optional()
+  includeIf: includeIfSchema.optional(),
+  prefetch: z.array(prefetchPlanIrSchema).optional()
 });
 var aggregateRootSchema = z.object({
   kind: z.literal("aggregate"),
@@ -4977,7 +6548,20 @@ var mutationRootSchema = 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: z.enum(["insert", "insertOne", "update", "updateByPk", "delete", "deleteByPk", "cowOverride", "cowRevert"]),
+  op: 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: z.enum(["insert", "update", "delete", "revert"]).optional(),
+  revertColumns: z.array(z.string()).optional(),
+  /** `@writeback(source:, mode:)` directives on this root. */
+  writeback: z.array(z.object({ source: z.string(), mode: z.enum(["sync", "async"]) })).optional(),
+  /** `@localOnly(source:)` — writeback columns deliberately kept local for these sources. */
+  localOnly: z.array(z.string()).optional(),
   alias: z.string(),
   table: z.string(),
   /** CoW ops: logical name of the synced twin (read through its policy-filtered view). */
@@ -5041,7 +6625,31 @@ var variableIrSchema = z.object({
   /** Absent = no default declared; see {@link variableDefaultIrSchema}. */
   defaultValue: variableDefaultIrSchema.optional()
 });
+var sqlColumnSchema = z.object({ name: z.string(), type: z.enum(["text", "boolean", "integer", "bigint", "numeric", "double", "uuid", "date", "timestamptz"]), nullable: z.boolean() });
 var compiledOperationSchema = z.object({
+  language: z.literal("sql").optional(),
+  /** Server-compiled object catalog and permission ceiling, never caller SQL. */
+  sqlQuery: z.object({
+    catalog: z.object({
+      identity: z.string(),
+      objects: z.array(z.object({
+        ref: z.string(),
+        table: z.string(),
+        columns: z.array(sqlColumnSchema.extend({ type: z.string() })).min(1),
+        scan: z.string().min(1),
+        read: z.array(z.string()).min(1)
+      }).strict()).min(1).max(256)
+    }).strict(),
+    read: z.array(z.string()).min(1).max(256),
+    maxRows: z.number().int().min(1).max(1e4)
+  }).strict().optional(),
+  sql: z.object({
+    text: z.string().min(1).max(1048576),
+    columns: z.array(sqlColumnSchema).min(1).max(256),
+    parameters: z.array(z.string()).max(128),
+    read: z.array(z.string()).min(1).max(256),
+    maxRows: z.number().int().min(1).max(1e4)
+  }).strict().optional(),
   irVersion: irVersionSchema,
   name: z.string(),
   opHash: z.string().regex(/^sha256:[0-9a-f]{64}$/),
@@ -5053,8 +6661,16 @@ var compiledOperationSchema = z.object({
   variables: z.array(variableIrSchema),
   /** Every table the op touches — data-token scoping + audit. */
   tableSet: z.array(z.string()).min(1),
-  roots: z.array(rootIrSchema).min(1)
+  roots: 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) {
@@ -5062,13 +6678,55 @@ var compiledOperationSchema = z.object({
     }
   }
 });
+var resolvedSourceIrSchema = z.object({
+  name: z.string(),
+  kind: z.enum(["manual", "etl", "prefetch"]),
+  /** Logical table key of the backing relation. */
+  table: z.string(),
+  columns: z.array(z.string()),
+  key: z.string().optional(),
+  fetch: z.union([
+    z.object({ shape: z.literal("single") }),
+    z.object({ shape: z.literal("batch"), maxKeys: z.number().int().positive() })
+  ]).optional(),
+  function: z.object({ kind: z.enum(["managed", "native"]), id: z.string() }).optional(),
+  prefetchDefaults: z.object({
+    maxStalenessMs: z.number().int().positive(),
+    timeoutMs: z.number().int().positive(),
+    onError: z.enum(["fallback", "fail"])
+  }).optional(),
+  writeback: z.object({
+    columns: z.array(z.string()),
+    defaultMode: z.enum(["sync", "async"]),
+    timeoutMs: z.number().int().positive(),
+    clearManualOnConfirm: z.boolean()
+  }).optional()
+});
+var resolvedMetaIrSchema = z.object({
+  /** Logical pk column of the resolved view (single-column). */
+  pk: z.string(),
+  /** Source name of the manual source. */
+  manual: z.string(),
+  sources: z.array(resolvedSourceIrSchema),
+  deletedBy: z.array(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: z.object({ table: z.string(), compute: z.string() }).optional()
+});
 var tableMetaIrSchema = z.object({
   table: z.string(),
+  namespace: z.string().optional(),
+  dependencies: z.array(z.string()).optional(),
+  foreignReferences: z.array(z.object({ column: z.string(), target: z.string(), targetColumn: z.string() })).optional(),
+  exportRead: z.union([z.literal(true), z.object({ capability: z.string() }), z.object({ role: z.string() })]).optional(),
+  exportWrite: z.union([z.literal(true), z.object({ capability: z.string() }), z.object({ role: z.string() })]).optional(),
   schema: z.string(),
   typename: 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
@@ -5102,6 +6760,22 @@ var tableMetaIrSchema = z.object({
    * `onUpdateFn`). Omitted when empty so pre-onUpdate artifacts still parse.
    */
   touchOnUpdate: z.array(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: z.record(z.string(), z.object({
+    at: z.string().optional(),
+    by: z.string().optional(),
+    rev: z.string().optional(),
+    source: z.string().optional(),
+    conflicts: z.string().optional()
+  }).strict()).optional(),
+  /** Resolved-table view metadata (sources, prefetch/writeback config) for the data plane. */
+  resolved: resolvedMetaIrSchema.optional(),
   constraints: z.array(z.object({ name: z.string(), columns: z.array(z.string()) })),
   /** Depth/node caps for dynamic filter trees on this table. */
   dynamicFilterMaxDepth: z.number().int().positive().default(6),
@@ -5111,13 +6785,21 @@ var compiledArtifactSchema = z.object({
   irVersion: irVersionSchema,
   namespace: z.string(),
   schemaHash: z.string(),
+  ownSchemaHash: z.string().optional(),
+  dependencies: z.record(z.string(), z.string()).optional(),
+  readPolicies: z.record(z.string(), predIrSchema).optional(),
   opsHash: z.string(),
+  /** Apply-observed synced objects without a serving backing; not part of the authored schema hash. */
+  unbackedTables: z.array(z.string()).optional(),
   tables: z.record(z.string(), tableMetaIrSchema),
   operations: z.record(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" });
     }
   }
 });
@@ -5130,7 +6812,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) {
@@ -5163,10 +6845,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;
@@ -5209,12 +6891,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);
@@ -5222,9 +6904,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);
       }
     }
   }
@@ -5236,20 +6918,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
         );
       }
@@ -5329,7 +7011,7 @@ function parseYaml(file, contents) {
     throw new OrmDefinitionError(error instanceof Error ? error.message : "invalid YAML", file);
   }
 }
-var isDefinitionFile = (name) => DEFINITION_FILE_EXTENSIONS.some((extension) => extname(name) === extension);
+var isDefinitionFile = (name2) => DEFINITION_FILE_EXTENSIONS.some((extension) => extname(name2) === extension);
 async function listDefinitionFiles(dir) {
   const entries = await readdir(dir, { withFileTypes: true });
   return entries.filter((entry) => entry.isFile() && isDefinitionFile(entry.name)).map((entry) => entry.name).sort();
@@ -5423,13 +7105,13 @@ async function readMigrationSql(dir, entry) {
 var checksumOf = (text4) => 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"
@@ -5445,13 +7127,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 = join(dir, MIGRATIONS_DIRNAME, META_DIRNAME);
   await mkdir(metaDir, { recursive: true });
   const snapshotText = `${JSON.stringify(plan.snapshot, null, 2)}
 `;
-  await writeFile(join(dir, MIGRATIONS_DIRNAME, `${name}.sql`), sql5);
+  await writeFile(join(dir, MIGRATIONS_DIRNAME, `${name2}.sql`), sql7);
   await writeFile(join(metaDir, `${pad(ordinal)}.snapshot.json`), snapshotText);
   const journal = {
     ...workspace.journal,
@@ -5459,10 +7141,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
       }
@@ -5470,7 +7152,7 @@ async function writeMigration({
   };
   await writeFile(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) {
@@ -5577,8 +7259,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;
     }
@@ -5618,7 +7300,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) {
@@ -5644,15 +7326,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,
@@ -5669,11 +7351,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,
@@ -5687,14 +7369,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,
@@ -5723,29 +7405,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`,
@@ -5819,8 +7501,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,
@@ -5833,7 +7515,527 @@ function canonicalActions(value) {
     ])
   );
 }
+var IMPORT_CONFLICT_MODES = ["error", "skip", "update"];
+var columnMapSchema = z.object({
+  /** ORM property name or Postgres column name. */
+  target: z.string().min(1).max(63),
+  /** Column on the source relation. Identifiers only — never an expression. */
+  source: 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: z.union([z.string().max(1e4), z.number(), z.boolean()]).optional()
+}).strict();
+var importSpecSchema = z.object({
+  table: z.string().min(1).max(63),
+  from: z.string().regex(QUALIFIED_TABLE_PATTERN),
+  columns: z.array(columnMapSchema).min(1).max(500),
+  onConflict: z.enum(IMPORT_CONFLICT_MODES).default("skip"),
+  batchSize: 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 = 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];
+}
 
-export { ACTION_REQUIRES_DENIED_SQLSTATE, ACTION_VALIDATES_FAILED_SQLSTATE, AUDIT_ACTIONS, CANONICAL_FORMAT, CAPABILITIES_CLAIM_KEY, CAPABILITY_KEY_PATTERN, CLAIMS_CONTRACT, CLAIMS_SETTING, CLAIM_KEY_PATTERN, CMP_OPS, COLUMN_BRAND, COLUMN_DEFAULT_FNS, COLUMN_IDENTIFIER_PATTERN, COLUMN_TYPES2 as COLUMN_TYPES, COMPARE_OPS, CONSUMER_ROLE_SUFFIX, ColumnBuilder, DATE_BUCKETS, DEFINITION_FILE_EXTENSIONS, ENUM_BRAND, HASH_DOMAIN, IDENTIFIER_PATTERN, IDENTIFIER_RE, INPUT_REF_KINDS, IR_VERSION, IrVersionError, LEGACY_IR_VERSION, LINK_BRAND, MAX_DEFINITION_FILE_BYTES, MAX_GENERATED_SDL_BYTES, MAX_IDENTIFIER_LENGTH, MIGRATIONS_DIRNAME, NAMESPACE_CONFIG_BRAND, NAMESPACE_CONFIG_FILE, NAMESPACE_CONFIG_FILENAMES, NAMESPACE_PATTERN, ORM_DATA_TOKEN_HEADER, ORM_MIGRATION_EXPORT_FILE, ORM_MIGRATION_EXPORT_MAX_BYTES, ORM_REGISTRATION_MAX_BYTES, ORM_SCHEMA_PREFIX, ORM_SERVICE_DATA_TOKEN_HEADER, ORM_TO_PIPELINE_TYPE, OrmDefinitionError, PredicateParseError, QUALIFIED_TABLE_PATTERN, RESERVED_COLUMN_NAMES, RESERVED_TABLE_NAMES, ROLES_CLAIM_KEY, SCHEMA_DIR, STATEMENT_KINDS, SYNCED_CONTRACT_HASH_DOMAIN, SYNCED_SOURCE_PATTERN, SYNCED_VIEW_EXECUTION_OWNER_ROLE, TABLE_BRAND, VIEW_BRAND, actionFunctionName, actionFunctionStatements, actionParamArg, actionParamOrder, actionParamSchema, actionPrepareChecks, actionSchema, actionWriteTargets, actionsInterfaceName, activeAuthoringContext, applyMigrationHints, applyMigrationHintsV2, beginAuthoringContext, buildActionParamsSchema, buildDrizzleEntities, buildDrizzleEntitiesV2, buildNamespaceDefinition, buildRebaseJournalEntry, canonicalActionSchema, canonicalColumnSchema, canonicalDefinitionSchema, canonicalEnumSchema, canonicalIndexSchema, canonicalLinkSchema, canonicalPoliciesSchema, canonicalRelations, canonicalTableSchema, canonicalViewSchema, canonicalizeDefinition, capabilityExpression, castParts, checksumOf, claimExpression, classifyDestructive, columnSchema, columnTypeSchema2 as columnTypeSchema, compileActionRequires, compileActionStatements, compileNamespace, compilePredIrToSql, compilePredicate, compiledArtifactSchema, compiledOperationSchema, computeCanonicalHash, computeDefinitionHash, computeSyncedContractHash, consumerRoleName, convertV1DefinitionToCanonical, createOrmMigrationExport, declaredCapabilityKeys, defineEnum, defineNamespace, defineSyncedTable, defineTable, defineView, deriveColumnName, diffCommand, diffStatements, emptyJournal, emptySnapshot, endAuthoringContext, extractNamedParams, extractOrmSyncedTableContract, generateNamespaceTypes, generateSnapshot, generateSnapshotV2, identifierSchema, indexByHash, isColumnBuilder, isEnumRef, isFunctionDefault, isOwnedStatement, isOwnedStatementV2, isQualifiedReference, isSeqLink, isSeqNamespaceConfig, isSeqTable, isSeqView, limitIrSchema, loadCommittedMigrations, loadCommittedTipMigration, loadNamespaceDefinition, loadNamespaceFromDir, migrationName, namespaceConfigSchema, namespaceSchema, normalizeCanonical, normalizeIr, normalizeSnapshot, orderIrSchema, ormMigrationExportSchema, ormSchemaName, overlayWinsUnion, overrideRowMutation, parseCanonicalDefinition, parseDefinitionSources, parseOrmMigrationExport, parsePredicate, parseTableFile, parsedPredicateSchema, pendingKitStatements, pendingKitStatementsV2, planMigration, planMigrationV2, policyExpressionSchema, policyVariantSchema, predIrSchema, predicateOperands, quoteIdentifier, quoteLiteral, readMigrationSql, readMigrationWorkspace, readSnapshot, rebaseViolations, referencedCapabilities, referencedColumns, renderMigrationSql, renderOrmMigrationExport, requiredArtifactIrVersion, revertOverlayMutation, rewriteSyncedSourceRelationsInViewQuery, roleExpression, rootIrSchema, securityStatements, selectionIrSchema, serializeNamespace, sqlTypeName, stableJson, syncedBackingRevokeStatements, syncedContractSurface, syncedTables, syncedViewDropStatements, syncedViewStatements, t, tableFileSchema, tableMetaIrSchema, tableReferenceSchema, toMany, toOne, toPlatformUser, typesInterfaceName, validateViewCatalogStatement, valueIrSchema, variableDefaultIrSchema, variableIrSchema, verifyRebaseIsNoop, walkPredicate, writeMigration };
+export { ACTION_REQUIRES_DENIED_SQLSTATE, ACTION_VALIDATES_FAILED_SQLSTATE, AUDIT_ACTIONS, CANONICAL_FORMAT, CAPABILITIES_CLAIM_KEY, CAPABILITY_KEY_PATTERN, CELLS_FIELD, CELL_PARTS, CELL_PART_SUFFIX, CLAIMS_CONTRACT, CLAIMS_SETTING, CLAIM_KEY_PATTERN, CMP_OPS, COLUMN_BRAND, COLUMN_DEFAULT_FNS, COLUMN_IDENTIFIER_PATTERN, COLUMN_TYPES2 as COLUMN_TYPES, COMPARE_OPS, COMPOSED_IR_VERSION, CONSUMER_ROLE_SUFFIX, ColumnBuilder, DATE_BUCKETS, DEFINITION_FILE_EXTENSIONS, ENUM_BRAND, GUARDED_IR_VERSION, HASH_DOMAIN, IDENTIFIER_PATTERN, IDENTIFIER_RE, IMPORT_CONFLICT_MODES, INPUT_REF_KINDS, IR_VERSION, IrVersionError, LEGACY_IR_VERSION, LINK_BRAND, MATERIALIZE_ACTOR, MATERIALIZE_CLAIMS_JSON, MAX_DEFINITION_FILE_BYTES, MAX_GENERATED_SDL_BYTES, MAX_IDENTIFIER_LENGTH, MAX_TRACKED_COLUMN_NAME, MIGRATIONS_DIRNAME, NAMESPACE_CONFIG_BRAND, NAMESPACE_CONFIG_FILE, NAMESPACE_CONFIG_FILENAMES, NAMESPACE_PATTERN, ORM_DATA_TOKEN_HEADER, ORM_MIGRATION_EXPORT_FILE, ORM_MIGRATION_EXPORT_MAX_BYTES, ORM_REGISTRATION_MAX_BYTES, ORM_SCHEMA_PREFIX, ORM_SERVICE_DATA_TOKEN_HEADER, ORM_TO_PIPELINE_TYPE, OrmDefinitionError, PredicateParseError, QUALIFIED_TABLE_PATTERN, RESERVED_COLUMN_NAMES, RESERVED_TABLE_NAMES, ROLES_CLAIM_KEY, RUNTIME_SQL_IR_VERSION, SCHEMA_DIR, SQL_IR_VERSION, STATEMENT_KINDS, SYNCED_CONTRACT_HASH_DOMAIN, SYNCED_SOURCE_PATTERN, SYNCED_VIEW_EXECUTION_OWNER_ROLE, TABLE_BRAND, VIEW_BRAND, actionFunctionName, actionFunctionStatements, actionParamArg, actionParamOrder, actionParamSchema, actionPrepareChecks, actionSchema, actionWriteTargets, actionsInterfaceName, activeAuthoringContext, applyMigrationHints, applyMigrationHintsV2, beginAuthoringContext, buildActionParamsSchema, buildDrizzleEntities, buildDrizzleEntitiesV2, buildNamespaceDefinition, buildRebaseJournalEntry, canonicalActionSchema, canonicalColumnSchema, canonicalDefinitionSchema, canonicalEnumSchema, canonicalIndexSchema, canonicalLinkSchema, canonicalPoliciesSchema, canonicalRelations, canonicalTableSchema, canonicalViewSchema, canonicalizeDefinition, capabilityExpression, castParts, cellColumnName, checksumOf, claimExpression, classifyDestructive, columnSchema, columnTypeSchema2 as columnTypeSchema, compileActionRequires, compileActionStatements, compileNamespace, compilePredIrToSql, compilePredicate, compiledArtifactSchema, compiledOperationSchema, computeCanonicalHash, computeDefinitionHash, computeSyncedContractHash, consumerRoleName, convertV1DefinitionToCanonical, createOrmMigrationExport, custom, declaredCapabilityKeys, defineEnum, defineNamespace, defineOperation, defineResolvedTable, defineSyncedTable, defineTable, defineView, deriveColumnName, diffCommand, diffStatements, emptyJournal, emptySnapshot, endAuthoringContext, etlSource, extractNamedParams, extractOrmSyncedTableContract, generateNamespaceTypes, generateSnapshot, generateSnapshotV2, highest, identifierSchema, importSpecSchema, indexByHash, isColumnBuilder, isEnumRef, isFunctionDefault, isOwnedStatement, isOwnedStatementV2, isQualifiedReference, isSeqLink, isSeqNamespaceConfig, isSeqTable, isSeqView, latest, limitIrSchema, loadCommittedMigrations, loadCommittedTipMigration, loadNamespaceDefinition, loadNamespaceFromDir, lowest, managedFn, manualSource, materializeLockKey, materializedRefreshFunctionName, migrationName, namespaceConfigSchema, namespaceSchema, nonNullFirst, normalizeCanonical, normalizeIr, normalizeSnapshot, objectRef, ontologyContractSchema, orderIrSchema, ormMigrationExportSchema, ormSchemaName, overlayWinsUnion, overrideRowMutation, parseCanonicalDefinition, parseDefinitionSources, parseOrmMigrationExport, parsePredicate, parseTableFile, parsedPredicateSchema, pendingKitStatements, pendingKitStatementsV2, planCommittedMigrationV2, planMigration, planMigrationV2, planTableImport, policyExpressionSchema, policyVariantSchema, predIrSchema, predicateOperands, prefetchPlanIrSchema, prefetchSource, priority, quoteIdentifier, quoteLiteral, readMigrationSql, readMigrationWorkspace, readOntologyContract, readSnapshot, rebaseViolations, referencedCapabilities, referencedColumns, renderMigrationSql, renderOrmMigrationExport, requiredArtifactIrVersion, resolvedMetaIrSchema, resolvedSourceIrSchema, revertOverlayMutation, rewriteSyncedSourceRelationsInViewQuery, roleExpression, rootIrSchema, securityStatements, selectionIrSchema, serializeNamespace, sqlTypeName, stableJson, syncedBackingRevokeStatements, syncedContractSurface, syncedTables, syncedViewDropStatements, syncedViewStatements, t, tableFileSchema, tableMetaIrSchema, tableReferenceSchema, toMany, toOne, toPlatformUser, typesInterfaceName, validateNamespaceCatalog, validateViewCatalogStatement, valueIrSchema, variableDefaultIrSchema, variableIrSchema, verifyRebaseIsNoop, walkPredicate, writeMigration };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map