@sequenceholdings/orm 2.0.0 → 2.1.1

package/dist/index.js

@@ -1,7 +1,7 @@
-import { sql, eq, notExists } from 'drizzle-orm';
-import { pgSchema, uniqueIndex, index, foreignKey, primaryKey, PgDialect, QueryBuilder, getViewConfig, extractUsedTable, jsonb, date, timestamp, boolean, doublePrecision, numeric, bigint, integer, text, uuid } from 'drizzle-orm/pg-core';
-import { createHash } from 'crypto';
+import { sql, eq, notExists, is, SQL } from 'drizzle-orm';
+import { pgSchema, uniqueIndex, index, foreignKey, check, primaryKey, getTableConfig, PgDialect, QueryBuilder, getViewConfig, extractUsedTable, jsonb, date, timestamp, boolean, doublePrecision, numeric, bigint, integer, text, uuid } from 'drizzle-orm/pg-core';
 import { z } from 'zod';
+import { createHash } from 'crypto';
 import { createJiti } from 'jiti';
 import { realpath, stat, readdir, readFile, mkdir, writeFile } from 'fs/promises';
 import { createRequire } from 'module';
@@ -34,10 +34,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. */
@@ -69,6 +71,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;
@@ -88,6 +99,11 @@ var ColumnBuilder = class {
     this.state.deprecated = true;
     return this;
   }
+  /** @internal System cell-metadata part of logical column `of` (generated resolved views only). */
+  cellPart(of, part) {
+    this.state.cell = { of, part };
+    return this;
+  }
   /** Whether `.primaryKey()` was called — collected into the table-level PK. */
   get isPrimaryKey() {
     return this.state.primaryKey;
@@ -112,9 +128,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;
   }
 };
@@ -138,11 +156,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_]*$/;
@@ -154,8 +173,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 {
@@ -231,6 +273,8 @@ function toOne(target, options) {
     on: options.on,
     references: options.references,
     enforce: options.enforce ?? false,
+    onDelete: options.onDelete,
+    onUpdate: options.onUpdate,
     description: options.description
   };
 }
@@ -242,6 +286,8 @@ function toMany(target, options) {
     on: options.on,
     references: options.references,
     enforce: false,
+    onDelete: void 0,
+    onUpdate: void 0,
     description: options.description
   };
 }
@@ -253,6 +299,8 @@ function toPlatformUser(options) {
     on: options.on,
     references: options.references,
     enforce: false,
+    onDelete: void 0,
+    onUpdate: void 0,
     description: options.description
   };
 }
@@ -262,10 +310,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
     );
   }
@@ -286,7 +334,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(
@@ -326,7 +380,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) {
@@ -415,7 +470,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);
@@ -533,11 +588,11 @@ function compileViewQueries(input) {
       );
     }
     if (!config.query) throw new OrmDefinitionError(`view "${authored.viewName}" produced no query`, authored.file);
