@sequenceholdings/orm 2.5.0 → 2.6.1

package/dist/index.js

@@ -1258,10 +1258,10 @@ function validateResolvedView({ view, tables, views = [] }) {
   const resolved = view.resolved;
   if (!resolved) return [];
   const errors = [];
-  const fail2 = (message) => errors.push(`resolved table '${view.view}': ${message}`);
+  const fail3 = (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) {
-    fail2("requires exactly one primary-key column");
+    fail3("requires exactly one primary-key column");
     return errors;
   }
   const systemNames = new Set(Object.values(RESOLVED_VIEW_SYSTEM_COLUMNS).map((c) => c.name));
@@ -1271,93 +1271,93 @@ function validateResolvedView({ view, tables, views = [] }) {
     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: fail2
+    fail: fail3
   };
-  if (resolved.sources.filter((source) => source.kind === "manual").length !== 1) fail2("requires exactly one manual source");
+  if (resolved.sources.filter((source) => source.kind === "manual").length !== 1) fail3("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)) fail2(`duplicate source '${source.name}'`);
+    if (scope.sourceByName.has(source.name)) fail3(`duplicate source '${source.name}'`);
     scope.sourceByName.set(source.name, source);
     const table = tableByName.get(source.table);
-    if (!table) fail2(`source '${source.name}' references unknown table '${source.table}'`);
+    if (!table) fail3(`source '${source.name}' references unknown table '${source.table}'`);
     else validateSource({ scope, source, table });
   }
   validateRules(scope);
   validateViewCells(scope);
   if (resolved.materialized) validateMaterialized({ scope, tableByName, views });
   for (const name2 of resolved.deletedBy) {
-    if (scope.sourceByName.get(name2)?.kind !== "manual") fail2(`deletedBy '${name2}' must be the manual source`);
+    if (scope.sourceByName.get(name2)?.kind !== "manual") fail3(`deletedBy '${name2}' must be the manual source`);
   }
   return errors;
 }
 function validateSource({ scope, source, table }) {
-  const { fail: fail2 } = scope;
-  if (source.kind === "etl" && table.source === void 0) fail2(`etl source '${source.name}' must reference a synced table`);
-  if (source.kind === "etl" && table.primaryKey?.length === 0) fail2(`etl source '${source.name}' cannot use an unkeyed synced table for resolved row identity`);
+  const { fail: fail3 } = scope;
+  if (source.kind === "etl" && table.source === void 0) fail3(`etl source '${source.name}' must reference a synced table`);
+  if (source.kind === "etl" && table.primaryKey?.length === 0) fail3(`etl source '${source.name}' cannot use an unkeyed synced table for resolved row identity`);
   if (source.kind !== "etl" && (table.internal !== true || table.cellMetadata !== true)) {
-    fail2(`${source.kind} source '${source.name}' must reference an internal table with cell metadata`);
+    fail3(`${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) fail2(`manual source '${source.name}' must carry '__rev' cell columns`);
-  if (source.kind === "prefetch" && hasRev) fail2(`prefetch source '${source.name}' must not carry '__rev' cell columns`);
+  if (source.kind === "manual" && !hasRev) fail3(`manual source '${source.name}' must carry '__rev' cell columns`);
+  if (source.kind === "prefetch" && hasRev) fail3(`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") {
-      fail2(`etl source '${source.name}' updatedAt must name a timestamptz/date column on '${source.table}'`);
+      fail3(`etl source '${source.name}' updatedAt must name a timestamptz/date column on '${source.table}'`);
     }
   }
   validatePrefetchFields({ scope, source });
 }
 function validatePrefetchFields({ scope, source }) {
-  const { fail: fail2, pkColumn } = scope;
+  const { fail: fail3, pkColumn } = scope;
   if (source.kind !== "prefetch") {
     if (source.key || source.fetch || source.function || source.prefetchDefaults || source.writeback) {
-      fail2(`only prefetch sources may declare key/fetch/function/prefetchDefaults/writeback ('${source.name}')`);
+      fail3(`only prefetch sources may declare key/fetch/function/prefetchDefaults/writeback ('${source.name}')`);
     }
     return;
   }
   if (!source.key || !source.fetch || !source.function || !source.prefetchDefaults) {
-    fail2(`prefetch source '${source.name}' requires key, fetch, function and prefetchDefaults`);
+    fail3(`prefetch source '${source.name}' requires key, fetch, function and prefetchDefaults`);
   } else if (source.key !== pkColumn.name && !source.columns.includes(source.key)) {
-    fail2(`prefetch source '${source.name}' key '${source.key}' must be the primary key or one of its columns`);
+    fail3(`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)) fail2(`prefetch source '${source.name}' writes back '${column}', which it does not supply`);
+    if (!source.columns.includes(column)) fail3(`prefetch source '${source.name}' writes back '${column}', which it does not supply`);
   }
 }
 function validateSourceColumns({ scope, source, byName }) {
-  const { fail: fail2, pkColumn, dataColumns } = scope;
+  const { fail: fail3, 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) fail2(`source '${source.name}' supplies unknown column '${column}'`);
-    else if (!theirs) fail2(`source '${source.name}' table '${source.table}' has no column '${column}'`);
-    else if (JSON.stringify(theirs.type) !== JSON.stringify(own.type)) fail2(`column '${column}' has a different type on source '${source.name}'`);
+    if (!own) fail3(`source '${source.name}' supplies unknown column '${column}'`);
+    else if (!theirs) fail3(`source '${source.name}' table '${source.table}' has no column '${column}'`);
+    else if (JSON.stringify(theirs.type) !== JSON.stringify(own.type)) fail3(`column '${column}' has a different type on source '${source.name}'`);
   }
 }
-function validateRules({ resolved, pkColumn, dataColumns, sourceByName, fail: fail2 }) {
+function validateRules({ resolved, pkColumn, dataColumns, sourceByName, fail: fail3 }) {
   const ruled = /* @__PURE__ */ new Set();
   for (const rule of resolved.resolve) {
     if (!dataColumns.has(rule.column) || rule.column === pkColumn.name) {
-      fail2(`resolve rule targets unknown column '${rule.column}'`);
+      fail3(`resolve rule targets unknown column '${rule.column}'`);
       continue;
     }
-    if (ruled.has(rule.column)) fail2(`column '${rule.column}' has more than one resolve rule`);
+    if (ruled.has(rule.column)) fail3(`column '${rule.column}' has more than one resolve rule`);
     ruled.add(rule.column);
     if (rule.comparator === "custom" !== (rule.orderBy !== void 0)) {
-      fail2(`column '${rule.column}': orderBy is required for custom comparators and only allowed there`);
+      fail3(`column '${rule.column}': orderBy is required for custom comparators and only allowed there`);
     }
-    if (new Set(rule.candidates).size !== rule.candidates.length) fail2(`column '${rule.column}' repeats a candidate`);
+    if (new Set(rule.candidates).size !== rule.candidates.length) fail3(`column '${rule.column}' repeats a candidate`);
     for (const candidate of rule.candidates) {
       const source = sourceByName.get(candidate);
-      if (!source) fail2(`column '${rule.column}' names unknown candidate source '${candidate}'`);
-      else if (!source.columns.includes(rule.column)) fail2(`column '${rule.column}' candidate '${candidate}' does not supply it`);
+      if (!source) fail3(`column '${rule.column}' names unknown candidate source '${candidate}'`);
+      else if (!source.columns.includes(rule.column)) fail3(`column '${rule.column}' candidate '${candidate}' does not supply it`);
     }
   }
   for (const column of dataColumns.keys()) {
-    if (column !== pkColumn.name && !ruled.has(column)) fail2(`column '${column}' has no resolve rule`);
+    if (column !== pkColumn.name && !ruled.has(column)) fail3(`column '${column}' has no resolve rule`);
   }
 }
 var VIEW_CELL_TYPES = {
@@ -1366,7 +1366,7 @@ var VIEW_CELL_TYPES = {
   by: "text",
   conflicts: "jsonb"
 };
-function validateViewCells({ view, dataColumns, pkColumn, fail: fail2 }) {
+function validateViewCells({ view, dataColumns, pkColumn, fail: fail3 }) {
   const expected = /* @__PURE__ */ new Map();
   for (const column of dataColumns.values()) {
     if (column.name === pkColumn.name) continue;
@@ -1378,34 +1378,34 @@ function validateViewCells({ view, dataColumns, pkColumn, fail: fail2 }) {
     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) {
-      fail2(`unexpected cell column '${column.name}'`);
+      fail3(`unexpected cell column '${column.name}'`);
       continue;
     }
-    if (column.type !== VIEW_CELL_TYPES[column.cell.part]) fail2(`cell column '${column.name}' must be ${VIEW_CELL_TYPES[column.cell.part]}`);
+    if (column.type !== VIEW_CELL_TYPES[column.cell.part]) fail3(`cell column '${column.name}' must be ${VIEW_CELL_TYPES[column.cell.part]}`);
     expected.delete(column.name);
   }
-  for (const name2 of expected.keys()) fail2(`missing cell column '${name2}'`);
+  for (const name2 of expected.keys()) fail3(`missing cell column '${name2}'`);
 }
 var columnSignature = (columns) => JSON.stringify(columns.map((column) => [column.name, column.columnName, column.type]));
 function validateMaterialized({ scope, tableByName, views }) {
-  const { view, resolved, fail: fail2 } = scope;
+  const { view, resolved, fail: fail3 } = scope;
   const { table: tableName, compute: computeName } = resolved.materialized;
   const table = tableByName.get(tableName);
   if (!table || table.internal !== true || table.materializes !== view.view) {
-    fail2(`materialized table '${tableName}' must be an internal table that materializes '${view.view}'`);
+    fail3(`materialized table '${tableName}' must be an internal table that materializes '${view.view}'`);
   } else {
-    if (columnSignature(table.columns) !== columnSignature(view.columns)) fail2(`materialized table '${tableName}' must have exactly the view's columns`);
-    if (JSON.stringify(table.primaryKey ?? []) !== JSON.stringify(view.primaryKey ?? [])) fail2(`materialized table '${tableName}' must share the view's primary key`);
+    if (columnSignature(table.columns) !== columnSignature(view.columns)) fail3(`materialized table '${tableName}' must have exactly the view's columns`);
+    if (JSON.stringify(table.primaryKey ?? []) !== JSON.stringify(view.primaryKey ?? [])) fail3(`materialized table '${tableName}' must share the view's primary key`);
   }
   const compute = views.find((candidate) => candidate.view === computeName);
-  if (!compute || compute.internal !== true) fail2(`compute view '${computeName}' must be an internal view`);
-  else if (columnSignature(compute.columns) !== columnSignature(view.columns)) fail2(`compute view '${computeName}' must have exactly the view's columns`);
+  if (!compute || compute.internal !== true) fail3(`compute view '${computeName}' must be an internal view`);
+  else if (columnSignature(compute.columns) !== columnSignature(view.columns)) fail3(`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) {
-      fail2(`etl source '${source.name}' must have read policy 'true' to be materialized (the copy is shared by every caller)`);
+      fail3(`etl source '${source.name}' must have read policy 'true' to be materialized (the copy is shared by every caller)`);
     }
   }
 }
@@ -1780,26 +1780,26 @@ var canonicalTableSchema = z.object({
   materializes: identifier2.optional()
 }).superRefine((table, ctx) => {
   if (table.primaryKey?.length !== 0) return;
-  const fail2 = (message, path = ["primaryKey"]) => ctx.addIssue({ code: "custom", path, message: `unkeyed table '${table.table}' ${message}` });
+  const fail3 = (message, path = ["primaryKey"]) => ctx.addIssue({ code: "custom", path, message: `unkeyed table '${table.table}' ${message}` });
   if (table.source === void 0 || table.columns.length === 0) {
-    fail2("requires a typed synced source");
+    fail3("requires a typed synced source");
   }
   if ([table.policies.write, table.policies.insert, table.policies.update].some((policy) => policy !== void 0)) {
-    fail2("is read-only and cannot declare write policies", ["policies"]);
+    fail3("is read-only and cannot declare write policies", ["policies"]);
   }
   const ownedCollections = [table.indexes, table.actions, table.checks, table.foreignKeys, table.cowMutations];
   const ownedMetadata = [table.cellMetadata, table.internal, table.materializes, table.renamedFrom];
   if (ownedCollections.some((items) => items !== void 0 && items.length > 0) || ownedMetadata.some((value) => value !== void 0)) {
-    fail2("cannot declare owned storage, constraints or identity operations");
+    fail3("cannot declare owned storage, constraints or identity operations");
   }
   for (const [index3, column] of table.columns.entries()) {
     const ownedColumnMetadata = [column.default, column.defaultFn, column.onUpdateFn, column.renamedFrom, column.cast, column.cell];
     if (column.unique || ownedColumnMetadata.some((value) => value !== void 0)) {
-      fail2("cannot declare column uniqueness, mutation defaults or migration metadata", ["columns", index3]);
+      fail3("cannot declare column uniqueness, mutation defaults or migration metadata", ["columns", index3]);
     }
   }
   for (const [index3, link] of table.links.entries()) {
-    if (link.enforce || link.kind === "toMany") fail2("cannot provide an identity for this link", ["links", index3]);
+    if (link.enforce || link.kind === "toMany") fail3("cannot provide an identity for this link", ["links", index3]);
   }
 });
 var MAX_VIEW_QUERY = 1e5;
@@ -1890,49 +1890,49 @@ function trackedCellColumns(table) {
 }
 var SUFFIXES = Object.values(CELL_PART_SUFFIX);
 function validateCellMetadata(table, index3, ctx) {
-  const fail2 = (message, path = ["tables", index3]) => ctx.addIssue({ code: "custom", path, message });
+  const fail3 = (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) fail2(`cell-metadata columns require cellMetadata on table '${table.table}'`, ["tables", index3, "columns", position]);
+    for (const { position } of cells) fail3(`cell-metadata columns require cellMetadata on table '${table.table}'`, ["tables", index3, "columns", position]);
     return;
   }
   if (table.source !== void 0) {
-    fail2(`synced table '${table.table}' cannot track cell metadata`);
+    fail3(`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) fail2(`only a resolved table's internal sources carry '__rev' cell columns ('${table.table}')`);
+  if (withRev && table.internal !== true) fail3(`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) {
-      fail2(`cell column '${column.name}' belongs to '${cell.of}', which is not a tracked column`, path);
+      fail3(`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") fail2(`a table cell column must be part at/by/rev, not '${cell.part}'`, path);
+    if (cell.part !== "at" && cell.part !== "by" && cell.part !== "rev") fail3(`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)) {
-      fail2(`cell column for '${owner.name}' ${cell.part} must be named '${cellColumnName(owner.name, cell.part)}' / '${cellColumnName(owner.columnName, cell.part)}'`, path);
+      fail3(`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) {
-      fail2(`cell column '${column.name}' must be a nullable, default-less ${CELL_PART_TYPES[cell.part]}`, path);
+      fail3(`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)) fail2(`duplicate cell column '${column.name}'`, path);
+    if (seen.has(key)) fail3(`duplicate cell column '${column.name}'`, path);
     seen.add(key);
   }
   for (const column of tracked) {
     if (column.columnName.length > MAX_TRACKED_COLUMN_NAME) {
-      fail2(`column '${column.columnName}' is too long to track cell metadata (max ${MAX_TRACKED_COLUMN_NAME} characters)`);
+      fail3(`column '${column.columnName}' is too long to track cell metadata (max ${MAX_TRACKED_COLUMN_NAME} characters)`);
     }
     if (SUFFIXES.some((suffix) => column.columnName.endsWith(suffix))) {
-      fail2(`column '${column.columnName}' ends in a reserved cell-metadata suffix (${SUFFIXES.join(", ")})`);
+      fail3(`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}`)) fail2(`tracked column '${column.name}' is missing its '${cellColumnName(column.columnName, part)}' cell column`);
+      if (!seen.has(`${column.name}:${part}`)) fail3(`tracked column '${column.name}' is missing its '${cellColumnName(column.columnName, part)}' cell column`);
     }
   }
 }
@@ -2000,38 +2000,38 @@ var localDefinitionSchema = z.object({
       }
     }
     for (const [index3, check] of (table.checks ?? []).entries()) {
-      const fail2 = (message) => ctx.addIssue({ code: "custom", path: ["tables", tableIndex, "checks", index3], message });
-      if (table.source) fail2("synced tables cannot declare checks");
-      if (names.has(check.name)) fail2(`duplicate constraint '${check.name}'`);
+      const fail3 = (message) => ctx.addIssue({ code: "custom", path: ["tables", tableIndex, "checks", index3], message });
+      if (table.source) fail3("synced tables cannot declare checks");
+      if (names.has(check.name)) fail3(`duplicate constraint '${check.name}'`);
       names.add(check.name);
       try {
         compileCheckExpression(check.expression, table.columns);
       } catch (error) {
-        fail2(error instanceof Error ? error.message : String(error));
+        fail3(error instanceof Error ? error.message : String(error));
       }
     }
     for (const [index3, fk] of (table.foreignKeys ?? []).entries()) {
-      const fail2 = (message) => ctx.addIssue({ code: "custom", path: ["tables", tableIndex, "foreignKeys", index3], message });
-      if (names.has(fk.name)) fail2(`duplicate foreign key '${fk.name}'`);
+      const fail3 = (message) => ctx.addIssue({ code: "custom", path: ["tables", tableIndex, "foreignKeys", index3], message });
+      if (names.has(fk.name)) fail3(`duplicate foreign key '${fk.name}'`);
       names.add(fk.name);
       const target = fkTables.get(fk.target);
       if (table.source || !target || target.source) {
-        fail2("foreign keys must connect owned tables in the same namespace");
+        fail3("foreign keys must connect owned tables in the same namespace");
         continue;
       }
-      if (fk.columns.length !== fk.references.length) fail2("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) fail2("foreign key columns must not repeat");
+      if (fk.columns.length !== fk.references.length) fail3("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) fail3("foreign key columns must not repeat");
       for (const [position, name2] of fk.columns.entries()) {
         const sourceColumn = table.columns.find((column) => column.columnName === name2);
         const targetColumn = target.columns.find((column) => column.columnName === fk.references[position]);
-        if (!sourceColumn || !targetColumn) fail2("foreign key references an unknown column");
-        else if (JSON.stringify(sourceColumn.type) !== JSON.stringify(targetColumn.type)) fail2("foreign key column types must match");
+        if (!sourceColumn || !targetColumn) fail3("foreign key references an unknown column");
+        else if (JSON.stringify(sourceColumn.type) !== JSON.stringify(targetColumn.type)) fail3("foreign key column types must match");
       }
       if (fk.onDelete === "set null" || fk.onUpdate === "set null") {
-        if (fk.columns.some((name2) => table.columns.find((column) => column.columnName === name2)?.nullable === false || table.primaryKey?.includes(name2))) fail2("SET NULL requires nullable source columns");
+        if (fk.columns.some((name2) => table.columns.find((column) => column.columnName === name2)?.nullable === false || table.primaryKey?.includes(name2))) fail3("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)))) fail2("foreign key target columns must form a unique key");
+      if (!uniqueKeys.some((key) => key.length === fk.references.length && key.every((column) => fk.references.includes(column)))) fail3("foreign key target columns must form a unique key");
     }
   }
   for (const [viewIndex, view] of (definition.views ?? []).entries()) {
@@ -2219,8 +2219,8 @@ function cloneColumn({ builder, property, notNull, primaryKey: primaryKey2 }) {
   return clone;
 }
 function planSource(input) {
-  const { sourceName, input: source, fail: fail2 } = input;
-  if (!IDENTIFIER_PATTERN.test(sourceName)) fail2(`source name "${sourceName}" must match ${IDENTIFIER_PATTERN}`);
+  const { sourceName, input: source, fail: fail3 } = input;
+  if (!IDENTIFIER_PATTERN.test(sourceName)) fail3(`source name "${sourceName}" must match ${IDENTIFIER_PATTERN}`);
   switch (source.kind) {
     case "manual":
       return {
@@ -2260,27 +2260,27 @@ function assertColumns(input, list2, what) {
   for (const column of list2) if (!input.dataColumns.includes(column)) input.fail(`${what} names unknown column "${column}"`);
 }
 function planEtl(input, source) {
-  const { sourceName, pk, dataColumns, fail: fail2 } = input;
+  const { sourceName, pk, dataColumns, fail: fail3 } = input;
   const table = typeof source.table === "function" ? source.table() : source.table;
-  if (!isSeqTable(table) || table.source === void 0) fail2(`etl source "${sourceName}" must reference a defineSyncedTable`);
+  if (!isSeqTable(table) || table.source === void 0) fail3(`etl source "${sourceName}" must reference a defineSyncedTable`);
   const synced = table;
-  if (synced.config.primaryKey?.length === 0) fail2(`etl source "${sourceName}" cannot use an unkeyed synced table for resolved row identity`);
-  if (!(pk in synced.columns)) fail2(`etl source "${sourceName}" table "${synced.tableName}" has no "${pk}" column`);
+  if (synced.config.primaryKey?.length === 0) fail3(`etl source "${sourceName}" cannot use an unkeyed synced table for resolved row identity`);
+  if (!(pk in synced.columns)) fail3(`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)) {
-    fail2(`etl source "${sourceName}" updatedAt "${source.updatedAt}" is not a column of "${synced.tableName}"`);
+    fail3(`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: fail2 } = input;
+  const { sourceName, pk, fail: fail3 } = input;
   assertColumns(input, source.columns, `prefetch source "${sourceName}"`);
   if (source.key !== pk && !source.columns.includes(source.key)) {
-    fail2(`prefetch source "${sourceName}" key "${source.key}" must be the primary key or one of its columns`);
+    fail3(`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)) fail2(`prefetch source "${sourceName}" writes back "${column}", which it does not supply`);
+    if (!source.columns.includes(column)) fail3(`prefetch source "${sourceName}" writes back "${column}", which it does not supply`);
   }
   const writeback = source.writeback;
   return {
@@ -2486,34 +2486,34 @@ var SYSTEM_VIEW_COLUMNS = {
 };
 function defineResolvedTable(name2, columns, config) {
   const file = activeAuthoringContext()?.currentFile;
-  const fail2 = (message) => {
+  const fail3 = (message) => {
     throw new OrmDefinitionError(`resolved table "${name2}": ${message}`, file);
   };
-  if (!IDENTIFIER_PATTERN.test(name2)) fail2(`name must match ${IDENTIFIER_PATTERN}`);
+  if (!IDENTIFIER_PATTERN.test(name2)) fail3(`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))) {
-      fail2(`column "${property}" collides with a reserved system column`);
+      fail3(`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) {
-      fail2(`column "${property}" is too long for a resolved table (max ${MAX_TRACKED_COLUMN_NAME} characters, room for cell parts)`);
+      fail3(`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) fail2("declare exactly one .primaryKey() column");
+  if (pkEntries.length !== 1) fail3("declare exactly one .primaryKey() column");
   const [pk, pkBuilder] = pkEntries[0];
   const dataColumns = Object.keys(columns).filter((property) => property !== pk);
-  if (dataColumns.length === 0) fail2("declare at least one non-key column");
+  if (dataColumns.length === 0) fail3("declare at least one non-key column");
   const sourceEntries = Object.entries(config.sources);
-  if (sourceEntries.filter(([, source]) => source.kind === "manual").length !== 1) fail2("declare exactly one manualSource()");
+  if (sourceEntries.filter(([, source]) => source.kind === "manual").length !== 1) fail3("declare exactly one manualSource()");
   const plans = sourceEntries.map(
-    ([sourceName, input]) => planSource({ viewName: name2, sourceName, input, columns, pk, pkBuilder, dataColumns, fail: fail2 })
+    ([sourceName, input]) => planSource({ viewName: name2, sourceName, input, columns, pk, pkBuilder, dataColumns, fail: fail3 })
   );
-  const rules = planRules({ config, plans, dataColumns, fail: fail2 });
+  const rules = planRules({ config, plans, dataColumns, fail: fail3 });
   const deletedBy = [...config.rows?.deletedBy ?? []];
   for (const source of deletedBy) {
-    if (plans.find((plan) => plan.name === source)?.kind !== "manual") fail2(`rows.deletedBy "${source}" must be the manual source`);
+    if (plans.find((plan) => plan.name === source)?.kind !== "manual") fail3(`rows.deletedBy "${source}" must be the manual source`);
   }
   const partType = { source: t.text, at: t.timestamptz, by: t.text, conflicts: t.jsonb };
   const viewColumns = {};
@@ -2576,11 +2576,11 @@ function defineResolvedTable(name2, columns, config) {
     }
   });
 }
-function planRules({ config, plans, dataColumns, fail: fail2 }) {
+function planRules({ config, plans, dataColumns, fail: fail3 }) {
   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)) fail2(`resolve names unknown column "${column}"`);
+    if (!dataColumns.includes(column)) fail3(`resolve names unknown column "${column}"`);
   }
   return dataColumns.map((column) => {
     const explicit = config.resolve?.[column];
@@ -2588,11 +2588,11 @@ function planRules({ config, plans, dataColumns, fail: fail2 }) {
     const candidates = explicit ? [...explicit.candidates] : comparator.candidates.filter((name2) => plans.find((plan) => plan.name === name2)?.columns.includes(column));
     for (const candidate of candidates) {
       const plan = plans.find((entry) => entry.name === candidate);
-      if (!plan) fail2(`column "${column}" names unknown source "${candidate}"`);
-      else if (!plan.columns.includes(column)) fail2(`column "${column}" candidate "${candidate}" does not supply it`);
+      if (!plan) fail3(`column "${column}" names unknown source "${candidate}"`);
+      else if (!plan.columns.includes(column)) fail3(`column "${column}" candidate "${candidate}" does not supply it`);
     }
-    if (candidates.length === 0) fail2(`column "${column}" has no candidate source`);
-    if (comparator.kind === "custom") assertSafeOrderBy({ orderBy: comparator.orderBy ?? "", column, fail: fail2 });
+    if (candidates.length === 0) fail3(`column "${column}" has no candidate source`);
+    if (comparator.kind === "custom") assertSafeOrderBy({ orderBy: comparator.orderBy ?? "", column, fail: fail3 });
     return {
       column,
       comparator: comparator.kind,
@@ -2643,18 +2643,18 @@ var ORDER_BY_KEYWORDS = /* @__PURE__ */ new Set([
 ]);
 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: fail2 }) {
+function assertSafeOrderBy({ orderBy, column, fail: fail3 }) {
   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)) {
-      fail2(`column "${column}" custom orderBy uses "${match[0]}" \u2014 only value, updated_at, source, actor, ord, SQL keywords and allowlisted functions`);
+      fail3(`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() === "") {
-    fail2(`column "${column}" custom orderBy contains an unsupported character near "${orderBy.slice(consumed, consumed + 10)}"`);
+    fail3(`column "${column}" custom orderBy contains an unsupported character near "${orderBy.slice(consumed, consumed + 10)}"`);
   }
 }
 function stableJson(value) {
@@ -3182,17 +3182,17 @@ function buildCanonicalLink({
 }) {
   const ownerKind = relationKind(relation);
   const ownerName = relationName(relation);
-  const fail2 = (message) => {
+  const fail3 = (message) => {
     throw new OrmDefinitionError(`${ownerKind} "${ownerName}": link "${linkName}" ${message}`, relation.file);
   };
   if (link.enforce && link.linkKind !== "toOne") {
-    return fail2("sets enforce: true, which is only supported on toOne links");
+    return fail3("sets enforce: true, which is only supported on toOne links");
   }
   if ((link.onDelete !== void 0 || link.onUpdate !== void 0) && !link.enforce) {
-    return fail2("sets a referential action without enforce: true");
+    return fail3("sets a referential action without enforce: true");
   }
   if (link.linkKind === "toPlatformUser") {
-    if (link.target !== void 0) return fail2("is toPlatformUser and must not declare a target table");
+    if (link.target !== void 0) return fail3("is toPlatformUser and must not declare a target table");
     return {
       name: linkName,
       kind: "toPlatformUser",
@@ -3203,7 +3203,7 @@ function buildCanonicalLink({
     };
   }
   if (typeof link.target === "object" && link.target?.kind === "seq-external-object") {
-    if (link.enforce) return fail2("cannot enforce a cross-namespace physical foreign key; use an ORM link without enforce");
+    if (link.enforce) return fail3("cannot enforce a cross-namespace physical foreign key; use an ORM link without enforce");
     return {
       name: linkName,
       kind: link.linkKind,
@@ -3215,13 +3215,13 @@ function buildCanonicalLink({
       ...link.description !== void 0 ? { description: link.description } : {}
     };
   }
-  const target = resolveRelationRef({ ref: link.target, fail: fail2 });
+  const target = resolveRelationRef({ ref: link.target, fail: fail3 });
   const targetName = relationName(target);
   if (!relationsByName.has(targetName)) {
-    return fail2(`targets ${relationKind(target)} "${targetName}" which is not part of this namespace`);
+    return fail3(`targets ${relationKind(target)} "${targetName}" which is not part of this namespace`);
   }
   if (link.enforce && (!isSeqTable(relation) || !isSeqTable(target))) {
-    return fail2("cannot enforce a PostgreSQL foreign key involving a view");
+    return fail3("cannot enforce a PostgreSQL foreign key involving a view");
   }
   const owningSide = link.linkKind === "toOne" ? relation : target;
   const referencedSide = link.linkKind === "toOne" ? target : relation;
@@ -3237,19 +3237,19 @@ function buildCanonicalLink({
     ...link.description !== void 0 ? { description: link.description } : {}
   };
 }
-function resolveRelationRef({ ref, fail: fail2 }) {
-  if (ref === void 0) return fail2("declares no target relation");
+function resolveRelationRef({ ref, fail: fail3 }) {
+  if (ref === void 0) return fail3("declares no target relation");
   if (typeof ref !== "function") return ref;
   let resolved;
   try {
     resolved = ref();
   } catch (error) {
-    return fail2(
+    return fail3(
       `target thunk threw (${error instanceof Error ? error.message : String(error)}) \u2014 lazy refs resolve at serialize time; make sure the target module ran`
     );
   }
   if (!isSeqTable(resolved) && !isSeqView(resolved)) {
-    return fail2("target thunk did not return a relation defined with defineTable/defineView");
+    return fail3("target thunk did not return a relation defined with defineTable/defineView");
   }
   return resolved;
 }
@@ -4121,19 +4121,19 @@ function compileComparison(op, left, right, columnTypes) {
   }
   return `${compileOperand(left, right, columnTypes)} ${SQL_COMPARE_OPS[op]} ${compileOperand(right, left, columnTypes)}`;
 }
-function compilePredicate(predicate, columnTypes) {
+function compilePredicate(predicate, columnTypes, options = {}) {
   switch (predicate.kind) {
     case "and":
     case "or": {
-      const joined = predicate.operands.map((operand) => compilePredicate(operand, columnTypes)).join(` ${predicate.kind.toUpperCase()} `);
+      const joined = predicate.operands.map((operand) => compilePredicate(operand, columnTypes, options)).join(` ${predicate.kind.toUpperCase()} `);
       return `(${joined})`;
     }
     case "not":
-      return `(NOT ${compilePredicate(predicate.operand, columnTypes)})`;
+      return `(NOT ${compilePredicate(predicate.operand, columnTypes, options)})`;
     case "compare":
       return `(${compileComparison(predicate.op, predicate.left, predicate.right, columnTypes)})`;
     case "capability":
-      return `(${capabilityExpression(predicate.key)})`;
+      return `(${options.statementClaimChecks ? "SELECT " : ""}${capabilityExpression(predicate.key)})`;
   }
 }
 
@@ -4219,9 +4219,9 @@ function compilePredIrToSql(pred, options = {}) {
     case "cmp":
       return compileCmp(pred.op, pred.column, pred.value, options);
     case "capability":
-      return `(${capabilityExpression(pred.key, pred.namespace ?? options.namespace)})`;
+      return `(${options.statementClaimChecks ? "SELECT " : ""}${capabilityExpression(pred.key, pred.namespace ?? options.namespace)})`;
     case "role":
-      return `(${roleExpression(pred.key, pred.namespace ?? options.namespace)})`;
+      return `(${options.statementClaimChecks ? "SELECT " : ""}${roleExpression(pred.key, pred.namespace ?? options.namespace)})`;
     case "exists":
       if (options.exists) return options.exists(pred);
       throw new OrmDefinitionError("synced view read policy cannot use 'exists' without a relationship resolver");
@@ -4797,7 +4797,9 @@ function syncedViewStatements({
   columnNamesByTable,
   columnTypesByTable,
   executionOwnerRole = SYNCED_VIEW_EXECUTION_OWNER_ROLE,
-  backingPrivileges = "grant"
+  backingPrivileges = "grant",
+  viewPrivileges = "grant",
+  statementClaimChecks = true
 }) {
   const schema = quoteIdentifier(ormSchemaName(definition.namespace));
   const role = quoteIdentifier(consumerRoleName(definition.namespace));
@@ -4840,9 +4842,10 @@ function syncedViewStatements({
     const readPolicy = table.policies?.read;
     const policyClause = readPolicyIr ? ` WHERE ${compilePredIrToSql(readPolicyIr, {
       namespace: definition.namespace,
+      statementClaimChecks,
       columnTypes,
       columnNames: columnNamesByTable?.get(table.table)
-    })}` : readPolicy ? ` WHERE ${compilePredicate(readPolicy.ast, narrowToV1ColumnTypes(columnTypes))}` : " WHERE false";
+    })}` : readPolicy ? ` WHERE ${compilePredicate(readPolicy.ast, narrowToV1ColumnTypes(columnTypes), { statementClaimChecks })}` : " WHERE false";
     if (backingPrivileges === "grant") {
       const selectPrivilege = backing.selectColumns ? `SELECT (${backing.selectColumns.map(quoteIdentifier).join(", ")})` : "SELECT";
       const hasSelectPrivilege = backing.selectColumns ? backing.selectColumns.map((column) => `pg_catalog.has_column_privilege(${quoteLiteral(executionOwnerRole)}, ${quoteLiteral(physicalTarget)}, ${quoteLiteral(column)}, 'SELECT')`).join("\n    AND ") : `pg_catalog.has_table_privilege(${quoteLiteral(executionOwnerRole)}, ${quoteLiteral(physicalTarget)}, 'SELECT')`;
@@ -4859,7 +4862,7 @@ END`)}`);
     statements.push(
       `CREATE OR REPLACE VIEW ${viewName} AS SELECT ${projection} FROM ${physicalTarget}${whereClause}`
     );
-    statements.push(`GRANT SELECT ON ${viewName} TO ${role}`);
+    if (viewPrivileges === "grant") statements.push(`GRANT SELECT ON ${viewName} TO ${role}`);
   }
   return statements;
 }
@@ -5197,15 +5200,15 @@ var sqlValues = /* @__PURE__ */ new Set([
 async function validateManagedViewQueries({ canonical }) {
   for (const definition of [canonical, ...canonical.imports ?? []]) {
     for (const view of definition.views ?? []) {
-      const fail2 = (message) => {
+      const fail3 = (message) => {
         throw new OrmDefinitionError(`managed view '${definition.namespace}/${view.view}': ${message}`);
       };
       parser ??= new PgParser({ version: 17 });
       const parsed = await parser.parse(view.query);
-      if (parsed.error || !parsed.tree) fail2("invalid SELECT query");
+      if (parsed.error || !parsed.tree) fail3("invalid SELECT query");
       const statements = list(obj(parsed.tree).stmts);
-      if (statements.length !== 1 || !obj(obj(statements[0]).stmt).SelectStmt) fail2("one SELECT query is required");
-      validateTree({ tree: parsed.tree, schema: ormSchemaName(definition.namespace), enums: definition.enums.map((entry) => entry.name), fail: fail2 });
+      if (statements.length !== 1 || !obj(obj(statements[0]).stmt).SelectStmt) fail3("one SELECT query is required");
+      validateTree({ tree: parsed.tree, schema: ormSchemaName(definition.namespace), enums: definition.enums.map((entry) => entry.name), fail: fail3 });
     }
   }
 }
@@ -5234,29 +5237,29 @@ function validateTree({ tree, ...scope }) {
   }
 }
 function validateNode({ kind, child, scope }) {
-  const { fail: fail2 } = scope;
-  if (kind.endsWith("Stmt") && kind !== "SelectStmt") fail2("only SELECT statements are permitted");
+  const { fail: fail3 } = scope;
+  if (kind.endsWith("Stmt") && kind !== "SelectStmt") fail3("only SELECT statements are permitted");
   if (kind === "FuncCall") {
     const call = obj(child);
     const parts = strings(call.funcname);
     const name2 = reviewedFunctionName({ parts, format: call.funcformat });
-    if (!name2 || !functions.has(name2)) fail2(`only explicitly allowlisted pg_catalog functions are permitted (found '${parts.join(".")}')`);
+    if (!name2 || !functions.has(name2)) fail3(`only explicitly allowlisted pg_catalog functions are permitted (found '${parts.join(".")}')`);
   }
   if (kind === "typeName" || kind === "TypeName") validateType({ node: obj(child), ...scope });
-  if (kind === "A_Expr" && pgCatalogName(strings(obj(child).name)) === void 0) fail2("only pg_catalog operators are permitted");
-  if (kind === "SortBy" && list(obj(child).useOp).length && pgCatalogName(strings(obj(child).useOp)) === void 0) fail2("only pg_catalog sort operators are permitted");
-  if (kind === "SQLValueFunction" && !sqlValues.has(String(obj(child).op))) fail2("unsupported SQL value expression");
-  if (kind === "ParamRef") fail2("view queries cannot contain parameters");
+  if (kind === "A_Expr" && pgCatalogName(strings(obj(child).name)) === void 0) fail3("only pg_catalog operators are permitted");
+  if (kind === "SortBy" && list(obj(child).useOp).length && pgCatalogName(strings(obj(child).useOp)) === void 0) fail3("only pg_catalog sort operators are permitted");
+  if (kind === "SQLValueFunction" && !sqlValues.has(String(obj(child).op))) fail3("unsupported SQL value expression");
+  if (kind === "ParamRef") fail3("view queries cannot contain parameters");
   if (kind === "A_Indirection" && list(obj(child).indirection).some((entry) => !obj(entry).A_Indices)) {
-    fail2("composite field notation is not permitted in managed views");
+    fail3("composite field notation is not permitted in managed views");
   }
 }
-function validateType({ node, schema, enums, fail: fail2 }) {
+function validateType({ node, schema, enums, fail: fail3 }) {
   const parts = strings(node.names);
   const builtin = pgCatalogName(parts);
   const managedEnum = parts.length === 1 && enums.includes(parts[0]) || parts.length === 2 && parts[0] === schema && enums.includes(parts[1]);
   if (node.setof || node.pct_type || !managedEnum && (!builtin || !scalarTypes.has(builtin))) {
-    fail2(`casts may only use supported pg_catalog scalar types or declared enums (found '${parts.join(".")}')`);
+    fail3(`casts may only use supported pg_catalog scalar types or declared enums (found '${parts.join(".")}')`);
   }
 }
 
@@ -6468,6 +6471,118 @@ async function guardedRun(run) {
     process.exit = originalExit;
   }
 }
+var parser2;
+var locations = /* @__PURE__ */ new Set(["location", "stmt_location", "stmt_len"]);
+async function assertSyncedViewDefinitionMatches({
+  viewDefinition,
+  expectedCreateStatements
+}) {
+  if (!expectedCreateStatements.length) fail2();
+  const expected = [];
+  for (const statement of expectedCreateStatements) {
+    const node = await parseStatement(statement);
+    const view = obj(node.ViewStmt);
+    requireKeys(view, ["view", "query", "replace", "withCheckOption"]);
+    if (view.replace !== true || view.withCheckOption !== "NO_CHECK_OPTION") fail2();
+    backingOf(obj(view.view));
+    expected.push(canonicalSelect(obj(obj(view.query).SelectStmt)));
+  }
+  const actual = await parseStatement(viewDefinition);
+  if (!expected.includes(canonicalSelect(obj(actual.SelectStmt)))) fail2();
+}
+function fail2() {
+  throw new OrmDefinitionError("synced view definition does not match the compiler");
+}
+async function parseStatement(sql7) {
+  if (!sql7.length || sql7.length > 262144) fail2();
+  parser2 ??= new PgParser({ version: 17 });
+  const parsed = await parser2.parse(sql7);
+  if (parsed.error || !parsed.tree) fail2();
+  const statements = list(obj(parsed.tree).stmts);
+  if (statements.length !== 1) fail2();
+  return obj(obj(statements[0]).stmt);
+}
+function requireKeys(node, allowed) {
+  for (const key of Object.keys(node)) if (!locations.has(key) && !allowed.includes(key)) fail2();
+}
+function backingOf(node) {
+  requireKeys(node, ["catalogname", "schemaname", "relname", "inh", "relpersistence"]);
+  if (node.catalogname !== "" || node.inh !== true || node.relpersistence !== "p") fail2();
+  const schema = str(node.schemaname);
+  const relation = str(node.relname);
+  if (!schema || !relation) fail2();
+  return { schema, relation };
+}
+function validateSelect(select, scalar2) {
+  requireKeys(select, ["targetList", "fromClause", "whereClause", "groupDistinct", "limitOption", "op", "all"]);
+  if (select.groupDistinct !== false || select.limitOption !== "LIMIT_OPTION_DEFAULT" || select.op !== "SETOP_NONE" || select.all !== false) fail2();
+  if (scalar2 && (list(select.fromClause).length || select.whereClause !== void 0 || list(select.targetList).length !== 1)) fail2();
+}
+function canonicalSelect(select) {
+  validateSelect(select, false);
+  const from = list(select.fromClause);
+  if (from.length !== 1) fail2();
+  const backing = backingOf(obj(obj(from[0]).RangeVar));
+  const targets = list(select.targetList);
+  if (!targets.length) fail2();
+  for (const target of targets) {
+    const node = obj(obj(target).ResTarget);
+    requireKeys(node, ["name", "val"]);
+    if (node.name !== "" || !obj(node.val).ColumnRef) fail2();
+  }
+  return JSON.stringify(normalize({ value: select, backing, scalar: false }));
+}
+function normalize({ value, backing, scalar: scalar2 }) {
+  if (Array.isArray(value)) return value.map((entry) => normalize({ value: entry, backing, scalar: scalar2 }));
+  if (!value || typeof value !== "object") return value;
+  const node = obj(value);
+  if (node.ColumnRef) return normalizeColumnRef({ ref: obj(node.ColumnRef), backing, scalar: scalar2 });
+  if (node.TypeCast && isLiteralTextCast(obj(node.TypeCast))) {
+    return normalize({ value: obj(node.TypeCast).arg, backing, scalar: scalar2 });
+  }
+  if (node.SubLink) return normalizeScalarSubLink({ sublink: obj(node.SubLink), backing });
+  const result = {};
+  for (const key of Object.keys(node).sort()) {
+    if (locations.has(key)) continue;
+    if (key === "ParamRef" || key === "RangeSubselect" || key === "JoinExpr" || key.endsWith("Stmt") && key !== "SelectStmt" || scalar2 && key === "RangeVar") fail2();
+    result[key] = normalize({ value: node[key], backing, scalar: scalar2 });
+  }
+  return result;
+}
+function normalizeColumnRef({ ref, backing, scalar: scalar2 }) {
+  if (scalar2) fail2();
+  requireKeys(ref, ["fields"]);
+  const fields = strings(ref.fields);
+  const qualified = fields.length === 2 && fields[0] === backing.relation || fields.length === 3 && fields[0] === backing.schema && fields[1] === backing.relation;
+  if (fields.length !== 1 && !qualified) fail2();
+  const column = fields.at(-1);
+  if (!column) fail2();
+  return { ColumnRef: { fields: [{ String: { sval: column } }] } };
+}
+function normalizeScalarSubLink({ sublink, backing }) {
+  requireKeys(sublink, ["subLinkType", "subLinkId", "subselect"]);
+  if (sublink.subLinkType !== "EXPR_SUBLINK" || sublink.subLinkId !== 0) fail2();
+  const select = obj(obj(sublink.subselect).SelectStmt);
+  validateSelect(select, true);
+  const target = obj(obj(list(select.targetList)[0]).ResTarget);
+  requireKeys(target, ["name", "val"]);
+  const normalizedSelect = { ...select, targetList: [{ ResTarget: { ...target, name: "" } }] };
+  return { SubLink: normalize({ value: { ...sublink, subselect: { SelectStmt: normalizedSelect } }, backing, scalar: true }) };
+}
+function isLiteralTextCast(cast) {
+  requireKeys(cast, ["arg", "typeName"]);
+  const arg = obj(cast.arg);
+  if (!arg.A_Const) return false;
+  const constant = obj(arg.A_Const);
+  if (constant.isnull !== false || !constant.sval || typeof obj(constant.sval).sval !== "string") return false;
+  const type = obj(cast.typeName);
+  const names = strings(type.names);
+  if (!(names.length === 1 && names[0] === "text" || names.length === 2 && names[0] === "pg_catalog" && names[1] === "text")) return false;
+  if (list(type.arrayBounds).length || list(type.typmods).length) return false;
+  requireKeys(type, ["names", "typeOid", "setof", "pct_type", "typemod"]);
+  if (type.typeOid !== 0 || type.setof !== false || type.pct_type !== false || type.typemod !== -1) return false;
+  return true;
+}
 
 // src/engine/index.ts
 var STATEMENT_KINDS = ["hint", "ddl", "security", "function", "synced_view"];
@@ -6537,6 +6652,11 @@ function renderOrmMigrationExport(exported) {
   if (Buffer.byteLength(text4, "utf8") > ORM_MIGRATION_EXPORT_MAX_BYTES) throw new Error("ORM migration export exceeds the size limit");
   return text4;
 }
+
+// src/client/sql.ts
+var BUILTIN_SQL_READ_HASH = "sha256:a50c477c952a5e0fe68ed158a4530e4aab573c09bcbb1a8ac454dc88a39a6258";
+
+// src/ir/index.ts
 var IR_VERSION = 5;
 var LEGACY_IR_VERSION = 1;
 var GUARDED_IR_VERSION = 2;
@@ -6869,7 +6989,8 @@ var compiledOperationSchema = z.object({
 }).superRefine((operation, ctx) => {
   if (operation.language === "sql") {
     const validPlan = operation.sqlQuery ? !operation.sql && operation.irVersion === RUNTIME_SQL_IR_VERSION : !!operation.sql && operation.irVersion === SQL_IR_VERSION;
-    if (!validPlan || operation.kind !== "query" || operation.roots.length !== 0 || !operation.requires?.capability) {
+    const builtin = operation.name === "BuiltinSqlRead" && operation.opHash === BUILTIN_SQL_READ_HASH && operation.requires === null;
+    if (!validPlan || operation.kind !== "query" || operation.roots.length !== 0 || !builtin && !operation.requires?.capability) {
       ctx.addIssue({ code: "custom", message: "SQL operations require a query-only v4 plan or v5 runtime contract, capability, and no GraphQL roots" });
     }
   } else if (operation.sql || operation.sqlQuery || operation.roots.length === 0) {
@@ -8240,6 +8361,6 @@ function resumeArguments({
   return [literal2.sql];
 }
 
-export { ACTION_REQUIRES_DENIED_SQLSTATE, ACTION_VALIDATES_FAILED_SQLSTATE, AUDIT_ACTIONS, CANONICAL_FORMAT, CAPABILITIES_CLAIM_KEY, CAPABILITY_KEY_PATTERN, CELLS_FIELD, CELL_PARTS, CELL_PART_SUFFIX, CLAIMS_CONTRACT, CLAIMS_SETTING, CLAIM_KEY_PATTERN, CMP_OPS, COLUMN_BRAND, COLUMN_DEFAULT_FNS, COLUMN_IDENTIFIER_PATTERN, COLUMN_TYPES2 as COLUMN_TYPES, COMPARE_OPS, COMPOSED_IR_VERSION, CONSUMER_ROLE_SUFFIX, ColumnBuilder, DATE_BUCKETS, DEFINITION_FILE_EXTENSIONS, ENUM_BRAND, EXTERNAL_POLICY_CLAIM_KEYS, GUARDED_IR_VERSION, HASH_DOMAIN, IDENTIFIER_PATTERN, IDENTIFIER_RE, IMPORT_CONFLICT_MODES, INPUT_REF_KINDS, IR_VERSION, IrVersionError, LEGACY_IR_VERSION, LINK_BRAND, MATERIALIZE_ACTOR, MATERIALIZE_CLAIMS_JSON, MAX_DEFINITION_FILE_BYTES, MAX_GENERATED_SDL_BYTES, MAX_IDENTIFIER_LENGTH, MAX_PERSISTED_READ_ROWS, MAX_TRACKED_COLUMN_NAME, MIGRATIONS_DIRNAME, NAMESPACE_CONFIG_BRAND, NAMESPACE_CONFIG_FILE, NAMESPACE_CONFIG_FILENAMES, NAMESPACE_PATTERN, ORM_DATA_TOKEN_HEADER, ORM_MIGRATION_EXPORT_FILE, ORM_MIGRATION_EXPORT_MAX_BYTES, ORM_REGISTRATION_MAX_BYTES, ORM_SCHEMA_PREFIX, ORM_SERVICE_DATA_TOKEN_HEADER, ORM_TO_PIPELINE_TYPE, OrmDefinitionError, PredicateParseError, QUALIFIED_TABLE_PATTERN, RESERVED_COLUMN_NAMES, RESERVED_TABLE_NAMES, ROLES_CLAIM_KEY, RUNTIME_SQL_IR_VERSION, SCHEMA_DIR, SQL_IR_VERSION, STATEMENT_KINDS, SYNCED_CONTRACT_HASH_DOMAIN, SYNCED_SOURCE_PATTERN, SYNCED_VIEW_EXECUTION_OWNER_ROLE, TABLE_BRAND, VIEW_BRAND, actionFunctionName, actionFunctionStatements, actionParamArg, actionParamOrder, actionParamSchema, actionPrepareChecks, actionSchema, actionWriteTargets, actionsInterfaceName, activeAuthoringContext, applyMigrationHints, applyMigrationHintsV2, beginAuthoringContext, buildActionParamsSchema, buildDrizzleEntities, buildDrizzleEntitiesV2, buildNamespaceDefinition, buildRebaseJournalEntry, canonicalActionSchema, canonicalColumnSchema, canonicalDefinitionSchema, canonicalEnumSchema, canonicalIndexSchema, canonicalLinkSchema, canonicalPoliciesSchema, canonicalRelations, canonicalTableSchema, canonicalViewSchema, canonicalizeDefinition, capabilityExpression, castParts, cellColumnName, checksumOf, claimExpression, classifyDestructive, columnSchema, columnTypeSchema2 as columnTypeSchema, compileActionRequires, compileActionStatements, compileNamespace, compilePredIrToSql, compilePredicate, compiledArtifactSchema, compiledOperationSchema, computeCanonicalHash, computeDefinitionHash, computeSyncedContractHash, consumerRoleName, convertV1DefinitionToCanonical, createOrmMigrationExport, custom, declaredCapabilityKeys, defineEnum, defineNamespace, defineOperation, defineResolvedTable, defineSyncedTable, defineTable, defineView, deriveColumnName, diffCommand, diffStatements, emptyJournal, emptySnapshot, endAuthoringContext, etlSource, extractNamedParams, extractOrmSyncedTableContract, generateNamespaceTypes, generateSnapshot, generateSnapshotV2, highest, identifierSchema, importSpecSchema, indexByHash, isColumnBuilder, isEnumRef, isExternalPolicyClaimKey, isFunctionDefault, isOwnedStatement, isOwnedStatementV2, isQualifiedReference, isSeqLink, isSeqNamespaceConfig, isSeqTable, isSeqView, latest, limitIrSchema, loadCommittedMigrations, loadCommittedTipMigration, loadNamespaceDefinition, loadNamespaceFromDir, lowest, managedFn, manualSource, materializeLockKey, materializedRefreshFunctionName, migrationName, namespaceConfigSchema, namespaceSchema, nonNullFirst, normalizeCanonical, normalizeIr, normalizeSnapshot, objectRef, ontologyContractSchema, orderIrSchema, ormMigrationExportSchema, ormSchemaName, overlayWinsUnion, overrideRowMutation, parseCanonicalDefinition, parseDefinitionSources, parseOrmMigrationExport, parsePredicate, parseTableFile, parsedPredicateSchema, pendingKitStatements, pendingKitStatementsV2, planCommittedMigrationV2, planMigration, planMigrationV2, planTableImport, policyExpressionSchema, policyVariantSchema, predIrSchema, predicateOperands, prefetchPlanIrSchema, prefetchSource, priority, quoteIdentifier, quoteLiteral, readMigrationSql, readMigrationWorkspace, readOntologyContract, readSnapshot, rebaseViolations, referencedCapabilities, referencedColumns, renderMigrationSql, renderOrmMigrationExport, requiredArtifactIrVersion, resolvedMetaIrSchema, resolvedSourceIrSchema, revertOverlayMutation, rewriteSyncedSourceRelationsInViewQuery, roleExpression, rootIrSchema, securityStatements, selectionIrSchema, serializeNamespace, sqlTypeName, stableJson, syncedBackingRevokeStatements, syncedContractSurface, syncedTables, syncedViewDropStatements, syncedViewStatements, t, tableFileSchema, tableMetaIrSchema, tableReferenceSchema, toMany, toOne, toPlatformUser, typesInterfaceName, validateNamespaceCatalog, validateViewCatalogStatement, valueIrSchema, variableDefaultIrSchema, variableIrSchema, verifyRebaseIsNoop, walkPredicate, writeMigration };
+export { ACTION_REQUIRES_DENIED_SQLSTATE, ACTION_VALIDATES_FAILED_SQLSTATE, AUDIT_ACTIONS, CANONICAL_FORMAT, CAPABILITIES_CLAIM_KEY, CAPABILITY_KEY_PATTERN, CELLS_FIELD, CELL_PARTS, CELL_PART_SUFFIX, CLAIMS_CONTRACT, CLAIMS_SETTING, CLAIM_KEY_PATTERN, CMP_OPS, COLUMN_BRAND, COLUMN_DEFAULT_FNS, COLUMN_IDENTIFIER_PATTERN, COLUMN_TYPES2 as COLUMN_TYPES, COMPARE_OPS, COMPOSED_IR_VERSION, CONSUMER_ROLE_SUFFIX, ColumnBuilder, DATE_BUCKETS, DEFINITION_FILE_EXTENSIONS, ENUM_BRAND, EXTERNAL_POLICY_CLAIM_KEYS, GUARDED_IR_VERSION, HASH_DOMAIN, IDENTIFIER_PATTERN, IDENTIFIER_RE, IMPORT_CONFLICT_MODES, INPUT_REF_KINDS, IR_VERSION, IrVersionError, LEGACY_IR_VERSION, LINK_BRAND, MATERIALIZE_ACTOR, MATERIALIZE_CLAIMS_JSON, MAX_DEFINITION_FILE_BYTES, MAX_GENERATED_SDL_BYTES, MAX_IDENTIFIER_LENGTH, MAX_PERSISTED_READ_ROWS, MAX_TRACKED_COLUMN_NAME, MIGRATIONS_DIRNAME, NAMESPACE_CONFIG_BRAND, NAMESPACE_CONFIG_FILE, NAMESPACE_CONFIG_FILENAMES, NAMESPACE_PATTERN, ORM_DATA_TOKEN_HEADER, ORM_MIGRATION_EXPORT_FILE, ORM_MIGRATION_EXPORT_MAX_BYTES, ORM_REGISTRATION_MAX_BYTES, ORM_SCHEMA_PREFIX, ORM_SERVICE_DATA_TOKEN_HEADER, ORM_TO_PIPELINE_TYPE, OrmDefinitionError, PredicateParseError, QUALIFIED_TABLE_PATTERN, RESERVED_COLUMN_NAMES, RESERVED_TABLE_NAMES, ROLES_CLAIM_KEY, RUNTIME_SQL_IR_VERSION, SCHEMA_DIR, SQL_IR_VERSION, STATEMENT_KINDS, SYNCED_CONTRACT_HASH_DOMAIN, SYNCED_SOURCE_PATTERN, SYNCED_VIEW_EXECUTION_OWNER_ROLE, TABLE_BRAND, VIEW_BRAND, actionFunctionName, actionFunctionStatements, actionParamArg, actionParamOrder, actionParamSchema, actionPrepareChecks, actionSchema, actionWriteTargets, actionsInterfaceName, activeAuthoringContext, applyMigrationHints, applyMigrationHintsV2, assertSyncedViewDefinitionMatches, beginAuthoringContext, buildActionParamsSchema, buildDrizzleEntities, buildDrizzleEntitiesV2, buildNamespaceDefinition, buildRebaseJournalEntry, canonicalActionSchema, canonicalColumnSchema, canonicalDefinitionSchema, canonicalEnumSchema, canonicalIndexSchema, canonicalLinkSchema, canonicalPoliciesSchema, canonicalRelations, canonicalTableSchema, canonicalViewSchema, canonicalizeDefinition, capabilityExpression, castParts, cellColumnName, checksumOf, claimExpression, classifyDestructive, columnSchema, columnTypeSchema2 as columnTypeSchema, compileActionRequires, compileActionStatements, compileNamespace, compilePredIrToSql, compilePredicate, compiledArtifactSchema, compiledOperationSchema, computeCanonicalHash, computeDefinitionHash, computeSyncedContractHash, consumerRoleName, convertV1DefinitionToCanonical, createOrmMigrationExport, custom, declaredCapabilityKeys, defineEnum, defineNamespace, defineOperation, defineResolvedTable, defineSyncedTable, defineTable, defineView, deriveColumnName, diffCommand, diffStatements, emptyJournal, emptySnapshot, endAuthoringContext, etlSource, extractNamedParams, extractOrmSyncedTableContract, generateNamespaceTypes, generateSnapshot, generateSnapshotV2, highest, identifierSchema, importSpecSchema, indexByHash, isColumnBuilder, isEnumRef, isExternalPolicyClaimKey, isFunctionDefault, isOwnedStatement, isOwnedStatementV2, isQualifiedReference, isSeqLink, isSeqNamespaceConfig, isSeqTable, isSeqView, latest, limitIrSchema, loadCommittedMigrations, loadCommittedTipMigration, loadNamespaceDefinition, loadNamespaceFromDir, lowest, managedFn, manualSource, materializeLockKey, materializedRefreshFunctionName, migrationName, namespaceConfigSchema, namespaceSchema, nonNullFirst, normalizeCanonical, normalizeIr, normalizeSnapshot, objectRef, ontologyContractSchema, orderIrSchema, ormMigrationExportSchema, ormSchemaName, overlayWinsUnion, overrideRowMutation, parseCanonicalDefinition, parseDefinitionSources, parseOrmMigrationExport, parsePredicate, parseTableFile, parsedPredicateSchema, pendingKitStatements, pendingKitStatementsV2, planCommittedMigrationV2, planMigration, planMigrationV2, planTableImport, policyExpressionSchema, policyVariantSchema, predIrSchema, predicateOperands, prefetchPlanIrSchema, prefetchSource, priority, quoteIdentifier, quoteLiteral, readMigrationSql, readMigrationWorkspace, readOntologyContract, readSnapshot, rebaseViolations, referencedCapabilities, referencedColumns, renderMigrationSql, renderOrmMigrationExport, requiredArtifactIrVersion, resolvedMetaIrSchema, resolvedSourceIrSchema, revertOverlayMutation, rewriteSyncedSourceRelationsInViewQuery, roleExpression, rootIrSchema, securityStatements, selectionIrSchema, serializeNamespace, sqlTypeName, stableJson, syncedBackingRevokeStatements, syncedContractSurface, syncedTables, syncedViewDropStatements, syncedViewStatements, t, tableFileSchema, tableMetaIrSchema, tableReferenceSchema, toMany, toOne, toPlatformUser, typesInterfaceName, validateNamespaceCatalog, validateViewCatalogStatement, valueIrSchema, variableDefaultIrSchema, variableIrSchema, verifyRebaseIsNoop, walkPredicate, writeMigration };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map