@sequenceholdings/orm 2.4.0 → 2.6.0

package/dist/cli.js

@@ -56,18 +56,22 @@ var init_rehearsal_poll = __esm({
 });
 
 // src/constants.ts
-var NAMESPACE_PATTERN = /^[a-z][a-z0-9_]{0,40}$/;
+var NAMESPACE_PATTERN = /^(?!(?:events|native_sources)$)[a-z][a-z0-9_]{0,40}$/;
 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 MAX_PERSISTED_READ_ROWS = 50001;
 var CLAIM_KEY_PATTERN = /^[a-z][a-z0-9_]*$/;
 var QUALIFIED_TABLE_PATTERN = /^[a-z][a-z0-9_]{0,62}\.[a-z][a-z0-9_]{0,62}$/;
 var SYNCED_SOURCE_PATTERN = QUALIFIED_TABLE_PATTERN;
 var ORM_SCHEMA_PREFIX = "orm_";
 var CONSUMER_ROLE_SUFFIX = "_consumer";
-var ormSchemaName = (namespace) => `${ORM_SCHEMA_PREFIX}${namespace}`;
-var consumerRoleName = (namespace) => `${ORM_SCHEMA_PREFIX}${namespace}${CONSUMER_ROLE_SUFFIX}`;
+var ormSchemaName = (namespace) => {
+  if (!NAMESPACE_PATTERN.test(namespace)) throw new Error(`invalid or reserved ORM namespace '${namespace}'`);
+  return `${ORM_SCHEMA_PREFIX}${namespace}`;
+};
+var consumerRoleName = (namespace) => `${ormSchemaName(namespace)}${CONSUMER_ROLE_SUFFIX}`;
 var DEFINITION_FILE_EXTENSIONS = [".yml", ".yaml"];
 var NAMESPACE_CONFIG_FILENAMES = /* @__PURE__ */ new Set(["namespace.yaml", "namespace.yml"]);
 var HASH_DOMAIN = "sequence-orm-definitions\0";