-    const tableDependencies = extractUsedTable(config.query).map((physical) => {
-      const logical = physicalToLogical.get(physical);
+    const tableDependencies = extractUsedTable(config.query).map((physical2) => {
+      const logical = physicalToLogical.get(physical2);
       if (!logical) {
         throw new OrmDefinitionError(
-          `view "${authored.viewName}" query references unmanaged relation "${physical}" \u2014 use relation(...) with a namespace table or view`,
+          `view "${authored.viewName}" query references unmanaged relation "${physical2}" \u2014 use relation(...) with a namespace table or view`,
           authored.file
         );
       }
@@ -861,9 +916,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 = z.object({
+  /** Claims-only guard (capability()/role()/claim() comparisons — no columns). */
+  when: z.string().min(1).max(1e3),
+  /** Exactly one of: allow-all bypass, or a row predicate. */
+  allow: z.literal(true).optional(),
+  policy: z.string().min(1).max(2e3).optional()
+}).refine((v) => v.allow === true !== (typeof v.policy === "string"), {
+  message: "A variant declares exactly one of allow: true or policy"
+});
+var policyExpressionSchema = z.union([
+  z.string().min(1).max(2e3),
+  z.object({
+    default: z.string().min(1).max(2e3),
+    variants: z.array(policyVariantSchema).max(10).default([])
+  })
+]);
+function parseDurationMs(input) {
+  if (typeof input === "number") return Number.isInteger(input) && input > 0 ? input : void 0;
+  const match = /^(\d+(?:\.\d+)?)(ms|s|m)$/.exec(input);
+  if (!match) return void 0;
+  const factor = match[2] === "ms" ? 1 : match[2] === "s" ? 1e3 : 6e4;
+  const value = Math.round(Number(match[1]) * factor);
+  return value > 0 ? value : void 0;
+}
+var identifier = z.string().min(1).max(63).regex(/^[a-z][a-z0-9_]*$/);
+var durationMs = z.number().int().positive().max(24 * 60 * 60 * 1e3);
+var RESOLVED_VIEW_SYSTEM_COLUMNS = {
+  writebackStatus: { name: "writebackStatus", columnName: "_writeback_status", type: "text" },
+  writebackError: { name: "writebackError", columnName: "_writeback_error", type: "text" }
+};
+var RESOLVED_SOURCE_SYSTEM_COLUMNS = {
+  tombstoned: { name: "sysTombstoned", columnName: "_tombstoned" },
+  fetchedAt: { name: "sysFetchedAt", columnName: "_fetched_at" },
+  writebackStatus: { name: "sysWritebackStatus", columnName: "_writeback_status" },
+  writebackError: { name: "sysWritebackError", columnName: "_writeback_error" },
+  writebackAt: { name: "sysWritebackAt", columnName: "_writeback_at" }
+};
+var RESOLVED_VIEW_CELL_PARTS = ["source", "at", "by", "conflicts"];
+var RESERVED_RESOLVED_COLUMN_NAMES = /* @__PURE__ */ new Set([
+  ...Object.values(RESOLVED_VIEW_SYSTEM_COLUMNS).flatMap((c) => [c.name, c.columnName]),
+  ...Object.values(RESOLVED_SOURCE_SYSTEM_COLUMNS).flatMap((c) => [c.name, c.columnName])
+]);
+var COMPARATORS = ["latest", "highest", "lowest", "priority", "nonNullFirst", "custom"];
+var canonicalFunctionRefSchema = z.object({
+  /** `managed` = a Managed Function id/slug; `native` = an in-process Atlas function (reserved). */
+  kind: z.enum(["managed", "native"]),
+  id: z.string().min(1).max(200)
+}).strict();
+var canonicalFetchShapeSchema = z.union([
+  z.object({ shape: z.literal("single") }).strict(),
+  z.object({ shape: z.literal("batch"), maxKeys: z.number().int().min(2).max(500) }).strict()
+]);
+var canonicalResolvedSourceSchema = z.object({
+  name: identifier,
+  kind: z.enum(["manual", "etl", "prefetch"]),
+  /** Backing relation in this namespace: an internal table (manual/prefetch) or a synced table (etl). */
+  table: identifier,
+  /** Resolved columns (logical names) this source supplies — the primary key is implicit. */
+  columns: z.array(z.string().min(1).max(63)).min(1).max(500),
+  /** etl: logical timestamptz/date column on the synced table used as every cell's updated_at. */
+  updatedAt: z.string().min(1).max(63).optional(),
+  /** prefetch: resolved column holding the source system's key (may be the primary key). */
+  key: z.string().min(1).max(63).optional(),
+  fetch: canonicalFetchShapeSchema.optional(),
+  function: canonicalFunctionRefSchema.optional(),
+  prefetchDefaults: z.object({
+    maxStalenessMs: durationMs,
+    timeoutMs: durationMs,
+    onError: z.enum(["fallback", "fail"])
+  }).strict().optional(),
+  writeback: z.object({
+    columns: z.array(z.string().min(1).max(63)).min(1).max(500),
+    defaultMode: z.enum(["sync", "async"]),
+    timeoutMs: durationMs,
+    /** Remove confirmed cells from the manual source so a stale edit cannot shadow the source. */
+    clearManualOnConfirm: z.boolean()
+  }).strict().optional()
+}).strict();
+var canonicalResolveRuleSchema = z.object({
+  column: z.string().min(1).max(63),
+  comparator: z.enum(COMPARATORS),
+  /** Source names, in tie-break order. */
+  candidates: z.array(identifier).min(1).max(16),
+  /** custom only: SQL ORDER BY key over value / updated_at / source / actor / ord. */
+  orderBy: z.string().min(1).max(2e3).optional()
+}).strict();
+var canonicalResolvedSchema = z.object({
+  sources: z.array(canonicalResolvedSourceSchema).min(1).max(16),
+  /** One rule per resolved (non-pk) column; documents the generated view for tooling. */
+  resolve: z.array(canonicalResolveRuleSchema).max(500),
+  /** Sources whose tombstone hides the resolved row (v1: the manual source only). */
+  deletedBy: z.array(identifier).max(1).default([]),
+  /**
+   * Materialized: the view reads an indexed internal table (`table`) that the
+   * data plane keeps in step with `compute`, the internal view holding the
+   * resolution query. Omitted when the view computes on read.
+   */
+  materialized: z.object({ table: identifier, compute: identifier }).strict().optional(),
+  /** Write policies evaluated against the RESOLVED row (reads use the view's read policy). */
+  policies: z.object({
+    write: policyExpressionSchema.optional(),
+    insert: policyExpressionSchema.optional(),
+    update: policyExpressionSchema.optional()
+  }).strict().default({})
+}).strict();
+function validateResolvedView({ view, tables, views = [] }) {
+  const resolved = view.resolved;
+  if (!resolved) return [];
+  const errors = [];
+  const fail = (message) => errors.push(`resolved table '${view.view}': ${message}`);
+  const pkColumn = view.primaryKey?.length === 1 ? view.columns.find((c) => c.columnName === view.primaryKey?.[0]) : void 0;
+  if (!pkColumn) {
+    fail("requires exactly one primary-key column");
+    return errors;
+  }
+  const systemNames = new Set(Object.values(RESOLVED_VIEW_SYSTEM_COLUMNS).map((c) => c.name));
+  const scope = {
+    view,
+    resolved,
+    pkColumn,
+    dataColumns: new Map(view.columns.filter((c) => !systemNames.has(c.name) && c.cell === void 0).map((c) => [c.name, c])),
+    sourceByName: /* @__PURE__ */ new Map(),
+    fail
+  };
+  if (resolved.sources.filter((source) => source.kind === "manual").length !== 1) fail("requires exactly one manual source");
+  const tableByName = new Map(tables.map((table) => [table.table, table]));
+  for (const source of resolved.sources) {
+    if (scope.sourceByName.has(source.name)) fail(`duplicate source '${source.name}'`);
+    scope.sourceByName.set(source.name, source);
+    const table = tableByName.get(source.table);
+    if (!table) fail(`source '${source.name}' references unknown table '${source.table}'`);
+    else validateSource({ scope, source, table });
+  }
+  validateRules(scope);
+  validateViewCells(scope);
+  if (resolved.materialized) validateMaterialized({ scope, tableByName, views });
+  for (const 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 = z.string().min(1).max(63).regex(IDENTIFIER_RE);
+var identifier2 = z.string().min(1).max(63).regex(IDENTIFIER_RE);
+var columnIdentifier = z.string().min(1).max(63).regex(COLUMN_IDENTIFIER_PATTERN);
 var COLUMN_TYPES = [
   "uuid",
   "text",
@@ -878,59 +1402,71 @@ var COLUMN_TYPES = [
 ];
 var columnTypeSchema = z.enum(COLUMN_TYPES);
 var canonicalEnumSchema = z.object({
-  name: identifier,
+  name: identifier2,
   values: z.array(z.string().min(1).max(63)).min(1).max(100)
 });
 var canonicalColumnSchema = z.object({
   /** Property name in TS (camelCase); columnName is the Postgres name. */
   name: z.string().min(1).max(63),
-  columnName: identifier,
-  type: z.union([columnTypeSchema, z.object({ enum: identifier })]),
+  columnName: columnIdentifier,
+  type: z.union([columnTypeSchema, z.object({ enum: identifier2 })]),
   nullable: z.boolean().default(true),
   unique: z.boolean().default(false),
   /** Literal default, or one of the allowlisted SQL functions. */
   default: z.union([z.string(), z.number(), z.boolean(), z.null()]).optional(),
   defaultFn: 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: z.enum(["now()"]).optional(),
   description: z.string().max(500).optional(),
   /** Migration hints — same semantics as v1. */
-  renamedFrom: identifier.optional(),
+  renamedFrom: columnIdentifier.optional(),
   cast: z.string().max(200).optional(),
-  deprecated: z.boolean().default(false)
+  deprecated: z.boolean().default(false),
+  /**
+   * Marks a system cell-metadata column (see CELL_PARTS in constants): part
+   * `part` of the cell of logical column `of`. Synthesized by authoring,
+   * never client-writable, absent from GraphQL scalar fields. Omitted on
+   * ordinary columns so their hashes are unchanged.
+   */
+  cell: z.object({ of: z.string().min(1).max(63), part: z.enum(CELL_PARTS) }).strict().optional()
+}).superRefine((column, ctx) => {
+  if (column.onUpdateFn === void 0) return;
+  if (typeof column.type !== "string" || column.type !== "timestamptz" && column.type !== "date") {
+    ctx.addIssue({
+      code: "custom",
+      path: ["onUpdateFn"],
+      message: `onUpdateFn '${column.onUpdateFn}' is only valid on timestamptz/date columns`
+    });
+  }
 });
 var canonicalLinkSchema = z.object({
   name: z.string().min(1).max(63),
   kind: z.enum(["toOne", "toMany", "toPlatformUser"]),
   /** Target table name (namespace-local). Absent for toPlatformUser. */
-  target: identifier.optional(),
+  target: identifier2.optional(),
   /** 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: z.boolean().default(false),
+  onDelete: z.enum(["cascade", "restrict", "no action", "set null", "set default"]).optional(),
+  onUpdate: z.enum(["cascade", "restrict", "no action", "set null", "set default"]).optional(),
   description: z.string().max(500).optional()
 });
 var canonicalIndexSchema = z.object({
-  columns: z.array(identifier).min(1),
+  columns: z.array(columnIdentifier).min(1),
   unique: z.boolean().default(false),
-  name: identifier.optional()
+  name: identifier2.optional()
 });
-var policyVariantSchema = z.object({
-  /** Claims-only guard (capability()/role()/claim() comparisons — no columns). */
-  when: z.string().min(1).max(1e3),
-  /** Exactly one of: allow-all bypass, or a row predicate. */
-  allow: z.literal(true).optional(),
-  policy: z.string().min(1).max(2e3).optional()
-}).refine((v) => v.allow === true !== (typeof v.policy === "string"), {
-  message: "A variant declares exactly one of allow: true or policy"
-});
-var policyExpressionSchema = z.union([
-  z.string().min(1).max(2e3),
-  z.object({
-    default: z.string().min(1).max(2e3),
-    variants: z.array(policyVariantSchema).max(10).default([])
-  })
-]);
+var canonicalCheckSchema = z.object({
+  name: identifier2,
+  expression: z.string().min(1).max(2e3)
+}).strict();
 var canonicalPoliciesSchema = z.object({
   read: policyExpressionSchema.optional(),
   write: policyExpressionSchema.optional(),
@@ -1118,7 +1654,7 @@ var VIEW_QUERY_FUNCTION_ALLOWLIST = [
   "width_bucket"
 ];
 var canonicalActionSchema = z.object({
-  name: identifier,
+  name: identifier2,
   requires: z.string().max(1e3).optional(),
   params: z.record(z.string(), z.object({
     type: columnTypeSchema,
@@ -1130,9 +1666,9 @@ var canonicalActionSchema = z.object({
 });
 var canonicalCowMutationSchema = z.object({
   kind: z.enum(["override", "revert"]),
-  name: identifier,
+  name: identifier2,
   /** Synced table (same namespace) the overlay copies from / falls back to. */
-  synced: identifier,
+  synced: identifier2,
   /** Single-column primary key PROPERTY (TS camelCase, like column `name`) shared by overlay and synced. */
   pk: z.string().min(1).max(63),
   /** Override: contract properties copied INSERT…SELECT from synced (pk included). Empty for revert. */
@@ -1159,17 +1695,28 @@ var canonicalCowMutationSchema = z.object({
     }
   }
 });
+var canonicalForeignKeySchema = z.object({
+  name: identifier2,
+  columns: z.array(columnIdentifier).min(1).max(8),
+  target: identifier2,
+  references: z.array(columnIdentifier).min(1).max(8),
+  deferrable: z.enum(["initially-immediate", "initially-deferred"]).optional(),
+  onDelete: z.enum(["cascade", "restrict", "no action", "set null", "set default"]).optional(),
+  onUpdate: z.enum(["cascade", "restrict", "no action", "set null", "set default"]).optional()
+}).strict();
 var canonicalTableSchema = z.object({
-  table: identifier,
+  table: identifier2,
   description: 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: z.string().regex(/^gold\.[a-z][a-z0-9_]*$/).optional(),
   columns: z.array(canonicalColumnSchema).default([]),
-  primaryKey: z.array(identifier).min(1).max(8).optional(),
+  primaryKey: z.array(columnIdentifier).min(1).max(8).optional(),
   links: z.array(canonicalLinkSchema).default([]),
   indexes: z.array(canonicalIndexSchema).default([]),
+  /** Omitted by old definitions, preserving their existing content hashes. */
+  checks: z.array(canonicalCheckSchema).max(100).optional(),
   policies: canonicalPoliciesSchema.default({}),
   /**
    * v1-conversion carry-over only. v2 has no action surface — the runtime
@@ -1178,26 +1725,64 @@ var canonicalTableSchema = z.object({
    */
   actions: z.array(canonicalActionSchema).default([]),
   /** Optional (not defaulted) so pre-CoW canonical documents keep byte-identical hashes. */
-  cowMutations: z.array(canonicalCowMutationSchema).optional()
+  cowMutations: z.array(canonicalCowMutationSchema).optional(),
+  /** Omitted by old definitions, preserving their existing content hashes. */
+  foreignKeys: z.array(canonicalForeignKeySchema).max(100).optional(),
+  /**
+   * Per-cell edit metadata (`cellMetadata: true` in authoring): every tracked
+   * column `c` carries typed `c__at` / `c__by` system columns (plus `c__rev`
+   * on a resolved table's internal sources), listed explicitly in `columns`
+   * with a `cell` marker so DDL and migrations treat them as ordinary columns.
+   * Omitted when off so existing definitions hash unchanged.
+   */
+  cellMetadata: z.literal(true).optional(),
+  /**
+   * System-owned backing table of a resolved table (its manual or prefetch
+   * source). Internal tables get DDL and IR metadata but no GraphQL surface;
+   * only the data plane writes them. Omitted when false.
+   */
+  internal: z.literal(true).optional(),
+  /**
+   * The materialized copy of resolved table `materializes` (internal): the
+   * same columns as that view, including its cell parts, maintained by the
+   * data plane. Omitted otherwise.
+   */
+  materializes: identifier2.optional()
 });
+var MAX_VIEW_QUERY = 1e5;
+var MAX_RESOLVED_VIEW_QUERY = 5e6;
 var canonicalViewSchema = z.object({
-  view: identifier,
+  view: identifier2,
   description: z.string().max(2e3).optional(),
   columns: z.array(canonicalColumnSchema).min(1),
   /** Logical identity for GraphQL only; PostgreSQL views have no PK constraint. */
-  primaryKey: z.array(identifier).min(1).max(8).optional(),
+  primaryKey: z.array(columnIdentifier).min(1).max(8).optional(),
   links: z.array(canonicalLinkSchema).default([]),
   policies: z.object({ read: policyExpressionSchema }).strict(),
-  query: z.string().min(1).max(1e5).refine(isSingleViewQuerySql, {
+  query: z.string().min(1).max(MAX_RESOLVED_VIEW_QUERY).refine(isSingleViewQuerySql, {
     message: "view query must be one SELECT/WITH statement without comments or dollar-quoted bodies"
   }),
   /** Namespace-local logical relation names, sorted for deterministic hashing. */
-  dependencies: z.array(identifier).max(500)
+  dependencies: z.array(identifier2).max(500),
+  /**
+   * Present when this view is a resolved table (defineResolvedTable): the
+   * multi-source metadata behind its generated query. Omitted otherwise so
+   * existing views hash unchanged.
+   */
+  resolved: canonicalResolvedSchema.optional(),
+  /** System-owned view (a materialized resolved table's compute view): no GraphQL surface. */
+  internal: z.literal(true).optional()
 }).superRefine((view, ctx) => {
+  if (view.resolved === void 0 && view.query.length > MAX_VIEW_QUERY) {
+    ctx.addIssue({ code: "custom", path: ["query"], message: `view query must be at most ${MAX_VIEW_QUERY} characters` });
+  }
   for (const [index3, column] of view.columns.entries()) {
     if (column.default !== void 0 || column.defaultFn !== void 0) {
       ctx.addIssue({ code: "custom", path: ["columns", index3], message: `view column '${column.name}' cannot declare a default` });
     }
+    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` });
     }
@@ -1205,15 +1790,82 @@ var canonicalViewSchema = z.object({
       ctx.addIssue({ code: "custom", path: ["columns", index3], message: `view column '${column.name}' cannot declare migration hints` });
     }
   }
+  if (view.resolved === void 0 && view.internal !== true) {
+    for (const [index3, column] of view.columns.entries()) {
+      if (column.cell) ctx.addIssue({ code: "custom", path: ["columns", index3], message: `only resolved tables carry cell columns ('${column.name}')` });
+    }
+  }
   for (const [index3, link] of view.links.entries()) {
     if (link.enforce) {
       ctx.addIssue({ code: "custom", path: ["links", index3, "enforce"], message: `view link '${link.name}' cannot enforce a foreign key` });
     }
+    if (link.onDelete !== void 0 || link.onUpdate !== void 0) {
+      ctx.addIssue({ code: "custom", path: ["links", index3], message: `view link '${link.name}' cannot declare referential actions` });
+    }
   }
 });
+var 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 = z.object({
   definition_format: z.literal(CANONICAL_FORMAT),
-  namespace: identifier.max(41),
+  namespace: identifier2.max(41),
   description: z.string().max(2e3).optional(),
   enums: z.array(canonicalEnumSchema).default([]),
   tables: z.array(canonicalTableSchema).min(0).max(500),
@@ -1231,6 +1883,74 @@ var canonicalDefinitionSchema = z.object({
       ctx.addIssue({ code: "custom", path: ["tables", index3, "table"], message: `duplicate relation '${table.table}'` });
     }
     seen.add(table.table);
+    validateCellMetadata(table, index3, ctx);
+    if (table.source !== void 0) {
+      for (const [columnIndex, column] of table.columns.entries()) {
+        if (column.onUpdateFn !== void 0) {
+          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()) {
@@ -1355,8 +2075,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));
 }
@@ -1366,12 +2090,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) } : {}
       };
@@ -1386,6 +2112,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 = getTableConfig(relation(plan.plans[0].table)).schema;
+  const keyBranches = plan.plans.map((source) => {
+    const where = source.kind === "prefetch" ? sql.raw(` WHERE NOT ${ident(tombstoned2)}`) : sql.raw("");
+    const sourcePk = ident(physical({ source, property: plan.pk }));
+    const selectedPk = sourcePk === ident(pkColumn) ? sourcePk : `${sourcePk} AS ${ident(pkColumn)}`;
+    return sql`SELECT ${sql.raw(selectedPk)} FROM ${relation(source.table)}${where}`;
+  });
+  const joins = plan.plans.map(
+    (source) => sql` LEFT JOIN ${relation(source.table)} AS ${sql.raw(alias(source.name))} ON ${sql.raw(`${alias(source.name)}.${ident(physical({ source, property: plan.pk }))} = "k".${ident(pkColumn)}`)}`
+  );
+  const cells = /* @__PURE__ */ new Map();
+  plan.rules.forEach((rule, index3) => {
+    const canonical = plan.columns[rule.column].toCanonicalColumn(rule.column);
+    const pgType = typeof canonical.type === "string" ? PG_TYPE[canonical.type] : `${schema === void 0 ? "" : `${ident(schema)}.`}${ident(canonical.type.enum)}`;
+    const candidates = rule.candidates.map((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 ? [sql.raw(cell.lateral)] : []);
+  const from = sql.join([sql`(${sql.join(keyBranches, sql.raw(" UNION "))}) AS "k"`, ...joins, ...laterals], sql.raw(""));
+  const selected = {
+    [plan.pk]: sql.raw(`"k".${ident(pkColumn)}`).as(pkColumn)
+  };
+  for (const [property, builder] of Object.entries(plan.columns)) {
+    if (property === plan.pk) continue;
+    const cell = cells.get(property);
+    const columnName = builder.columnNameFor(property);
+    selected[property] = sql.raw(cell.value).as(columnName);
+    for (const [part, expression] of Object.entries(cell.parts)) {
+      selected[cellColumnName(property, part)] = sql.raw(expression).as(cellColumnName(columnName, part));
+    }
+  }
+  const manual = plan.plans.find((source) => source.kind === "manual");
+  const system = RESOLVED_VIEW_SYSTEM_COLUMNS;
+  selected[system.writebackStatus.name] = sql.raw(`${alias(manual.name)}.${ident(RESOLVED_SOURCE_SYSTEM_COLUMNS.writebackStatus.columnName)}`).as(system.writebackStatus.columnName);
+  selected[system.writebackError.name] = sql.raw(`${alias(manual.name)}.${ident(RESOLVED_SOURCE_SYSTEM_COLUMNS.writebackError.columnName)}`).as(system.writebackError.columnName);
+  const hidden = plan.deletedBy.map((name) => `NOT COALESCE(${alias(name)}.${ident(tombstoned2)}, false)`);
+  const query = qb.select(selected).from(from);
+  return hidden.length > 0 ? query.where(sql.raw(hidden.join(" AND "))) : query;
+}
+function managedFn(id) {
+  return { kind: "managed", id };
+}
+function manualSource() {
+  return { kind: "manual" };
+}
+function etlSource(input) {
+  return { kind: "etl", ...input };
+}
+function prefetchSource(input) {
+  return { kind: "prefetch", ...input };
+}
+var latest = (candidates) => ({ kind: "latest", candidates });
+var highest = (candidates) => ({ kind: "highest", candidates });
+var lowest = (candidates) => ({ kind: "lowest", candidates });
+var priority = (candidates) => ({ kind: "priority", candidates });
+var nonNullFirst = (candidates) => ({ kind: "nonNullFirst", candidates });
+var custom = (candidates, orderBy) => ({ kind: "custom", candidates, orderBy });
+var SYSTEM_VIEW_COLUMNS = {
+  [RESOLVED_VIEW_SYSTEM_COLUMNS.writebackStatus.name]: () => t.text(RESOLVED_VIEW_SYSTEM_COLUMNS.writebackStatus.columnName),
+  [RESOLVED_VIEW_SYSTEM_COLUMNS.writebackError.name]: () => t.text(RESOLVED_VIEW_SYSTEM_COLUMNS.writebackError.columnName)
+};
+function defineResolvedTable(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,
+        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(",")}]`;
@@ -1492,8 +2666,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) {
@@ -1595,6 +2780,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`,
@@ -1632,6 +2820,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(
@@ -1645,6 +2838,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" }))
@@ -1697,6 +2929,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);
     }
@@ -1734,7 +2972,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({
@@ -1751,6 +3015,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 {
@@ -1779,6 +3046,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 } : {}
   };
 }
@@ -1957,6 +3226,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": createRequire(import.meta.url).resolve("drizzle-orm"),
         "@sequenceholdings/orm": options.ormModulePath,
         "@sequenceholdings/orm/authoring": options.ormModulePath
       }
@@ -2228,7 +3501,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) {
@@ -2302,7 +3575,7 @@ function readString(source, start) {
   }
   throw new PredicateParseError("unterminated string literal", start);
 }
-var Parser = class {
+var Parser2 = class {
   constructor(tokens) {
     this.tokens = tokens;
   }
@@ -2434,7 +3707,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
@@ -2519,8 +3792,8 @@ var actionSchema = 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)];
 }
@@ -2587,17 +3860,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 = {
   "=": "=",
@@ -2677,8 +3939,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);
@@ -2743,10 +4005,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":
@@ -2790,11 +4052,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);
@@ -2843,8 +4105,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}`);
     });
   }
@@ -3226,14 +4488,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;
 }
@@ -3298,7 +4560,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));
@@ -3318,8 +4581,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),
@@ -3332,8 +4595,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}`
     );
@@ -3352,10 +4617,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;
     }
   }
@@ -3394,8 +4659,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}`);
@@ -3605,6 +4870,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) => uuid(name),
   text: (name) => text(name),
@@ -3622,7 +4971,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 = pgSchema(schemaName);
   const imports = { [SCHEMA_IMPORT_KEY2]: schema };
@@ -3637,11 +4986,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 })])
@@ -3709,18 +5066,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 === "-") {
@@ -3740,7 +5097,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" };
@@ -3759,9 +5116,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] ?? "" };
@@ -3793,8 +5150,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;
         }
@@ -3816,7 +5173,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;
@@ -3860,15 +5217,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;
   });
