@sequenceholdings/orm 2.10.0 → 2.11.1

package/dist/compiler.cjs

@@ -9,16 +9,21 @@ var pgParser = require('@supabase/pg-parser');
 
 // src/constants.ts
 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 ormSchemaName = (namespace) => {
   if (!NAMESPACE_PATTERN.test(namespace)) throw new Error(`invalid or reserved ORM namespace '${namespace}'`);
   return `${ORM_SCHEMA_PREFIX}${namespace}`;
 };
+var RESERVED_TABLE_NAMES = /* @__PURE__ */ new Set(["actions", "query"]);
+var RESERVED_COLUMN_NAMES = /* @__PURE__ */ new Set(["select", "order", "limit", "offset"]);
 var CELL_PARTS = ["at", "by", "rev", "source", "conflicts"];
 var CELL_PART_SUFFIX = {
   at: "__at",
@@ -250,6 +255,748 @@ var Parser = class {
 function compileCheckExpression(source, columns) {
   return new Parser(tokenize(source), columns).parse();
 }
+
+// src/predicate/ast.ts
+var COMPARE_OPS = ["=", "!=", "<", "<=", ">", ">="];
+function walkPredicate(predicate, visit2) {
+  visit2(predicate);
+  if (predicate.kind === "and" || predicate.kind === "or") {
+    for (const operand of predicate.operands) walkPredicate(operand, visit2);
+  }
+  if (predicate.kind === "not") walkPredicate(predicate.operand, visit2);
+}
+function predicateOperands(predicate) {
+  const operands = [];
+  walkPredicate(predicate, (node) => {
+    if (node.kind === "compare") operands.push(node.left, node.right);
+  });
+  return operands;
+}
+function referencedColumns(predicate) {
+  const names = predicateOperands(predicate).flatMap(
+    (operand) => operand.kind === "column" ? [operand.name] : []
+  );
+  return [...new Set(names)];
+}
+var identifierSchema = zod.z.string().max(MAX_IDENTIFIER_LENGTH).regex(IDENTIFIER_PATTERN, "must be a lowercase identifier (a-z, 0-9, _)");
+var namespaceSchema = zod.z.string().regex(NAMESPACE_PATTERN, "must be lowercase, start with a letter, and be at most 41 characters");
+var tableReferenceSchema = zod.z.string().refine(
+  (value) => IDENTIFIER_PATTERN.test(value) || QUALIFIED_TABLE_PATTERN.test(value),
+  "must be a table name or a schema-qualified table reference"
+);
+
+// src/schema/columns.ts
+var COLUMN_TYPES = [
+  "uuid",
+  "text",
+  "integer",
+  "bigint",
+  "numeric",
+  "double",
+  "boolean",
+  "timestamptz",
+  "date",
+  "jsonb"
+];
+var columnTypeSchema = zod.z.enum(COLUMN_TYPES);
+var FUNCTION_DEFAULTS = {
+  "gen_random_uuid()": ["uuid"],
+  "now()": ["timestamptz", "date"]
+};
+var CAST_PATTERN = /^([a-z][a-z0-9_]*)::([a-z]+)$/;
+function defaultIssue(value, type) {
+  if (typeof value === "boolean") return type === "boolean" ? null : `boolean default is invalid for type '${type}'`;
+  if (typeof value === "number") {
+    if (!["integer", "bigint", "numeric", "double"].includes(type)) {
+      return `numeric default is invalid for type '${type}'`;
+    }
+    if (["integer", "bigint"].includes(type)) {
+      if (!Number.isInteger(value)) return `default for type '${type}' must be an integer`;
+      if (!Number.isSafeInteger(value)) {
+        return `default for type '${type}' exceeds the safe integer range \u2014 YAML numbers lose precision past 2^53`;
+      }
+    }
+    if (type === "numeric" && Math.abs(value) > Number.MAX_SAFE_INTEGER) {
+      return "numeric default exceeds the safe float range \u2014 write it as a string (e.g. '9007199254740993') to keep exact precision";
+    }
+    return null;
+  }
+  const allowedTypes = FUNCTION_DEFAULTS[value];
+  if (allowedTypes) return allowedTypes.includes(type) ? null : `default '${value}' is invalid for type '${type}'`;
+  return null;
+}
+var columnSchema = zod.z.strictObject({
+  type: columnTypeSchema,
+  primary_key: zod.z.boolean().optional(),
+  nullable: zod.z.boolean().optional(),
+  unique: zod.z.boolean().optional(),
+  default: zod.z.union([zod.z.string(), zod.z.number(), zod.z.boolean()]).optional(),
+  description: zod.z.string().optional(),
+  renamed_from: identifierSchema.optional(),
+  cast: zod.z.string().optional(),
+  deprecated: zod.z.boolean().optional()
+}).superRefine((column, ctx) => {
+  if (column.default !== void 0) {
+    const issue = defaultIssue(column.default, column.type);
+    if (issue) ctx.addIssue({ code: "custom", message: issue, path: ["default"] });
+  }
+  if (column.primary_key && column.nullable) {
+    ctx.addIssue({ code: "custom", message: "a primary key column cannot be nullable", path: ["nullable"] });
+  }
+  if (column.primary_key && column.deprecated) {
+    ctx.addIssue({ code: "custom", message: "a primary key column cannot be deprecated", path: ["deprecated"] });
+  }
+  if (column.cast && !CAST_PATTERN.test(column.cast)) {
+    ctx.addIssue({ code: "custom", message: "cast must have the shape '<column>::<type>'", path: ["cast"] });
+  }
+});
+function castParts(cast) {
+  const match = CAST_PATTERN.exec(cast);
+  if (!match) return null;
+  return { column: match[1], type: match[2] };
+}
+
+// src/errors.ts
+var OrmDefinitionError = class extends Error {
+  constructor(message, file) {
+    super(file ? `${file}: ${message}` : message);
+    this.file = file;
+  }
+  name = "OrmDefinitionError";
+};
+var PredicateParseError = class extends Error {
+  constructor(message, position) {
+    super(`${message} (at position ${position})`);
+    this.position = position;
+  }
+  name = "PredicateParseError";
+};
+
+// src/predicate/parse.ts
+var KEYWORDS = /* @__PURE__ */ new Set(["and", "or", "not", "true", "false", "null", "claim", "capability"]);
+var OPERATOR_PATTERN = /^(!=|<=|>=|<>|=|<|>)/;
+var IDENTIFIER_START = /[a-z_]/;
+var IDENTIFIER_CHAR = /[a-z0-9_.-]/;
+var NUMBER_PATTERN = /^-?\d+(\.\d+)?/;
+function tokenize2(source) {
+  const tokens = [];
+  let position = 0;
+  while (position < source.length) {
+    const char = source[position];
+    if (/\s/.test(char)) {
+      position += 1;
+      continue;
+    }
+    if (char === "(") {
+      tokens.push({ kind: "lparen", value: char, position });
+      position += 1;
+      continue;
+    }
+    if (char === ")") {
+      tokens.push({ kind: "rparen", value: char, position });
+      position += 1;
+      continue;
+    }
+    if (char === ",") {
+      tokens.push({ kind: "comma", value: char, position });
+      position += 1;
+      continue;
+    }
+    if (char === "'") {
+      const { value, end } = readString(source, position);
+      tokens.push({ kind: "string", value, position });
+      position = end;
+      continue;
+    }
+    const operator = OPERATOR_PATTERN.exec(source.slice(position));
+    if (operator) {
+      const value = operator[0] === "<>" ? "!=" : operator[0];
+      tokens.push({ kind: "operator", value, position });
+      position += operator[0].length;
+      continue;
+    }
+    const number = NUMBER_PATTERN.exec(source.slice(position));
+    if (number && !IDENTIFIER_START.test(char)) {
+      tokens.push({ kind: "number", value: number[0], position });
+      position += number[0].length;
+      continue;
+    }
+    if (IDENTIFIER_START.test(char)) {
+      let end = position;
+      while (end < source.length && IDENTIFIER_CHAR.test(source[end])) end += 1;
+      tokens.push({ kind: "identifier", value: source.slice(position, end), position });
+      position = end;
+      continue;
+    }
+    throw new PredicateParseError(`unexpected character '${char}'`, position);
+  }
+  tokens.push({ kind: "end", value: "", position: source.length });
+  return tokens;
+}
+function readString(source, start) {
+  let value = "";
+  let position = start + 1;
+  while (position < source.length) {
+    const char = source[position];
+    if (char !== "'") {
+      value += char;
+      position += 1;
+      continue;
+    }
+    if (source[position + 1] === "'") {
+      value += "'";
+      position += 2;
+      continue;
+    }
+    return { value, end: position + 1 };
+  }
+  throw new PredicateParseError("unterminated string literal", start);
+}
+var Parser2 = class {
+  constructor(tokens) {
+    this.tokens = tokens;
+  }
+  index = 0;
+  parse() {
+    const predicate = this.parseOr();
+    this.expect("end", "end of expression");
+    return predicate;
+  }
+  parseOr() {
+    const operands = [this.parseAnd()];
+    while (this.matchKeyword("or")) operands.push(this.parseAnd());
+    return operands.length === 1 ? operands[0] : { kind: "or", operands };
+  }
+  parseAnd() {
+    const operands = [this.parseNot()];
+    while (this.matchKeyword("and")) operands.push(this.parseNot());
+    return operands.length === 1 ? operands[0] : { kind: "and", operands };
+  }
+  parseNot() {
+    if (this.matchKeyword("not")) return { kind: "not", operand: this.parseNot() };
+    return this.parsePrimary();
+  }
+  parsePrimary() {
+    if (this.peek().kind === "lparen") {
+      this.advance();
+      const inner = this.parseOr();
+      this.expect("rparen", "')'");
+      return inner;
+    }
+    if (this.peekKeyword("capability")) {
+      const capability = this.parseCapability();
+      const next = this.peek();
+      if (next.kind === "operator") {
+        throw new PredicateParseError("capability() is boolean-valued and cannot appear in a comparison", next.position);
+      }
+      return capability;
+    }
+    return this.parseComparison();
+  }
+  parseCapability() {
+    this.advance();
+    const key = this.parseCallArgument("capability");
+    if (!CAPABILITY_KEY_PATTERN.test(key)) {
+      throw new PredicateParseError(`invalid capability key '${key}'`, this.peek().position);
+    }
+    return { kind: "capability", key };
+  }
+  parseComparison() {
+    const left = this.parseOperand();
+    const operator = this.expect("operator", "a comparison operator");
+    if (!COMPARE_OPS.includes(operator.value)) {
+      throw new PredicateParseError(`unsupported operator '${operator.value}'`, operator.position);
+    }
+    const right = this.parseOperand();
+    return { kind: "compare", op: operator.value, left, right };
+  }
+  parseOperand() {
+    const token = this.peek();
+    if (token.kind === "string") {
+      this.advance();
+      return { kind: "literal", value: token.value };
+    }
+    if (token.kind === "number") {
+      this.advance();
+      const value = Number(token.value);
+      if (!Number.isFinite(value) || Number.isInteger(value) && !Number.isSafeInteger(value)) {
+        throw new PredicateParseError(
+          `numeric literal '${token.value}' exceeds safe integer precision \u2014 quote it as a string`,
+          token.position
+        );
+      }
+      return { kind: "literal", value };
+    }
+    if (token.kind !== "identifier") {
+      throw new PredicateParseError(`expected an operand, got '${token.value || "end"}'`, token.position);
+    }
+    this.advance();
+    if (token.value === "true" || token.value === "false") {
+      return { kind: "literal", value: token.value === "true" };
+    }
+    if (token.value === "null") return { kind: "literal", value: null };
+    if (token.value === "claim") {
+      const key = this.parseCallArgument("claim");
+      if (!CLAIM_KEY_PATTERN.test(key)) {
+        throw new PredicateParseError(`invalid claim key '${key}'`, token.position);
+      }
+      return { kind: "claim", key };
+    }
+    if (token.value === "capability") {
+      throw new PredicateParseError("capability() is boolean-valued and cannot appear in a comparison", token.position);
+    }
+    if (KEYWORDS.has(token.value) || !IDENTIFIER_PATTERN.test(token.value)) {
+      throw new PredicateParseError(`invalid column reference '${token.value}'`, token.position);
+    }
+    return { kind: "column", name: token.value };
+  }
+  parseCallArgument(fn) {
+    this.expect("lparen", `'(' after ${fn}`);
+    const argument = this.expect("string", `a quoted key in ${fn}(...)`);
+    this.expect("rparen", `')' after ${fn} key`);
+    return argument.value;
+  }
+  peek() {
+    return this.tokens[this.index];
+  }
+  peekKeyword(keyword) {
+    const token = this.peek();
+    return token.kind === "identifier" && token.value === keyword;
+  }
+  matchKeyword(keyword) {
+    if (!this.peekKeyword(keyword)) return false;
+    this.advance();
+    return true;
+  }
+  advance() {
+    const token = this.peek();
+    if (token.kind !== "end") this.index += 1;
+    return token;
+  }
+  expect(kind, description) {
+    const token = this.peek();
+    if (token.kind !== kind) {
+      throw new PredicateParseError(`expected ${description}, got '${token.value || "end"}'`, token.position);
+    }
+    return this.advance();
+  }
+};
+function parsePredicate(source) {
+  const trimmed = source.trim();
+  if (trimmed.length === 0) throw new PredicateParseError("empty predicate", 0);
+  return { source: trimmed, ast: new Parser2(tokenize2(trimmed)).parse() };
+}
+
+// src/schema/predicates.ts
+var parsedPredicateSchema = zod.z.string().transform((source, ctx) => {
+  try {
+    return parsePredicate(source);
+  } catch (error) {
+    ctx.addIssue({ code: "custom", message: error instanceof Error ? error.message : String(error) });
+    return zod.z.NEVER;
+  }
+});
+
+// src/schema/actions.ts
+var EXECUTES_VERB_PATTERN = /^\s*(insert|update|delete)\b/i;
+var DOLLAR_QUOTE_PATTERN = /\$[a-zA-Z0-9_]*\$/;
+var RETURNING_PATTERN = /\breturning\b/i;
+var ESCAPE_STRING_PATTERN = /(?<![a-zA-Z0-9_])[Ee]'/;
+var MASKED_CLAIM_CALL_PATTERN = /\b(?:claim|capability)\(\s*''\s*\)/g;
+var BARE_CLAIM_CALL_PATTERN = /\b(?:claim|capability)\s*\(/;
+var EXISTS_ENTRY_PATTERN = /^exists\(\s*'([^']+)'\s*,\s*([a-z][a-z0-9_]*)\s*\)$/;
+var NAMED_PARAM_PATTERN = /(?<!:):([a-z][a-z0-9_]*)/g;
+var QUOTED_STRING_PATTERN = /'(?:[^']|'')*'/g;
+var SQL_COMMENT_PATTERN = /--|\/\*/;
+var actionParamSchema = zod.z.strictObject({
+  type: columnTypeSchema,
+  optional: zod.z.boolean().optional(),
+  description: zod.z.string().optional()
+});
+var validatesEntrySchema = zod.z.string().transform((source, ctx) => {
+  const match = EXISTS_ENTRY_PATTERN.exec(source.trim());
+  if (!match) {
+    ctx.addIssue({ code: "custom", message: "validates entries must have the shape exists('<table>', <param>)" });
+    return zod.z.NEVER;
+  }
+  const table = tableReferenceSchema.safeParse(match[1]);
+  if (!table.success) {
+    ctx.addIssue({ code: "custom", message: `invalid table reference '${match[1]}'` });
+    return zod.z.NEVER;
+  }
+  return { source: source.trim(), table: table.data, param: match[2] };
+});
+var AUDIT_ACTIONS = ["create", "update", "delete"];
+var auditSchema = zod.z.strictObject({
+  action: zod.z.enum(AUDIT_ACTIONS),
+  resource: identifierSchema.optional()
+});
+var actionSchema = zod.z.strictObject({
+  description: zod.z.string().optional(),
+  requires: parsedPredicateSchema.optional(),
+  params: zod.z.record(identifierSchema, actionParamSchema).optional(),
+  validates: zod.z.array(validatesEntrySchema).optional(),
+  // One statement, or an ordered list run atomically in the action function.
+  executes: zod.z.union([zod.z.string().min(1), zod.z.array(zod.z.string().min(1)).min(1)]),
+  // Declares the columns the action's RETURNING yields. Present → the
+  // function returns those rows (typed in the client); absent → the action
+  // reports rows_affected only. The column names/types must match the
+  // RETURNING list, which Postgres enforces at CREATE FUNCTION.
+  returns: zod.z.record(identifierSchema, columnTypeSchema).optional(),
+  audit: auditSchema.optional()
+}).superRefine((action, ctx) => {
+  const params = Object.keys(action.params ?? {});
+  if (action.requires && referencedColumns(action.requires.ast).length > 0) {
+    ctx.addIssue({
+      code: "custom",
+      message: "requires may reference claims and capabilities only, not columns",
+      path: ["requires"]
+    });
+  }
+  for (const issue of executesIssues(action.executes, new Set(params), action.returns !== void 0)) {
+    ctx.addIssue({ code: "custom", message: issue, path: ["executes"] });
+  }
+  if (action.returns && Object.keys(action.returns).length === 0) {
+    ctx.addIssue({ code: "custom", message: "returns must declare at least one column", path: ["returns"] });
+  }
+  for (const [index, entry] of (action.validates ?? []).entries()) {
+    if (!params.includes(entry.param)) {
+      ctx.addIssue({
+        code: "custom",
+        message: `validates references undeclared param '${entry.param}'`,
+        path: ["validates", index]
+      });
+    }
+  }
+});
+function extractNamedParams(sql) {
+  const withoutStrings = sql.replace(QUOTED_STRING_PATTERN, "''");
+  const names = [...withoutStrings.matchAll(NAMED_PARAM_PATTERN)].map((match) => match[1]);
+  return [...new Set(names)];
+}
+function actionStatementSources(executes) {
+  return (Array.isArray(executes) ? executes : [executes]).map((statement) => statement.trim());
+}
+function executesIssues(executes, declaredParams, hasReturns) {
+  const issues = [];
+  const statements = actionStatementSources(executes);
+  statements.forEach((statement, index) => {
+    const withoutStrings = statement.replace(QUOTED_STRING_PATTERN, "''");
+    const at = statements.length > 1 ? ` (statement ${index + 1})` : "";
+    if (!EXECUTES_VERB_PATTERN.test(statement)) issues.push(`executes must be INSERT, UPDATE, or DELETE${at}`);
+    if (withoutStrings.replace(/;\s*$/, "").includes(";")) issues.push(`each executes entry must be a single statement${at}`);
+    if (SQL_COMMENT_PATTERN.test(withoutStrings)) issues.push(`executes must not contain SQL comments${at}`);
+    if (DOLLAR_QUOTE_PATTERN.test(withoutStrings)) issues.push(`executes must not use dollar-quoted strings${at}`);
+    if (ESCAPE_STRING_PATTERN.test(withoutStrings)) issues.push(`executes must not use escape strings (E'\u2026')${at}`);
+    if (withoutStrings.includes('"')) issues.push(`executes must not use double-quoted identifiers${at}`);
+    if (BARE_CLAIM_CALL_PATTERN.test(withoutStrings.replace(MASKED_CLAIM_CALL_PATTERN, ""))) {
+      issues.push(`executes has a malformed claim()/capability() call \u2014 use e.g. claim('sub')${at}`);
+    }
+    if (RETURNING_PATTERN.test(withoutStrings) && !(hasReturns && index === statements.length - 1)) {
+      issues.push(
+        hasReturns ? `only the last executes statement may use RETURNING${at}` : `executes must not use RETURNING unless the action declares returns${at}`
+      );
+    }
+  });
+  const last = statements.at(-1);
+  if (hasReturns && last && !RETURNING_PATTERN.test(last.replace(QUOTED_STRING_PATTERN, "''"))) {
+    issues.push("the last executes statement must use RETURNING to populate the declared returns columns");
+  }
+  const undeclared = extractNamedParams(statements.join("\n")).filter((name2) => !declaredParams.has(name2));
+  if (undeclared.length > 0) issues.push(`executes references undeclared params: ${undeclared.join(", ")}`);
+  return issues;
+}
+
+// src/schema/table.ts
+var linkSchema = zod.z.strictObject({
+  to: tableReferenceSchema,
+  on: identifierSchema,
+  enforce: zod.z.boolean().optional(),
+  description: zod.z.string().optional()
+});
+var indexSchema = zod.z.union([
+  zod.z.array(identifierSchema).min(1),
+  zod.z.strictObject({
+    columns: zod.z.array(identifierSchema).min(1),
+    unique: zod.z.boolean().optional(),
+    name: identifierSchema.optional()
+  })
+]).transform((index) => Array.isArray(index) ? { columns: index } : index);
+var policiesSchema = zod.z.strictObject({
+  read: parsedPredicateSchema.optional(),
+  write: parsedPredicateSchema.optional(),
+  insert: parsedPredicateSchema.optional(),
+  update: parsedPredicateSchema.optional()
+});
+zod.z.strictObject({
+  namespace: namespaceSchema,
+  table: identifierSchema,
+  description: zod.z.string().optional(),
+  columns: zod.z.record(identifierSchema, columnSchema).optional(),
+  source: zod.z.string().regex(SYNCED_SOURCE_PATTERN, "source must be a qualified lowercase schema.table identifier").optional(),
+  links: zod.z.record(identifierSchema, linkSchema).optional(),
+  indexes: zod.z.array(indexSchema).optional(),
+  policies: policiesSchema.optional(),
+  actions: zod.z.record(identifierSchema, actionSchema).optional()
+}).superRefine((table, ctx) => {
+  if (RESERVED_TABLE_NAMES.has(table.table)) {
+    ctx.addIssue({ code: "custom", message: `'${table.table}' is a reserved table name`, path: ["table"] });
+  }
+  for (const name2 of Object.keys(table.columns ?? {})) {
+    if (RESERVED_COLUMN_NAMES.has(name2)) {
+      ctx.addIssue({
+        code: "custom",
+        message: `column '${name2}' collides with the Data API's reserved query parameters (select, order, limit, offset) \u2014 it could never be filtered`,
+        path: ["columns", name2]
+      });
+    }
+  }
+  if (table.source) validateSyncedTable(table, ctx);
+  else validateColumnTable(table, ctx);
+  validateLinks(table, ctx);
+  validatePolicyColumns(table, ctx);
+  validateDerivedNameLengths(table, ctx);
+});
+var indexName = (table, definition) => definition.name ?? `ix_${table}_${definition.columns.join("_")}`;
+var policyName = (table, suffix) => `${table}_${suffix}`;
+var foreignKeyName = (table, link) => `fk_${table}_${link}`;
+function validateSyncedTable(table, ctx) {
+  const forbidden = [
+    ["actions", "synced tables are read-only; actions are not allowed"],
+    ["indexes", "v1 synced tables cannot declare indexes; declare them with defineSyncedTable({ indexes }) in a v2 definition"]
+  ];
+  for (const [field, message] of forbidden) {
+    if (table[field] !== void 0) ctx.addIssue({ code: "custom", message, path: [field] });
+  }
+  if (table.policies?.write) {
+    ctx.addIssue({ code: "custom", message: "synced tables are read-only", path: ["policies", "write"] });
+  }
+  if (table.policies?.insert) {
+    ctx.addIssue({ code: "custom", message: "synced tables are read-only", path: ["policies", "insert"] });
+  }
+  if (table.policies?.update) {
+    ctx.addIssue({ code: "custom", message: "synced tables are read-only", path: ["policies", "update"] });
+  }
+  const columns = table.columns ?? {};
+  const names = Object.keys(columns);
+  if (names.length === 0) return;
+  const primaryKeys = names.filter((name2) => columns[name2]?.primary_key);
+  if (primaryKeys.length !== 1) {
+    ctx.addIssue({ code: "custom", message: "exactly one column must be primary_key", path: ["columns"] });
+  }
+  validateRenames(columns, names, ctx);
+  for (const name2 of names) {
+    const column = columns[name2];
+    if (!column) continue;
+    const cast = column.cast ? castParts(column.cast) : null;
+    if (column.cast && cast?.column !== name2) {
+      ctx.addIssue({
+        code: "custom",
+        message: "cast must reference the column it is declared on",
+        path: ["columns", name2, "cast"]
+      });
+    }
+    if (cast && cast.type !== column.type) {
+      ctx.addIssue({
+        code: "custom",
+        message: `cast target '${cast.type}' must match the declared type '${column.type}'`,
+        path: ["columns", name2, "cast"]
+      });
+    }
+  }
+}
+function validateRenames(columns, names, ctx) {
+  const renameSources = /* @__PURE__ */ new Map();
+  for (const name2 of names) {
+    const renamedFrom = columns[name2]?.renamed_from;
+    if (!renamedFrom) continue;
+    if (renamedFrom === name2 || names.includes(renamedFrom)) {
+      ctx.addIssue({
+        code: "custom",
+        message: "renamed_from must name a column that no longer exists",
+        path: ["columns", name2, "renamed_from"]
+      });
+    }
+    const claimed = renameSources.get(renamedFrom);
+    if (claimed) {
+      ctx.addIssue({
+        code: "custom",
+        message: `renamed_from '${renamedFrom}' is already claimed by '${claimed}'`,
+        path: ["columns", name2, "renamed_from"]
+      });
+    }
+    renameSources.set(renamedFrom, name2);
+  }
+}
+function validateColumnTable(table, ctx) {
+  const columns = table.columns ?? {};
+  const names = Object.keys(columns);
+  if (names.length === 0) {
+    ctx.addIssue({ code: "custom", message: "a table must declare columns or a source", path: ["columns"] });
+    return;
+  }
+  const primaryKeys = names.filter((name2) => columns[name2]?.primary_key);
+  if (primaryKeys.length !== 1) {
+    ctx.addIssue({ code: "custom", message: "exactly one column must be primary_key", path: ["columns"] });
+  }
+  validateRenames(columns, names, ctx);
+  for (const name2 of names) {
+    const column = columns[name2];
+    if (!column) continue;
+    const cast = column.cast ? castParts(column.cast) : null;
+    if (column.cast && cast?.column !== name2) {
+      ctx.addIssue({
+        code: "custom",
+        message: "cast must reference the column it is declared on",
+        path: ["columns", name2, "cast"]
+      });
+    }
+    if (cast && cast.type !== column.type) {
+      ctx.addIssue({
+        code: "custom",
+        message: `cast target '${cast.type}' must match the declared type '${column.type}'`,
+        path: ["columns", name2, "cast"]
+      });
+    }
+  }
+  for (const [position, index] of (table.indexes ?? []).entries()) {
+    if (new Set(index.columns).size !== index.columns.length) {
+      ctx.addIssue({
+        code: "custom",
+        message: "index names a column more than once",
+        path: ["indexes", position]
+      });
+    }
+    for (const column of index.columns) {
+      if (!names.includes(column)) {
+        ctx.addIssue({
+          code: "custom",
+          message: `index references unknown column '${column}'`,
+          path: ["indexes", position]
+        });
+      }
+    }
+  }
+}
+function validateLinks(table, ctx) {
+  const columnNames = Object.keys(table.columns ?? {});
+  for (const [name2, link] of Object.entries(table.links ?? {})) {
+    if (columnNames.length > 0 && !columnNames.includes(link.on)) {
+      ctx.addIssue({ code: "custom", message: `link references unknown column '${link.on}'`, path: ["links", name2, "on"] });
+    }
+    if (link.enforce && link.to.includes(".")) {
+      ctx.addIssue({
+        code: "custom",
+        message: "enforce is only valid for links inside the namespace; cross-boundary links stay soft",
+        path: ["links", name2, "enforce"]
+      });
+    }
+    if (link.enforce && table.source) {
+      ctx.addIssue({
+        code: "custom",
+        message: "a synced table cannot enforce foreign keys \u2014 its DDL is owned by the sync",
+        path: ["links", name2, "enforce"]
+      });
+    }
+  }
+}
+function validateDerivedNameLengths(table, ctx) {
+  const worstPolicy = policyName(table.table, "insert");
+  if (!table.source && worstPolicy.length > MAX_IDENTIFIER_LENGTH) {
+    ctx.addIssue({
+      code: "custom",
+      message: `table name is too long \u2014 the derived policy name '${worstPolicy}' exceeds Postgres's ${MAX_IDENTIFIER_LENGTH}-byte identifier limit`,
+      path: ["table"]
+    });
+  }
+  for (const [position, index] of (table.indexes ?? []).entries()) {
+    const name2 = indexName(table.table, index);
+    if (name2.length > MAX_IDENTIFIER_LENGTH) {
+      ctx.addIssue({
+        code: "custom",
+        message: `derived index name '${name2}' exceeds Postgres's ${MAX_IDENTIFIER_LENGTH}-byte identifier limit \u2014 set a shorter explicit name`,
+        path: ["indexes", position]
+      });
+    }
+  }
+  for (const [name2, link] of Object.entries(table.links ?? {})) {
+    const constraint = foreignKeyName(table.table, name2);
+    if (link.enforce && constraint.length > MAX_IDENTIFIER_LENGTH) {
+      ctx.addIssue({
+        code: "custom",
+        message: `derived foreign-key name '${constraint}' exceeds Postgres's ${MAX_IDENTIFIER_LENGTH}-byte identifier limit \u2014 shorten the link or table name`,
+        path: ["links", name2]
+      });
+    }
+  }
+  for (const name2 of Object.keys(table.actions ?? {})) {
+    const fnName = `action_${name2}`;
+    if (fnName.length > MAX_IDENTIFIER_LENGTH) {
+      ctx.addIssue({
+        code: "custom",
+        message: `derived action function name '${fnName}' exceeds Postgres's ${MAX_IDENTIFIER_LENGTH}-byte identifier limit \u2014 shorten the action name`,
+        path: ["actions", name2]
+      });
+    }
+  }
+}
+var TYPE_GROUPS = {
+  integer: "numeric",
+  bigint: "numeric",
+  numeric: "numeric",
+  double: "numeric",
+  text: "text",
+  uuid: "uuid",
+  date: "temporal",
+  timestamptz: "temporal",
+  boolean: "boolean",
+  jsonb: "jsonb"
+};
+function validatePolicyColumns(table, ctx) {
+  const columns = table.columns ?? {};
+  const columnNames = Object.keys(columns);
+  if (columnNames.length === 0) return;
+  for (const kind of ["read", "write", "insert", "update"]) {
+    const predicate = table.policies?.[kind];
+    if (!predicate) continue;
+    for (const column of referencedColumns(predicate.ast)) {
+      if (!columnNames.includes(column)) {
+        ctx.addIssue({
+          code: "custom",
+          message: `policy references unknown column '${column}'`,
+          path: ["policies", kind]
+        });
+      }
+    }
+    walkPredicate(predicate.ast, (node) => {
+      if (node.kind !== "compare") return;
+      const issue = comparisonTypeIssue(node.left, node.right, columns);
+      if (issue) ctx.addIssue({ code: "custom", message: issue, path: ["policies", kind] });
+    });
+  }
+}
+function comparisonTypeIssue(left, right, columns) {
+  const groupOf = (operand) => operand.kind === "column" ? columns[operand.name] ? TYPE_GROUPS[columns[operand.name].type] : null : null;
+  if (left.kind === "column" && right.kind === "column") {
+    const leftGroup = groupOf(left);
+    const rightGroup = groupOf(right);
+    if (leftGroup && rightGroup && leftGroup !== rightGroup) {
+      return `policy compares '${left.name}' (${columns[left.name].type}) with '${right.name}' (${columns[right.name].type}) \u2014 incomparable types`;
+    }
+    return null;
+  }
+  const column = left.kind === "column" ? left : right.kind === "column" ? right : null;
+  const literal = left.kind === "literal" ? left : right.kind === "literal" ? right : null;
+  if (!column || !literal || literal.value === null) return null;
+  const columnGroup = groupOf(column);
+  if (!columnGroup) return null;
+  if (typeof literal.value === "string") return null;
+  const literalGroup = typeof literal.value === "number" ? "numeric" : "boolean";
+  if (literalGroup !== columnGroup) {
+    return `policy compares '${column.name}' (${columns[column.name].type}) with a ${typeof literal.value} literal \u2014 incomparable types`;
+  }
+  return null;
+}
 var policyVariantSchema = zod.z.object({
   /** Claims-only guard (capability()/role()/claim() comparisons — no columns). */
   when: zod.z.string().min(1).max(1e3),
@@ -566,7 +1313,7 @@ var CANONICAL_FORMAT = 2;
 var IDENTIFIER_RE = /^[a-z][a-z0-9_]*$/;
 var identifier2 = zod.z.string().min(1).max(63).regex(IDENTIFIER_RE);
 var columnIdentifier = zod.z.string().min(1).max(63).regex(COLUMN_IDENTIFIER_PATTERN);
-var COLUMN_TYPES = [
+var COLUMN_TYPES2 = [
   "uuid",
   "text",
   "integer",
@@ -578,7 +1325,7 @@ var COLUMN_TYPES = [
   "date",
   "jsonb"
 ];
-var columnTypeSchema = zod.z.enum(COLUMN_TYPES);
+var columnTypeSchema2 = zod.z.enum(COLUMN_TYPES2);
 var canonicalEnumSchema = zod.z.object({
   name: identifier2,
   values: zod.z.array(zod.z.string().min(1).max(63)).min(1).max(100)
@@ -587,7 +1334,7 @@ var canonicalColumnSchema = zod.z.object({
   /** Property name in TS (camelCase); columnName is the Postgres name. */
   name: zod.z.string().min(1).max(63),
   columnName: columnIdentifier,
-  type: zod.z.union([columnTypeSchema, zod.z.object({ enum: identifier2 })]),
+  type: zod.z.union([columnTypeSchema2, zod.z.object({ enum: identifier2 })]),
   nullable: zod.z.boolean().default(true),
   unique: zod.z.boolean().default(false),
   /** Literal default, or one of the allowlisted SQL functions. */
@@ -837,7 +1584,7 @@ var canonicalActionSchema = zod.z.object({
   name: identifier2,
   requires: zod.z.string().max(1e3).optional(),
   params: zod.z.record(zod.z.string(), zod.z.object({
-    type: columnTypeSchema,
+    type: columnTypeSchema2,
     nullable: zod.z.boolean().default(false)
   })).default({}),
   executes: zod.z.string().min(1).max(1e4),
@@ -938,7 +1685,8 @@ var canonicalTableSchema = zod.z.object({
   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 ownedIndexes = table.source === void 0 ? table.indexes : table.indexes.filter((index) => index.unique);
+  const ownedCollections = [ownedIndexes, 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");
@@ -1040,6 +1788,23 @@ function trackedCellColumns(table) {
   return table.columns.filter((column) => column.cell === void 0 && !pk.has(column.columnName) && column.onUpdateFn === void 0);
 }
 var SUFFIXES = Object.values(CELL_PART_SUFFIX);
+function validateSyncedIndexes(table, tableIndex, ctx) {
+  if (table.source === void 0) return;
+  const columns = new Set(table.columns.map((column) => column.columnName));
+  for (const [position, index] of table.indexes.entries()) {
+    const fail4 = (message) => ctx.addIssue({ code: "custom", path: ["tables", tableIndex, "indexes", position], message: `synced table '${table.table}' ${message}` });
+    if (columns.size === 0) fail4("must declare columns to declare indexes");
+    if (index.unique) fail4("cannot declare a unique index");
+    if (new Set(index.columns).size !== index.columns.length) fail4("index names a column more than once");
+    for (const column of index.columns) {
+      if (columns.size > 0 && !columns.has(column)) fail4(`index references unknown column '${column}'`);
+    }
+    const name2 = indexName(table.table, index);
+    if (name2.length > MAX_IDENTIFIER_LENGTH) {
+      fail4(`derived index name '${name2}' exceeds Postgres's ${MAX_IDENTIFIER_LENGTH}-byte identifier limit \u2014 set a shorter explicit name`);
+    }
+  }
+}
 function validateCellMetadata(table, index, ctx) {
   const fail4 = (message, path = ["tables", index]) => ctx.addIssue({ code: "custom", path, message });
   const cells = table.columns.flatMap((column, position) => column.cell ? [{ column, position, cell: column.cell }] : []);
@@ -1106,12 +1871,24 @@ var localDefinitionSchema = zod.z.object({
   }).default({ uses: [] })
 }).superRefine((definition, ctx) => {
   const seen = /* @__PURE__ */ new Set();
+  const syncedIndexOwners = /* @__PURE__ */ new Map();
   for (const [index, table] of definition.tables.entries()) {
     if (seen.has(table.table)) {
       ctx.addIssue({ code: "custom", path: ["tables", index, "table"], message: `duplicate relation '${table.table}'` });
     }
     seen.add(table.table);
     validateCellMetadata(table, index, ctx);
+    validateSyncedIndexes(table, index, ctx);
+    if (table.source !== void 0) {
+      for (const [position, entry] of table.indexes.entries()) {
+        const name2 = indexName(table.table, entry);
+        const owner = syncedIndexOwners.get(name2);
+        if (owner !== void 0) {
+          ctx.addIssue({ code: "custom", path: ["tables", index, "indexes", position], message: `synced index '${name2}' is also declared on '${owner}'` });
+        }
+        syncedIndexOwners.set(name2, table.table);
+      }
+    }
     if (table.source !== void 0) {
       for (const [columnIndex, column] of table.columns.entries()) {
         if (column.onUpdateFn !== void 0) {
@@ -1360,9 +2137,6 @@ function normalizeCanonical(definition) {
   return normalized;
 }
 
-// src/client/sql.ts
-var BUILTIN_SQL_READ_HASH = "sha256:a50c477c952a5e0fe68ed158a4530e4aab573c09bcbb1a8ac454dc88a39a6258";
-
 // src/ir/index.ts
 var IR_VERSION = 6;
 var LEGACY_IR_VERSION = 1;
@@ -1653,7 +2427,7 @@ var variableDefaultIrSchema = zod.z.object({
 var variableIrSchema = zod.z.object({
   name: zod.z.string(),
   type: zod.z.union([
-    zod.z.object({ kind: zod.z.literal("scalar"), scalar: zod.z.enum(COLUMN_TYPES) }),
+    zod.z.object({ kind: zod.z.literal("scalar"), scalar: zod.z.enum(COLUMN_TYPES2) }),
     /** `values` is the declared membership whitelist — the executor validates against it. */
     zod.z.object({ kind: zod.z.literal("enum"), name: zod.z.string(), values: zod.z.array(zod.z.string()).min(1) }),
     /** §4f dynamic slot: validated against `tables[table]` whitelists at runtime. */
@@ -1691,8 +2465,7 @@ var compiledOperationSchema = zod.z.object({
     maxRows: zod.z.number().int().min(1).max(1e4)
   }).strict().optional(),
   irVersion: irVersionSchema,
-  name: zod.z.string(),
-  opHash: zod.z.string().regex(/^sha256:[0-9a-f]{64}$/),
+  name: zod.z.string().regex(/^[_A-Za-z][_0-9A-Za-z]{0,254}$/),
   kind: zod.z.enum(["query", "mutation"]),
   requires: zod.z.object({
     capability: zod.z.string().optional(),
@@ -1708,7 +2481,7 @@ var compiledOperationSchema = zod.z.object({
   }
   if (operation.language === "sql") {
     const validPlan = operation.sqlQuery ? !operation.sql && operation.irVersion === RUNTIME_SQL_IR_VERSION : !!operation.sql && operation.irVersion === SQL_IR_VERSION;
-    const builtin = operation.name === "BuiltinSqlRead" && operation.opHash === BUILTIN_SQL_READ_HASH && operation.requires === null;
+    const builtin = operation.name === "BuiltinSqlRead" && 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" });
     }
@@ -1723,7 +2496,7 @@ var compiledOperationSchema = zod.z.object({
   }
 });
 var resolvedSourceIrSchema = zod.z.object({
-  name: zod.z.string(),
+  name: zod.z.string().regex(/^[_A-Za-z][_0-9A-Za-z]{0,254}$/),
   kind: zod.z.enum(["manual", "etl", "prefetch"]),
   /** Logical table key of the backing relation. */
   table: zod.z.string(),
@@ -1786,7 +2559,7 @@ var tableMetaIrSchema = zod.z.object({
   columns: zod.z.array(zod.z.object({
     name: zod.z.string(),
     columnName: zod.z.string(),
-    type: zod.z.union([zod.z.enum(COLUMN_TYPES), zod.z.object({ enum: zod.z.string(), values: zod.z.array(zod.z.string()) })]),
+    type: zod.z.union([zod.z.enum(COLUMN_TYPES2), zod.z.object({ enum: zod.z.string(), values: zod.z.array(zod.z.string()) })]),
     nullable: zod.z.boolean()
   })),
   /** Empty for keyless read-only views; keyed tables and views list logical columns. */
@@ -1837,7 +2610,6 @@ var compiledArtifactSchema = zod.z.object({
   ownSchemaHash: zod.z.string().optional(),
   dependencies: zod.z.record(zod.z.string(), zod.z.string()).optional(),
   readPolicies: zod.z.record(zod.z.string(), predIrSchema).optional(),
-  opsHash: zod.z.string(),
   /** Apply-observed synced objects without a serving backing; not part of the authored schema hash. */
   unbackedTables: zod.z.array(zod.z.string()).optional(),
   tables: zod.z.record(zod.z.string(), tableMetaIrSchema),
@@ -1923,7 +2695,7 @@ function graphqlScalarFor(type) {
 }
 var COLUMN_TYPE_BY_SCALAR = new Map([
   ["ID", "text"],
-  ...COLUMN_TYPES.map((type) => [graphqlScalarFor(type), type])
+  ...COLUMN_TYPES2.map((type) => [graphqlScalarFor(type), type])
 ]);
 function columnTypeForScalar(scalarName) {
   return COLUMN_TYPE_BY_SCALAR.get(scalarName);
@@ -2024,14 +2796,14 @@ var PolicyCompileError = class extends Error {
 };
 
 // src/predicate-v2/parse.ts
-var KEYWORDS = /* @__PURE__ */ new Set(["and", "or", "not", "true", "false", "null", "claim", "capability", "role", "exists"]);
-var OPERATOR_PATTERN = /^(!=|<=|>=|<>|=|<|>)/;
-var IDENTIFIER_START = /[a-zA-Z_]/;
-var IDENTIFIER_CHAR = /[a-zA-Z0-9_]/;
-var NUMBER_PATTERN = /^-?\d+(\.\d+)?/;
+var KEYWORDS2 = /* @__PURE__ */ new Set(["and", "or", "not", "true", "false", "null", "claim", "capability", "role", "exists"]);
+var OPERATOR_PATTERN2 = /^(!=|<=|>=|<>|=|<|>)/;
+var IDENTIFIER_START2 = /[a-zA-Z_]/;
+var IDENTIFIER_CHAR2 = /[a-zA-Z0-9_]/;
+var NUMBER_PATTERN2 = /^-?\d+(\.\d+)?/;
 var SCALAR_CLAIM_KEYS = Object.entries(CLAIMS_CONTRACT).filter(([, type]) => !type.endsWith("[]")).map(([key]) => key);
 var ARRAY_CLAIM_KEYS = Object.entries(CLAIMS_CONTRACT).filter(([, type]) => type.endsWith("[]")).map(([key]) => key);
-function tokenize2(source) {
+function tokenize3(source) {
   const tokens = [];
   let position = 0;
   while (position < source.length) {
@@ -2061,27 +2833,27 @@ function tokenize2(source) {
       continue;
     }
     if (char === "'") {
-      const { value, end } = readString(source, position);
+      const { value, end } = readString2(source, position);
       tokens.push({ kind: "string", value, position });
       position = end;
       continue;
     }
-    const operator = OPERATOR_PATTERN.exec(source.slice(position));
+    const operator = OPERATOR_PATTERN2.exec(source.slice(position));
     if (operator) {
       const value = operator[0] === "<>" ? "!=" : operator[0];
       tokens.push({ kind: "operator", value, position });
       position += operator[0].length;
       continue;
     }
-    const number = NUMBER_PATTERN.exec(source.slice(position));
-    if (number && !IDENTIFIER_START.test(char)) {
+    const number = NUMBER_PATTERN2.exec(source.slice(position));
+    if (number && !IDENTIFIER_START2.test(char)) {
       tokens.push({ kind: "number", value: number[0], position });
       position += number[0].length;
       continue;
     }
-    if (IDENTIFIER_START.test(char)) {
+    if (IDENTIFIER_START2.test(char)) {
       let end = position;
-      while (end < source.length && IDENTIFIER_CHAR.test(source[end])) end += 1;
+      while (end < source.length && IDENTIFIER_CHAR2.test(source[end])) end += 1;
       tokens.push({ kind: "identifier", value: source.slice(position, end), position });
       position = end;
       continue;
@@ -2091,7 +2863,7 @@ function tokenize2(source) {
   tokens.push({ kind: "end", value: "", position: source.length });
   return tokens;
 }
-function readString(source, start) {
+function readString2(source, start) {
   let value = "";
   let position = start + 1;
   while (position < source.length) {
@@ -2110,7 +2882,7 @@ function readString(source, start) {
   }
   throw new PolicyParseError("unterminated string literal", start);
 }
-var Parser2 = class {
+var Parser3 = class {
   constructor(tokens) {
     this.tokens = tokens;
   }
@@ -2252,7 +3024,7 @@ var Parser2 = class {
   /** `ident(.ident)*` — first segment must not be a keyword; later segments may be (e.g. `author.role`). */
   parsePath(description) {
     const first = this.peek();
-    if (first.kind !== "identifier" || KEYWORDS.has(first.value)) {
+    if (first.kind !== "identifier" || KEYWORDS2.has(first.value)) {
       throw new PolicyParseError(`expected ${description}, got '${first.value || "end"}'`, first.position);
     }
     this.advance();
@@ -2298,7 +3070,7 @@ var Parser2 = class {
 function parsePolicy(source) {
   const trimmed = source.trim();
   if (trimmed.length === 0) throw new PolicyParseError("empty policy expression", 0);
-  return { source: trimmed, ast: new Parser2(tokenize2(trimmed)).parse() };
+  return { source: trimmed, ast: new Parser3(tokenize3(trimmed)).parse() };
 }
 
 // src/predicate-v2/compile.ts
@@ -2983,15 +3755,6 @@ function classifyInputType(name2, tableByTypename) {
   return void 0;
 }
 
-// src/errors.ts
-var OrmDefinitionError = class extends Error {
-  constructor(message, file) {
-    super(file ? `${file}: ${message}` : message);
-    this.file = file;
-  }
-  name = "OrmDefinitionError";
-};
-
 // src/canonical/composition.ts
 function localContract(definition) {
   return normalizeCanonical(localDefinitionSchema.parse(definition));
@@ -3551,24 +4314,6 @@ function flattenOperation({
 }) {
   return { ...operation, selectionSet: flattenSelectionSet(operation.selectionSet, fragments, []) };
 }
-var COMPILER_MAJOR = 1;
-var OP_HASH_DOMAIN = "sequence-orm-op\0";
-var OPS_HASH_DOMAIN = "sequence-orm-opset\0";
-function canonicalOperationText(definition) {
-  const document2 = { kind: graphql.Kind.DOCUMENT, definitions: [definition] };
-  return graphql.print(document2);
-}
-function computeOpHash({
-  definition,
-  schemaHash
-}) {
-  const digest2 = crypto.createHash("sha256").update(OP_HASH_DOMAIN).update(`${COMPILER_MAJOR}\0${schemaHash}\0`).update(canonicalOperationText(definition)).digest("hex");
-  return `sha256:${digest2}`;
-}
-function computeOpsHash(opHashes) {
-  const digest2 = crypto.createHash("sha256").update(OPS_HASH_DOMAIN).update([...opHashes].sort().join("\n")).digest("hex");
-  return `sha256:${digest2}`;
-}
 var SOURCE_DIRECTIVES = /* @__PURE__ */ new Set(["prefetch", "writeback", "localOnly"]);
 var fail = (message, code) => {
   throw new DocumentCompileError(message, code);
@@ -5064,7 +5809,6 @@ function compileNamespace({ canonical, sdl, documents }) {
         operations[restricted.name] = {
           irVersion: usesServicePrincipal(roots) ? SERVICE_PRINCIPAL_IR_VERSION : canonical.imports?.length ? COMPOSED_IR_VERSION : roots.some((root) => root.kind === "mutation" && root.assertAffectedRows !== void 0) ? GUARDED_IR_VERSION : LEGACY_IR_VERSION,
           name: restricted.name,
-          opHash: computeOpHash({ definition: flattened, schemaHash }),
           kind: restricted.kind,
           requires: restricted.requires,
           variables: restricted.variables,
@@ -5097,7 +5841,6 @@ function compileNamespace({ canonical, sdl, documents }) {
       dependencies: Object.fromEntries(canonical.imports.map((owner) => [owner.namespace, computeSchemaHash(localContract(owner))]))
     } : {},
     readPolicies: Object.fromEntries(ctx.readPolicies),
-    opsHash: computeOpsHash(Object.values(operations).map((op) => op.opHash)),
     tables: ctx.tables,
     operations
   };
@@ -5105,11 +5848,10 @@ function compileNamespace({ canonical, sdl, documents }) {
   const manifest = {
     namespace: ctx.namespace,
     schemaHash,
-    opsHash: normalized.opsHash,
     operations: Object.fromEntries(
       Object.values(normalized.operations).map((op) => [
         op.name,
-        { opHash: op.opHash, kind: op.kind, requires: op.requires }
+        op
       ])
     )
   };
@@ -5505,6 +6247,10 @@ function validateOnConflictInput({
   }
   return finish(collector, { constraint, updateColumns });
 }
+function canonicalOperationText(definition) {
+  const document2 = { kind: graphql.Kind.DOCUMENT, definitions: [definition] };
+  return graphql.print(document2);
+}
 
 // src/sdl/generate.ts
 var SdlGenerationError = class extends Error {
@@ -6483,7 +7229,6 @@ function createSqlCatalog({ canonical, publishedObjects, executionTarget }) {
 }
 function createSqlCatalogFromContext({ canonical, publishedObjects, executionTarget, ctx, identity: suppliedIdentity }) {
   if (!publishedObjects.length || new Set(publishedObjects).size !== publishedObjects.length) throw new Error("SQL objects must be explicitly declared and unique");
-  const identity = suppliedIdentity ?? sqlHash(`ontology-sql-v1\0${computeSchemaHash(canonical)}\0${executionTarget}`);
   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 ?? []];
@@ -6508,7 +7253,7 @@ function createSqlCatalogFromContext({ canonical, publishedObjects, executionTar
     const scan = `SELECT ${projection} FROM ${quoteIdentifier(meta.schema)}.${quoteIdentifier(meta.table)} AS ${quoteIdentifier("p0")} WHERE ${compileStaticPolicySql({ table: meta, predicate: policy, tables: ctx.tables, namespace: canonical.namespace, alias: "p0", onRead: (target) => reads.add(refOf(target)) })}`;
     return { ref, table: meta.table, columns, scan, read: [...reads].sort() };
   });
-  return { identity, objects };
+  return { identity: suppliedIdentity ?? sqlHash(JSON.stringify(["ontology-sql-catalog-v2", executionTarget, objects])), objects };
 }
 
 // src/sql/ast.ts
@@ -7062,20 +7807,10 @@ async function compileSqlDocuments({ input, result, sqlDocuments }) {
       const catalog = createSqlCatalog({ canonical: input.canonical, publishedObjects: read, executionTarget: "registered-operation" });
       if ("mode" in definition) {
         if (catalog.objects.some((object) => object.read.some((ref) => !read.includes(ref)))) throw new Error("SQL policy accesses an undeclared ontology object");
-        const opHash2 = sqlHash(JSON.stringify([
-          "sequence-runtime-sql-operation-v1",
-          definition.name,
-          definition.namespace,
-          definition.requires.capability,
-          read,
-          catalog.identity,
-          definition.maxRows
-        ]));
         result.artifact.operations[definition.name] = compiledOperationSchema.parse({
           irVersion: RUNTIME_SQL_IR_VERSION,
           language: "sql",
           name: definition.name,
-          opHash: opHash2,
           kind: "query",
           requires: definition.requires,
           variables: [
@@ -7086,7 +7821,7 @@ async function compileSqlDocuments({ input, result, sqlDocuments }) {
           tableSet: read.map((ref) => ref.split("/")[1]).sort(),
           sqlQuery: { catalog, read, maxRows: definition.maxRows }
         });
-        result.manifest.operations[definition.name] = { opHash: opHash2, kind: "query", requires: definition.requires };
+        result.manifest.operations[definition.name] = result.artifact.operations[definition.name];
         continue;
       }
       const names = Object.keys(definition.parameters).sort();
@@ -7104,20 +7839,10 @@ async function compileSqlDocuments({ input, result, sqlDocuments }) {
         nullable: !definition.parameters[name2].required,
         list: false
       }));
-      const opHash = sqlHash(JSON.stringify([
-        "sequence-sql-operation-v1",
-        definition.name,
-        definition.namespace,
-        definition.requires.capability,
-        read,
-        variables,
-        plan.queryHash
-      ]));
       const operation = compiledOperationSchema.parse({
         irVersion: SQL_IR_VERSION,
         language: "sql",
         name: definition.name,
-        opHash,
         kind: "query",
         requires: definition.requires,
         variables,
@@ -7126,7 +7851,7 @@ async function compileSqlDocuments({ input, result, sqlDocuments }) {
         sql: { text: plan.text, columns: plan.columns, parameters: names, read, maxRows: plan.maxRows }
       });
       result.artifact.operations[definition.name] = operation;
-      result.manifest.operations[definition.name] = { opHash, kind: "query", requires: definition.requires };
+      result.manifest.operations[definition.name] = result.artifact.operations[definition.name];
     } catch (error) {
       return { ok: false, diagnostics: [...result.diagnostics, {
         severity: "error",
@@ -7138,8 +7863,6 @@ async function compileSqlDocuments({ input, result, sqlDocuments }) {
   }
   const required = requiredArtifactIrVersion(Object.values(result.artifact.operations));
   if (required > result.artifact.irVersion) result.artifact.irVersion = required;
-  result.artifact.opsHash = computeOpsHash(Object.values(result.artifact.operations).map((op) => op.opHash));
-  result.manifest.opsHash = result.artifact.opsHash;
   return { ...result, artifact: normalizeIr(result.artifact) };
 }
 async function managedViewDiagnostics(canonical) {
@@ -7238,14 +7961,13 @@ function compileBuiltinSqlArtifact({ namespace, definitions, read, unbackedObjec
     namespace,
     executionTarget,
     read,
-    definitions.map((definition) => [definition.namespace, computeSchemaHash(definition)]).sort()
+    objects
   ])) };
   return normalizeIr({
     irVersion: usesServicePrincipal(policies) ? SERVICE_PRINCIPAL_IR_VERSION : RUNTIME_SQL_IR_VERSION,
     namespace,
     schemaHash: catalog.identity,
     ownSchemaHash: localHash(anchor),
-    opsHash: BUILTIN_SQL_READ_HASH,
     dependencies: Object.fromEntries(definitions.filter((definition) => definition.namespace !== namespace).map((definition) => [definition.namespace, localHash(definition)])),
     tables,
     readPolicies: policies,
@@ -7253,7 +7975,6 @@ function compileBuiltinSqlArtifact({ namespace, definitions, read, unbackedObjec
     operations: { BuiltinSqlRead: {
       irVersion: RUNTIME_SQL_IR_VERSION,
       name: "BuiltinSqlRead",
-      opHash: BUILTIN_SQL_READ_HASH,
       language: "sql",
       kind: "query",
       requires: null,
@@ -7418,13 +8139,11 @@ function composeObjectSqlArtifact({ namespace, bundles }) {
     irVersion: usesServicePrincipal(readPolicies) ? SERVICE_PRINCIPAL_IR_VERSION : RUNTIME_SQL_IR_VERSION,
     namespace,
     schemaHash: identity,
-    opsHash: BUILTIN_SQL_READ_HASH,
     tables,
     readPolicies,
     operations: { BuiltinSqlRead: {
       irVersion: RUNTIME_SQL_IR_VERSION,
       name: "BuiltinSqlRead",
-      opHash: BUILTIN_SQL_READ_HASH,
       language: "sql",
       kind: "query",
       requires: null,
@@ -7438,12 +8157,13 @@ function composeObjectSqlArtifact({ namespace, bundles }) {
     } }
   });
 }
+
+// src/compiler-gql/dataset-previews.ts
 var DATASET_PREVIEW_LIMIT = 100;
 function compileDatasetPreviews(input) {
   const canonical = normalizeCanonical(input);
   const { ctx, diagnostics } = buildCompileContext(canonical);
   if (diagnostics.some((diagnostic) => diagnostic.severity === "error")) throw new NamespaceCompileError(diagnostics);
-  const schemaHash = computeSchemaHash(canonical);
   const operations = {};
   for (const relation of canonicalRelations(canonical)) {
     if (relation.internal || relation.source !== void 0) continue;
@@ -7468,11 +8188,9 @@ function compileDatasetPreviews(input) {
         throw new DocumentCompileError(`object '${meta.namespace}/${table}' is not exported for reads`, "unexported-object");
       }
     }
-    const hash = crypto.createHash("sha256").update("sequence-orm-dataset-preview-v1\0").update(stableJson({ schemaHash, roots, tableSet })).digest("hex");
     operations[relation.table] = compiledOperationSchema.parse({
       irVersion: usesServicePrincipal(roots) ? SERVICE_PRINCIPAL_IR_VERSION : canonical.imports?.length ? COMPOSED_IR_VERSION : LEGACY_IR_VERSION,
       name: `DatasetPreview_${relation.table}`,
-      opHash: `sha256:${hash}`,
       kind: "query",
       requires: null,
       variables: [],
@@ -7541,7 +8259,6 @@ function projectOperationMetadata({ artifact, operation }) {
   });
 }
 
-exports.COMPILER_MAJOR = COMPILER_MAJOR;
 exports.CONST_TRUE = CONST_TRUE;
 exports.DATASET_PREVIEW_LIMIT = DATASET_PREVIEW_LIMIT;
 exports.DEFAULT_LIMIT = DEFAULT_LIMIT;
@@ -7579,8 +8296,6 @@ exports.compilePolicy = compilePolicy;
 exports.compilePredicateV2 = compilePredicateV2;
 exports.compileRuntimeSql = compileRuntimeSql;
 exports.composeObjectSqlArtifact = composeObjectSqlArtifact;
-exports.computeOpHash = computeOpHash;
-exports.computeOpsHash = computeOpsHash;
 exports.computePinnedColumnsByTable = computePinnedColumnsByTable;
 exports.computeSchemaHash = computeSchemaHash;
 exports.defineOperation = defineOperation;