@sequenceholdings/orm 2.0.0 → 2.1.1

package/dist/index.cjs

@@ -2,8 +2,8 @@
 
 var drizzleOrm = require('drizzle-orm');
 var pgCore = require('drizzle-orm/pg-core');
-var crypto = require('crypto');
 var zod = require('zod');
+var crypto = require('crypto');
 var jiti = require('jiti');
 var promises = require('fs/promises');
 var module$1 = require('module');
@@ -36,10 +36,12 @@ var ColumnBuilder = class {
       hasDefault: false,
       defaultValue: void 0,
       defaultFn: void 0,
+      onUpdateFn: void 0,
       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. */
@@ -71,6 +73,15 @@ var ColumnBuilder = class {
     this.state.defaultFn = void 0;
     return this;
   }
+  /**
+   * Stamp this column with Postgres `now()` on every UPDATE. Only valid on
+   * timestamptz/date; the compiler drops it from SetInput so callers cannot
+   * supply a value.
+   */
+  onUpdate(value) {
+    this.state.onUpdateFn = value;
+    return this;
+  }
   description(text4) {
     this.state.description = text4;
     return this;
@@ -90,6 +101,11 @@ var ColumnBuilder = class {
     this.state.deprecated = true;
     return this;
   }
+  /** @internal System cell-metadata part of logical column `of` (generated resolved views only). */
+  cellPart(of, part) {
+    this.state.cell = { of, part };
+    return this;
+  }
   /** Whether `.primaryKey()` was called — collected into the table-level PK. */
   get isPrimaryKey() {
     return this.state.primaryKey;
@@ -114,9 +130,11 @@ var ColumnBuilder = class {
     };
     if (this.state.hasDefault) column.default = this.state.defaultValue ?? null;
     if (this.state.defaultFn !== void 0) column.defaultFn = this.state.defaultFn;
+    if (this.state.onUpdateFn !== void 0) column.onUpdateFn = this.state.onUpdateFn;
     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;
   }
 };
@@ -140,11 +158,12 @@ var t = {
 
 // src/constants.ts
 var NAMESPACE_PATTERN = /^[a-z][a-z0-9_]{0,40}$/;
-var 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 IDENTIFIER_PATTERN = /^[a-z][a-z0-9_]*$/;
+var COLUMN_IDENTIFIER_PATTERN = /^_?[a-z][a-z0-9_]*$/;
+var MAX_IDENTIFIER_LENGTH = 63;
+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_]*$/;
@@ -156,8 +175,31 @@ var DEFINITION_FILE_EXTENSIONS = [".yml", ".yaml"];
 var NAMESPACE_CONFIG_FILENAMES = /* @__PURE__ */ new Set(["namespace.yaml", "namespace.yml"]);
 var HASH_DOMAIN = "sequence-orm-definitions\0";
 var MAX_DEFINITION_FILE_BYTES = 1024 * 1024;
+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 {
@@ -233,6 +275,8 @@ function toOne(target, options) {
     on: options.on,
     references: options.references,
     enforce: options.enforce ?? false,
+    onDelete: options.onDelete,
+    onUpdate: options.onUpdate,
     description: options.description
   };
 }
@@ -244,6 +288,8 @@ function toMany(target, options) {
     on: options.on,
     references: options.references,
     enforce: false,
+    onDelete: void 0,
+    onUpdate: void 0,
     description: options.description
   };
 }
@@ -255,6 +301,8 @@ function toPlatformUser(options) {
     on: options.on,
     references: options.references,
     enforce: false,
+    onDelete: void 0,
+    onUpdate: void 0,
     description: options.description
   };
 }