@@ -3879,15 +5236,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 = 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()])
       )
@@ -3905,7 +5265,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`);
@@ -3921,13 +5281,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$1) => check(check$1.name, sql.raw(compileCheckExpression(check$1.expression, table.columns)))),
+    ...buildForeignKeys2(table, self, built, byName),
+    ...(table.foreignKeys ?? []).map((fk) => {
+      const target = fk.target === table.table ? self : built.get(fk.target);
+      if (!target) throw new OrmDefinitionError(`foreign key '${fk.name}' has no target '${fk.target}'`);
+      let constraint = foreignKey({
+        name: fk.name,
+        columns: fk.columns.map((column) => self[column]),
+        foreignColumns: fk.references.map((column) => target[column])
+      });
+      if (fk.onDelete !== void 0) constraint = constraint.onDelete(fk.onDelete);
+      if (fk.onUpdate !== void 0) constraint = constraint.onUpdate(fk.onUpdate);
+      return constraint;
+    })
   ]);
   return drizzleTable.enableRLS();
 }
@@ -3944,7 +5317,8 @@ function buildColumnV2({
   column,
   singlePrimaryKey,
   compositeMembers,
-  enums
+  enums,
+  introspection
 }) {
   const factory = resolveColumnFactory(table, column, enums);
   let builder = factory(column.columnName);
@@ -3965,7 +5339,7 @@ function buildColumnV2({
     }
     builder = builder.default(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(sql.raw(`${quoteLiteral(column.default)}::jsonb`)) : builder.default(column.default);
   }
   return builder;
 }
@@ -4016,11 +5390,14 @@ function buildForeignKeys2(table, self, built, byName) {
         `enforced link '${link.name}' on '${table.table}' references unknown column '${targetColumn ? link.on : referencedColumn}'`
       );
     }
-    return foreignKey({
+    let constraint = foreignKey({
       name: foreignKeyName(table.table, link.name),
       columns: [sourceColumn],
       foreignColumns: [targetColumn]
     });
+    if (link.onDelete !== void 0) constraint = constraint.onDelete(link.onDelete);
+    if (link.onUpdate !== void 0) constraint = constraint.onUpdate(link.onUpdate);
+    return constraint;
   });
 }
 var singlePrimaryKeyOf = (table) => table.primaryKey?.length === 1 ? table.primaryKey[0] : void 0;
@@ -4141,16 +5518,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);
@@ -4160,7 +5552,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))),
@@ -4187,15 +5586,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,
@@ -4213,9 +5641,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);
@@ -4323,20 +5751,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;
@@ -4344,8 +5854,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;
       }
@@ -4450,7 +5959,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) => sql`ARRAY[${sql.join(values.map((value) => sql`${value}`), sql`, `)}]::text[]`;
+  const schema = ormSchemaName(canonical.namespace);
+  const result = await shimExecute(db).execute(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(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,
@@ -4463,11 +6028,31 @@ async function pendingStatements({
   );
   return statementsToExecute.filter((statement) => !owned.test(statement));
 }
+function correctIntrospectionQuery(query) {
+  if (!is(query, SQL)) return query;
+  const compiled = new 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 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 };
     }
@@ -4507,21 +6092,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 = z.string().regex(/^sha256:[0-9a-f]{64}$/);
+var ormMigrationPayloadSchema = z.object({
+  canonical_definition: canonicalDefinitionSchema,
+  documents: z.array(z.object({ path: z.string().min(1).max(2048), contents: z.string().max(1e6) }).strict()).max(5e3),
+  client_manifest: z.object({ ops_hash: hash, operations: z.record(z.string(), hash) }).strict(),
+  sdl: z.string().refine((value) => Buffer.byteLength(value, "utf8") <= MAX_GENERATED_SDL_BYTES, {
+    message: `sdl exceeds ${MAX_GENERATED_SDL_BYTES} bytes`
+  }),
+  schema_snapshot: z.json(),
+  // The existing ORM committed-migration validator and replay engine remain
+  // authoritative. This envelope hashes the provenance, never authorizes SQL.
+  migration: z.json().optional()
+}).strict();
+var ormMigrationExportSchema = z.object({
+  schema_version: z.literal(1),
+  schema_hash: hash,
+  payload: ormMigrationPayloadSchema,
+  checksum: z.string().regex(/^[0-9a-f]{64}$/)
+}).strict();
+function checksum(value) {
+  return 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 = z.union([z.literal(LEGACY_IR_VERSION), z.literal(IR_VERSION)]);
+var operationVersionSchema = 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?",
@@ -4593,6 +6230,21 @@ var selectionIrSchema = z.lazy(
   () => z.object({
     typename: z.string(),
     columns: z.array(z.object({ alias: z.string(), column: z.string() })),
+    cells: z.object({
+      alias: z.string(),
+      typename: z.string(),
+      fields: z.array(z.object({
+        alias: z.string(),
+        column: z.string(),
+        typename: z.string(),
+        parts: z.array(z.object({
+          alias: z.string(),
+          part: z.enum(["source", "at", "by", "conflicts"]),
+          fields: z.array(z.object({ alias: z.string(), field: z.enum(["source", "at", "value"]) })).optional(),
+          typename: z.string().optional()
+        }))
+      }))
+    }).optional(),
     relations: z.array(z.object({
       alias: z.string(),
       link: z.string(),
@@ -4614,6 +6266,11 @@ var selectionIrSchema = z.lazy(
   })
 );
 var includeIfSchema = z.object({ variable: z.string(), negated: z.boolean() });
+var prefetchPlanIrSchema = z.object({
+  source: z.string(),
+  maxStalenessMs: z.number().int().positive().optional(),
+  key: z.union([z.object({ one: valueIrSchema }), z.object({ many: valueIrSchema })])
+});
 var selectRootSchema = z.object({
   kind: z.literal("select"),
   alias: z.string(),
@@ -4625,7 +6282,8 @@ var selectRootSchema = z.object({
   distinctOn: z.union([z.array(z.string()), z.object({ slot: z.string() })]).optional(),
   limit: limitIrSchema,
   offset: z.object({ variable: z.string().optional(), value: z.number().int().optional() }).optional(),
-  includeIf: includeIfSchema.optional()
+  includeIf: includeIfSchema.optional(),
+  prefetch: z.array(prefetchPlanIrSchema).optional()
 });
 var byPkRootSchema = z.object({
   kind: z.literal("byPk"),
@@ -4635,7 +6293,8 @@ var byPkRootSchema = z.object({
   pk: z.array(z.object({ column: z.string(), value: valueIrSchema })).min(1),
   /** Policy predicate — ANDed with the PK match. */
   where: predIrSchema,
-  includeIf: includeIfSchema.optional()
+  includeIf: includeIfSchema.optional(),
+  prefetch: z.array(prefetchPlanIrSchema).optional()
 });
 var aggregateRootSchema = z.object({
   kind: z.literal("aggregate"),
@@ -4648,6 +6307,33 @@ var aggregateRootSchema = z.object({
   nodes: selectionIrSchema.optional(),
   includeIf: includeIfSchema.optional()
 });
+var DATE_BUCKETS = ["year", "quarter", "month", "week", "day", "hour"];
+var groupByKeyIrSchema = z.object({
+  column: z.string(),
+  bucket: z.enum(DATE_BUCKETS).optional()
+});
+var aggregateGroupsRootSchema = z.object({
+  kind: z.literal("aggregateGroups"),
+  alias: z.string(),
+  table: z.string(),
+  /** Composed at compile time: AND(policy, documentWhere?, dynamicFilter?). */
+  where: predIrSchema,
+  groupBy: 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: z.array(z.object({ alias: z.string(), column: z.string() })).default([]),
+  count: z.object({ columns: z.array(z.string()).optional(), distinct: z.boolean().optional() }).optional(),
+  sum: z.array(z.string()).optional(),
+  avg: z.array(z.string()).optional(),
+  /** Bounds the GROUP count, not the scanned rows — see MAX_GROUPS. */
+  limit: limitIrSchema,
+  offset: z.object({ variable: z.string().optional(), value: z.number().int().optional() }).optional(),
+  includeIf: includeIfSchema.optional()
+});
 var writeValuesSchema = z.union([
   z.object({ slot: z.string() }),
   z.object({ entries: z.array(z.object({ column: z.string(), value: valueIrSchema })) })
@@ -4666,7 +6352,20 @@ var mutationRootSchema = z.object({
    * coalesce view falls back to synced. Both are gated on a matching synced
    * row and carry the write policy in `where` like update/delete.
    */
-  op: z.enum(["insert", "insertOne", "update", "updateByPk", "delete", "deleteByPk", "cowOverride", "cowRevert"]),
+  op: z.enum(["insert", "insertOne", "update", "updateByPk", "delete", "deleteByPk", "cowOverride", "cowRevert", "resolvedWrite"]),
+  /**
+   * resolvedWrite: a write to a resolved table (`table` is its view). The
+   * executor gates on the resolved row (write policy in `where`), writes only
+   * the touched cells into the manual source, then re-checks `insertCheck`
+   * against the resolved row. `revert` clears `revertColumns` from the manual
+   * source; `delete` tombstones the row there.
+   */
+  resolvedAction: z.enum(["insert", "update", "delete", "revert"]).optional(),
+  revertColumns: z.array(z.string()).optional(),
+  /** `@writeback(source:, mode:)` directives on this root. */
+  writeback: z.array(z.object({ source: z.string(), mode: z.enum(["sync", "async"]) })).optional(),
+  /** `@localOnly(source:)` — writeback columns deliberately kept local for these sources. */
+  localOnly: z.array(z.string()).optional(),
   alias: z.string(),
   table: z.string(),
   /** CoW ops: logical name of the synced twin (read through its policy-filtered view). */
@@ -4693,12 +6392,15 @@ var mutationRootSchema = z.object({
   insertCheck: predIrSchema.optional(),
   returning: selectionIrSchema.nullable(),
   affectedRows: z.boolean().default(false),
+  /** v2: abort the transaction when the actual write count differs, regardless of selection. */
+  assertAffectedRows: z.number().int().min(0).max(2147483647).optional(),
   includeIf: includeIfSchema.optional()
 });
 var rootIrSchema = z.discriminatedUnion("kind", [
   selectRootSchema,
   byPkRootSchema,
   aggregateRootSchema,
+  aggregateGroupsRootSchema,
   mutationRootSchema
 ]);
 var INPUT_REF_KINDS = [
@@ -4728,7 +6430,7 @@ var variableIrSchema = z.object({
   defaultValue: variableDefaultIrSchema.optional()
 });
 var compiledOperationSchema = z.object({
-  irVersion: z.literal(IR_VERSION),
+  irVersion: irVersionSchema,
   name: z.string(),
   opHash: z.string().regex(/^sha256:[0-9a-f]{64}$/),
   kind: z.enum(["query", "mutation"]),
@@ -4740,6 +6442,50 @@ var compiledOperationSchema = z.object({
   /** Every table the op touches — data-token scoping + audit. */
   tableSet: z.array(z.string()).min(1),
   roots: 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 = z.object({
+  name: z.string(),
+  kind: z.enum(["manual", "etl", "prefetch"]),
+  /** Logical table key of the backing relation. */
+  table: z.string(),
+  columns: z.array(z.string()),
+  key: z.string().optional(),
+  fetch: z.union([
+    z.object({ shape: z.literal("single") }),
+    z.object({ shape: z.literal("batch"), maxKeys: z.number().int().positive() })
+  ]).optional(),
+  function: z.object({ kind: z.enum(["managed", "native"]), id: z.string() }).optional(),
+  prefetchDefaults: z.object({
+    maxStalenessMs: z.number().int().positive(),
+    timeoutMs: z.number().int().positive(),
+    onError: z.enum(["fallback", "fail"])
+  }).optional(),
+  writeback: z.object({
+    columns: z.array(z.string()),
+    defaultMode: z.enum(["sync", "async"]),
+    timeoutMs: z.number().int().positive(),
+    clearManualOnConfirm: z.boolean()
+  }).optional()
+});
+var resolvedMetaIrSchema = z.object({
+  /** Logical pk column of the resolved view (single-column). */
+  pk: z.string(),
+  /** Source name of the manual source. */
+  manual: z.string(),
+  sources: z.array(resolvedSourceIrSchema),
+  deletedBy: z.array(z.string()),
+  /**
+   * Materialized: the view reads `table`, which the data plane refreshes from
+   * the `compute` view (claims-gated) whenever it writes a source row.
+   */
+  materialized: z.object({ table: z.string(), compute: z.string() }).optional()
 });
 var tableMetaIrSchema = z.object({
   table: z.string(),
@@ -4776,18 +6522,45 @@ var tableMetaIrSchema = z.object({
   insertable: z.array(z.string()),
   settable: z.array(z.string()),
   appendable: z.array(z.string()),
+  /**
+   * Logical columns stamped with Postgres `now()` on UPDATE (canonical
+   * `onUpdateFn`). Omitted when empty so pre-onUpdate artifacts still parse.
+   */
+  touchOnUpdate: z.array(z.string()).optional(),
+  /**
+   * Per-cell metadata: logical column → the logical names of its cell-part
+   * columns (which are listed in `columns`, but never filterable, orderable or
+   * writable). Tables stamp `at`/`by` (and a manual source `rev`) on every
+   * write; resolved views expose `source`/`at`/`by`/`conflicts`. Omitted when
+   * the relation tracks no cells.
+   */
+  cells: z.record(z.string(), z.object({
+    at: z.string().optional(),
+    by: z.string().optional(),
+    rev: z.string().optional(),
+    source: z.string().optional(),
+    conflicts: z.string().optional()
+  }).strict()).optional(),
+  /** Resolved-table view metadata (sources, prefetch/writeback config) for the data plane. */
+  resolved: resolvedMetaIrSchema.optional(),
   constraints: z.array(z.object({ name: z.string(), columns: z.array(z.string()) })),
   /** Depth/node caps for dynamic filter trees on this table. */
   dynamicFilterMaxDepth: z.number().int().positive().default(6),
   dynamicFilterMaxNodes: z.number().int().positive().default(64)
 });
 var compiledArtifactSchema = z.object({
-  irVersion: z.literal(IR_VERSION),
+  irVersion: irVersionSchema,
   namespace: z.string(),
   schemaHash: z.string(),
   opsHash: z.string(),
   tables: z.record(z.string(), tableMetaIrSchema),
   operations: z.record(z.string(), compiledOperationSchema)
+}).superRefine((artifact, ctx) => {
+  for (const [name, operation] of Object.entries(artifact.operations)) {
+    if (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) {
@@ -4798,7 +6571,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) {
@@ -5114,12 +6887,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 = join(dir, MIGRATIONS_DIRNAME, META_DIRNAME);
   await mkdir(metaDir, { recursive: true });
   const snapshotText = `${JSON.stringify(plan.snapshot, null, 2)}
 `;
-  await writeFile(join(dir, MIGRATIONS_DIRNAME, `${name}.sql`), sql4);
+  await writeFile(join(dir, MIGRATIONS_DIRNAME, `${name}.sql`), sql7);
   await writeFile(join(metaDir, `${pad(ordinal)}.snapshot.json`), snapshotText);
   const journal = {
     ...workspace.journal,
@@ -5130,7 +6903,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
       }
@@ -5245,8 +7018,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;
     }
@@ -5286,7 +7059,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) {
@@ -5392,7 +7165,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 = {
@@ -5400,11 +7173,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,
@@ -5502,6 +7275,6 @@ function canonicalActions(value) {
   );
 }
 
-export { ACTION_REQUIRES_DENIED_SQLSTATE, ACTION_VALIDATES_FAILED_SQLSTATE, AUDIT_ACTIONS, CANONICAL_FORMAT, CAPABILITIES_CLAIM_KEY, CAPABILITY_KEY_PATTERN, CLAIMS_CONTRACT, CLAIMS_SETTING, CLAIM_KEY_PATTERN, CMP_OPS, COLUMN_BRAND, COLUMN_DEFAULT_FNS, COLUMN_TYPES2 as COLUMN_TYPES, COMPARE_OPS, CONSUMER_ROLE_SUFFIX, ColumnBuilder, DEFINITION_FILE_EXTENSIONS, ENUM_BRAND, HASH_DOMAIN, IDENTIFIER_PATTERN, IDENTIFIER_RE, INPUT_REF_KINDS, IR_VERSION, IrVersionError, LINK_BRAND, MAX_DEFINITION_FILE_BYTES, MAX_IDENTIFIER_LENGTH, MIGRATIONS_DIRNAME, NAMESPACE_CONFIG_BRAND, NAMESPACE_CONFIG_FILE, NAMESPACE_CONFIG_FILENAMES, NAMESPACE_PATTERN, ORM_DATA_TOKEN_HEADER, ORM_SCHEMA_PREFIX, ORM_SERVICE_DATA_TOKEN_HEADER, ORM_TO_PIPELINE_TYPE, OrmDefinitionError, PredicateParseError, QUALIFIED_TABLE_PATTERN, RESERVED_COLUMN_NAMES, RESERVED_TABLE_NAMES, ROLES_CLAIM_KEY, SCHEMA_DIR, STATEMENT_KINDS, SYNCED_CONTRACT_HASH_DOMAIN, SYNCED_SOURCE_PATTERN, SYNCED_VIEW_EXECUTION_OWNER_ROLE, TABLE_BRAND, VIEW_BRAND, actionFunctionName, actionFunctionStatements, actionParamArg, actionParamOrder, actionParamSchema, actionPrepareChecks, actionSchema, actionWriteTargets, actionsInterfaceName, activeAuthoringContext, applyMigrationHints, applyMigrationHintsV2, beginAuthoringContext, buildActionParamsSchema, buildDrizzleEntities, buildDrizzleEntitiesV2, buildNamespaceDefinition, buildRebaseJournalEntry, canonicalActionSchema, canonicalColumnSchema, canonicalDefinitionSchema, canonicalEnumSchema, canonicalIndexSchema, canonicalLinkSchema, canonicalPoliciesSchema, canonicalRelations, canonicalTableSchema, canonicalViewSchema, canonicalizeDefinition, capabilityExpression, castParts, checksumOf, claimExpression, classifyDestructive, columnSchema, columnTypeSchema2 as columnTypeSchema, compileActionRequires, compileActionStatements, compileNamespace, compilePredIrToSql, compilePredicate, compiledArtifactSchema, compiledOperationSchema, computeCanonicalHash, computeDefinitionHash, computeSyncedContractHash, consumerRoleName, convertV1DefinitionToCanonical, declaredCapabilityKeys, defineEnum, defineNamespace, defineSyncedTable, defineTable, defineView, deriveColumnName, diffCommand, diffStatements, emptyJournal, emptySnapshot, endAuthoringContext, extractNamedParams, extractOrmSyncedTableContract, generateNamespaceTypes, generateSnapshot, generateSnapshotV2, identifierSchema, indexByHash, isColumnBuilder, isEnumRef, isFunctionDefault, isOwnedStatement, isOwnedStatementV2, isQualifiedReference, isSeqLink, isSeqNamespaceConfig, isSeqTable, isSeqView, limitIrSchema, loadCommittedMigrations, loadCommittedTipMigration, loadNamespaceDefinition, loadNamespaceFromDir, migrationName, namespaceConfigSchema, namespaceSchema, normalizeCanonical, normalizeIr, normalizeSnapshot, orderIrSchema, ormSchemaName, overlayWinsUnion, overrideRowMutation, parseCanonicalDefinition, parseDefinitionSources, parsePredicate, parseTableFile, parsedPredicateSchema, pendingKitStatements, pendingKitStatementsV2, planMigration, planMigrationV2, policyExpressionSchema, policyVariantSchema, predIrSchema, predicateOperands, quoteIdentifier, quoteLiteral, readMigrationSql, readMigrationWorkspace, readSnapshot, rebaseViolations, referencedCapabilities, referencedColumns, renderMigrationSql, revertOverlayMutation, rewriteSyncedSourceRelationsInViewQuery, roleExpression, rootIrSchema, securityStatements, selectionIrSchema, serializeNamespace, sqlTypeName, stableJson, syncedBackingRevokeStatements, syncedContractSurface, syncedTables, syncedViewDropStatements, syncedViewStatements, t, tableFileSchema, tableMetaIrSchema, tableReferenceSchema, toMany, toOne, toPlatformUser, typesInterfaceName, validateViewCatalogStatement, valueIrSchema, variableDefaultIrSchema, variableIrSchema, verifyRebaseIsNoop, walkPredicate, writeMigration };
+export { ACTION_REQUIRES_DENIED_SQLSTATE, ACTION_VALIDATES_FAILED_SQLSTATE, AUDIT_ACTIONS, CANONICAL_FORMAT, CAPABILITIES_CLAIM_KEY, CAPABILITY_KEY_PATTERN, CELLS_FIELD, CELL_PARTS, CELL_PART_SUFFIX, CLAIMS_CONTRACT, CLAIMS_SETTING, CLAIM_KEY_PATTERN, CMP_OPS, COLUMN_BRAND, COLUMN_DEFAULT_FNS, COLUMN_IDENTIFIER_PATTERN, COLUMN_TYPES2 as COLUMN_TYPES, COMPARE_OPS, CONSUMER_ROLE_SUFFIX, ColumnBuilder, DATE_BUCKETS, DEFINITION_FILE_EXTENSIONS, ENUM_BRAND, HASH_DOMAIN, IDENTIFIER_PATTERN, IDENTIFIER_RE, INPUT_REF_KINDS, IR_VERSION, IrVersionError, LEGACY_IR_VERSION, LINK_BRAND, MATERIALIZE_ACTOR, MATERIALIZE_CLAIMS_JSON, MAX_DEFINITION_FILE_BYTES, MAX_GENERATED_SDL_BYTES, MAX_IDENTIFIER_LENGTH, MAX_TRACKED_COLUMN_NAME, MIGRATIONS_DIRNAME, NAMESPACE_CONFIG_BRAND, NAMESPACE_CONFIG_FILE, NAMESPACE_CONFIG_FILENAMES, NAMESPACE_PATTERN, ORM_DATA_TOKEN_HEADER, ORM_MIGRATION_EXPORT_FILE, ORM_MIGRATION_EXPORT_MAX_BYTES, ORM_REGISTRATION_MAX_BYTES, ORM_SCHEMA_PREFIX, ORM_SERVICE_DATA_TOKEN_HEADER, ORM_TO_PIPELINE_TYPE, OrmDefinitionError, PredicateParseError, QUALIFIED_TABLE_PATTERN, RESERVED_COLUMN_NAMES, RESERVED_TABLE_NAMES, ROLES_CLAIM_KEY, SCHEMA_DIR, STATEMENT_KINDS, SYNCED_CONTRACT_HASH_DOMAIN, SYNCED_SOURCE_PATTERN, SYNCED_VIEW_EXECUTION_OWNER_ROLE, TABLE_BRAND, VIEW_BRAND, actionFunctionName, actionFunctionStatements, actionParamArg, actionParamOrder, actionParamSchema, actionPrepareChecks, actionSchema, actionWriteTargets, actionsInterfaceName, activeAuthoringContext, applyMigrationHints, applyMigrationHintsV2, beginAuthoringContext, buildActionParamsSchema, buildDrizzleEntities, buildDrizzleEntitiesV2, buildNamespaceDefinition, buildRebaseJournalEntry, canonicalActionSchema, canonicalColumnSchema, canonicalDefinitionSchema, canonicalEnumSchema, canonicalIndexSchema, canonicalLinkSchema, canonicalPoliciesSchema, canonicalRelations, canonicalTableSchema, canonicalViewSchema, canonicalizeDefinition, capabilityExpression, castParts, cellColumnName, checksumOf, claimExpression, classifyDestructive, columnSchema, columnTypeSchema2 as columnTypeSchema, compileActionRequires, compileActionStatements, compileNamespace, compilePredIrToSql, compilePredicate, compiledArtifactSchema, compiledOperationSchema, computeCanonicalHash, computeDefinitionHash, computeSyncedContractHash, consumerRoleName, convertV1DefinitionToCanonical, createOrmMigrationExport, custom, declaredCapabilityKeys, defineEnum, defineNamespace, defineResolvedTable, defineSyncedTable, defineTable, defineView, deriveColumnName, diffCommand, diffStatements, emptyJournal, emptySnapshot, endAuthoringContext, etlSource, extractNamedParams, extractOrmSyncedTableContract, generateNamespaceTypes, generateSnapshot, generateSnapshotV2, highest, identifierSchema, indexByHash, isColumnBuilder, isEnumRef, isFunctionDefault, isOwnedStatement, isOwnedStatementV2, isQualifiedReference, isSeqLink, isSeqNamespaceConfig, isSeqTable, isSeqView, latest, limitIrSchema, loadCommittedMigrations, loadCommittedTipMigration, loadNamespaceDefinition, loadNamespaceFromDir, lowest, managedFn, manualSource, materializeLockKey, materializedRefreshFunctionName, migrationName, namespaceConfigSchema, namespaceSchema, nonNullFirst, normalizeCanonical, normalizeIr, normalizeSnapshot, orderIrSchema, ormMigrationExportSchema, ormSchemaName, overlayWinsUnion, overrideRowMutation, parseCanonicalDefinition, parseDefinitionSources, parseOrmMigrationExport, parsePredicate, parseTableFile, parsedPredicateSchema, pendingKitStatements, pendingKitStatementsV2, planCommittedMigrationV2, planMigration, planMigrationV2, policyExpressionSchema, policyVariantSchema, predIrSchema, predicateOperands, prefetchPlanIrSchema, prefetchSource, priority, quoteIdentifier, quoteLiteral, readMigrationSql, readMigrationWorkspace, readSnapshot, rebaseViolations, referencedCapabilities, referencedColumns, renderMigrationSql, renderOrmMigrationExport, requiredArtifactIrVersion, resolvedMetaIrSchema, resolvedSourceIrSchema, revertOverlayMutation, rewriteSyncedSourceRelationsInViewQuery, roleExpression, rootIrSchema, securityStatements, selectionIrSchema, serializeNamespace, sqlTypeName, stableJson, syncedBackingRevokeStatements, syncedContractSurface, syncedTables, syncedViewDropStatements, syncedViewStatements, t, tableFileSchema, tableMetaIrSchema, tableReferenceSchema, toMany, toOne, toPlatformUser, typesInterfaceName, validateViewCatalogStatement, valueIrSchema, variableDefaultIrSchema, variableIrSchema, verifyRebaseIsNoop, walkPredicate, writeMigration };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map