@sequenceholdings/orm 2.3.0 → 2.5.0

package/dist/compiler.cjs

@@ -8,12 +8,17 @@ var pgParser = require('@supabase/pg-parser');
 // src/compiler-gql/artifact.ts
 
 // src/constants.ts
+var NAMESPACE_PATTERN = /^(?!(?:events|native_sources)$)[a-z][a-z0-9_]{0,40}$/;
 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 QUALIFIED_TABLE_PATTERN = /^[a-z][a-z0-9_]{0,62}\.[a-z][a-z0-9_]{0,62}$/;
 var ORM_SCHEMA_PREFIX = "orm_";
-var ormSchemaName = (namespace) => `${ORM_SCHEMA_PREFIX}${namespace}`;
+var ormSchemaName = (namespace) => {
+  if (!NAMESPACE_PATTERN.test(namespace)) throw new Error(`invalid or reserved ORM namespace '${namespace}'`);
+  return `${ORM_SCHEMA_PREFIX}${namespace}`;
+};
 var CELL_PARTS = ["at", "by", "rev", "source", "conflicts"];
 var CELL_PART_SUFFIX = {
   at: "__at",
@@ -389,6 +394,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`);
   }
@@ -620,6 +626,163 @@ function isSingleViewQuerySql(value) {
   }
   return state === "normal" && !/\$[a-z_0-9]*\$/i.test(query);
 }
+var VIEW_QUERY_FUNCTION_ALLOWLIST = [
+  "abs",
+  "age",
+  "array_agg",
+  "array_append",
+  "array_cat",
+  "array_dims",
+  "array_length",
+  "array_lower",
+  "array_ndims",
+  "array_position",
+  "array_positions",
+  "array_prepend",
+  "array_remove",
+  "array_replace",
+  "array_to_string",
+  "array_trim",
+  "array_upper",
+  "ascii",
+  "avg",
+  "bit_and",
+  "bit_or",
+  "bit_xor",
+  "bool_and",
+  "bool_or",
+  "btrim",
+  "cardinality",
+  "cbrt",
+  "ceil",
+  "ceiling",
+  "char_length",
+  "character_length",
+  "chr",
+  "concat",
+  "concat_ws",
+  "count",
+  "cume_dist",
+  "date_bin",
+  "date_part",
+  "date_trunc",
+  "decode",
+  "degrees",
+  "dense_rank",
+  "encode",
+  "enum_first",
+  "enum_last",
+  "enum_range",
+  "every",
+  "exp",
+  "first_value",
+  "floor",
+  "format",
+  "grouping",
+  "initcap",
+  "json_agg",
+  "json_array_length",
+  "json_build_array",
+  "json_build_object",
+  "json_extract_path",
+  "json_extract_path_text",
+  "json_object_agg",
+  "json_object_keys",
+  "json_strip_nulls",
+  "json_typeof",
+  "jsonb_agg",
+  "jsonb_array_length",
+  "jsonb_build_array",
+  "jsonb_build_object",
+  "jsonb_extract_path",
+  "jsonb_extract_path_text",
+  "jsonb_insert",
+  "jsonb_object_agg",
+  "jsonb_object_keys",
+  "jsonb_path_exists",
+  "jsonb_path_match",
+  "jsonb_path_query",
+  "jsonb_path_query_array",
+  "jsonb_path_query_first",
+  "jsonb_pretty",
+  "jsonb_set",
+  "jsonb_set_lax",
+  "jsonb_strip_nulls",
+  "jsonb_typeof",
+  "justify_days",
+  "justify_hours",
+  "justify_interval",
+  "lag",
+  "last_value",
+  "lead",
+  "left",
+  "length",
+  "ln",
+  "log",
+  "lower",
+  "lpad",
+  "ltrim",
+  "make_date",
+  "make_interval",
+  "make_time",
+  "make_timestamp",
+  "make_timestamptz",
+  "max",
+  "md5",
+  "min",
+  "mod",
+  "nth_value",
+  "ntile",
+  "octet_length",
+  "percent_rank",
+  "pi",
+  "power",
+  "quote_ident",
+  "quote_literal",
+  "quote_nullable",
+  "radians",
+  "rank",
+  "regexp_count",
+  "regexp_instr",
+  "regexp_like",
+  "regexp_match",
+  "regexp_matches",
+  "regexp_replace",
+  "regexp_split_to_array",
+  "regexp_split_to_table",
+  "repeat",
+  "replace",
+  "reverse",
+  "right",
+  "round",
+  "row_number",
+  "rpad",
+  "rtrim",
+  "sign",
+  "split_part",
+  "sqrt",
+  "starts_with",
+  "string_agg",
+  "string_to_array",
+  "strpos",
+  "substr",
+  "substring",
+  "sum",
+  "timezone",
+  "to_ascii",
+  "to_char",
+  "to_date",
+  "to_hex",
+  "to_json",
+  "to_jsonb",
+  "to_number",
+  "to_timestamp",
+  "translate",
+  "trunc",
+  "unnest",
+  "upper",
+  "width_bucket"
+];
 var canonicalActionSchema = zod.z.object({
   name: identifier2,
   requires: zod.z.string().max(1e3).optional(),
@@ -680,7 +843,7 @@ var canonicalTableSchema = zod.z.object({
   /** Synced/reflected read-only tables (`source: schema.table`) — v1 semantics. */
   source: zod.z.string().regex(QUALIFIED_TABLE_PATTERN).optional(),
   columns: zod.z.array(canonicalColumnSchema).default([]),
-  primaryKey: zod.z.array(columnIdentifier).min(1).max(8).optional(),
+  primaryKey: zod.z.array(columnIdentifier).max(8).optional(),
   links: zod.z.array(canonicalLinkSchema).default([]),
   indexes: zod.z.array(canonicalIndexSchema).default([]),
   /** Omitted by old definitions, preserving their existing content hashes. */
@@ -716,6 +879,29 @@ var canonicalTableSchema = zod.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 [index, 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", index]);
+    }
+  }
+  for (const [index, link] of table.links.entries()) {
+    if (link.enforce || link.kind === "toMany") fail4("cannot provide an identity for this link", ["links", index]);
+  }
 });
 var MAX_VIEW_QUERY = 1e5;
 var MAX_RESOLVED_VIEW_QUERY = 5e6;
@@ -772,6 +958,26 @@ var canonicalViewSchema = zod.z.object({
     }
   }
 });
+function validateUnkeyedLinkIdentities({ definition, ctx }) {
+  const tables = new Map(definition.tables.map((table) => [table.table, table]));
+  const relations = [
+    ...definition.tables.map((table, index) => ({ kind: "tables", index, links: table.links })),
+    ...(definition.views ?? []).map((view, index) => ({ kind: "views", index, 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",
@@ -835,7 +1041,7 @@ var exportGateSchema = zod.z.union([zod.z.literal(true), zod.z.object({ capabili
 var relationExportSchema = zod.z.object({ read: exportGateSchema, write: exportGateSchema.optional() }).strict();
 var localDefinitionSchema = zod.z.object({
   definition_format: zod.z.literal(CANONICAL_FORMAT),
-  namespace: identifier2.max(41),
+  namespace: identifier2.max(41).regex(NAMESPACE_PATTERN, "invalid or reserved ORM namespace"),
   description: zod.z.string().max(2e3).optional(),
   enums: zod.z.array(canonicalEnumSchema).default([]),
   tables: zod.z.array(canonicalTableSchema).min(0).max(500),
@@ -869,6 +1075,7 @@ var localDefinitionSchema = zod.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` });
@@ -1191,7 +1398,7 @@ var limitIrSchema = zod.z.object({
   variable: zod.z.string().optional(),
   value: zod.z.number().int().positive().optional(),
   default: zod.z.number().int().positive(),
-  max: zod.z.number().int().positive()
+  max: zod.z.number().int().positive().max(MAX_PERSISTED_READ_ROWS)
 });
 var selectionIrSchema = zod.z.lazy(
   () => zod.z.object({
@@ -1856,6 +2063,7 @@ var Parser2 = class {
       return node;
     }
     if (this.peekKeyword("exists")) return this.parseExists();
+    if (this.peekKeyword("visible") && this.tokens[this.index + 1]?.kind === "lparen") return this.parseVisible();
     return this.parseComparison();
   }
   parseBooleanCall(fn) {
@@ -1875,6 +2083,13 @@ var Parser2 = class {
     this.expect("rparen", "')' closing exists(...)");
     return { kind: "exists", path, where };
   }
+  parseVisible() {
+    this.advance();
+    this.expect("lparen", "'(' after visible");
+    const path = this.parsePath("a link path in visible(...)");
+    this.expect("rparen", "')' closing visible(...)");
+    return { kind: "visible", path };
+  }
   parseComparison() {
     const left = this.parseOperand();
     const operator = this.expect("operator", "a comparison operator");
@@ -1990,6 +2205,24 @@ function parsePolicy(source) {
 
 // src/predicate-v2/compile.ts
 var POLICY_MAX_LINK_DEPTH = 3;
+function scopeToNamespace(pred, namespace) {
+  switch (pred.kind) {
+    case "capability":
+    case "role":
+      return pred.namespace ? pred : { ...pred, namespace };
+    case "and":
+    case "or":
+      return { ...pred, operands: pred.operands.map((operand) => scopeToNamespace(operand, namespace)) };
+    case "not":
+      return { ...pred, operand: scopeToNamespace(pred.operand, namespace) };
+    case "exists":
+      return { ...pred, where: scopeToNamespace(pred.where, namespace) };
+    case "aggPredicate":
+      return pred.where ? { ...pred, where: scopeToNamespace(pred.where, namespace) } : pred;
+    default:
+      return pred;
+  }
+}
 var CMP_BY_OP = {
   "=": "eq",
   "!=": "neq",
@@ -2023,7 +2256,7 @@ function resolveLink(info, ref) {
 function columnCandidates(info) {
   return [...info.columns.map((c) => c.name), ...info.links.map((l) => l.name)];
 }
-var PolicyCompiler = class {
+var PolicyCompiler = class _PolicyCompiler {
   constructor(ctx) {
     this.ctx = ctx;
   }
@@ -2036,13 +2269,15 @@ var PolicyCompiler = class {
         return { kind: node.kind, operands: node.operands.map((operand) => this.compile(operand, table, depth)) };
       case "not":
         assertNoNegatedExternalClaim(node.operand);
-        return { kind: "not", operand: this.compile(node.operand, table, depth) };
+        return { kind: "not", operand: new _PolicyCompiler({ ...this.ctx, negated: true }).compile(node.operand, table, depth) };
       case "capability":
         return { kind: "capability", key: node.key };
       case "role":
         return { kind: "role", key: node.key };
       case "exists":
         return this.compileExists(node.path, node.where, table, depth);
+      case "visible":
+        return this.compileVisible(node.path, table, depth);
       case "compare":
         return this.compileCompare(node, table, depth);
     }
@@ -2056,6 +2291,36 @@ var PolicyCompiler = class {
     }
     return pred;
   }
+  /** `visible(path)` → `exists(path, <final target's read policy>)`. */
+  compileVisible(path, table, depth) {
+    const { links, finalTable } = this.resolveLinkPath(path, table, depth, { toOneOnly: false });
+    const readPolicy = this.ctx.resolver.readPolicy;
+    if (!readPolicy) {
+      throw new PolicyCompileError(
+        `visible(${path.join(".")}) needs the target's read policy, which this compile context does not provide`,
+        "visible-unresolvable"
+      );
+    }
+    if (this.ctx.visiting.includes(finalTable)) {
+      throw new PolicyCompileError(
+        `visible(${path.join(".")}) on '${table}' reaches '${finalTable}' whose read policy is already being expanded (${[...this.ctx.visiting, finalTable].join(" \u2192 ")})`,
+        "visible-cycle"
+      );
+    }
+    const expression = readPolicy(finalTable);
+    let pred = expression === void 0 ? { kind: "const", value: true } : compilePolicyAt({
+      expression,
+      table: finalTable,
+      ctx: { ...this.ctx, visiting: [...this.ctx.visiting, finalTable] },
+      depth: depth + links.length
+    });
+    const owner = this.ctx.resolver.policyNamespace?.(finalTable);
+    if (owner) pred = scopeToNamespace(pred, owner);
+    for (let i = links.length - 1; i >= 0; i -= 1) {
+      pred = { kind: "exists", link: links[i].name, where: pred };
+    }
+    return pred;
+  }
   resolveLinkPath(path, table, depth, { toOneOnly }) {
     const links = [];
     let current = table;
@@ -2116,6 +2381,7 @@ var PolicyCompiler = class {
       );
     }
     if (valueSide.kind === "claim" && isExternalPolicyClaimKey(valueSide.key)) {
+      if (this.ctx.negated) throw negatedExternalClaim(valueSide.key);
       assertExternalClaimComparison({ op, key: valueSide.key, column: info.columns.find((c) => c.name === column) });
     }
     let cmp = this.buildCmp(op, column, valueSide);
@@ -2153,22 +2419,30 @@ function assertExternalClaimComparison({ op, key, column }) {
     );
   }
 }
+function negatedExternalClaim(key) {
+  return new PolicyCompileError(
+    `claim('${key}') cannot appear under not(): a negated borrower comparison admits other borrowers' rows`,
+    "unsupported-comparison"
+  );
+}
 function assertNoNegatedExternalClaim(operand) {
   walkPolicy(operand, (node) => {
     if (node.kind !== "compare") return;
     const claim = [node.left, node.right].find((side) => side.kind === "claim" && isExternalPolicyClaimKey(side.key));
-    if (claim?.kind === "claim") {
-      throw new PolicyCompileError(
-        `claim('${claim.key}') cannot appear under not(): a negated borrower comparison admits other borrowers' rows`,
-        "unsupported-comparison"
-      );
-    }
+    if (claim?.kind === "claim") throw negatedExternalClaim(claim.key);
   });
 }
 function compilePredicateV2({ expression, table, resolver, maxLinkDepth }) {
+  return compilePredicateAt({
+    expression,
+    table,
+    depth: 0,
+    ctx: { resolver, maxLinkDepth: maxLinkDepth ?? POLICY_MAX_LINK_DEPTH, visiting: [table] }
+  });
+}
+function compilePredicateAt({ expression, table, ctx, depth }) {
   const parsed = typeof expression === "string" ? parsePolicy(expression) : expression;
-  const compiler = new PolicyCompiler({ resolver, maxLinkDepth: maxLinkDepth ?? POLICY_MAX_LINK_DEPTH });
-  return compiler.compile(parsed.ast, table, 0);
+  return new PolicyCompiler(ctx).compile(parsed.ast, table, depth);
 }
 function assertClaimsOnlyWhen(parsed) {
   walkPolicy(parsed.ast, (node) => {
@@ -2185,25 +2459,34 @@ function assertClaimsOnlyWhen(parsed) {
         "when-not-claims-only"
       );
     }
-    if (node.kind === "exists") {
+    if (node.kind === "exists" || node.kind === "visible") {
       throw new PolicyCompileError(
-        "variant 'when' guards are claims-only \u2014 exists() is not allowed",
+        `variant 'when' guards are claims-only \u2014 ${node.kind}() is not allowed`,
         "when-not-claims-only"
       );
     }
   });
 }
-function compilePolicy({ expression, table, resolver, maxLinkDepth }) {
-  if (typeof expression === "string") {
-    return compilePredicateV2({ expression, table, resolver, maxLinkDepth });
-  }
-  const defaultPred = compilePredicateV2({ expression: expression.default, table, resolver, maxLinkDepth });
+function initialVisiting({ table, access }) {
+  return (access ?? "read") === "read" ? [table] : [];
+}
+function compilePolicy({ expression, table, resolver, maxLinkDepth, access }) {
+  return compilePolicyAt({
+    expression,
+    table,
+    depth: 0,
+    ctx: { resolver, maxLinkDepth: maxLinkDepth ?? POLICY_MAX_LINK_DEPTH, visiting: initialVisiting({ table, access }) }
+  });
+}
+function compilePolicyAt({ expression, table, ctx, depth }) {
+  if (typeof expression === "string") return compilePredicateAt({ expression, table, ctx, depth });
+  const defaultPred = compilePredicateAt({ expression: expression.default, table, ctx, depth });
   if (expression.variants.length === 0) return defaultPred;
   const branches = expression.variants.map((variant) => {
     const parsedWhen = parsePolicy(variant.when);
     assertClaimsOnlyWhen(parsedWhen);
-    const when = compilePredicateV2({ expression: parsedWhen, table, resolver, maxLinkDepth });
-    const grant = variant.allow === true ? { kind: "const", value: true } : compilePredicateV2({ expression: variant.policy, table, resolver, maxLinkDepth });
+    const when = compilePredicateAt({ expression: parsedWhen, table, ctx, depth });
+    const grant = variant.allow === true ? { kind: "const", value: true } : compilePredicateAt({ expression: variant.policy, table, ctx, depth });
     return { kind: "and", operands: [when, grant] };
   });
   return { kind: "or", operands: [defaultPred, ...branches] };
@@ -2419,12 +2702,6 @@ var PolicyInjector = class {
     if (root.op === "resolvedWrite") return this.injectResolvedWrite(root, returning);
     if (root.op === "insert" || root.op === "insertOne") {
       const insertPolicy = this.insert(table);
-      if (predContainsExists(insertPolicy)) {
-        throw new DocumentCompileError(
-          `table '${table}' cannot be inserted into: v2.0 insert checks are claims + inserted-values only, but its insert policy traverses a link (exists)`,
-          "insert-check-unrepresentable"
-        );
-      }
       const pins = (this.ctx.pins.get(table) ?? []).map(
         (pin) => ({ column: pin.column, value: { kind: "claim", key: pin.claim } })
       );
@@ -2439,22 +2716,14 @@ var PolicyInjector = class {
     const updatePolicy = this.update(table);
     const where = andPred(updatePolicy, root.where ? this.injectDocPred(root.where, table) : void 0);
     if (root.op === "update" || root.op === "updateByPk") {
-      const check = predContainsExists(updatePolicy) && !this.ctx.composed ? {} : { insertCheck: updatePolicy };
-      return { ...root, where, ...check, returning };
+      return { ...root, where, insertCheck: updatePolicy, returning };
     }
     if (root.op === "cowOverride") {
       const insertPolicy = this.insert(table);
-      if (predContainsExists(insertPolicy)) {
-        throw new DocumentCompileError(
-          `table '${table}' cannot be copy-on-write overridden: v2.0 insert checks are claims + inserted-values only, but its insert policy traverses a link (exists)`,
-          "insert-check-unrepresentable"
-        );
-      }
       const pins = (this.ctx.pins.get(table) ?? []).map(
         (pin) => ({ column: pin.column, value: { kind: "claim", key: pin.claim } })
       );
-      const check = predContainsExists(updatePolicy) && !this.ctx.composed ? {} : { insertCheck: updatePolicy };
-      return { ...root, pinnedColumns: pins, cowCopyCheck: insertPolicy, where, ...check, returning };
+      return { ...root, pinnedColumns: pins, cowCopyCheck: insertPolicy, where, insertCheck: updatePolicy, returning };
     }
     return { ...root, where, returning };
   }
@@ -2676,7 +2945,7 @@ function scopePolicy(pred, namespace) {
   switch (pred.kind) {
     case "capability":
     case "role":
-      return { ...pred, namespace };
+      return pred.namespace ? pred : { ...pred, namespace };
     case "and":
     case "or":
       return { ...pred, operands: pred.operands.map((p) => scopePolicy(p, namespace)) };
@@ -2766,6 +3035,7 @@ function buildCompileContext(rawCanonical) {
   const platformMeta = usesPlatformUsers ? platformUserMeta() : void 0;
   if (platformMeta) tables[PLATFORM_USER_TABLE] = platformMeta;
   const syncedTableNames = new Set(canonical.tables.filter((t) => t.source !== void 0).map((t) => t.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) => {
@@ -2779,6 +3049,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);
@@ -2826,13 +3097,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 ? primaryKey : primaryKey.length > 0 ? primaryKey : ["id"],
+      primaryKey: isView || unkeyedSyncedTableNames.has(table.table) ? primaryKey : primaryKey.length > 0 ? primaryKey : ["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) => !primaryKey.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) => !primaryKey.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: primaryKey[0] }) } : {},
@@ -2856,6 +3127,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;
@@ -2885,7 +3166,14 @@ function buildCompileContext(rawCanonical) {
   const updatePolicies = /* @__PURE__ */ new Map();
   const pins = /* @__PURE__ */ new Map();
   const splitWritePolicyTables = /* @__PURE__ */ new Set();
-  const resolver = { tables };
+  const readPolicyExpressions = new Map(relations.map((relation) => [relation.table, relation.policies.read]));
+  const resolver = {
+    tables,
+    readPolicy: (table) => readPolicyExpressions.get(table),
+    // In a composed namespace, an imported table's read policy (inlined by
+    // visible()) is checked against the namespace that owns it.
+    ...normalized.imports?.length ? { policyNamespace: (table) => owners.get(table)?.namespace } : {}
+  };
   for (const table of relations) {
     const isView = viewNames.has(table.table);
     const compilePolicyFor = (access, store) => {
@@ -2894,7 +3182,7 @@ function buildCompileContext(rawCanonical) {
         return;
       }
       try {
-        const pred = compilePolicy({ expression, table: table.table, resolver });
+        const pred = compilePolicy({ expression, table: table.table, resolver, access });
         store.set(table.table, normalized.imports?.length ? scopePolicy(pred, owners.get(table.table).namespace) : pred);
       } catch (error) {
         if (error instanceof PolicyCompileError || error instanceof PolicyParseError) {
@@ -2914,7 +3202,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);
@@ -2989,7 +3277,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) {
@@ -3369,8 +3657,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];
   }
@@ -3574,13 +3864,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 === graphql.Kind.VARIABLE) return { ...base2, variable: node.name.value };
     if (node.kind === graphql.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");
   }
@@ -4379,7 +4669,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;
@@ -4438,6 +4734,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 !== graphql.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;
@@ -4598,6 +4907,7 @@ function restrictOperation({
     name: name2,
     kind: operation.operation === "mutation" ? "mutation" : "query",
     requires: parseRequires(operation),
+    readBudget: parseReadBudget(operation),
     variables,
     definition: operation
   };
@@ -5638,6 +5948,118 @@ function bindNamedParameters({ sql, 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.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) {
@@ -5653,7 +6075,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));
@@ -5747,6 +6175,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"
+    }];
+  }
+}
 var parameterName = zod.z.string().regex(/^[A-Za-z_][A-Za-z0-9_]*$/).max(63).refine((value) => !["__proto__", "prototype", "constructor"].includes(value), "reserved parameter name");
 var parameter = zod.z.discriminatedUnion("type", [
   zod.z.object({ type: zod.z.literal("text"), value: zod.z.string().nullable() }).strict(),
@@ -5886,6 +6326,7 @@ exports.typeNameForTable = typeNameForTable;
 exports.validateAppendInput = validateAppendInput;
 exports.validateBoolExpInput = validateBoolExpInput;
 exports.validateInsertInput = validateInsertInput;
+exports.validateManagedViewQueries = validateManagedViewQueries;
 exports.validateOnConflictInput = validateOnConflictInput;
 exports.validateOrderByInput = validateOrderByInput;
 exports.validateSelectColumns = validateSelectColumns;