@@ -264,10 +312,10 @@ function isSeqLink(value) {
 function isSeqTable(value) {
   return typeof value === "object" && value !== null && value.kind === TABLE_BRAND;
 }
-function assertIdentifier({ value, what, file }) {
-  if (!IDENTIFIER_PATTERN.test(value) || value.length > MAX_IDENTIFIER_LENGTH) {
+function assertIdentifier({ value, what, file, pattern = IDENTIFIER_PATTERN }) {
+  if (!pattern.test(value) || value.length > MAX_IDENTIFIER_LENGTH) {
     throw new OrmDefinitionError(
-      `${what} "${value}" must match ${IDENTIFIER_PATTERN} and be at most ${MAX_IDENTIFIER_LENGTH} characters`,
+      `${what} "${value}" must match ${pattern} and be at most ${MAX_IDENTIFIER_LENGTH} characters`,
       file
     );
   }
@@ -288,7 +336,13 @@ function defineTable(name, columns, config = {}) {
       );
     }
     const columnName = builder.columnNameFor(propertyName);
-    assertIdentifier({ value: columnName, what: `table "${name}": column "${propertyName}" column name`, file });
+    assertIdentifier({ value: columnName, what: `table "${name}": 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 "${name}": "${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(
@@ -328,7 +382,8 @@ function defineSyncedTable(name, columnsOrConfig, maybeConfig) {
     assertIdentifier({
       value: columnName,
       what: `synced table "${name}": column "${propertyName}" column name`,
-      file
+      file,
+      pattern: COLUMN_IDENTIFIER_PATTERN
     });
     const existing = seenColumnNames.get(columnName);
     if (existing !== void 0) {
@@ -417,7 +472,7 @@ function defineView(name, columns, config) {
       );
     }
     const columnName = builder.columnNameFor(propertyName);
-    if (!IDENTIFIER_PATTERN.test(columnName) || columnName.length > MAX_IDENTIFIER_LENGTH) {
+    if (!COLUMN_IDENTIFIER_PATTERN.test(columnName) || columnName.length > MAX_IDENTIFIER_LENGTH) {
       throw new OrmDefinitionError(`view "${name}": column "${propertyName}" has invalid column name "${columnName}"`, file);
     }
     const existing = seenColumnNames.get(columnName);
@@ -535,11 +590,11 @@ function compileViewQueries(input) {
       );
     }
     if (!config.query) throw new OrmDefinitionError(`view "${authored.viewName}" produced no query`, authored.file);
-    const tableDependencies = pgCore.extractUsedTable(config.query).map((physical) => {
-      const logical = physicalToLogical.get(physical);
+    const tableDependencies = pgCore.extractUsedTable(config.query).map((physical2) => {
+      const logical = physicalToLogical.get(physical2);
       if (!logical) {
         throw new OrmDefinitionError(
-          `view "${authored.viewName}" query references unmanaged relation "${physical}" \u2014 use relation(...) with a namespace table or view`,
+          `view "${authored.viewName}" query references unmanaged relation "${physical2}" \u2014 use relation(...) with a namespace table or view`,
           authored.file
         );
       }
@@ -863,9 +918,478 @@ function scalarColumnType(table, property, helper) {
   }
   return 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/checks/compile.ts
+function tokenize(source) {
+  const tokens = [];
+  for (let position = 0; position < source.length; ) {
+    const char = source[position];
+    if (/\s/.test(char)) {
+      position++;
+      continue;
+    }
+    if (char === "(" || char === ")" || char === ",") {
+      tokens.push({ kind: char === "(" ? "lparen" : char === ")" ? "rparen" : "comma", value: char, position });
+      position++;
+      continue;
+    }
+    if (char === "'") {
+      const start = position++;
+      let value = "";
+      let closed = false;
+      while (position < source.length) {
+        if (source[position] !== "'") {
+          value += source[position++];
+          continue;
+        }
+        if (source[position + 1] === "'") {
+          value += "'";
+          position += 2;
+          continue;
+        }
+        position++;
+        closed = true;
+        break;
+      }
+      if (!closed) throw new Error(`unterminated string at position ${start}`);
+      if (/[\x00-\x1f\x7f]/.test(value)) throw new Error(`control character in string at position ${start}`);
+      tokens.push({ kind: "string", value, position: start });
+      continue;
+    }
+    const operator = /^(<=|>=|<>|!=|!~|=|<|>|~)/.exec(source.slice(position));
+    if (operator) {
+      tokens.push({ kind: "operator", value: operator[0] === "<>" ? "!=" : operator[0], position });
+      position += operator[0].length;
+      continue;
+    }
+    const number = /^-?\d+(?:\.\d+)?/.exec(source.slice(position));
+    if (number) {
+      tokens.push({ kind: "number", value: number[0], position });
+      position += number[0].length;
+      continue;
+    }
+    const identifier3 = /^[a-zA-Z_][a-zA-Z_0-9]*/.exec(source.slice(position));
+    if (identifier3) {
+      tokens.push({ kind: "identifier", value: identifier3[0], position });
+      position += identifier3[0].length;
+      continue;
+    }
+    throw new Error(`unexpected character '${char}' at position ${position}`);
+  }
+  tokens.push({ kind: "end", value: "", position: source.length });
+  if (tokens.length > 256) throw new Error("check expression exceeds 256 tokens");
+  return tokens;
+}
+var Parser = class {
+  constructor(tokens, columns) {
+    this.tokens = tokens;
+    this.columns = /* @__PURE__ */ new Map();
+    for (const column of columns) {
+      for (const alias of [column.name, column.columnName]) {
+        const previous = this.columns.get(alias);
+        if (previous && previous.columnName !== column.columnName) {
+          throw new Error(`ambiguous check column '${alias}'`);
+        }
+        this.columns.set(alias, column);
+      }
+    }
+  }
+  index = 0;
+  depth = 0;
+  columns;
+  parse() {
+    const expression = this.parseOr();
+    this.expect("end", "end of expression");
+    return expression;
+  }
+  parseOr() {
+    let left = this.parseAnd();
+    while (this.matchKeyword("or")) left = `(${left} OR ${this.parseAnd()})`;
+    return left;
+  }
+  parseAnd() {
+    let left = this.parseNot();
+    while (this.matchKeyword("and")) left = `(${left} AND ${this.parseNot()})`;
+    return left;
+  }
+  parseNot() {
+    if (this.matchKeyword("not")) return `(NOT ${this.parseNot()})`;
+    return this.parsePrimary();
+  }
+  parsePrimary() {
+    if (this.peek().kind === "lparen") {
+      if (++this.depth > 32) throw new Error("check expression nesting exceeds 32 levels");
+      this.advance();
+      const expression = this.parseOr();
+      this.expect("rparen", "')'");
+      this.depth--;
+      return `(${expression})`;
+    }
+    return this.parseComparison();
+  }
+  parseComparison() {
+    const left = this.parseValue();
+    if (this.matchKeyword("is")) {
+      const negate = this.matchKeyword("not");
+      this.expectKeyword("null");
+      return `${left.sql} IS ${negate ? "NOT " : ""}NULL`;
+    }
+    if (this.matchKeyword("between")) {
+      const lower = this.parseValue();
+      this.expectKeyword("and");
+      const upper = this.parseValue();
+      return `${left.sql} BETWEEN ${lower.sql} AND ${upper.sql}`;
+    }
+    if (this.matchKeyword("in")) {
+      this.expect("lparen", "'(' after IN");
+      const values = [this.parseValue()];
+      while (this.peek().kind === "comma") {
+        this.advance();
+        values.push(this.parseValue());
+      }
+      this.expect("rparen", "')' after IN values");
+      if (values.some((value) => !value.literal)) throw new Error("IN values must be literals");
+      return `${left.sql} IN (${values.map((value) => value.sql).join(", ")})`;
+    }
+    const operator = this.expect("operator", "a comparison operator");
+    const right = this.parseValue();
+    if (operator.value === "~" || operator.value === "!~") {
+      if (left.column && left.column.type !== "text") throw new Error("regex checks require a text column");
+      if (!right.literal) throw new Error("regex pattern must be a literal");
+    }
+    return `${left.sql} ${operator.value} ${right.sql}`;
+  }
+  parseValue() {
+    const token = this.advance();
+    if (token.kind === "string") return { sql: quoteLiteral(token.value), literal: true };
+    if (token.kind === "number") {
+      const number = Number(token.value);
+      if (!Number.isFinite(number) || Number.isInteger(number) && !Number.isSafeInteger(number)) {
+        throw new Error(`unsafe numeric literal at position ${token.position}`);
+      }
+      return { sql: token.value, literal: true };
+    }
+    if (token.kind !== "identifier") throw new Error(`expected a column or literal at position ${token.position}`);
+    const keyword = token.value.toLowerCase();
+    if (keyword === "true" || keyword === "false" || keyword === "null") return { sql: keyword.toUpperCase(), literal: true };
+    if (keyword === "btrim") {
+      this.expect("lparen", "'(' after btrim");
+      const column2 = this.parseColumn();
+      this.expect("rparen", "')' after btrim column");
+      if (column2.type !== "text") throw new Error("btrim requires a text column");
+      return { sql: `btrim(${quoteIdentifier(column2.columnName)})`, column: column2 };
+    }
+    const column = this.columns.get(token.value);
+    if (!column) throw new Error(`unknown check column '${token.value}'`);
+    return { sql: quoteIdentifier(column.columnName), column };
+  }
+  parseColumn() {
+    const token = this.expect("identifier", "a column name");
+    const column = this.columns.get(token.value);
+    if (!column) throw new Error(`unknown check column '${token.value}'`);
+    return column;
+  }
+  peek() {
+    return this.tokens[this.index];
+  }
+  advance() {
+    const token = this.peek();
+    if (token.kind !== "end") this.index++;
+    return token;
+  }
+  matchKeyword(keyword) {
+    if (this.peek().kind !== "identifier" || this.peek().value.toLowerCase() !== keyword) return false;
+    this.advance();
+    return true;
+  }
+  expectKeyword(keyword) {
+    if (!this.matchKeyword(keyword)) throw new Error(`expected '${keyword}' at position ${this.peek().position}`);
+  }
+  expect(kind, description) {
+    const token = this.peek();
+    if (token.kind !== kind) throw new Error(`expected ${description} at position ${token.position}`);
+    return this.advance();
+  }
+};
+function compileCheckExpression(source, columns) {
+  return new Parser(tokenize(source), columns).parse();
+}
+var policyVariantSchema = zod.z.object({
+  /** Claims-only guard (capability()/role()/claim() comparisons — no columns). */
+  when: zod.z.string().min(1).max(1e3),
+  /** Exactly one of: allow-all bypass, or a row predicate. */
+  allow: zod.z.literal(true).optional(),
+  policy: zod.z.string().min(1).max(2e3).optional()
+}).refine((v) => v.allow === true !== (typeof v.policy === "string"), {
+  message: "A variant declares exactly one of allow: true or policy"
+});
+var policyExpressionSchema = zod.z.union([
+  zod.z.string().min(1).max(2e3),
+  zod.z.object({
+    default: zod.z.string().min(1).max(2e3),
+    variants: zod.z.array(policyVariantSchema).max(10).default([])
+  })
+]);
+function parseDurationMs(input) {
+  if (typeof input === "number") return Number.isInteger(input) && input > 0 ? input : void 0;
+  const match = /^(\d+(?:\.\d+)?)(ms|s|m)$/.exec(input);
+  if (!match) return void 0;
+  const factor = match[2] === "ms" ? 1 : match[2] === "s" ? 1e3 : 6e4;
+  const value = Math.round(Number(match[1]) * factor);
+  return value > 0 ? value : void 0;
+}
+var identifier = zod.z.string().min(1).max(63).regex(/^[a-z][a-z0-9_]*$/);
+var durationMs = zod.z.number().int().positive().max(24 * 60 * 60 * 1e3);
+var RESOLVED_VIEW_SYSTEM_COLUMNS = {
+  writebackStatus: { name: "writebackStatus", columnName: "_writeback_status", type: "text" },
+  writebackError: { name: "writebackError", columnName: "_writeback_error", type: "text" }
+};
+var RESOLVED_SOURCE_SYSTEM_COLUMNS = {
+  tombstoned: { name: "sysTombstoned", columnName: "_tombstoned" },
+  fetchedAt: { name: "sysFetchedAt", columnName: "_fetched_at" },
+  writebackStatus: { name: "sysWritebackStatus", columnName: "_writeback_status" },
+  writebackError: { name: "sysWritebackError", columnName: "_writeback_error" },
+  writebackAt: { name: "sysWritebackAt", columnName: "_writeback_at" }
+};
+var RESOLVED_VIEW_CELL_PARTS = ["source", "at", "by", "conflicts"];
+var RESERVED_RESOLVED_COLUMN_NAMES = /* @__PURE__ */ new Set([
+  ...Object.values(RESOLVED_VIEW_SYSTEM_COLUMNS).flatMap((c) => [c.name, c.columnName]),
+  ...Object.values(RESOLVED_SOURCE_SYSTEM_COLUMNS).flatMap((c) => [c.name, c.columnName])
+]);
+var COMPARATORS = ["latest", "highest", "lowest", "priority", "nonNullFirst", "custom"];
+var canonicalFunctionRefSchema = zod.z.object({
+  /** `managed` = a Managed Function id/slug; `native` = an in-process Atlas function (reserved). */
+  kind: zod.z.enum(["managed", "native"]),
+  id: zod.z.string().min(1).max(200)
+}).strict();
+var canonicalFetchShapeSchema = zod.z.union([
+  zod.z.object({ shape: zod.z.literal("single") }).strict(),
+  zod.z.object({ shape: zod.z.literal("batch"), maxKeys: zod.z.number().int().min(2).max(500) }).strict()
+]);
+var canonicalResolvedSourceSchema = zod.z.object({
+  name: identifier,
+  kind: zod.z.enum(["manual", "etl", "prefetch"]),
+  /** Backing relation in this namespace: an internal table (manual/prefetch) or a synced table (etl). */
+  table: identifier,
+  /** Resolved columns (logical names) this source supplies — the primary key is implicit. */
+  columns: zod.z.array(zod.z.string().min(1).max(63)).min(1).max(500),
+  /** etl: logical timestamptz/date column on the synced table used as every cell's updated_at. */
+  updatedAt: zod.z.string().min(1).max(63).optional(),
+  /** prefetch: resolved column holding the source system's key (may be the primary key). */
+  key: zod.z.string().min(1).max(63).optional(),
+  fetch: canonicalFetchShapeSchema.optional(),
+  function: canonicalFunctionRefSchema.optional(),
+  prefetchDefaults: zod.z.object({
+    maxStalenessMs: durationMs,
+    timeoutMs: durationMs,
+    onError: zod.z.enum(["fallback", "fail"])
+  }).strict().optional(),
+  writeback: zod.z.object({
+    columns: zod.z.array(zod.z.string().min(1).max(63)).min(1).max(500),
+    defaultMode: zod.z.enum(["sync", "async"]),
+    timeoutMs: durationMs,
+    /** Remove confirmed cells from the manual source so a stale edit cannot shadow the source. */
+    clearManualOnConfirm: zod.z.boolean()
+  }).strict().optional()
+}).strict();
+var canonicalResolveRuleSchema = zod.z.object({
+  column: zod.z.string().min(1).max(63),
+  comparator: zod.z.enum(COMPARATORS),
+  /** Source names, in tie-break order. */
+  candidates: zod.z.array(identifier).min(1).max(16),
+  /** custom only: SQL ORDER BY key over value / updated_at / source / actor / ord. */
+  orderBy: zod.z.string().min(1).max(2e3).optional()
+}).strict();
+var canonicalResolvedSchema = zod.z.object({
+  sources: zod.z.array(canonicalResolvedSourceSchema).min(1).max(16),
+  /** One rule per resolved (non-pk) column; documents the generated view for tooling. */
+  resolve: zod.z.array(canonicalResolveRuleSchema).max(500),
+  /** Sources whose tombstone hides the resolved row (v1: the manual source only). */
+  deletedBy: zod.z.array(identifier).max(1).default([]),
+  /**
+   * Materialized: the view reads an indexed internal table (`table`) that the
+   * data plane keeps in step with `compute`, the internal view holding the
+   * resolution query. Omitted when the view computes on read.
+   */
+  materialized: zod.z.object({ table: identifier, compute: identifier }).strict().optional(),
+  /** Write policies evaluated against the RESOLVED row (reads use the view's read policy). */
+  policies: zod.z.object({
+    write: policyExpressionSchema.optional(),
+    insert: policyExpressionSchema.optional(),
+    update: policyExpressionSchema.optional()
+  }).strict().default({})
+}).strict();
+function validateResolvedView({ view, tables, views = [] }) {
+  const resolved = view.resolved;
+  if (!resolved) return [];
+  const errors = [];
+  const fail = (message) => errors.push(`resolved table '${view.view}': ${message}`);
+  const pkColumn = view.primaryKey?.length === 1 ? view.columns.find((c) => c.columnName === view.primaryKey?.[0]) : void 0;
+  if (!pkColumn) {
+    fail("requires exactly one primary-key column");
+    return errors;
+  }
+  const systemNames = new Set(Object.values(RESOLVED_VIEW_SYSTEM_COLUMNS).map((c) => c.name));
+  const scope = {
+    view,
+    resolved,
+    pkColumn,
+    dataColumns: new Map(view.columns.filter((c) => !systemNames.has(c.name) && c.cell === void 0).map((c) => [c.name, c])),
+    sourceByName: /* @__PURE__ */ new Map(),
+    fail
+  };
+  if (resolved.sources.filter((source) => source.kind === "manual").length !== 1) fail("requires exactly one manual source");
+  const tableByName = new Map(tables.map((table) => [table.table, table]));
+  for (const source of resolved.sources) {
+    if (scope.sourceByName.has(source.name)) fail(`duplicate source '${source.name}'`);
+    scope.sourceByName.set(source.name, source);
+    const table = tableByName.get(source.table);
+    if (!table) fail(`source '${source.name}' references unknown table '${source.table}'`);
+    else validateSource({ scope, source, table });
+  }
+  validateRules(scope);
+  validateViewCells(scope);
+  if (resolved.materialized) validateMaterialized({ scope, tableByName, views });
+  for (const name of resolved.deletedBy) {
+    if (scope.sourceByName.get(name)?.kind !== "manual") fail(`deletedBy '${name}' 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 name of expected.keys()) fail(`missing cell column '${name}'`);
+}
+var columnSignature = (columns) => JSON.stringify(columns.map((column) => [column.name, column.columnName, column.type]));
+function validateMaterialized({ scope, tableByName, views }) {
+  const { view, resolved, fail } = scope;
+  const { table: tableName, compute: computeName } = resolved.materialized;
+  const table = tableByName.get(tableName);
+  if (!table || table.internal !== true || table.materializes !== view.view) {
+    fail(`materialized table '${tableName}' must be an internal table that materializes '${view.view}'`);
+  } else {
+    if (columnSignature(table.columns) !== columnSignature(view.columns)) fail(`materialized table '${tableName}' must have exactly the view's columns`);
+    if (JSON.stringify(table.primaryKey ?? []) !== JSON.stringify(view.primaryKey ?? [])) fail(`materialized table '${tableName}' must share the view's primary key`);
+  }
+  const compute = views.find((candidate) => candidate.view === computeName);
+  if (!compute || compute.internal !== true) fail(`compute view '${computeName}' must be an internal view`);
+  else if (columnSignature(compute.columns) !== columnSignature(view.columns)) fail(`compute view '${computeName}' must have exactly the view's columns`);
+  for (const source of resolved.sources) {
+    if (source.kind !== "etl") continue;
+    const read = tableByName.get(source.table)?.policies?.read;
+    const unconditional = typeof read === "string" ? read.trim() === "true" : read !== void 0 && read.default.trim() === "true" && read.variants.length === 0;
+    if (!unconditional) {
+      fail(`etl source '${source.name}' must have read policy 'true' to be materialized (the copy is shared by every caller)`);
+    }
+  }
+}
+
+// src/canonical/v2.ts
 var CANONICAL_FORMAT = 2;
 var IDENTIFIER_RE = /^[a-z][a-z0-9_]*$/;
-var identifier = zod.z.string().min(1).max(63).regex(IDENTIFIER_RE);
+var identifier2 = zod.z.string().min(1).max(63).regex(IDENTIFIER_RE);
+var columnIdentifier = zod.z.string().min(1).max(63).regex(COLUMN_IDENTIFIER_PATTERN);
 var COLUMN_TYPES = [
   "uuid",
   "text",
@@ -880,59 +1404,71 @@ var COLUMN_TYPES = [
 ];
 var columnTypeSchema = zod.z.enum(COLUMN_TYPES);
 var canonicalEnumSchema = zod.z.object({
-  name: identifier,
+  name: identifier2,
   values: zod.z.array(zod.z.string().min(1).max(63)).min(1).max(100)
 });
 var canonicalColumnSchema = zod.z.object({
   /** Property name in TS (camelCase); columnName is the Postgres name. */
   name: zod.z.string().min(1).max(63),
-  columnName: identifier,
-  type: zod.z.union([columnTypeSchema, zod.z.object({ enum: identifier })]),
+  columnName: columnIdentifier,
+  type: zod.z.union([columnTypeSchema, zod.z.object({ enum: identifier2 })]),
   nullable: zod.z.boolean().default(true),
   unique: zod.z.boolean().default(false),
   /** Literal default, or one of the allowlisted SQL functions. */
   default: zod.z.union([zod.z.string(), zod.z.number(), zod.z.boolean(), zod.z.null()]).optional(),
   defaultFn: zod.z.enum(["gen_random_uuid()", "now()"]).optional(),
+  /**
+   * Stamp this column from the database clock on UPDATE (`now()`). The
+   * column stays insertable (defaults fill gaps) but is omitted from
+   * SetInput / settable so callers cannot backdate it.
+   */
+  onUpdateFn: zod.z.enum(["now()"]).optional(),
   description: zod.z.string().max(500).optional(),
   /** Migration hints — same semantics as v1. */
-  renamedFrom: identifier.optional(),
+  renamedFrom: columnIdentifier.optional(),
   cast: zod.z.string().max(200).optional(),
-  deprecated: zod.z.boolean().default(false)
+  deprecated: zod.z.boolean().default(false),
+  /**
+   * Marks a system cell-metadata column (see CELL_PARTS in constants): part
+   * `part` of the cell of logical column `of`. Synthesized by authoring,
+   * never client-writable, absent from GraphQL scalar fields. Omitted on
+   * ordinary columns so their hashes are unchanged.
+   */
+  cell: zod.z.object({ of: zod.z.string().min(1).max(63), part: zod.z.enum(CELL_PARTS) }).strict().optional()
+}).superRefine((column, ctx) => {
+  if (column.onUpdateFn === void 0) return;
+  if (typeof column.type !== "string" || column.type !== "timestamptz" && column.type !== "date") {
+    ctx.addIssue({
+      code: "custom",
+      path: ["onUpdateFn"],
+      message: `onUpdateFn '${column.onUpdateFn}' is only valid on timestamptz/date columns`
+    });
+  }
 });
 var canonicalLinkSchema = zod.z.object({
   name: zod.z.string().min(1).max(63),
   kind: zod.z.enum(["toOne", "toMany", "toPlatformUser"]),
   /** Target table name (namespace-local). Absent for toPlatformUser. */
-  target: identifier.optional(),
+  target: identifier2.optional(),
   /** FK column on the owning side (toOne/toPlatformUser: on this table; toMany: on the target). */
-  on: identifier,
+  on: columnIdentifier,
   /** Referenced column on the target (default: target's PK / platform user `sub`). */
-  references: identifier.optional(),
+  references: columnIdentifier.optional(),
   /** enforce: true emits a real FK constraint (same-namespace toOne only). */
   enforce: zod.z.boolean().default(false),
+  onDelete: zod.z.enum(["cascade", "restrict", "no action", "set null", "set default"]).optional(),
+  onUpdate: zod.z.enum(["cascade", "restrict", "no action", "set null", "set default"]).optional(),
   description: zod.z.string().max(500).optional()
 });
 var canonicalIndexSchema = zod.z.object({
-  columns: zod.z.array(identifier).min(1),
+  columns: zod.z.array(columnIdentifier).min(1),
   unique: zod.z.boolean().default(false),
-  name: identifier.optional()
+  name: identifier2.optional()
 });
-var policyVariantSchema = zod.z.object({
-  /** Claims-only guard (capability()/role()/claim() comparisons — no columns). */
-  when: zod.z.string().min(1).max(1e3),
-  /** Exactly one of: allow-all bypass, or a row predicate. */
-  allow: zod.z.literal(true).optional(),
-  policy: zod.z.string().min(1).max(2e3).optional()
-}).refine((v) => v.allow === true !== (typeof v.policy === "string"), {
-  message: "A variant declares exactly one of allow: true or policy"
-});
-var policyExpressionSchema = zod.z.union([
-  zod.z.string().min(1).max(2e3),
-  zod.z.object({
-    default: zod.z.string().min(1).max(2e3),
-    variants: zod.z.array(policyVariantSchema).max(10).default([])
-  })
-]);
+var canonicalCheckSchema = zod.z.object({
+  name: identifier2,
+  expression: zod.z.string().min(1).max(2e3)
+}).strict();
 var canonicalPoliciesSchema = zod.z.object({
   read: policyExpressionSchema.optional(),
   write: policyExpressionSchema.optional(),
@@ -1120,7 +1656,7 @@ var VIEW_QUERY_FUNCTION_ALLOWLIST = [
   "width_bucket"
 ];
 var canonicalActionSchema = zod.z.object({
-  name: identifier,
+  name: identifier2,
   requires: zod.z.string().max(1e3).optional(),
   params: zod.z.record(zod.z.string(), zod.z.object({
     type: columnTypeSchema,
@@ -1132,9 +1668,9 @@ var canonicalActionSchema = zod.z.object({
 });
 var canonicalCowMutationSchema = zod.z.object({
   kind: zod.z.enum(["override", "revert"]),
-  name: identifier,
+  name: identifier2,
   /** Synced table (same namespace) the overlay copies from / falls back to. */
-  synced: identifier,
+  synced: identifier2,
   /** Single-column primary key PROPERTY (TS camelCase, like column `name`) shared by overlay and synced. */
   pk: zod.z.string().min(1).max(63),
   /** Override: contract properties copied INSERT…SELECT from synced (pk included). Empty for revert. */
@@ -1161,17 +1697,28 @@ var canonicalCowMutationSchema = zod.z.object({
     }
   }
 });
+var canonicalForeignKeySchema = zod.z.object({
+  name: identifier2,
+  columns: zod.z.array(columnIdentifier).min(1).max(8),
+  target: identifier2,
+  references: zod.z.array(columnIdentifier).min(1).max(8),
+  deferrable: zod.z.enum(["initially-immediate", "initially-deferred"]).optional(),
+  onDelete: zod.z.enum(["cascade", "restrict", "no action", "set null", "set default"]).optional(),
+  onUpdate: zod.z.enum(["cascade", "restrict", "no action", "set null", "set default"]).optional()
+}).strict();
 var canonicalTableSchema = zod.z.object({
-  table: identifier,
+  table: identifier2,
   description: zod.z.string().max(2e3).optional(),
   /** Table-level rename hint (new in v2). */
-  renamedFrom: identifier.optional(),
+  renamedFrom: identifier2.optional(),
   /** Synced/reflected read-only tables (`source: gold.*`) — v1 semantics. */
   source: zod.z.string().regex(/^gold\.[a-z][a-z0-9_]*$/).optional(),
   columns: zod.z.array(canonicalColumnSchema).default([]),
-  primaryKey: zod.z.array(identifier).min(1).max(8).optional(),
+  primaryKey: zod.z.array(columnIdentifier).min(1).max(8).optional(),
   links: zod.z.array(canonicalLinkSchema).default([]),
   indexes: zod.z.array(canonicalIndexSchema).default([]),
+  /** Omitted by old definitions, preserving their existing content hashes. */
+  checks: zod.z.array(canonicalCheckSchema).max(100).optional(),
   policies: canonicalPoliciesSchema.default({}),
   /**
    * v1-conversion carry-over only. v2 has no action surface — the runtime
@@ -1180,26 +1727,64 @@ var canonicalTableSchema = zod.z.object({
    */
   actions: zod.z.array(canonicalActionSchema).default([]),
   /** Optional (not defaulted) so pre-CoW canonical documents keep byte-identical hashes. */
-  cowMutations: zod.z.array(canonicalCowMutationSchema).optional()
+  cowMutations: zod.z.array(canonicalCowMutationSchema).optional(),
+  /** Omitted by old definitions, preserving their existing content hashes. */
+  foreignKeys: zod.z.array(canonicalForeignKeySchema).max(100).optional(),
+  /**
+   * Per-cell edit metadata (`cellMetadata: true` in authoring): every tracked
+   * column `c` carries typed `c__at` / `c__by` system columns (plus `c__rev`
+   * on a resolved table's internal sources), listed explicitly in `columns`
+   * with a `cell` marker so DDL and migrations treat them as ordinary columns.
+   * Omitted when off so existing definitions hash unchanged.
+   */
+  cellMetadata: zod.z.literal(true).optional(),
+  /**
+   * System-owned backing table of a resolved table (its manual or prefetch
+   * source). Internal tables get DDL and IR metadata but no GraphQL surface;
+   * only the data plane writes them. Omitted when false.
+   */
+  internal: zod.z.literal(true).optional(),
+  /**
+   * The materialized copy of resolved table `materializes` (internal): the
+   * same columns as that view, including its cell parts, maintained by the
+   * data plane. Omitted otherwise.
+   */
+  materializes: identifier2.optional()
 });
+var MAX_VIEW_QUERY = 1e5;
+var MAX_RESOLVED_VIEW_QUERY = 5e6;
 var canonicalViewSchema = zod.z.object({
-  view: identifier,
+  view: identifier2,
   description: zod.z.string().max(2e3).optional(),
   columns: zod.z.array(canonicalColumnSchema).min(1),
   /** Logical identity for GraphQL only; PostgreSQL views have no PK constraint. */
-  primaryKey: zod.z.array(identifier).min(1).max(8).optional(),
+  primaryKey: zod.z.array(columnIdentifier).min(1).max(8).optional(),
   links: zod.z.array(canonicalLinkSchema).default([]),
   policies: zod.z.object({ read: policyExpressionSchema }).strict(),
-  query: zod.z.string().min(1).max(1e5).refine(isSingleViewQuerySql, {
+  query: zod.z.string().min(1).max(MAX_RESOLVED_VIEW_QUERY).refine(isSingleViewQuerySql, {
     message: "view query must be one SELECT/WITH statement without comments or dollar-quoted bodies"
   }),
   /** Namespace-local logical relation names, sorted for deterministic hashing. */
-  dependencies: zod.z.array(identifier).max(500)
+  dependencies: zod.z.array(identifier2).max(500),
+  /**
+   * Present when this view is a resolved table (defineResolvedTable): the
+   * multi-source metadata behind its generated query. Omitted otherwise so
+   * existing views hash unchanged.
+   */
+  resolved: canonicalResolvedSchema.optional(),
+  /** System-owned view (a materialized resolved table's compute view): no GraphQL surface. */
+  internal: zod.z.literal(true).optional()
 }).superRefine((view, ctx) => {
+  if (view.resolved === void 0 && view.query.length > MAX_VIEW_QUERY) {
+    ctx.addIssue({ code: "custom", path: ["query"], message: `view query must be at most ${MAX_VIEW_QUERY} characters` });
+  }
   for (const [index3, column] of view.columns.entries()) {
     if (column.default !== void 0 || column.defaultFn !== void 0) {
       ctx.addIssue({ code: "custom", path: ["columns", index3], message: `view column '${column.name}' cannot declare a default` });
     }
+    if (column.onUpdateFn !== void 0) {
+      ctx.addIssue({ code: "custom", path: ["columns", index3], message: `view column '${column.name}' cannot declare onUpdateFn` });
+    }
     if (column.unique) {
       ctx.addIssue({ code: "custom", path: ["columns", index3], message: `view column '${column.name}' cannot declare unique` });
     }
@@ -1207,15 +1792,82 @@ var canonicalViewSchema = zod.z.object({
       ctx.addIssue({ code: "custom", path: ["columns", index3], message: `view column '${column.name}' cannot declare migration hints` });
     }
   }
+  if (view.resolved === void 0 && view.internal !== true) {
+    for (const [index3, column] of view.columns.entries()) {
+      if (column.cell) ctx.addIssue({ code: "custom", path: ["columns", index3], message: `only resolved tables carry cell columns ('${column.name}')` });
+    }
+  }
   for (const [index3, link] of view.links.entries()) {
     if (link.enforce) {
       ctx.addIssue({ code: "custom", path: ["links", index3, "enforce"], message: `view link '${link.name}' cannot enforce a foreign key` });
     }
+    if (link.onDelete !== void 0 || link.onUpdate !== void 0) {
+      ctx.addIssue({ code: "custom", path: ["links", index3], message: `view link '${link.name}' cannot declare referential actions` });
+    }
   }
 });
+var 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 canonicalDefinitionSchema = zod.z.object({
   definition_format: zod.z.literal(CANONICAL_FORMAT),
-  namespace: identifier.max(41),
+  namespace: identifier2.max(41),
   description: zod.z.string().max(2e3).optional(),
   enums: zod.z.array(canonicalEnumSchema).default([]),
   tables: zod.z.array(canonicalTableSchema).min(0).max(500),
@@ -1233,6 +1885,74 @@ var canonicalDefinitionSchema = zod.z.object({
       ctx.addIssue({ code: "custom", path: ["tables", index3, "table"], message: `duplicate relation '${table.table}'` });
     }
     seen.add(table.table);
+    validateCellMetadata(table, index3, ctx);
+    if (table.source !== void 0) {
+      for (const [columnIndex, column] of table.columns.entries()) {
+        if (column.onUpdateFn !== void 0) {
+          ctx.addIssue({
+            code: "custom",
+            path: ["tables", index3, "columns", columnIndex],
+            message: `synced table '${table.table}' column '${column.name}' cannot declare onUpdateFn`
+          });
+        }
+      }
+    }
+  }
+  const fkTables = new Map(definition.tables.map((table) => [table.table, table]));
+  for (const [tableIndex, table] of definition.tables.entries()) {
+    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}'`);
+      names.add(fk.name);
+      const target = fkTables.get(fk.target);
+      if (table.source || !target || target.source) {
+        fail("foreign keys must connect owned tables in the same namespace");
+        continue;
+      }
+      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);
+        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((name) => table.columns.find((column) => column.columnName === name)?.nullable === false || table.primaryKey?.includes(name))) 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()) {
@@ -1357,8 +2077,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));
 }
@@ -1368,12 +2092,14 @@ function normalizeCanonical(definition) {
     ...definition,
     enums: sortByName(definition.enums),
     tables: [...definition.tables].sort((a, b) => a.table.localeCompare(b.table)).map((t2) => {
-      const { cowMutations, ...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) } : {}
       };
@@ -1388,6 +2114,454 @@ function normalizeCanonical(definition) {
   }
   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 name = physical({ source, property: column });
+  const value = `CAST(${a}.${ident(name)} 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(name, "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(name, "by"))}` };
+}
+function outranks({ i, j, key, direction, inclusive }) {
+  const ki = i[key];
+  const kj = j[key];
+  const op = inclusive ? `${direction}=` : direction;
+  return inclusive ? `(${kj} IS NULL OR (${ki} IS NOT NULL AND ${ki} ${op} ${kj}))` : `(${ki} IS NOT NULL AND (${kj} IS NULL OR ${ki} ${op} ${kj}))`;
+}
+function rankedWinner({ candidates, key, direction }) {
+  const branches = candidates.map((candidate, index3) => {
+    const beats = candidates.map((other, otherIndex) => otherIndex === index3 ? null : `(NOT ${other.has} OR ${outranks({ i: candidate, j: other, key, direction, inclusive: index3 < otherIndex })})`).filter((clause) => clause !== null);
+    return `WHEN ${[candidate.has, ...beats].join(" AND ")} THEN ${index3 + 1}`;
+  });
+  return `CASE ${branches.join(" ")} END`;
+}
+function winnerIndex({ comparator, candidates }) {
+  const firstWith = (test) => candidates.map((candidate, index3) => `WHEN ${test(candidate)} THEN ${index3 + 1}`).join(" ");
+  if (candidates.length === 1 || comparator === "priority") return `CASE ${firstWith((c) => c.has)} END`;
+  switch (comparator) {
+    case "latest":
+      return rankedWinner({ candidates, key: "at", direction: ">" });
+    case "highest":
+      return rankedWinner({ candidates, key: "value", direction: ">" });
+    case "lowest":
+      return rankedWinner({ candidates, key: "value", direction: "<" });
+    case "nonNullFirst":
+      return `CASE ${firstWith((c) => `${c.has} AND ${c.value} IS NOT NULL`)} ${firstWith((c) => c.has)} END`;
+  }
+}
+function pick(winner, candidates, field) {
+  return `CASE ${winner} ${candidates.map((candidate, index3) => `WHEN ${index3 + 1} THEN ${field(candidate)}`).join(" ")} END`;
+}
+function loserSql({ loser, winner }) {
+  return `CASE WHEN ${loser.has} AND ${loser.value} IS DISTINCT FROM ${winner.value} AND ${loser.at} > ${winner.at} THEN jsonb_build_array(jsonb_build_object('source', ${literal(loser.source)}, 'value', to_jsonb(${loser.value}), 'at', ${loser.at})) ELSE '[]'::jsonb END`;
+}
+function losersAgainst({ candidates, winner, isWinner }) {
+  const losers = candidates.flatMap((loser, index3) => {
+    const excluded = isWinner(loser, index3);
+    if (excluded === true) return [];
+    const clause = loserSql({ loser, winner });
+    return [excluded === false ? clause : `CASE WHEN ${excluded} THEN '[]'::jsonb ELSE ${clause} END`];
+  });
+  return losers.length === 0 ? "CAST(NULL AS jsonb)" : `NULLIF(${losers.join(" || ")}, '[]'::jsonb)`;
+}
+function builtinCell({ comparator, candidates }) {
+  const winner = winnerIndex({ comparator, candidates });
+  const conflicts = comparator === "latest" || candidates.length < 2 ? "CAST(NULL AS jsonb)" : `CASE ${winner} ${candidates.map((known, index3) => `WHEN ${index3 + 1} THEN ${losersAgainst({ candidates, winner: known, isWinner: (_c, other) => other === index3 })}`).join(" ")} END`;
+  return {
+    value: pick(winner, candidates, (c) => c.value),
+    parts: {
+      source: pick(winner, candidates, (c) => literal(c.source)),
+      at: pick(winner, candidates, (c) => c.at),
+      by: pick(winner, candidates, (c) => c.by),
+      conflicts
+    }
+  };
+}
+function customCell({ candidates, orderBy, index: index3 }) {
+  const w = ident(`w_${index3}`);
+  const rows = candidates.map((c, ord) => `(${literal(c.source)}, ${c.has}, ${c.value}, ${c.at}, ${c.by}, ${ord})`);
+  const lateral = ` LEFT JOIN LATERAL (SELECT max(winner.source) AS source, (array_agg(winner.value))[1] AS value, max(winner.updated_at) AS updated_at, max(winner.actor) AS actor FROM (WITH cand(source, has, value, updated_at, actor, ord) AS (VALUES ${rows.join(", ")}) SELECT c.source, c.value, c.updated_at, c.actor FROM cand c WHERE c.has ORDER BY ${orderBy}, c.ord LIMIT 1) AS winner) AS ${w} ON true`;
+  const winner = { value: `${w}.value`, at: `${w}.updated_at` };
+  return {
+    value: winner.value,
+    lateral,
+    parts: {
+      source: `${w}.source`,
+      at: winner.at,
+      by: `${w}.actor`,
+      conflicts: candidates.length < 2 ? "CAST(NULL AS jsonb)" : losersAgainst({ candidates, winner, isWinner: (c) => `${w}.source = ${literal(c.source)}` })
+    }
+  };
+}
+function buildResolvedQuery({ context, plan }) {
+  const { qb, relation } = context;
+  const pkColumn = plan.columns[plan.pk].columnNameFor(plan.pk);
+  const alias = (source) => ident(`s_${source}`);
+  const tombstoned2 = RESOLVED_SOURCE_SYSTEM_COLUMNS.tombstoned.columnName;
+  const sourceByName = new Map(plan.plans.map((source) => [source.name, source]));
+  const schema = pgCore.getTableConfig(relation(plan.plans[0].table)).schema;
+  const keyBranches = plan.plans.map((source) => {
+    const where = source.kind === "prefetch" ? drizzleOrm.sql.raw(` WHERE NOT ${ident(tombstoned2)}`) : drizzleOrm.sql.raw("");
+    const sourcePk = ident(physical({ source, property: plan.pk }));
+    const selectedPk = sourcePk === ident(pkColumn) ? sourcePk : `${sourcePk} AS ${ident(pkColumn)}`;
+    return drizzleOrm.sql`SELECT ${drizzleOrm.sql.raw(selectedPk)} FROM ${relation(source.table)}${where}`;
+  });
+  const joins = plan.plans.map(
+    (source) => drizzleOrm.sql` LEFT JOIN ${relation(source.table)} AS ${drizzleOrm.sql.raw(alias(source.name))} ON ${drizzleOrm.sql.raw(`${alias(source.name)}.${ident(physical({ source, property: plan.pk }))} = "k".${ident(pkColumn)}`)}`
+  );
+  const cells = /* @__PURE__ */ new Map();
+  plan.rules.forEach((rule, index3) => {
+    const canonical = plan.columns[rule.column].toCanonicalColumn(rule.column);
+    const pgType = typeof canonical.type === "string" ? PG_TYPE[canonical.type] : `${schema === void 0 ? "" : `${ident(schema)}.`}${ident(canonical.type.enum)}`;
+    const candidates = rule.candidates.map((name) => candidateSql({ source: sourceByName.get(name), column: rule.column, pk: plan.pk, pgType }));
+    cells.set(rule.column, rule.comparator === "custom" ? customCell({ candidates, orderBy: rule.orderBy, index: index3 }) : builtinCell({ comparator: rule.comparator, candidates }));
+  });
+  const laterals = [...cells.values()].flatMap((cell) => cell.lateral ? [drizzleOrm.sql.raw(cell.lateral)] : []);
+  const from = drizzleOrm.sql.join([drizzleOrm.sql`(${drizzleOrm.sql.join(keyBranches, drizzleOrm.sql.raw(" UNION "))}) AS "k"`, ...joins, ...laterals], drizzleOrm.sql.raw(""));
+  const selected = {
+    [plan.pk]: drizzleOrm.sql.raw(`"k".${ident(pkColumn)}`).as(pkColumn)
+  };
+  for (const [property, builder] of Object.entries(plan.columns)) {
+    if (property === plan.pk) continue;
+    const cell = cells.get(property);
+    const columnName = builder.columnNameFor(property);
+    selected[property] = drizzleOrm.sql.raw(cell.value).as(columnName);
+    for (const [part, expression] of Object.entries(cell.parts)) {
+      selected[cellColumnName(property, part)] = drizzleOrm.sql.raw(expression).as(cellColumnName(columnName, part));
+    }
+  }
+  const manual = plan.plans.find((source) => source.kind === "manual");
+  const system = RESOLVED_VIEW_SYSTEM_COLUMNS;
+  selected[system.writebackStatus.name] = drizzleOrm.sql.raw(`${alias(manual.name)}.${ident(RESOLVED_SOURCE_SYSTEM_COLUMNS.writebackStatus.columnName)}`).as(system.writebackStatus.columnName);
+  selected[system.writebackError.name] = drizzleOrm.sql.raw(`${alias(manual.name)}.${ident(RESOLVED_SOURCE_SYSTEM_COLUMNS.writebackError.columnName)}`).as(system.writebackError.columnName);
+  const hidden = plan.deletedBy.map((name) => `NOT COALESCE(${alias(name)}.${ident(tombstoned2)}, false)`);
+  const query = qb.select(selected).from(from);
+  return hidden.length > 0 ? query.where(drizzleOrm.sql.raw(hidden.join(" AND "))) : query;
+}
+function managedFn(id) {
+  return { kind: "managed", id };
+}
+function manualSource() {
+  return { kind: "manual" };
+}
+function etlSource(input) {
+  return { kind: "etl", ...input };
+}
+function prefetchSource(input) {
+  return { kind: "prefetch", ...input };
+}
+var latest = (candidates) => ({ kind: "latest", candidates });
+var highest = (candidates) => ({ kind: "highest", candidates });
+var lowest = (candidates) => ({ kind: "lowest", candidates });
+var priority = (candidates) => ({ kind: "priority", candidates });
+var nonNullFirst = (candidates) => ({ kind: "nonNullFirst", candidates });
+var custom = (candidates, orderBy) => ({ kind: "custom", candidates, orderBy });
+var SYSTEM_VIEW_COLUMNS = {
+  [RESOLVED_VIEW_SYSTEM_COLUMNS.writebackStatus.name]: () => t.text(RESOLVED_VIEW_SYSTEM_COLUMNS.writebackStatus.columnName),
+  [RESOLVED_VIEW_SYSTEM_COLUMNS.writebackError.name]: () => t.text(RESOLVED_VIEW_SYSTEM_COLUMNS.writebackError.columnName)
+};
+function defineResolvedTable(name, columns, config) {
+  const file = activeAuthoringContext()?.currentFile;
+  const fail = (message) => {
+    throw new OrmDefinitionError(`resolved table "${name}": ${message}`, file);
+  };
+  if (!IDENTIFIER_PATTERN.test(name)) 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: name, 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(name, typedColumns, { ...surface, query: (context) => buildResolvedQuery({ context, plan: queryPlan }), resolved });
+  }
+  const materialize = config.materialize === true ? {} : config.materialize;
+  const computeName = `${name}__compute`;
+  const tableName = `${name}__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 "${name}". System-maintained from "${computeName}".`,
+    internal: true,
+    materializes: name,
+    ...materialize.indexes !== void 0 ? { indexes: materialize.indexes } : {}
+  });
+  return defineView(name, typedColumns, {
+    ...surface,
+    query: (context) => {
+      const handle = context.relation(table);
+      const selected = Object.fromEntries(Object.entries(viewColumns).map(([property, builder]) => [
+        property,
+        drizzleOrm.sql`${handle[property]}`.as(builder.columnNameFor(property))
+      ]));
+      return context.qb.select(selected).from(context.relation(table));
+    },
+    resolved: {
+      ...resolved,
+      internalTables: [...resolved.internalTables, table],
+      internalViews: [compute],
+      materialized: { table: tableName, compute: computeName }
+    }
+  });
+}
+function planRules({ config, plans, dataColumns, fail }) {
+  const kindOrder = { manual: 0, prefetch: 1, etl: 2 };
+  const fallback = config.default ?? priority([...plans].sort((a, b) => kindOrder[a.kind] - kindOrder[b.kind]).map((plan) => plan.name));
+  for (const column of Object.keys(config.resolve ?? {})) {
+    if (!dataColumns.includes(column)) fail(`resolve names unknown column "${column}"`);
+  }
+  return dataColumns.map((column) => {
+    const explicit = config.resolve?.[column];
+    const comparator = explicit ?? fallback;
+    const candidates = explicit ? [...explicit.candidates] : comparator.candidates.filter((name) => plans.find((plan) => plan.name === name)?.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);
   if (Array.isArray(value)) return `[${value.map(stableJson).join(",")}]`;
@@ -1494,8 +2668,19 @@ function defineNamespace(input) {
   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) {
@@ -1597,6 +2782,9 @@ function buildCanonicalTable({ table, relationsByName, enumsByName }) {
   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`,
@@ -1634,6 +2822,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(
@@ -1647,6 +2840,45 @@ 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) => {
+      const target = resolveRelationRef({ ref: fk.target, fail: (message) => {
+        throw new OrmDefinitionError(message, table.file);
+      } });
+      if (!isSeqTable(target) || !relationsByName.has(target.tableName)) throw new OrmDefinitionError("foreign key target must be a table in this namespace", table.file);
+      return {
+        name: fk.name,
+        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.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" }))
@@ -1699,6 +2931,12 @@ function buildCanonicalView({
     if (column.default !== void 0 || column.defaultFn !== void 0) {
       throw new OrmDefinitionError(`view "${view.viewName}": column "${propertyName}" cannot declare a default`, view.file);
     }
+    if (column.onUpdateFn !== void 0) {
+      throw new OrmDefinitionError(
+        `view "${view.viewName}": column "${propertyName}" cannot declare onUpdateFn`,
+        view.file
+      );
+    }
     if (column.unique) {
       throw new OrmDefinitionError(`view "${view.viewName}": column "${propertyName}" cannot declare unique`, view.file);
     }
@@ -1736,7 +2974,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({
@@ -1753,6 +3017,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 {
@@ -1781,6 +3048,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 } : {}
   };
 }
@@ -1959,6 +3228,10 @@ async function loadNamespaceFromDir(dir, options = {}) {
     fsCache: false,
     ...options.ormModulePath !== void 0 ? {
       alias: {
+        // The public /drizzle barrel re-exports this pinned dependency.
+        // Explicitly map it before the root alias: otherwise jiti appends
+        // "/drizzle" to the overridden module's filename.
+        "@sequenceholdings/orm/drizzle": module$1.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href))).resolve("drizzle-orm"),
         "@sequenceholdings/orm": options.ormModulePath,
         "@sequenceholdings/orm/authoring": options.ormModulePath
       }
@@ -2230,7 +3503,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) {
@@ -2304,7 +3577,7 @@ function readString(source, start) {
   }
   throw new PredicateParseError("unterminated string literal", start);
 }
-var Parser = class {
+var Parser2 = class {
   constructor(tokens) {
     this.tokens = tokens;
   }
@@ -2436,7 +3709,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
@@ -2521,8 +3794,8 @@ var actionSchema = zod.z.strictObject({
     }
   }
 });
-function extractNamedParams(sql4) {
-  const withoutStrings = sql4.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)];
 }
@@ -2589,17 +3862,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 = {
   "=": "=",
@@ -2679,8 +3941,8 @@ var actionParamArg = (name) => `p_${name}`;
 function compileActionStatements(action, renderParam = actionParamArg) {
   return actionStatementSources(action.executes).map((statement) => compileStatement(statement, renderParam));
 }
-function compileStatement(sql4, renderParam) {
-  const compiled = sql4.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);
@@ -2745,10 +4007,10 @@ 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 col = isEnum ? `${quoteIdentifier(physical2)}::text` : quoteIdentifier(physical2);
   const columnType = isEnum ? "text" : declared;
   switch (op) {
     case "eq":
@@ -2792,11 +4054,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);
@@ -2845,8 +4107,8 @@ function actionPrepareChecks(definition) {
     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((sql4, index3) => {
-      const checked = action.returns && index3 === compiled.length - 1 ? returnProjection(action.returns, sql4) : sql4;
+    compiled.forEach((sql7, index3) => {
+      const checked = action.returns && index3 === compiled.length - 1 ? returnProjection(action.returns, sql7) : sql7;
       statements.push(`PREPARE ${quoteIdentifier(`orm_check_${name}_${index3}`)}${signature} AS ${checked}`);
     });
   }
@@ -3228,14 +4490,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;
 }
@@ -3300,7 +4562,8 @@ function syncedViewStatements({
   readPolicyIrByTable,
   columnNamesByTable,
   columnTypesByTable,
-  executionOwnerRole = SYNCED_VIEW_EXECUTION_OWNER_ROLE
+  executionOwnerRole = SYNCED_VIEW_EXECUTION_OWNER_ROLE,
+  backingPrivileges = "grant"
 }) {
   const schema = quoteIdentifier(ormSchemaName(definition.namespace));
   const role = quoteIdentifier(consumerRoleName(definition.namespace));
@@ -3320,8 +4583,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),
@@ -3334,8 +4597,10 @@ function syncedViewStatements({
       columnTypes,
       columnNames: columnNamesByTable?.get(table.table)
     })}` : readPolicy ? ` WHERE ${compilePredicate(readPolicy.ast, narrowToV1ColumnTypes(columnTypes))}` : " WHERE false";
-    statements.push(`GRANT USAGE ON SCHEMA ${quoteIdentifier(physical.schema)} TO ${owner}`);
-    statements.push(`GRANT SELECT ON ${physicalTarget} TO ${owner}`);
+    if (backingPrivileges === "grant") {
+      statements.push(`GRANT USAGE ON SCHEMA ${quoteIdentifier(physical2.schema)} TO ${owner}`);
+      statements.push(`GRANT SELECT ON ${physicalTarget} TO ${owner}`);
+    }
     statements.push(
       `CREATE OR REPLACE VIEW ${viewName} AS SELECT * FROM ${physicalTarget}${whereClause}`
     );
@@ -3354,10 +4619,10 @@ function mergeSyncedViewColumnTypes({
     if (def?.type) fromTable[name] = 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;
     }
   }
@@ -3396,8 +4661,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}`);
@@ -3607,6 +4872,90 @@ 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, table, compute, columns, pk }) {
+  const fn = `${quoteIdentifier(schema)}.${quoteIdentifier(materializedRefreshFunctionName(name))}`;
+  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, name));
+  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 name of Object.keys(previous).sort()) {
+    if (!current.has(name)) statements.push(`DROP FUNCTION IF EXISTS ${schema}.${quoteIdentifier(materializedRefreshFunctionName(name))}(boolean)`);
+  }
+  for (const [name, create] of [...current].sort(([a], [b]) => a.localeCompare(b))) {
+    if (previous[name] === create) continue;
+    const fn = `${schema}.${quoteIdentifier(materializedRefreshFunctionName(name))}(boolean)`;
+    statements.push(create, `REVOKE ALL ON FUNCTION ${fn} FROM PUBLIC`);
+  }
+  return statements;
+}
+
+// src/engine/canonical2.ts
 var FACTORIES2 = {
   uuid: (name) => pgCore.uuid(name),
   text: (name) => pgCore.text(name),
@@ -3624,7 +4973,7 @@ var FACTORIES2 = {
 var SCHEMA_IMPORT_KEY2 = "$schema";
 var enumImportKey = (name) => `$enum_${name}`;
 var columnTablesV2 = (definition) => definition.tables.filter((table) => !table.source);
-function buildDrizzleEntitiesV2(definition) {
+function buildDrizzleEntitiesV2(definition, options = {}) {
   const schemaName = ormSchemaName(definition.namespace);
   const schema = pgCore.pgSchema(schemaName);
   const imports = { [SCHEMA_IMPORT_KEY2]: schema };
@@ -3639,11 +4988,19 @@ function buildDrizzleEntitiesV2(definition) {
   }
   const byName = new Map(definition.tables.map((table) => [table.table, table]));
   for (const table of sortByEnforcedLinks2(columnTablesV2(definition))) {
-    const drizzleTable = buildTable2(schema, table, built, enums, byName);
+    const drizzleTable = buildTable2(schema, table, built, enums, byName, options.introspection ?? false);
     built.set(table.table, drizzleTable);
     imports[table.table] = drizzleTable;
     tables[table.table] = drizzleTable;
   }
+  if (options.introspection) {
+    for (const table of definition.tables.filter((table2) => table2.source)) {
+      const columns = Object.fromEntries(
+        table.columns.map((column) => [column.columnName, buildViewColumnV2({ view: table.table, column, enums })])
+      );
+      imports[table.table] = schema.view(table.table, columns).existing();
+    }
+  }
   for (const view of definition.views ?? []) {
     const columns = Object.fromEntries(
       view.columns.map((column) => [column.columnName, buildViewColumnV2({ view: view.view, column, enums })])
@@ -3711,18 +5068,18 @@ function rewriteSyncedSourceRelationsInViewQuery({
     return rewritten;
   });
 }
-function transformSqlOutsideLiterals(sql4, 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(sql4.slice(codeStart, end)));
+    if (end > codeStart) out.push(transform(sql7.slice(codeStart, end)));
     codeStart = end;
   };
-  while (i < sql4.length) {
-    const c = sql4[i];
-    const next = i + 1 < sql4.length ? sql4[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 === "-") {
@@ -3742,7 +5099,7 @@ function transformSqlOutsideLiterals(sql4, transform) {
           break;
         }
         if ((c === "E" || c === "e") && next === "'") {
-          const prev = i > 0 ? sql4[i - 1] : "";
+          const prev = i > 0 ? sql7[i - 1] : "";
           if (!/[A-Za-z0-9_]/.test(prev)) {
             emitCode(i);
             state = { kind: "e-single" };
@@ -3761,9 +5118,9 @@ function transformSqlOutsideLiterals(sql4, transform) {
           break;
         }
         if (c === "$") {
-          const prev = i > 0 ? sql4[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(sql4.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] ?? "" };
@@ -3795,8 +5152,8 @@ function transformSqlOutsideLiterals(sql4, transform) {
         break;
       }
       case "e-single": {
-        if (c === "\\" && i + 1 < sql4.length) {
-          out.push(c, sql4[i + 1]);
+        if (c === "\\" && i + 1 < sql7.length) {
+          out.push(c, sql7[i + 1]);
           i += 2;
           break;
         }
@@ -3818,7 +5175,7 @@ function transformSqlOutsideLiterals(sql4, transform) {
       }
       case "dollar": {
         const closer = `$${state.tag}$`;
-        if (sql4.startsWith(closer, i)) {
+        if (sql7.startsWith(closer, i)) {
           out.push(closer);
           state = { kind: "normal" };
           i += closer.length;
@@ -3862,15 +5219,15 @@ function transformSqlOutsideLiterals(sql4, transform) {
       }
     }
   }
-  emitCode(sql4.length);
+  emitCode(sql7.length);
   return out.join("");
 }
 function escapeRegExp(value) {
   return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
-function sqlReferencesQualifiedRelation(sql4, sourceSchema, sourceName) {
+function sqlReferencesQualifiedRelation(sql7, sourceSchema, sourceName) {
   let referenced = false;
-  transformSqlOutsideLiterals(sql4, (segment) => {
+  transformSqlOutsideLiterals(sql7, (segment) => {
     if (qualifiedRelationPattern(sourceSchema, sourceName).test(segment)) referenced = true;
     return segment;
   });
@@ -3881,15 +5238,18 @@ function qualifiedRelationPattern(sourceSchema, sourceName) {
   const namePattern = `(?:"${escapeRegExp(sourceName)}"|${escapeRegExp(sourceName)})`;
   return new RegExp(`(?<![\\w."])${schemaPattern}\\.${namePattern}(?![\\w"])`, "g");
 }
-function replaceQualifiedRelation(sql4, sourceSchema, sourceName, boundSchema, boundTable) {
-  return sql4.replace(qualifiedRelationPattern(sourceSchema, sourceName), `"${boundSchema}"."${boundTable}"`);
+function replaceQualifiedRelation(sql7, sourceSchema, sourceName, boundSchema, boundTable) {
+  return sql7.replace(qualifiedRelationPattern(sourceSchema, sourceName), `"${boundSchema}"."${boundTable}"`);
 }
 function generateSnapshotV2(definition, previousId3) {
   const { imports, schemaName } = buildDrizzleEntitiesV2(definition);
   const snapshot = api.generateDrizzleJson(imports, previousId3, [schemaName]);
-  if ((definition.views?.length ?? 0) > 0) {
+  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()])
       )
@@ -3907,7 +5267,7 @@ function buildViewColumnV2({
   if (!column.nullable) builder = builder.notNull();
   return builder;
 }
-function buildTable2(schema, table, built, enums, byName) {
+function buildTable2(schema, table, built, enums, byName, introspection) {
   const primaryKeyColumns = table.primaryKey ?? [];
   if (primaryKeyColumns.length === 0) {
     throw new OrmDefinitionError(`table '${table.table}' declares no primaryKey`);
@@ -3923,13 +5283,26 @@ function buildTable2(schema, table, built, enums, byName) {
   const columns = Object.fromEntries(
     table.columns.map((column) => [
       column.columnName,
-      buildColumnV2({ table: table.table, column, singlePrimaryKey, compositeMembers, enums })
+      buildColumnV2({ table: table.table, column, singlePrimaryKey, compositeMembers, enums, introspection })
     ])
   );
   const drizzleTable = schema.table(table.table, columns, (self) => [
     ...buildCompositePrimaryKey(table, primaryKeyColumns, self),
     ...buildIndexes2(table, self),
-    ...buildForeignKeys2(table, self, built, byName)
+    ...(table.checks ?? []).map((check) => pgCore.check(check.name, drizzleOrm.sql.raw(compileCheckExpression(check.expression, table.columns)))),
+    ...buildForeignKeys2(table, self, built, byName),
+    ...(table.foreignKeys ?? []).map((fk) => {
+      const target = fk.target === table.table ? self : built.get(fk.target);
+      if (!target) throw new OrmDefinitionError(`foreign key '${fk.name}' has no target '${fk.target}'`);
+      let constraint = pgCore.foreignKey({
+        name: fk.name,
+        columns: fk.columns.map((column) => self[column]),
+        foreignColumns: fk.references.map((column) => target[column])
+      });
+      if (fk.onDelete !== void 0) constraint = constraint.onDelete(fk.onDelete);
+      if (fk.onUpdate !== void 0) constraint = constraint.onUpdate(fk.onUpdate);
+      return constraint;
+    })
   ]);
   return drizzleTable.enableRLS();
 }
@@ -3946,7 +5319,8 @@ function buildColumnV2({
   column,
   singlePrimaryKey,
   compositeMembers,
-  enums
+  enums,
+  introspection
 }) {
   const factory = resolveColumnFactory(table, column, enums);
   let builder = factory(column.columnName);
@@ -3967,7 +5341,7 @@ function buildColumnV2({
     }
     builder = builder.default(drizzleOrm.sql.raw(column.defaultFn));
   } else if (column.default !== void 0 && column.default !== null) {
-    builder = builder.default(column.default);
+    builder = introspection && column.type === "jsonb" && typeof column.default === "string" ? builder.default(drizzleOrm.sql.raw(`${quoteLiteral(column.default)}::jsonb`)) : builder.default(column.default);
   }
   return builder;
 }
@@ -4018,11 +5392,14 @@ function buildForeignKeys2(table, self, built, byName) {
         `enforced link '${link.name}' on '${table.table}' references unknown column '${targetColumn ? link.on : referencedColumn}'`
       );
     }
-    return pgCore.foreignKey({
+    let constraint = pgCore.foreignKey({
       name: foreignKeyName(table.table, link.name),
       columns: [sourceColumn],
       foreignColumns: [targetColumn]
     });
+    if (link.onDelete !== void 0) constraint = constraint.onDelete(link.onDelete);
+    if (link.onUpdate !== void 0) constraint = constraint.onUpdate(link.onUpdate);
+    return constraint;
   });
 }
 var singlePrimaryKeyOf = (table) => table.primaryKey?.length === 1 ? table.primaryKey[0] : void 0;
@@ -4143,16 +5520,31 @@ 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);
   assertValidViewDependencies(canonical);
   const hints = applyMigrationHintsV2(previous, canonical);
   const snapshot = generateSnapshotV2(canonical, previousId(previous));
-  const baseDdl = await diffStatements(withoutViews(hints.adjusted), withoutViews(snapshot));
+  const generatedBaseDdl = await diffStatements(withoutViews(hints.adjusted), withoutViews(snapshot));
+  const baseDdl = orderForeignKeyAdditions(canonical, generatedBaseDdl);
   const previousViews = snapshotViews(hints.adjusted);
   const currentViews = snapshotViews(snapshot);
   const previousDependencies = snapshotViewDependencies(hints.adjusted);
@@ -4162,7 +5554,14 @@ 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))),
@@ -4189,15 +5588,44 @@ async function planMigrationV2({
     ...dropOrder.map((name) => ({ kind: "ddl", sql: requiredViewStatement(dropDdl, name, schema, "DROP") })),
     ...hints.statements.map((statement) => ({ kind: "hint", sql: statement })),
     ...baseDdl.map((statement) => ({ kind: "ddl", sql: statement.replace(/;\s*$/, "") })),
+    ...foreignKeyTimingStatements(canonical, previous, baseDdl).map((sql7) => ({ kind: "ddl", sql: sql7 })),
     ...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}'`);
       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 };
 }
+function orderForeignKeyAdditions(canonical, statements) {
+  if (!canonical.tables.some((table) => table.foreignKeys?.length)) return [...statements];
+  const addsForeignKey = (statement) => /^ALTER TABLE[\s\S]* ADD CONSTRAINT[\s\S]* FOREIGN KEY\b/.test(statement);
+  return [...statements.filter((statement) => !addsForeignKey(statement)), ...statements.filter(addsForeignKey)];
+}
+function foreignKeyTimingStatements(canonical, previous, baseDdl) {
+  const prior = previous._sequenceOrm?.foreignKeys ?? {};
+  const result = [];
+  for (const table of canonical.tables) {
+    for (const fk of table.foreignKeys ?? []) {
+      const before = prior[`${table.table}.${fk.name}`];
+      const recreated = baseDdl.some((statement) => statement.includes(`ALTER TABLE ${quoteIdentifier(ormSchemaName(canonical.namespace))}.${quoteIdentifier(table.table)} ADD CONSTRAINT ${quoteIdentifier(fk.name)}`));
+      if (fk.deferrable ? !before || before.deferrable !== fk.deferrable || recreated : before?.deferrable && !recreated) {
+        result.push(foreignKeyTimingSql(ormSchemaName(canonical.namespace), table.table, fk.name, fk.deferrable));
+      }
+    }
+  }
+  return result;
+}
+function foreignKeyTimingSql(schema, table, name, 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}`;
+}
 function validateViewCatalogStatement({
   canonical,
   view,
@@ -4215,9 +5643,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);
@@ -4325,20 +5753,102 @@ 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((name) => dependencies[name] === 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(([name, column]) => {
+    const next = is2.columns[name];
+    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 = (name) => /* @__PURE__ */ new Set([...previousDependencies[name] ?? [], ...currentDependencies[name] ?? []]);
   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);
+      if (before === void 0 || after === void 0 || stableJson(before) !== stableJson(after)) return true;
+      return [...dependenciesOf(name)].some((dependency) => reach.has(dependency));
     })
   );
   let grew = true;
@@ -4346,8 +5856,7 @@ function affectedViewNames({
     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))) {
+      if ([...dependenciesOf(name)].some((dependency) => affected.has(dependency))) {
         affected.add(name);
         grew = true;
       }
@@ -4452,7 +5961,63 @@ async function pendingKitStatementsV2({
   canonical,
   db
 }) {
-  return pendingStatements({ entities: buildDrizzleEntitiesV2(canonical), db, owned: V2_OWNED_STATEMENT });
+  const { desired, defaultDrift } = await normalizeJsonDefaultsForIntrospection(canonical, db);
+  const entities = buildDrizzleEntitiesV2(desired, { introspection: true });
+  const pending = await pendingStatements({ entities, db, owned: V2_OWNED_STATEMENT });
+  return [...orderForeignKeyAdditions(canonical, pending), ...defaultDrift, ...await pendingForeignKeyTimingStatements(canonical, db)];
+}
+async function normalizeJsonDefaultsForIntrospection(canonical, db) {
+  const defaults = canonical.tables.flatMap((table, tableIndex) => table.source ? [] : table.columns.flatMap((column, columnIndex) => column.type === "jsonb" && typeof column.default === "string" ? [{ tableIndex, columnIndex, table: table.table, column: column.columnName, value: column.default }] : []));
+  if (defaults.length === 0) return { desired: canonical, defaultDrift: [] };
+  const array = (values) => drizzleOrm.sql`ARRAY[${drizzleOrm.sql.join(values.map((value) => drizzleOrm.sql`${value}`), drizzleOrm.sql`, `)}]::text[]`;
+  const schema = ormSchemaName(canonical.namespace);
+  const result = await shimExecute(db).execute(drizzleOrm.sql`
+    SELECT desired.ordinal, desired.value::jsonb::text AS normalized,
+      attribute.attnum IS NOT NULL AS column_exists,
+      coalesce(pg_get_expr(ad.adbin, ad.adrelid) = quote_literal(desired.value::jsonb::text) || '::jsonb', false) AS matches
+    FROM unnest(${array(defaults.map((item) => item.table))}, ${array(defaults.map((item) => item.column))}, ${array(defaults.map((item) => item.value))})
+      WITH ORDINALITY AS desired(table_name, column_name, value, ordinal)
+    LEFT JOIN pg_catalog.pg_namespace namespace ON namespace.nspname = ${schema}
+    LEFT JOIN pg_catalog.pg_class relation ON relation.relnamespace = namespace.oid AND relation.relname = desired.table_name
+    LEFT JOIN pg_catalog.pg_attribute attribute ON attribute.attrelid = relation.oid AND attribute.attname = desired.column_name AND NOT attribute.attisdropped
+    LEFT JOIN pg_catalog.pg_attrdef ad ON ad.adrelid = relation.oid AND ad.adnum = attribute.attnum
+    ORDER BY desired.ordinal
+  `);
+  const rows = result.rows;
+  if (!Array.isArray(rows) || rows.length !== defaults.length || rows.some((row, index3) => Number(row.ordinal) !== index3 + 1 || typeof row.normalized !== "string" || typeof row.column_exists !== "boolean" || typeof row.matches !== "boolean")) {
+    throw new Error("invalid JSON default introspection result");
+  }
+  const desired = structuredClone(canonical);
+  const defaultDrift = [];
+  defaults.forEach((item, index3) => {
+    const row = rows[index3];
+    desired.tables[item.tableIndex].columns[item.columnIndex].default = JSON.stringify(JSON.parse(row.normalized));
+    if (row.column_exists && !row.matches) defaultDrift.push(
+      `ALTER TABLE ${quoteIdentifier(schema)}.${quoteIdentifier(item.table)} ALTER COLUMN ${quoteIdentifier(item.column)} SET DEFAULT ${quoteLiteral(item.value)}::jsonb;`
+    );
+  });
+  return { desired, defaultDrift };
+}
+async function pendingForeignKeyTimingStatements(canonical, db) {
+  const keys = canonical.tables.flatMap((table) => (table.foreignKeys ?? []).map((fk) => ({ table: table.table, fk })));
+  if (keys.length === 0) return [];
+  const schema = ormSchemaName(canonical.namespace);
+  const result = await shimExecute(db).execute(drizzleOrm.sql`
+    SELECT relation.relname AS table_name, constraint_row.conname AS name,
+      constraint_row.condeferrable AS deferrable, constraint_row.condeferred AS deferred
+    FROM pg_catalog.pg_constraint AS constraint_row
+    JOIN pg_catalog.pg_class AS relation ON relation.oid = constraint_row.conrelid
+    JOIN pg_catalog.pg_namespace AS namespace ON namespace.oid = relation.relnamespace
+    WHERE namespace.nspname = ${schema} AND constraint_row.contype = 'f'
+  `);
+  const rows = result.rows;
+  return keys.flatMap(({ table, fk }) => {
+    const actual = rows.find((row) => row.table_name === table && row.name === fk.name);
+    const deferrable = fk.deferrable !== void 0;
+    const deferred = fk.deferrable === "initially-deferred";
+    if (actual ? actual.deferrable === deferrable && actual.deferred === deferred : !deferrable) return [];
+    return [foreignKeyTimingSql(schema, table, fk.name, fk.deferrable)];
+  });
 }
 async function pendingStatements({
   entities,
@@ -4465,11 +6030,31 @@ async function pendingStatements({
   );
   return statementsToExecute.filter((statement) => !owned.test(statement));
 }
+function correctIntrospectionQuery(query) {
+  if (!drizzleOrm.is(query, drizzleOrm.SQL)) return query;
+  const compiled = new pgCore.PgDialect().sqlToQuery(query);
+  let text4 = compiled.sql;
+  const indexJoin = "pg_constraint con ON con.conindid = idx.indexrelid";
+  if (text4.includes("AS generated_by_constraint") && text4.includes(indexJoin)) {
+    text4 = text4.replace(indexJoin, `${indexJoin} AND con.contype IN ('p', 'u', 'x')`);
+  }
+  const sourceJoin = "LEFT JOIN pg_catalog.pg_attribute att ON att.attnum = ANY (con.conkey)";
+  const targetJoin = "LEFT JOIN pg_catalog.pg_attribute fatt ON fatt.attnum = ANY (con.confkey)";
+  if (text4.includes(sourceJoin) && text4.includes(targetJoin) && text4.includes("AND con.contype IN ('f')")) {
+    text4 = text4.replace(
+      sourceJoin,
+      "JOIN LATERAL unnest(con.conkey, con.confkey) WITH ORDINALITY AS fk_key(source_num, target_num, ordinal) ON true LEFT JOIN pg_catalog.pg_attribute att ON att.attnum = fk_key.source_num"
+    ).replace(targetJoin, "LEFT JOIN pg_catalog.pg_attribute fatt ON fatt.attnum = fk_key.target_num").replace(/;\s*$/, "") + " ORDER BY con.conname, fk_key.ordinal";
+  }
+  if (text4 === compiled.sql) return query;
+  if (compiled.params.length !== 0) throw new Error("parameterized Drizzle catalog query cannot be normalized");
+  return drizzleOrm.sql.raw(text4);
+}
 function shimExecute(db) {
   const execute = db.execute.bind(db);
   return {
     execute: async (query) => {
-      const result = await execute(query);
+      const result = await execute(correctIntrospectionQuery(query));
       if (result && typeof result === "object" && "rows" in result) return result;
       return { rows: result };
     }
@@ -4509,21 +6094,73 @@ async function planMigration({
   const ddl = await diffStatements(hints.adjusted, snapshot);
   const policyDrops = policyDropStatements(schema, snapshotTableNames(previous, schema));
   const statements = [
-    ...policyDrops.map((sql4) => ({ kind: "security", sql: sql4 })),
-    ...hints.statements.map((sql4) => ({ kind: "hint", sql: sql4 })),
-    ...ddl.map((sql4) => ({ kind: "ddl", sql: sql4.replace(/;\s*$/, "") })),
-    ...securityStatements(definition).map((sql4) => ({ kind: "security", sql: sql4 })),
+    ...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((sql4) => ({ kind: "function", sql: sql4 })),
-    ...actionFunctionStatements(definition).map((sql4) => ({ kind: "function", sql: sql4 }))
+    ...actionPrepareChecks(definition).map((sql7) => ({ kind: "function", sql: sql7 })),
+    ...actionFunctionStatements(definition).map((sql7) => ({ kind: "function", sql: sql7 }))
   ];
   return { namespace: definition.namespace, schema, statements, snapshot };
 }
 var compileNamespace = (definition) => planMigration({ definition });
 var previousId2 = (snapshot) => snapshot.id;
-var IR_VERSION = 1;
+var ORM_MIGRATION_EXPORT_FILE = "orm.migration.json";
+var ORM_MIGRATION_EXPORT_MAX_BYTES = ORM_REGISTRATION_MAX_BYTES;
+var hash = zod.z.string().regex(/^sha256:[0-9a-f]{64}$/);
+var ormMigrationPayloadSchema = zod.z.object({
+  canonical_definition: canonicalDefinitionSchema,
+  documents: zod.z.array(zod.z.object({ path: zod.z.string().min(1).max(2048), contents: zod.z.string().max(1e6) }).strict()).max(5e3),
+  client_manifest: zod.z.object({ ops_hash: hash, operations: zod.z.record(zod.z.string(), hash) }).strict(),
+  sdl: zod.z.string().refine((value) => Buffer.byteLength(value, "utf8") <= MAX_GENERATED_SDL_BYTES, {
+    message: `sdl exceeds ${MAX_GENERATED_SDL_BYTES} bytes`
+  }),
+  schema_snapshot: zod.z.json(),
+  // The existing ORM committed-migration validator and replay engine remain
+  // authoritative. This envelope hashes the provenance, never authorizes SQL.
+  migration: zod.z.json().optional()
+}).strict();
+var ormMigrationExportSchema = zod.z.object({
+  schema_version: zod.z.literal(1),
+  schema_hash: hash,
+  payload: ormMigrationPayloadSchema,
+  checksum: zod.z.string().regex(/^[0-9a-f]{64}$/)
+}).strict();
+function checksum(value) {
+  return crypto.createHash("sha256").update(stableJson(value)).digest("hex");
+}
+function createOrmMigrationExport({ schemaHash, payload }) {
+  const contents = { schema_version: 1, schema_hash: hash.parse(schemaHash), payload: ormMigrationPayloadSchema.parse(payload) };
+  return { ...contents, checksum: checksum(contents) };
+}
+function parseOrmMigrationExport(text4) {
+  if (Buffer.byteLength(text4, "utf8") > ORM_MIGRATION_EXPORT_MAX_BYTES) throw new Error("ORM migration export exceeds the size limit");
+  const exported = ormMigrationExportSchema.parse(JSON.parse(text4));
+  const { checksum: expected, ...contents } = exported;
+  if (checksum(contents) !== expected) throw new Error("ORM migration export checksum mismatch; regenerate and commit it");
+  return exported;
+}
+function renderOrmMigrationExport(exported) {
+  const text4 = `${JSON.stringify(exported, null, 2)}
+`;
+  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 LEGACY_IR_VERSION = 1;
+var irVersionSchema = zod.z.union([zod.z.literal(LEGACY_IR_VERSION), zod.z.literal(IR_VERSION)]);
+var operationVersionSchema = zod.z.object({ irVersion: irVersionSchema });
+function requiredArtifactIrVersion(operations) {
+  let required = LEGACY_IR_VERSION;
+  for (const operation of operations) {
+    const { irVersion } = operationVersionSchema.parse(operation);
+    if (irVersion > required) required = irVersion;
+  }
+  return required;
+}
 var CLAIMS_CONTRACT = {
   sub: "string",
   org: "string?",
@@ -4595,6 +6232,21 @@ var selectionIrSchema = zod.z.lazy(
   () => zod.z.object({
     typename: zod.z.string(),
     columns: zod.z.array(zod.z.object({ alias: zod.z.string(), column: zod.z.string() })),
+    cells: zod.z.object({
+      alias: zod.z.string(),
+      typename: zod.z.string(),
+      fields: zod.z.array(zod.z.object({
+        alias: zod.z.string(),
+        column: zod.z.string(),
+        typename: zod.z.string(),
+        parts: zod.z.array(zod.z.object({
+          alias: zod.z.string(),
+          part: zod.z.enum(["source", "at", "by", "conflicts"]),
+          fields: zod.z.array(zod.z.object({ alias: zod.z.string(), field: zod.z.enum(["source", "at", "value"]) })).optional(),
+          typename: zod.z.string().optional()
+        }))
+      }))
+    }).optional(),
     relations: zod.z.array(zod.z.object({
       alias: zod.z.string(),
       link: zod.z.string(),
@@ -4616,6 +6268,11 @@ var selectionIrSchema = zod.z.lazy(
   })
 );
 var includeIfSchema = zod.z.object({ variable: zod.z.string(), negated: zod.z.boolean() });
+var prefetchPlanIrSchema = zod.z.object({
+  source: zod.z.string(),
+  maxStalenessMs: zod.z.number().int().positive().optional(),
+  key: zod.z.union([zod.z.object({ one: valueIrSchema }), zod.z.object({ many: valueIrSchema })])
+});
 var selectRootSchema = zod.z.object({
   kind: zod.z.literal("select"),
   alias: zod.z.string(),
@@ -4627,7 +6284,8 @@ var selectRootSchema = zod.z.object({
   distinctOn: zod.z.union([zod.z.array(zod.z.string()), zod.z.object({ slot: zod.z.string() })]).optional(),
   limit: limitIrSchema,
   offset: zod.z.object({ variable: zod.z.string().optional(), value: zod.z.number().int().optional() }).optional(),
-  includeIf: includeIfSchema.optional()
+  includeIf: includeIfSchema.optional(),
+  prefetch: zod.z.array(prefetchPlanIrSchema).optional()
 });
 var byPkRootSchema = zod.z.object({
   kind: zod.z.literal("byPk"),
@@ -4637,7 +6295,8 @@ var byPkRootSchema = zod.z.object({
   pk: zod.z.array(zod.z.object({ column: zod.z.string(), value: valueIrSchema })).min(1),
   /** Policy predicate — ANDed with the PK match. */
   where: predIrSchema,
-  includeIf: includeIfSchema.optional()
+  includeIf: includeIfSchema.optional(),
+  prefetch: zod.z.array(prefetchPlanIrSchema).optional()
 });
 var aggregateRootSchema = zod.z.object({
   kind: zod.z.literal("aggregate"),
@@ -4650,6 +6309,33 @@ var aggregateRootSchema = zod.z.object({
   nodes: selectionIrSchema.optional(),
   includeIf: includeIfSchema.optional()
 });
+var DATE_BUCKETS = ["year", "quarter", "month", "week", "day", "hour"];
+var groupByKeyIrSchema = zod.z.object({
+  column: zod.z.string(),
+  bucket: zod.z.enum(DATE_BUCKETS).optional()
+});
+var aggregateGroupsRootSchema = zod.z.object({
+  kind: zod.z.literal("aggregateGroups"),
+  alias: zod.z.string(),
+  table: zod.z.string(),
+  /** Composed at compile time: AND(policy, documentWhere?, dynamicFilter?). */
+  where: predIrSchema,
+  groupBy: zod.z.array(groupByKeyIrSchema).min(1),
+  /**
+   * The `key { … }` projection: which group columns appear in each entry's key
+   * object, in selection order. A subset of `groupBy` (the compiler rejects a
+   * key field that is not a group key — it would be indeterminate within the
+   * group). Empty when the document selects only `aggregate`.
+   */
+  key: zod.z.array(zod.z.object({ alias: zod.z.string(), column: zod.z.string() })).default([]),
+  count: zod.z.object({ columns: zod.z.array(zod.z.string()).optional(), distinct: zod.z.boolean().optional() }).optional(),
+  sum: zod.z.array(zod.z.string()).optional(),
+  avg: zod.z.array(zod.z.string()).optional(),
+  /** Bounds the GROUP count, not the scanned rows — see MAX_GROUPS. */
+  limit: limitIrSchema,
+  offset: zod.z.object({ variable: zod.z.string().optional(), value: zod.z.number().int().optional() }).optional(),
+  includeIf: includeIfSchema.optional()
+});
 var writeValuesSchema = zod.z.union([
   zod.z.object({ slot: zod.z.string() }),
   zod.z.object({ entries: zod.z.array(zod.z.object({ column: zod.z.string(), value: valueIrSchema })) })
@@ -4668,7 +6354,20 @@ var mutationRootSchema = zod.z.object({
    * coalesce view falls back to synced. Both are gated on a matching synced
    * row and carry the write policy in `where` like update/delete.
    */
-  op: zod.z.enum(["insert", "insertOne", "update", "updateByPk", "delete", "deleteByPk", "cowOverride", "cowRevert"]),
+  op: zod.z.enum(["insert", "insertOne", "update", "updateByPk", "delete", "deleteByPk", "cowOverride", "cowRevert", "resolvedWrite"]),
+  /**
+   * resolvedWrite: a write to a resolved table (`table` is its view). The
+   * executor gates on the resolved row (write policy in `where`), writes only
+   * the touched cells into the manual source, then re-checks `insertCheck`
+   * against the resolved row. `revert` clears `revertColumns` from the manual
+   * source; `delete` tombstones the row there.
+   */
+  resolvedAction: zod.z.enum(["insert", "update", "delete", "revert"]).optional(),
+  revertColumns: zod.z.array(zod.z.string()).optional(),
+  /** `@writeback(source:, mode:)` directives on this root. */
+  writeback: zod.z.array(zod.z.object({ source: zod.z.string(), mode: zod.z.enum(["sync", "async"]) })).optional(),
+  /** `@localOnly(source:)` — writeback columns deliberately kept local for these sources. */
+  localOnly: zod.z.array(zod.z.string()).optional(),
   alias: zod.z.string(),
   table: zod.z.string(),
   /** CoW ops: logical name of the synced twin (read through its policy-filtered view). */
@@ -4695,12 +6394,15 @@ var mutationRootSchema = zod.z.object({
   insertCheck: predIrSchema.optional(),
   returning: selectionIrSchema.nullable(),
   affectedRows: zod.z.boolean().default(false),
+  /** v2: abort the transaction when the actual write count differs, regardless of selection. */
+  assertAffectedRows: zod.z.number().int().min(0).max(2147483647).optional(),
   includeIf: includeIfSchema.optional()
 });
 var rootIrSchema = zod.z.discriminatedUnion("kind", [
   selectRootSchema,
   byPkRootSchema,
   aggregateRootSchema,
+  aggregateGroupsRootSchema,
   mutationRootSchema
 ]);
 var INPUT_REF_KINDS = [
@@ -4730,7 +6432,7 @@ var variableIrSchema = zod.z.object({
   defaultValue: variableDefaultIrSchema.optional()
 });
 var compiledOperationSchema = zod.z.object({
-  irVersion: zod.z.literal(IR_VERSION),
+  irVersion: irVersionSchema,
   name: zod.z.string(),
   opHash: zod.z.string().regex(/^sha256:[0-9a-f]{64}$/),
   kind: zod.z.enum(["query", "mutation"]),
@@ -4742,6 +6444,50 @@ var compiledOperationSchema = zod.z.object({
   /** Every table the op touches — data-token scoping + audit. */
   tableSet: zod.z.array(zod.z.string()).min(1),
   roots: zod.z.array(rootIrSchema).min(1)
+}).superRefine((operation, ctx) => {
+  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) {
+      ctx.addIssue({ code: "custom", path: ["roots", index3], message: "affected-row assertions require unconditional mutation roots and IR v2" });
+    }
+  }
+});
+var resolvedSourceIrSchema = zod.z.object({
+  name: zod.z.string(),
+  kind: zod.z.enum(["manual", "etl", "prefetch"]),
+  /** Logical table key of the backing relation. */
+  table: zod.z.string(),
+  columns: zod.z.array(zod.z.string()),
+  key: zod.z.string().optional(),
+  fetch: zod.z.union([
+    zod.z.object({ shape: zod.z.literal("single") }),
+    zod.z.object({ shape: zod.z.literal("batch"), maxKeys: zod.z.number().int().positive() })
+  ]).optional(),
+  function: zod.z.object({ kind: zod.z.enum(["managed", "native"]), id: zod.z.string() }).optional(),
+  prefetchDefaults: zod.z.object({
+    maxStalenessMs: zod.z.number().int().positive(),
+    timeoutMs: zod.z.number().int().positive(),
+    onError: zod.z.enum(["fallback", "fail"])
+  }).optional(),
+  writeback: zod.z.object({
+    columns: zod.z.array(zod.z.string()),
+    defaultMode: zod.z.enum(["sync", "async"]),
+    timeoutMs: zod.z.number().int().positive(),
+    clearManualOnConfirm: zod.z.boolean()
+  }).optional()
+});
+var resolvedMetaIrSchema = zod.z.object({
+  /** Logical pk column of the resolved view (single-column). */
+  pk: zod.z.string(),
+  /** Source name of the manual source. */
+  manual: zod.z.string(),
+  sources: zod.z.array(resolvedSourceIrSchema),
+  deletedBy: zod.z.array(zod.z.string()),
+  /**
+   * Materialized: the view reads `table`, which the data plane refreshes from
+   * the `compute` view (claims-gated) whenever it writes a source row.
+   */
+  materialized: zod.z.object({ table: zod.z.string(), compute: zod.z.string() }).optional()
 });
 var tableMetaIrSchema = zod.z.object({
   table: zod.z.string(),
@@ -4778,18 +6524,45 @@ var tableMetaIrSchema = zod.z.object({
   insertable: zod.z.array(zod.z.string()),
   settable: zod.z.array(zod.z.string()),
   appendable: zod.z.array(zod.z.string()),
+  /**
+   * Logical columns stamped with Postgres `now()` on UPDATE (canonical
+   * `onUpdateFn`). Omitted when empty so pre-onUpdate artifacts still parse.
+   */
+  touchOnUpdate: zod.z.array(zod.z.string()).optional(),
+  /**
+   * Per-cell metadata: logical column → the logical names of its cell-part
+   * columns (which are listed in `columns`, but never filterable, orderable or
+   * writable). Tables stamp `at`/`by` (and a manual source `rev`) on every
+   * write; resolved views expose `source`/`at`/`by`/`conflicts`. Omitted when
+   * the relation tracks no cells.
+   */
+  cells: zod.z.record(zod.z.string(), zod.z.object({
+    at: zod.z.string().optional(),
+    by: zod.z.string().optional(),
+    rev: zod.z.string().optional(),
+    source: zod.z.string().optional(),
+    conflicts: zod.z.string().optional()
+  }).strict()).optional(),
+  /** Resolved-table view metadata (sources, prefetch/writeback config) for the data plane. */
+  resolved: resolvedMetaIrSchema.optional(),
   constraints: zod.z.array(zod.z.object({ name: zod.z.string(), columns: zod.z.array(zod.z.string()) })),
   /** Depth/node caps for dynamic filter trees on this table. */
   dynamicFilterMaxDepth: zod.z.number().int().positive().default(6),
   dynamicFilterMaxNodes: zod.z.number().int().positive().default(64)
 });
 var compiledArtifactSchema = zod.z.object({
-  irVersion: zod.z.literal(IR_VERSION),
+  irVersion: irVersionSchema,
   namespace: zod.z.string(),
   schemaHash: zod.z.string(),
   opsHash: zod.z.string(),
   tables: zod.z.record(zod.z.string(), tableMetaIrSchema),
   operations: zod.z.record(zod.z.string(), compiledOperationSchema)
+}).superRefine((artifact, ctx) => {
+  for (const [name, operation] of Object.entries(artifact.operations)) {
+    if (operation.irVersion > artifact.irVersion) {
+      ctx.addIssue({ code: "custom", path: ["operations", name, "irVersion"], message: "operation requires a newer IR version than its artifact" });
+    }
+  }
 });
 var IrVersionError = class extends Error {
   constructor(found) {
@@ -4800,7 +6573,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 !== IR_VERSION) throw new IrVersionError(version);
+  if (version !== LEGACY_IR_VERSION && version !== IR_VERSION) throw new IrVersionError(version);
   return compiledArtifactSchema.parse(raw);
 }
 function indexByHash(artifact) {
@@ -5116,12 +6889,12 @@ async function writeMigration({
   const tip = workspace.journal.entries.at(-1);
   const ordinal = (tip?.ordinal ?? 0) + 1;
   const name = migrationName(ordinal, contentHash);
-  const sql4 = renderMigrationSql({ name, namespace: workspace.journal.namespace, contentHash, plan });
+  const sql7 = renderMigrationSql({ name, namespace: workspace.journal.namespace, contentHash, plan });
   const metaDir = path.join(dir, MIGRATIONS_DIRNAME, META_DIRNAME);
   await promises.mkdir(metaDir, { recursive: true });
   const snapshotText = `${JSON.stringify(plan.snapshot, null, 2)}
 `;
-  await promises.writeFile(path.join(dir, MIGRATIONS_DIRNAME, `${name}.sql`), sql4);
+  await promises.writeFile(path.join(dir, MIGRATIONS_DIRNAME, `${name}.sql`), sql7);
   await promises.writeFile(path.join(metaDir, `${pad(ordinal)}.snapshot.json`), snapshotText);
   const journal = {
     ...workspace.journal,
@@ -5132,7 +6905,7 @@ async function writeMigration({
         name,
         content_hash: contentHash,
         previous_content_hash: tip?.content_hash ?? null,
-        checksum: checksumOf(sql4),
+        checksum: checksumOf(sql7),
         snapshot_checksum: checksumOf(snapshotText),
         destructive
       }
@@ -5247,8 +7020,8 @@ async function checkWorkspace({
   let previousId3;
   let previousHash = null;
   for (const entry of workspace.journal.entries) {
-    const sql4 = await readMigrationSql(dir, entry);
-    if (checksumOf(sql4) !== 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;
     }
@@ -5288,7 +7061,7 @@ async function checkWorkspace({
   log(`migrations in sync \u2014 ${workspace.journal.entries.length} committed, tip ${tip.name}`);
   return 0;
 }
-var firstLine = (sql4) => sql4.split("\n")[0] ?? sql4;
+var firstLine = (sql7) => sql7.split("\n")[0] ?? sql7;
 
 // src/migrations/from-yaml.ts
 function convertV1DefinitionToCanonical(definition) {
@@ -5394,7 +7167,7 @@ function buildRebaseJournalEntry({ namespace, previousHash, newHash, ordinal, sn
     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 sql4 = renderRebaseMigrationSql({ name, namespace, previousHash, newHash });
+  const sql7 = renderRebaseMigrationSql({ name, namespace, previousHash, newHash });
   const snapshotText = `${JSON.stringify(snapshot, null, 2)}
 `;
   const entry = {
@@ -5402,11 +7175,11 @@ function buildRebaseJournalEntry({ namespace, previousHash, newHash, ordinal, sn
     name,
     content_hash: newHash,
     previous_content_hash: previousHash,
-    checksum: checksumOf(sql4),
+    checksum: checksumOf(sql7),
     snapshot_checksum: checksumOf(snapshotText),
     destructive: false
   };
-  return { name, entry, sql: sql4, snapshotText };
+  return { name, entry, sql: sql7, snapshotText };
 }
 function renderRebaseMigrationSql({
   name,
@@ -5530,16 +7303,21 @@ exports.AUDIT_ACTIONS = AUDIT_ACTIONS;
 exports.CANONICAL_FORMAT = CANONICAL_FORMAT;
 exports.CAPABILITIES_CLAIM_KEY = CAPABILITIES_CLAIM_KEY;
 exports.CAPABILITY_KEY_PATTERN = CAPABILITY_KEY_PATTERN;
+exports.CELLS_FIELD = CELLS_FIELD;
+exports.CELL_PARTS = CELL_PARTS;
+exports.CELL_PART_SUFFIX = CELL_PART_SUFFIX;
 exports.CLAIMS_CONTRACT = CLAIMS_CONTRACT;
 exports.CLAIMS_SETTING = CLAIMS_SETTING;
 exports.CLAIM_KEY_PATTERN = CLAIM_KEY_PATTERN;
 exports.CMP_OPS = CMP_OPS;
 exports.COLUMN_BRAND = COLUMN_BRAND;
 exports.COLUMN_DEFAULT_FNS = COLUMN_DEFAULT_FNS;
+exports.COLUMN_IDENTIFIER_PATTERN = COLUMN_IDENTIFIER_PATTERN;
 exports.COLUMN_TYPES = COLUMN_TYPES2;
 exports.COMPARE_OPS = COMPARE_OPS;
 exports.CONSUMER_ROLE_SUFFIX = CONSUMER_ROLE_SUFFIX;
 exports.ColumnBuilder = ColumnBuilder;
+exports.DATE_BUCKETS = DATE_BUCKETS;
 exports.DEFINITION_FILE_EXTENSIONS = DEFINITION_FILE_EXTENSIONS;
 exports.ENUM_BRAND = ENUM_BRAND;
 exports.HASH_DOMAIN = HASH_DOMAIN;
@@ -5548,15 +7326,23 @@ exports.IDENTIFIER_RE = IDENTIFIER_RE;
 exports.INPUT_REF_KINDS = INPUT_REF_KINDS;
 exports.IR_VERSION = IR_VERSION;
 exports.IrVersionError = IrVersionError;
+exports.LEGACY_IR_VERSION = LEGACY_IR_VERSION;
 exports.LINK_BRAND = LINK_BRAND;
+exports.MATERIALIZE_ACTOR = MATERIALIZE_ACTOR;
+exports.MATERIALIZE_CLAIMS_JSON = MATERIALIZE_CLAIMS_JSON;
 exports.MAX_DEFINITION_FILE_BYTES = MAX_DEFINITION_FILE_BYTES;
+exports.MAX_GENERATED_SDL_BYTES = MAX_GENERATED_SDL_BYTES;
 exports.MAX_IDENTIFIER_LENGTH = MAX_IDENTIFIER_LENGTH;
+exports.MAX_TRACKED_COLUMN_NAME = MAX_TRACKED_COLUMN_NAME;
 exports.MIGRATIONS_DIRNAME = MIGRATIONS_DIRNAME;
 exports.NAMESPACE_CONFIG_BRAND = NAMESPACE_CONFIG_BRAND;
 exports.NAMESPACE_CONFIG_FILE = NAMESPACE_CONFIG_FILE;
 exports.NAMESPACE_CONFIG_FILENAMES = NAMESPACE_CONFIG_FILENAMES;
 exports.NAMESPACE_PATTERN = NAMESPACE_PATTERN;
 exports.ORM_DATA_TOKEN_HEADER = ORM_DATA_TOKEN_HEADER;
+exports.ORM_MIGRATION_EXPORT_FILE = ORM_MIGRATION_EXPORT_FILE;
+exports.ORM_MIGRATION_EXPORT_MAX_BYTES = ORM_MIGRATION_EXPORT_MAX_BYTES;
+exports.ORM_REGISTRATION_MAX_BYTES = ORM_REGISTRATION_MAX_BYTES;
 exports.ORM_SCHEMA_PREFIX = ORM_SCHEMA_PREFIX;
 exports.ORM_SERVICE_DATA_TOKEN_HEADER = ORM_SERVICE_DATA_TOKEN_HEADER;
 exports.ORM_TO_PIPELINE_TYPE = ORM_TO_PIPELINE_TYPE;
@@ -5604,6 +7390,7 @@ exports.canonicalViewSchema = canonicalViewSchema;
 exports.canonicalizeDefinition = canonicalizeDefinition;
 exports.capabilityExpression = capabilityExpression;
 exports.castParts = castParts;
+exports.cellColumnName = cellColumnName;
 exports.checksumOf = checksumOf;
 exports.claimExpression = claimExpression;
 exports.classifyDestructive = classifyDestructive;
@@ -5621,9 +7408,12 @@ exports.computeDefinitionHash = computeDefinitionHash;
 exports.computeSyncedContractHash = computeSyncedContractHash;
 exports.consumerRoleName = consumerRoleName;
 exports.convertV1DefinitionToCanonical = convertV1DefinitionToCanonical;
+exports.createOrmMigrationExport = createOrmMigrationExport;
+exports.custom = custom;
 exports.declaredCapabilityKeys = declaredCapabilityKeys;
 exports.defineEnum = defineEnum;
 exports.defineNamespace = defineNamespace;
+exports.defineResolvedTable = defineResolvedTable;
 exports.defineSyncedTable = defineSyncedTable;
 exports.defineTable = defineTable;
 exports.defineView = defineView;
@@ -5633,11 +7423,13 @@ exports.diffStatements = diffStatements;
 exports.emptyJournal = emptyJournal;
 exports.emptySnapshot = emptySnapshot;
 exports.endAuthoringContext = endAuthoringContext;
+exports.etlSource = etlSource;
 exports.extractNamedParams = extractNamedParams;
 exports.extractOrmSyncedTableContract = extractOrmSyncedTableContract;
 exports.generateNamespaceTypes = generateNamespaceTypes;
 exports.generateSnapshot = generateSnapshot;
 exports.generateSnapshotV2 = generateSnapshotV2;
+exports.highest = highest;
 exports.identifierSchema = identifierSchema;
 exports.indexByHash = indexByHash;
 exports.isColumnBuilder = isColumnBuilder;
@@ -5650,34 +7442,47 @@ exports.isSeqLink = isSeqLink;
 exports.isSeqNamespaceConfig = isSeqNamespaceConfig;
 exports.isSeqTable = isSeqTable;
 exports.isSeqView = isSeqView;
+exports.latest = latest;
 exports.limitIrSchema = limitIrSchema;
 exports.loadCommittedMigrations = loadCommittedMigrations;
 exports.loadCommittedTipMigration = loadCommittedTipMigration;
 exports.loadNamespaceDefinition = loadNamespaceDefinition;
 exports.loadNamespaceFromDir = loadNamespaceFromDir;
+exports.lowest = lowest;
+exports.managedFn = managedFn;
+exports.manualSource = manualSource;
+exports.materializeLockKey = materializeLockKey;
+exports.materializedRefreshFunctionName = materializedRefreshFunctionName;
 exports.migrationName = migrationName;
 exports.namespaceConfigSchema = namespaceConfigSchema;
 exports.namespaceSchema = namespaceSchema;
+exports.nonNullFirst = nonNullFirst;
 exports.normalizeCanonical = normalizeCanonical;
 exports.normalizeIr = normalizeIr;
 exports.normalizeSnapshot = normalizeSnapshot;
 exports.orderIrSchema = orderIrSchema;
+exports.ormMigrationExportSchema = ormMigrationExportSchema;
 exports.ormSchemaName = ormSchemaName;
 exports.overlayWinsUnion = overlayWinsUnion;
 exports.overrideRowMutation = overrideRowMutation;
 exports.parseCanonicalDefinition = parseCanonicalDefinition;
 exports.parseDefinitionSources = parseDefinitionSources;
+exports.parseOrmMigrationExport = parseOrmMigrationExport;
 exports.parsePredicate = parsePredicate;
 exports.parseTableFile = parseTableFile;
 exports.parsedPredicateSchema = parsedPredicateSchema;
 exports.pendingKitStatements = pendingKitStatements;
 exports.pendingKitStatementsV2 = pendingKitStatementsV2;
+exports.planCommittedMigrationV2 = planCommittedMigrationV2;
 exports.planMigration = planMigration;
 exports.planMigrationV2 = planMigrationV2;
 exports.policyExpressionSchema = policyExpressionSchema;
 exports.policyVariantSchema = policyVariantSchema;
 exports.predIrSchema = predIrSchema;
 exports.predicateOperands = predicateOperands;
+exports.prefetchPlanIrSchema = prefetchPlanIrSchema;
+exports.prefetchSource = prefetchSource;
+exports.priority = priority;
 exports.quoteIdentifier = quoteIdentifier;
 exports.quoteLiteral = quoteLiteral;
 exports.readMigrationSql = readMigrationSql;
@@ -5687,6 +7492,10 @@ exports.rebaseViolations = rebaseViolations;
 exports.referencedCapabilities = referencedCapabilities;
 exports.referencedColumns = referencedColumns;
 exports.renderMigrationSql = renderMigrationSql;
+exports.renderOrmMigrationExport = renderOrmMigrationExport;
+exports.requiredArtifactIrVersion = requiredArtifactIrVersion;
+exports.resolvedMetaIrSchema = resolvedMetaIrSchema;
+exports.resolvedSourceIrSchema = resolvedSourceIrSchema;
 exports.revertOverlayMutation = revertOverlayMutation;
 exports.rewriteSyncedSourceRelationsInViewQuery = rewriteSyncedSourceRelationsInViewQuery;
 exports.roleExpression = roleExpression;