@@ -535,6 +539,7 @@ function validateResolvedView({ view, tables, views = [] }) {
 function validateSource({ scope, source, table }) {
   const { fail: fail4 } = scope;
   if (source.kind === "etl" && table.source === void 0) fail4(`etl source '${source.name}' must reference a synced table`);
+  if (source.kind === "etl" && table.primaryKey?.length === 0) fail4(`etl source '${source.name}' cannot use an unkeyed synced table for resolved row identity`);
   if (source.kind !== "etl" && (table.internal !== true || table.cellMetadata !== true)) {
     fail4(`${source.kind} source '${source.name}' must reference an internal table with cell metadata`);
   }
@@ -983,7 +988,7 @@ var canonicalTableSchema = z.object({
   /** Synced/reflected read-only tables (`source: schema.table`) — v1 semantics. */
   source: z.string().regex(QUALIFIED_TABLE_PATTERN).optional(),
   columns: z.array(canonicalColumnSchema).default([]),
-  primaryKey: z.array(columnIdentifier).min(1).max(8).optional(),
+  primaryKey: z.array(columnIdentifier).max(8).optional(),
   links: z.array(canonicalLinkSchema).default([]),
   indexes: z.array(canonicalIndexSchema).default([]),
   /** Omitted by old definitions, preserving their existing content hashes. */
@@ -1019,6 +1024,29 @@ var canonicalTableSchema = z.object({
    * data plane. Omitted otherwise.
    */
   materializes: identifier2.optional()
+}).superRefine((table, ctx) => {
+  if (table.primaryKey?.length !== 0) return;
+  const fail4 = (message, path = ["primaryKey"]) => ctx.addIssue({ code: "custom", path, message: `unkeyed table '${table.table}' ${message}` });
+  if (table.source === void 0 || table.columns.length === 0) {
+    fail4("requires a typed synced source");
+  }
+  if ([table.policies.write, table.policies.insert, table.policies.update].some((policy) => policy !== void 0)) {
+    fail4("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)) {
+    fail4("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)) {
+      fail4("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") fail4("cannot provide an identity for this link", ["links", index3]);
+  }
 });
 var MAX_VIEW_QUERY = 1e5;
 var MAX_RESOLVED_VIEW_QUERY = 5e6;
@@ -1075,6 +1103,26 @@ var canonicalViewSchema = z.object({
     }
   }
 });
+function validateUnkeyedLinkIdentities({ definition, ctx }) {
+  const tables = new Map(definition.tables.map((table) => [table.table, table]));
+  const relations = [
+    ...definition.tables.map((table, index3) => ({ kind: "tables", index: index3, links: table.links })),
+    ...(definition.views ?? []).map((view, index3) => ({ kind: "views", index: index3, links: view.links }))
+  ];
+  for (const relation of relations) {
+    for (const [linkIndex, link] of relation.links.entries()) {
+      if (link.kind !== "toOne" || link.namespace !== void 0 && link.namespace !== definition.namespace) continue;
+      const target = link.target === void 0 ? void 0 : tables.get(link.target);
+      if (target?.source !== void 0 && target.primaryKey?.length === 0) {
+        ctx.addIssue({
+          code: "custom",
+          path: [relation.kind, relation.index, "links", linkIndex],
+          message: `link '${link.name}' cannot use unkeyed table '${target.table}' as a to-one identity`
+        });
+      }
+    }
+  }
+}
 var CELL_PART_TYPES = {
   at: "timestamptz",
   by: "text",
@@ -1138,7 +1186,7 @@ var exportGateSchema = z.union([z.literal(true), z.object({ capability: z.string
 var relationExportSchema = z.object({ read: exportGateSchema, write: exportGateSchema.optional() }).strict();
 var localDefinitionSchema = z.object({
   definition_format: z.literal(CANONICAL_FORMAT),
-  namespace: identifier2.max(41),
+  namespace: identifier2.max(41).regex(NAMESPACE_PATTERN, "invalid or reserved ORM namespace"),
   description: z.string().max(2e3).optional(),
   enums: z.array(canonicalEnumSchema).default([]),
   tables: z.array(canonicalTableSchema).min(0).max(500),
@@ -1172,6 +1220,7 @@ var localDefinitionSchema = z.object({
     }
   }
   const fkTables = new Map(definition.tables.map((table) => [table.table, table]));
+  validateUnkeyedLinkIdentities({ definition, ctx });
   const relations = /* @__PURE__ */ new Set([...fkTables.keys(), ...(definition.views ?? []).map((view) => view.view)]);
   for (const name2 of Object.keys(definition.exports ?? {})) {
     if (!relations.has(name2)) ctx.addIssue({ code: "custom", path: ["exports", name2], message: `export '${name2}' is not a local object` });
@@ -1406,6 +1455,9 @@ function normalizeCanonical(definition) {
   return normalized;
 }
 
+// src/client/sql.ts
+var BUILTIN_SQL_READ_HASH = "sha256:a50c477c952a5e0fe68ed158a4530e4aab573c09bcbb1a8ac454dc88a39a6258";
+
 // src/ir/index.ts
 var IR_VERSION = 5;
 var LEGACY_IR_VERSION = 1;
@@ -1494,7 +1546,7 @@ var limitIrSchema = z.object({
   variable: z.string().optional(),
   value: z.number().int().positive().optional(),
   default: z.number().int().positive(),
-  max: z.number().int().positive()
+  max: z.number().int().positive().max(MAX_PERSISTED_READ_ROWS)
 });
 var selectionIrSchema = z.lazy(
   () => z.object({
@@ -1739,7 +1791,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) {
@@ -3118,6 +3171,7 @@ function buildCompileContext(rawCanonical) {
   const platformMeta = usesPlatformUsers ? platformUserMeta() : void 0;
   if (platformMeta) tables[PLATFORM_USER_TABLE] = platformMeta;
   const syncedTableNames = new Set(canonical.tables.filter((t2) => t2.source !== void 0).map((t2) => t2.table));
+  const unkeyedSyncedTableNames = new Set(relations.filter((table) => table.source !== void 0 && table.primaryKey?.length === 0).map((table) => table.table));
   const viewDependencies = new Map((canonical.views ?? []).map((view) => [view.view, view.dependencies]));
   const claimsGatedMemo = /* @__PURE__ */ new Map();
   const relationIsClaimsGated = (name2) => {
@@ -3131,6 +3185,7 @@ function buildCompileContext(rawCanonical) {
   };
   for (const table of relations) {
     const isView = viewNames.has(table.table);
+    const readOnly = isView || unkeyedSyncedTableNames.has(table.table);
     const owner = owners.get(table.table);
     const entries = resolveColumnEntries(table, enums, diagnostics);
     columnEntries.set(table.table, entries);
@@ -3178,13 +3233,13 @@ function buildCompileContext(rawCanonical) {
       // are claims-gated — see tableMetaIrSchema.claimsGated.
       claimsGated: relationIsClaimsGated(table.table),
       columns: entries.map(({ deprecated: _deprecated, onUpdateFn: _onUpdateFn, ...column }) => column),
-      primaryKey: isView ? primaryKey2 : primaryKey2.length > 0 ? primaryKey2 : ["id"],
+      primaryKey: isView || unkeyedSyncedTableNames.has(table.table) ? primaryKey2 : primaryKey2.length > 0 ? primaryKey2 : ["id"],
       links: [],
       filterable: data.map((c) => c.name),
       orderable: data.filter((c) => c.type !== "jsonb").map((c) => c.name),
-      insertable: resolved ? resolvedWritable(data) : isView ? [] : active.map((c) => c.name),
-      settable: resolved ? resolvedWritable(data).filter((name2) => !primaryKey2.includes(name2)) : isView ? [] : active.filter((c) => !c.onUpdateFn).map((c) => c.name),
-      appendable: isView ? [] : active.filter((c) => c.type === "jsonb").map((c) => c.name),
+      insertable: resolved ? resolvedWritable(data) : readOnly ? [] : active.map((c) => c.name),
+      settable: resolved ? resolvedWritable(data).filter((name2) => !primaryKey2.includes(name2)) : readOnly ? [] : active.filter((c) => !c.onUpdateFn).map((c) => c.name),
+      appendable: readOnly ? [] : active.filter((c) => c.type === "jsonb").map((c) => c.name),
       ...touchOnUpdate.length > 0 ? { touchOnUpdate } : {},
       ...cells ? { cells } : {},
       ...resolved ? { resolved: resolvedMeta({ resolved, pk: primaryKey2[0] }) } : {},
@@ -3208,6 +3263,16 @@ function buildCompileContext(rawCanonical) {
         });
         continue;
       }
+      const identityTable = link.kind === "toOne" ? targetName : link.kind === "toMany" ? table.table : void 0;
+      if (identityTable !== void 0 && unkeyedSyncedTableNames.has(identityTable)) {
+        diagnostics.push({
+          severity: "error",
+          code: "unkeyed-link-identity",
+          table: table.table,
+          message: `link '${link.name}' cannot use unkeyed table '${identityTable}' as a row identity`
+        });
+        continue;
+      }
       const targetEntries = targetName === PLATFORM_USER_TABLE ? target.columns.map((c) => ({ ...c, deprecated: false, onUpdateFn: false })) : columnEntries.get(targetName);
       const onEntries = link.kind === "toMany" ? targetEntries : entries;
       const referencesEntries = link.kind === "toMany" ? entries : targetEntries;
@@ -3273,7 +3338,7 @@ function buildCompileContext(rawCanonical) {
     compilePolicyFor("write", writePolicies);
     compilePolicyFor("insert", insertPolicies);
     compilePolicyFor("update", updatePolicies);
-    if (isView && table.resolved === void 0) {
+    if (isView && table.resolved === void 0 || unkeyedSyncedTableNames.has(table.table)) {
       writePolicies.set(table.table, CONST_FALSE);
       insertPolicies.set(table.table, CONST_FALSE);
       updatePolicies.set(table.table, CONST_FALSE);
@@ -3348,7 +3413,7 @@ function buildCompileContext(rawCanonical) {
   const queryRoots = /* @__PURE__ */ new Map();
   const mutationRoots = /* @__PURE__ */ new Map();
   for (const table of relations) {
-    if (table.internal === true) continue;
+    if (table.internal === true || unkeyedSyncedTableNames.has(table.table)) continue;
     const roots = queryRootNames(table.table);
     queryRoots.set(roots.select, { kind: "select", table: table.table });
     if ((tables[table.table]?.primaryKey.length ?? 0) > 0) {
@@ -3728,8 +3793,10 @@ var OperationLowerer = class {
   constructor(ctx, restricted) {
     this.ctx = ctx;
     this.variables = new Map(restricted.variables.map((v) => [v.name, v]));
+    this.maxRows = restricted.readBudget ?? MAX_LIMIT;
   }
   variables;
+  maxRows;
   meta(table) {
     return this.ctx.tables[table];
   }
@@ -3933,13 +4000,13 @@ var OperationLowerer = class {
     });
   }
   lowerLimit(node) {
-    const base2 = { default: DEFAULT_LIMIT, max: MAX_LIMIT };
+    const base2 = { default: DEFAULT_LIMIT, max: this.maxRows };
     if (!node) return base2;
     if (node.kind === Kind.VARIABLE) return { ...base2, variable: node.name.value };
     if (node.kind === Kind.INT) {
       const value = Number(node.value);
       if (value < 1) fail2("limit must be a positive integer", "invalid-limit");
-      return { ...base2, value: Math.min(value, MAX_LIMIT) };
+      return { ...base2, value: Math.min(value, this.maxRows) };
     }
     fail2("limit must be an integer literal or a variable", "invalid-limit");
   }
@@ -4738,7 +4805,13 @@ var OperationLowerer = class {
 };
 function lowerOperation({ restricted, ctx }) {
   const lowerer = new OperationLowerer(ctx, restricted);
-  return lowerer.lowerRoots(restricted.definition, restricted.kind);
+  const roots = lowerer.lowerRoots(restricted.definition, restricted.kind);
+  if (restricted.readBudget === void 0) return roots;
+  const root = roots[0];
+  if (restricted.kind !== "query" || restricted.definition.selectionSet.selections.length !== 1 || roots.length !== 1 || root?.kind !== "select" || root.selection.relations.length > 0 || root.selection.aggregates.length > 0 || root.selection.cells !== void 0 || root.prefetch?.length) {
+    fail2("@readBudget requires one flat select root without related selections, aggregates, cells, or prefetch", "invalid-read-budget");
+  }
+  return roots;
 }
 function isCellColumn(meta, name2) {
   if (!meta.cells) return false;
@@ -4797,6 +4870,19 @@ function parseDocuments({
   }
   return { documents: parsed, diagnostics };
 }
+function parseReadBudget(operation) {
+  const directives = operation.directives?.filter((directive) => directive.name.value === "readBudget") ?? [];
+  if (directives.length === 0) return void 0;
+  const value = directives[0]?.arguments?.find((argument) => argument.name.value === "maxRows")?.value;
+  if (operation.operation !== "query" || directives.length !== 1 || value?.kind !== Kind.INT) {
+    throw new DocumentCompileError("@readBudget requires a literal maxRows on a query", "invalid-read-budget");
+  }
+  const maxRows = Number(value.value);
+  if (!Number.isSafeInteger(maxRows) || maxRows < 1 || maxRows > MAX_PERSISTED_READ_ROWS) {
+    throw new DocumentCompileError(`@readBudget(maxRows:) must be between 1 and ${MAX_PERSISTED_READ_ROWS}`, "invalid-read-budget");
+  }
+  return maxRows;
+}
 function unwrapType(node, variable) {
   let nullable = true;
   let list2 = false;
@@ -4957,6 +5043,7 @@ function restrictOperation({
     name: name2,
     kind: operation.operation === "mutation" ? "mutation" : "query",
     requires: parseRequires(operation),
+    readBudget: parseReadBudget(operation),
     variables,
     definition: operation
   };
@@ -5087,9 +5174,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");
@@ -5197,7 +5284,8 @@ function createSqlCatalog({ canonical, publishedObjects, executionTarget }) {
   const { ctx, diagnostics } = buildCompileContext(canonical);
   if (diagnostics.some((d) => d.severity === "error")) throw new Error(diagnostics.map((d) => d.message).join("; "));
   const identity = sqlHash(`ontology-sql-v1\0${computeSchemaHash(canonical)}\0${executionTarget}`);
-  const refOf = (meta) => `${meta.namespace ?? canonical.namespace}/${meta.table}`;
+  const logicalNames = new Map(Object.entries(ctx.tables).map(([key, meta]) => [meta, key]));
+  const refOf = (meta) => `${meta.namespace ?? canonical.namespace}/${logicalNames.get(meta)}`;
   const definitions = [canonical, ...canonical.imports ?? []];
   const internal = new Set(definitions.flatMap((owner) => [
     ...owner.tables.filter((t2) => t2.internal).map((t2) => `${owner.namespace}/${t2.table}`),
@@ -5273,15 +5361,22 @@ function only(node, keys) {
 var parser;
 var SQL_TYPES = ["text", "boolean", "integer", "bigint", "numeric", "double", "uuid", "date", "timestamptz"];
 var pgType = (type) => type === "double" ? "double precision" : SQL_TYPES.some((t2) => t2 === type) ? type : fail3("unsupported SQL type");
-async function compileOntologySql({ catalog, sql: sql4, parameterTypes = [], maxRows = 1e3 }) {
-  if (!Number.isInteger(maxRows) || maxRows < 1 || maxRows > 1e4 || Buffer.byteLength(sql4) > 65536) fail3("SQL limit exceeded");
+async function parseSelect(sql4) {
+  if (Buffer.byteLength(sql4) > 65536) fail3("SQL limit exceeded");
   parser ??= new PgParser({ version: 17 });
   const parsed = await parser.parse(sql4);
   if (parsed.error || !parsed.tree) fail3("invalid SQL");
   const statements = list(obj(parsed.tree).stmts);
   if (statements.length !== 1) fail3("one SQL SELECT is required");
+  const statement = obj(obj(statements[0]).stmt);
+  if (!statement.SelectStmt) fail3("one SQL SELECT is required");
+  return statement;
+}
+async function compileOntologySql({ catalog, sql: sql4, parameterTypes = [], maxRows = 1e3 }) {
+  if (!Number.isInteger(maxRows) || maxRows < 1 || maxRows > 1e4 || Buffer.byteLength(sql4) > 65536) fail3("SQL limit exceeded");
+  const statement = await parseSelect(sql4);
   const emitter = new SqlEmitter({ catalog, parameterTypes });
-  const result = emitter.select(obj(obj(statements[0]).stmt), { relations: [], ctes: /* @__PURE__ */ new Map() });
+  const result = emitter.select(statement, { relations: [], ctes: /* @__PURE__ */ new Map() });
   if (emitter.used.size !== parameterTypes.length) fail3("SQL parameters must be used exactly as declared");
   if (!emitter.read.size) fail3("SQL operation must read an ontology object");
   return {
@@ -5614,6 +5709,118 @@ function bindNamedParameters({ sql: sql4, names }) {
   }
   return result;
 }
+var parser2;
+var functions = new Set(VIEW_QUERY_FUNCTION_ALLOWLIST);
+var scalarTypes = /* @__PURE__ */ new Set([
+  "bool",
+  "boolean",
+  "int2",
+  "int4",
+  "int8",
+  "integer",
+  "bigint",
+  "smallint",
+  "numeric",
+  "decimal",
+  "float4",
+  "float8",
+  "real",
+  "text",
+  "varchar",
+  "bpchar",
+  "uuid",
+  "date",
+  "timestamp",
+  "timestamptz",
+  "time",
+  "timetz",
+  "interval",
+  "json",
+  "jsonb",
+  "bytea"
+]);
+var sqlValues = /* @__PURE__ */ new Set([
+  "SVFOP_CURRENT_DATE",
+  "SVFOP_CURRENT_TIME",
+  "SVFOP_CURRENT_TIME_N",
+  "SVFOP_CURRENT_TIMESTAMP",
+  "SVFOP_CURRENT_TIMESTAMP_N",
+  "SVFOP_LOCALTIME",
+  "SVFOP_LOCALTIME_N",
+  "SVFOP_LOCALTIMESTAMP",
+  "SVFOP_LOCALTIMESTAMP_N",
+  "SVFOP_CURRENT_ROLE",
+  "SVFOP_CURRENT_USER",
+  "SVFOP_USER",
+  "SVFOP_SESSION_USER",
+  "SVFOP_CURRENT_CATALOG",
+  "SVFOP_CURRENT_SCHEMA"
+]);
+async function validateManagedViewQueries({ canonical }) {
+  for (const definition of [canonical, ...canonical.imports ?? []]) {
+    for (const view of definition.views ?? []) {
+      const fail4 = (message) => {
+        throw new OrmDefinitionError(`managed view '${definition.namespace}/${view.view}': ${message}`);
+      };
+      parser2 ??= new PgParser({ version: 17 });
+      const parsed = await parser2.parse(view.query);
+      if (parsed.error || !parsed.tree) fail4("invalid SELECT query");
+      const statements = list(obj(parsed.tree).stmts);
+      if (statements.length !== 1 || !obj(obj(statements[0]).stmt).SelectStmt) fail4("one SELECT query is required");
+      validateTree({ tree: parsed.tree, schema: ormSchemaName(definition.namespace), enums: definition.enums.map((entry) => entry.name), fail: fail4 });
+    }
+  }
+}
+function pgCatalogName(parts) {
+  if (parts.length === 1) return parts[0];
+  if (parts.length === 2 && parts[0] === "pg_catalog") return parts[1];
+  return void 0;
+}
+function reviewedFunctionName({ parts, format }) {
+  return format === "COERCE_SQL_SYNTAX" && parts.length === 2 && parts[0] === "pg_catalog" && parts[1] === "position" ? "strpos" : pgCatalogName(parts);
+}
+function validateTree({ tree, ...scope }) {
+  const pending = [tree];
+  while (pending.length) {
+    const value = pending.pop();
+    if (Array.isArray(value)) {
+      pending.push(...value);
+      continue;
+    }
+    if (!value || typeof value !== "object") continue;
+    const node = obj(value);
+    for (const [kind, child] of Object.entries(node)) {
+      validateNode({ kind, child, scope });
+      pending.push(child);
+    }
+  }
+}
+function validateNode({ kind, child, scope }) {
+  const { fail: fail4 } = scope;
+  if (kind.endsWith("Stmt") && kind !== "SelectStmt") fail4("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)) fail4(`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) fail4("only pg_catalog operators are permitted");
+  if (kind === "SortBy" && list(obj(child).useOp).length && pgCatalogName(strings(obj(child).useOp)) === void 0) fail4("only pg_catalog sort operators are permitted");
+  if (kind === "SQLValueFunction" && !sqlValues.has(String(obj(child).op))) fail4("unsupported SQL value expression");
+  if (kind === "ParamRef") fail4("view queries cannot contain parameters");
+  if (kind === "A_Indirection" && list(obj(child).indirection).some((entry) => !obj(entry).A_Indices)) {
+    fail4("composite field notation is not permitted in managed views");
+  }
+}
+function validateType({ node, schema, enums, fail: fail4 }) {
+  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))) {
+    fail4(`casts may only use supported pg_catalog scalar types or declared enums (found '${parts.join(".")}')`);
+  }
+}
 
 // src/sql/operations.ts
 function isSqlOperationDocument(path, contents) {
@@ -5629,7 +5836,13 @@ function isSqlOperationDocument(path, contents) {
 async function compileOperationDocuments(input) {
   const sqlDocuments = input.documents.filter((d) => isSqlOperationDocument(d.path, d.contents));
   const result = compileNamespace({ ...input, documents: input.documents.filter((d) => !isSqlOperationDocument(d.path, d.contents)) });
-  if (!result.ok || !sqlDocuments.length) return result;
+  if (!result.ok) return result;
+  const viewDiagnostics = await managedViewDiagnostics(input.canonical);
+  if (viewDiagnostics.length) return { ok: false, diagnostics: [...result.diagnostics, ...viewDiagnostics] };
+  if (!sqlDocuments.length) return result;
+  return compileSqlDocuments({ input, result, sqlDocuments });
+}
+async function compileSqlDocuments({ input, result, sqlDocuments }) {
   for (const document of sqlDocuments) {
     try {
       const definition = defineOperation(JSON.parse(document.contents));
@@ -5723,6 +5936,18 @@ async function compileOperationDocuments(input) {
   result.manifest.opsHash = result.artifact.opsHash;
   return { ...result, artifact: normalizeIr(result.artifact) };
 }
+async function managedViewDiagnostics(canonical) {
+  try {
+    await validateManagedViewQueries({ canonical });
+    return [];
+  } catch (error) {
+    return [{
+      severity: "error",
+      code: "invalid-view-query",
+      message: error instanceof Error ? error.message : "invalid managed view query"
+    }];
+  }
+}
 
 // src/sql/codegen.ts
 var typeOf = (type) => ["integer", "double"].includes(type) ? "number" : type === "boolean" ? "boolean" : "string";
@@ -7570,19 +7795,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)})`;
   }
 }
 
@@ -7818,7 +8043,7 @@ function snapshotTableNames(snapshot, schema) {
 // src/engine/materialized-refresh.ts
 function materializedRefreshFunctions(canonical) {
   const schema = ormSchemaName(canonical.namespace);
-  const functions = /* @__PURE__ */ new Map();
+  const functions2 = /* @__PURE__ */ new Map();
   for (const view of canonical.views ?? []) {
     const materialized = view.resolved?.materialized;
     if (!materialized) continue;
@@ -7827,7 +8052,7 @@ function materializedRefreshFunctions(canonical) {
     if (!table || pk.length === 0) {
       throw new OrmDefinitionError(`materialized resolved table '${view.view}' needs its table and primary key`);
     }
-    functions.set(view.view, refreshFunctionSql({
+    functions2.set(view.view, refreshFunctionSql({
       schema,
       name: view.view,
       table: materialized.table,
@@ -7836,7 +8061,7 @@ function materializedRefreshFunctions(canonical) {
       pk
     }));
   }
-  return functions;
+  return functions2;
 }
 function refreshFunctionSql({ schema, name: name2, table, compute, columns, pk }) {
   const fn = `${quoteIdentifier(schema)}.${quoteIdentifier(materializedRefreshFunctionName(name2))}`;
@@ -8480,6 +8705,7 @@ async function planWithViewRecreation({
   previousSnapshot,
   viewRecreation
 }) {
+  await validateManagedViewQueries({ canonical });
   const schema = ormSchemaName(canonical.namespace);
   const previous = previousSnapshot ? normalizeSnapshot(previousSnapshot) : emptySnapshot(canonical.namespace);
   assertValidViewDependencies(canonical);
@@ -9770,6 +9996,9 @@ function generateSdl(canonical, options = {}) {
   blocks.push(
     '"""Gates an operation behind a platform capability or custom role \u2014 checked by the data plane before execution."""\ndirective @requires(capability: String, role: String) on QUERY | MUTATION'
   );
+  if (!options.omitReadBudgetDirective) blocks.push(
+    '"""Sets a document-authored ceiling of 1\u201350001 rows for one flat select root. Runtime variables cannot raise it."""\ndirective @readBudget(maxRows: Int!) on QUERY'
+  );
   blocks.push("directive @skip(if: Boolean!) on FIELD | FRAGMENT_SPREAD | INLINE_FRAGMENT");
   blocks.push(
     '"""Abort the entire mutation unless this root affects exactly the document-authored number of rows. Mutation roots only; cannot be conditional."""\ndirective @assertAffectedRows(exactly: Int!) on FIELD'
@@ -11974,7 +12203,7 @@ function emitSyncedTable(table) {
   lines.push("  },", "  {");
   lines.push(`    source: ${quote(table.source ?? "")},`);
   if (table.description !== void 0) lines.push(`    description: ${quote(table.description)},`);
-  if (singlePrimaryKey === void 0 && table.primaryKey && table.primaryKey.length > 0) {
+  if (singlePrimaryKey === void 0 && table.primaryKey !== void 0) {
     lines.push(`    primaryKey: ${jsonLiteral(table.primaryKey, 4)},`);
   }
   if (table.links.length > 0) {