@sequenceholdings/orm 0.1.2 → 0.1.3

package/dist/predicate-v2.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/predicate-v2/ast.ts","../src/predicate-v2/errors.ts","../src/constants.ts","../src/canonical/v2.ts","../src/ir/index.ts","../src/predicate-v2/parse.ts","../src/predicate-v2/compile.ts"],"names":["z"],"mappings":"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","file":"predicate-v2.js","sourcesContent":["import type { ClaimKey } from '../ir/index.js'\n\nexport const POLICY_COMPARE_OPS = ['=', '!=', '<', '<=', '>', '>='] as const\nexport type PolicyCompareOp = (typeof POLICY_COMPARE_OPS)[number]\n\nexport type PolicyOperand =\n  /** A column reference, or a dotted to-one path ending in a column (`a.b.c`). */\n  | { kind: 'path'; segments: readonly string[] }\n  /** `claim('sub')` / `claim('org')` — the only claim() keys in CLAIMS_CONTRACT. */\n  | { kind: 'claim'; key: ClaimKey }\n  | { kind: 'literal'; value: string | number | boolean | null }\n\nexport type PolicyNode =\n  | { kind: 'and'; operands: readonly PolicyNode[] }\n  | { kind: 'or'; operands: readonly PolicyNode[] }\n  | { kind: 'not'; operand: PolicyNode }\n  | { kind: 'compare'; op: PolicyCompareOp; left: PolicyOperand; right: PolicyOperand }\n  /** Boolean claims leaves — pre-resolved against the caller's claims at runtime. */\n  | { kind: 'capability'; key: string }\n  | { kind: 'role'; key: string }\n  /** `exists(<link-path>, <pred>)` — the inner predicate runs against the final target. */\n  | { kind: 'exists'; path: readonly string[]; where: PolicyNode }\n\nexport interface ParsedPolicy {\n  readonly source: string\n  readonly ast: PolicyNode\n}\n\nexport function walkPolicy(node: PolicyNode, visit: (node: PolicyNode) => void): void {\n  visit(node)\n  if (node.kind === 'and' || node.kind === 'or') {\n    for (const operand of node.operands) walkPolicy(operand, visit)\n  }\n  if (node.kind === 'not') walkPolicy(node.operand, visit)\n  if (node.kind === 'exists') walkPolicy(node.where, visit)\n}\n","/** Parse-time failure — bad token stream, malformed call, invalid claim key. */\nexport class PolicyParseError extends Error {\n  override readonly name = 'PolicyParseError'\n\n  constructor(\n    message: string,\n    readonly position: number,\n  ) {\n    super(`${message} (at position ${position})`)\n  }\n}\n\nexport type PolicyCompileErrorCode =\n  | 'unknown-table'\n  | 'unknown-column'\n  | 'unknown-link'\n  | 'not-to-one'\n  | 'link-depth-exceeded'\n  | 'unsupported-comparison'\n  | 'invalid-null-comparison'\n  | 'when-not-claims-only'\n\n/**\n * Compile-time failure — the parsed policy references something the table\n * doesn't declare, or uses a shape the v2.0 IR cannot represent. Carries\n * `candidates` so the error can name what IS available.\n */\nexport class PolicyCompileError extends Error {\n  override readonly name = 'PolicyCompileError'\n\n  constructor(\n    message: string,\n    readonly code: PolicyCompileErrorCode,\n    readonly candidates: readonly string[] = [],\n  ) {\n    super(candidates.length > 0 ? `${message} (candidates: ${candidates.join(', ')})` : message)\n  }\n}\n","/** Namespace names become Postgres identifiers (`orm_<ns>` schema, `orm_<ns>_consumer` role) — the tight grammar is a security control, not cosmetics. */\nexport const NAMESPACE_PATTERN = /^[a-z][a-z0-9_]{0,40}$/\n\nexport const IDENTIFIER_PATTERN = /^[a-z][a-z0-9_]*$/\nexport const MAX_IDENTIFIER_LENGTH = 63\n\n/**\n * The Data API carries a delegated, attenuated data token on this header (not\n * `Authorization`, which stays the app-user/session bearer). One definition\n * shared by the client transport, the server's caller resolver, and the\n * function-invoke minter, so all three agree.\n */\nexport const ORM_DATA_TOKEN_HEADER = 'x-sequence-data-token'\n\n/**\n * The SEPARATE header the invoke proxy uses to hand a managed function its\n * *service* data token — the escalation path. A function receives BOTH this and\n * `ORM_DATA_TOKEN_HEADER`; the default `createOrmClient` reads the user token,\n * the deliberately-named `createServiceOrmClient` reads THIS one. Two distinct\n * headers so reaching for the service identity is always an explicit act, never\n * an accidental default. Both are sent to the Data API on `ORM_DATA_TOKEN_HEADER`\n * — the server stays mode-agnostic and resolves whatever sub the token carries.\n */\nexport const ORM_SERVICE_DATA_TOKEN_HEADER = 'x-sequence-data-token-service'\n\n/**\n * Custom Roles & Capabilities claim keys as policies reference them: a\n * host-scoped registry key, or an org pin's `org/<key>`. Matches the registry\n * key grammar EXACTLY (`[a-z0-9-]`, 1–64 chars, no `_` — the FGA object-id\n * delimiter) so any capability that's declarable/attachable in namespace.yaml\n * can also be referenced here — a stricter pattern would let a valid key\n * register yet fail at apply (e.g. `org/2fa`, a one-char or digit-led key).\n */\nexport const CAPABILITY_KEY_PATTERN = /^(?:org\\/)?[a-z0-9-]{1,64}$/\n\nexport const CLAIM_KEY_PATTERN = /^[a-z][a-z0-9_]*$/\n\n/** Qualified reference to a table outside the defining file: `<schema>.<table>`. */\nexport const QUALIFIED_TABLE_PATTERN = /^[a-z][a-z0-9_]*\\.[a-z][a-z0-9_]*$/\n\n/** Synced reflected sources are restricted to the gold layer. */\nexport const SYNCED_SOURCE_PATTERN = /^gold\\.[a-z][a-z0-9_]*$/\n\nexport const ORM_SCHEMA_PREFIX = 'orm_'\nexport const CONSUMER_ROLE_SUFFIX = '_consumer'\n\nexport const ormSchemaName = (namespace: string): string => `${ORM_SCHEMA_PREFIX}${namespace}`\nexport const consumerRoleName = (namespace: string): string =>\n  `${ORM_SCHEMA_PREFIX}${namespace}${CONSUMER_ROLE_SUFFIX}`\n\nexport const DEFINITION_FILE_EXTENSIONS = ['.yml', '.yaml'] as const\n\n/** Reserved basenames for the namespace-level config file (description, org capability pins). */\nexport const NAMESPACE_CONFIG_FILENAMES = new Set(['namespace.yaml', 'namespace.yml'])\n\nexport const HASH_DOMAIN = 'sequence-orm-definitions\\0'\n\n/**\n * The one size guard the package owns: a per-file byte cap where the loader\n * reads untrusted YAML into memory — a real failure mode, not a product\n * limit. Counts of tables/indexes/params and policy/SQL lengths are\n * deliberately uncapped; Postgres enforces its own limits loudly at apply.\n */\nexport const MAX_DEFINITION_FILE_BYTES = 1024 * 1024\n\n/** `/api/data/<ns>/actions/…` and `/api/data/<ns>/query` share the table path segment. */\nexport const RESERVED_TABLE_NAMES = new Set(['actions', 'query'])\n\n/**\n * The Data API's query-string grammar owns these parameter names — a column\n * with one of them could never be filtered over the wire, so definitions\n * refuse it up front (\"validate rejects only what can never work\").\n */\nexport const RESERVED_COLUMN_NAMES = new Set(['select', 'order', 'limit', 'offset'])\n","/**\n * Canonical namespace definition v2 — the data-only JSON a consumer's\n * TypeScript schema serializes to. This is v2's equivalent of the v1 YAML\n * `NamespaceDefinition`: the CLI's jiti loader produces it, the content hash\n * is computed over it, the server re-validates it (consumer TS never runs\n * server-side), and the SDL generator / GraphQL compiler / migration engine\n * all consume it.\n *\n * FROZEN CONTRACT (week 1): downstream tracks build against these shapes.\n * Additive evolution only; `definition_format` discriminates on the wire.\n */\nimport { z } from 'zod'\n\nexport const CANONICAL_FORMAT = 2 as const\n\n/** Identifier grammar shared with v1 (`^[a-z][a-z0-9_]*$`, ≤63 bytes). */\nexport const IDENTIFIER_RE = /^[a-z][a-z0-9_]*$/\nconst identifier = z.string().min(1).max(63).regex(IDENTIFIER_RE)\n\n/** The 10 v1 column types, unchanged in v2. */\nexport const COLUMN_TYPES = [\n  'uuid', 'text', 'integer', 'bigint', 'numeric', 'double',\n  'boolean', 'timestamptz', 'date', 'jsonb',\n] as const\nexport type ColumnType = (typeof COLUMN_TYPES)[number]\n\nconst columnTypeSchema = z.enum(COLUMN_TYPES)\n\n/** Enum columns reference a namespace-level `defineEnum` by name. */\nexport const canonicalEnumSchema = z.object({\n  name: identifier,\n  values: z.array(z.string().min(1).max(63)).min(1).max(100),\n})\nexport type CanonicalEnum = z.infer<typeof canonicalEnumSchema>\n\nexport const canonicalColumnSchema = z.object({\n  /** Property name in TS (camelCase); columnName is the Postgres name. */\n  name: z.string().min(1).max(63),\n  columnName: identifier,\n  type: z.union([columnTypeSchema, z.object({ enum: identifier })]),\n  nullable: z.boolean().default(true),\n  unique: z.boolean().default(false),\n  /** Literal default, or one of the allowlisted SQL functions. */\n  default: z.union([z.string(), z.number(), z.boolean(), z.null()]).optional(),\n  defaultFn: z.enum(['gen_random_uuid()', 'now()']).optional(),\n  description: z.string().max(500).optional(),\n  /** Migration hints — same semantics as v1. */\n  renamedFrom: identifier.optional(),\n  cast: z.string().max(200).optional(),\n  deprecated: z.boolean().default(false),\n})\nexport type CanonicalColumn = z.infer<typeof canonicalColumnSchema>\n\nexport const canonicalLinkSchema = z.object({\n  name: z.string().min(1).max(63),\n  kind: z.enum(['toOne', 'toMany', 'toPlatformUser']),\n  /** Target table name (namespace-local). Absent for toPlatformUser. */\n  target: identifier.optional(),\n  /** FK column on the owning side (toOne/toPlatformUser: on this table; toMany: on the target). */\n  on: identifier,\n  /** Referenced column on the target (default: target's PK / platform user `sub`). */\n  references: identifier.optional(),\n  /** enforce: true emits a real FK constraint (same-namespace toOne only). */\n  enforce: z.boolean().default(false),\n  description: z.string().max(500).optional(),\n})\nexport type CanonicalLink = z.infer<typeof canonicalLinkSchema>\n\nexport const canonicalIndexSchema = z.object({\n  columns: z.array(identifier).min(1),\n  unique: z.boolean().default(false),\n  name: identifier.optional(),\n})\n\n/**\n * Policy expressions stay DSL SOURCE STRINGS in the canonical form — parsing\n * and claim-key validation happen in both CLI and server via the shared\n * predicate parser. Variants follow §4c permissive-union semantics.\n */\nexport const policyVariantSchema = z.object({\n  /** Claims-only guard (capability()/role()/claim() comparisons — no columns). */\n  when: z.string().min(1).max(1000),\n  /** Exactly one of: allow-all bypass, or a row predicate. */\n  allow: z.literal(true).optional(),\n  policy: z.string().min(1).max(2000).optional(),\n}).refine((v) => (v.allow === true) !== (typeof v.policy === 'string'), {\n  message: 'A variant declares exactly one of allow: true or policy',\n})\n\nexport const policyExpressionSchema = z.union([\n  z.string().min(1).max(2000),\n  z.object({\n    default: z.string().min(1).max(2000),\n    variants: z.array(policyVariantSchema).max(10).default([]),\n  }),\n])\nexport type PolicyExpression = z.infer<typeof policyExpressionSchema>\n\nexport const canonicalPoliciesSchema = z.object({\n  read: policyExpressionSchema.optional(),\n  write: policyExpressionSchema.optional(),\n  insert: policyExpressionSchema.optional(),\n  update: policyExpressionSchema.optional(),\n})\n\n/**\n * View SQL is generated by Drizzle in the authoring process, then crosses the\n * CLI → Atlas JSON boundary. Keep the canonical form to one SELECT statement:\n * PostgreSQL validates the complete grammar when the view is created, while\n * this scanner prevents statement stacking before the text reaches DDL.\n */\nexport function isSingleViewQuerySql(value: string): boolean {\n  const query = value.trim()\n  if (!/^\\(*(?:select|with)\\b/i.test(query) || query.includes('\\0')) return false\n\n  let state: 'normal' | 'single' | 'double' = 'normal'\n  for (let index = 0; index < query.length; index += 1) {\n    const char = query[index]\n    const next = query[index + 1]\n    if (state === 'single') {\n      if (char === \"'\" && next === \"'\") index += 1\n      else if (char === \"'\") state = 'normal'\n      continue\n    }\n    if (state === 'double') {\n      if (char === '\"' && next === '\"') index += 1\n      else if (char === '\"') state = 'normal'\n      continue\n    }\n    if (char === \"'\") state = 'single'\n    else if (char === '\"') state = 'double'\n    else if (char === ';' || (char === '-' && next === '-') || (char === '/' && next === '*')) return false\n  }\n  return state === 'normal' && !/\\$[a-z_0-9]*\\$/i.test(query)\n}\n\n/**\n * Managed views execute as the shared ORM relation owner. Treat function use\n * as a capability boundary: a new function is unavailable until it is\n * deliberately reviewed here as side-effect-free. The migration engine checks\n * the functions PostgreSQL actually resolved against this list and pg_catalog,\n * so qualification and same-named functions in a consumer schema cannot evade\n * the boundary.\n */\nexport const VIEW_QUERY_FUNCTION_ALLOWLIST = [\n  'abs',\n  'age',\n  'array_agg',\n  'array_append',\n  'array_cat',\n  'array_dims',\n  'array_length',\n  'array_lower',\n  'array_ndims',\n  'array_position',\n  'array_positions',\n  'array_prepend',\n  'array_remove',\n  'array_replace',\n  'array_to_string',\n  'array_trim',\n  'array_upper',\n  'ascii',\n  'avg',\n  'bit_and',\n  'bit_or',\n  'bit_xor',\n  'bool_and',\n  'bool_or',\n  'btrim',\n  'cardinality',\n  'cbrt',\n  'ceil',\n  'ceiling',\n  'char_length',\n  'character_length',\n  'chr',\n  'concat',\n  'concat_ws',\n  'count',\n  'cume_dist',\n  'date_bin',\n  'date_part',\n  'date_trunc',\n  'decode',\n  'degrees',\n  'dense_rank',\n  'encode',\n  'enum_first',\n  'enum_last',\n  'enum_range',\n  'every',\n  'exp',\n  'first_value',\n  'floor',\n  'format',\n  'grouping',\n  'initcap',\n  'json_agg',\n  'json_array_length',\n  'json_build_array',\n  'json_build_object',\n  'json_extract_path',\n  'json_extract_path_text',\n  'json_object_agg',\n  'json_object_keys',\n  'json_strip_nulls',\n  'json_typeof',\n  'jsonb_agg',\n  'jsonb_array_length',\n  'jsonb_build_array',\n  'jsonb_build_object',\n  'jsonb_extract_path',\n  'jsonb_extract_path_text',\n  'jsonb_insert',\n  'jsonb_object_agg',\n  'jsonb_object_keys',\n  'jsonb_path_exists',\n  'jsonb_path_match',\n  'jsonb_path_query',\n  'jsonb_path_query_array',\n  'jsonb_path_query_first',\n  'jsonb_pretty',\n  'jsonb_set',\n  'jsonb_set_lax',\n  'jsonb_strip_nulls',\n  'jsonb_typeof',\n  'justify_days',\n  'justify_hours',\n  'justify_interval',\n  'lag',\n  'last_value',\n  'lead',\n  'left',\n  'length',\n  'ln',\n  'log',\n  'lower',\n  'lpad',\n  'ltrim',\n  'make_date',\n  'make_interval',\n  'make_time',\n  'make_timestamp',\n  'make_timestamptz',\n  'max',\n  'md5',\n  'min',\n  'mod',\n  'nth_value',\n  'ntile',\n  'octet_length',\n  'percent_rank',\n  'pi',\n  'power',\n  'quote_ident',\n  'quote_literal',\n  'quote_nullable',\n  'radians',\n  'rank',\n  'regexp_count',\n  'regexp_instr',\n  'regexp_like',\n  'regexp_match',\n  'regexp_matches',\n  'regexp_replace',\n  'regexp_split_to_array',\n  'regexp_split_to_table',\n  'repeat',\n  'replace',\n  'reverse',\n  'right',\n  'round',\n  'row_number',\n  'rpad',\n  'rtrim',\n  'sign',\n  'split_part',\n  'sqrt',\n  'starts_with',\n  'string_agg',\n  'string_to_array',\n  'strpos',\n  'substr',\n  'substring',\n  'sum',\n  'timezone',\n  'to_ascii',\n  'to_char',\n  'to_date',\n  'to_hex',\n  'to_json',\n  'to_jsonb',\n  'to_number',\n  'to_timestamp',\n  'translate',\n  'trunc',\n  'unnest',\n  'upper',\n  'width_bucket',\n] as const\n\n/** Actions carry over from v1 as compiled named-SQL ops (plan: resolved OQ-1). */\nexport const canonicalActionSchema = z.object({\n  name: identifier,\n  requires: z.string().max(1000).optional(),\n  params: z.record(z.string(), z.object({\n    type: columnTypeSchema,\n    nullable: z.boolean().default(false),\n  })).default({}),\n  executes: z.string().min(1).max(10_000),\n  returns: z.enum(['rows', 'rowsAffected', 'scalar']).default('rowsAffected'),\n  audit: z.object({ action: z.string(), resource: z.string() }).optional(),\n})\n\n/**\n * Copy-on-write mutations for overlay tables backed by a synced twin\n * (v2-only). Structured metadata, never authored SQL: the compiler and data\n * plane generate the INSERT…SELECT / UPDATE / DELETE statements from it, so\n * there is no SQL surface to validate and write policies inject like any\n * other mutation. `override` copies the synced row into the overlay\n * (ON CONFLICT DO NOTHING) then updates the `set` columns; `revert` deletes\n * the overlay row so the coalesce view falls back to synced.\n */\nexport const canonicalCowMutationSchema = z.object({\n  kind: z.enum(['override', 'revert']),\n  name: identifier,\n  /** Synced table (same namespace) the overlay copies from / falls back to. */\n  synced: identifier,\n  /** Single-column primary key PROPERTY (TS camelCase, like column `name`) shared by overlay and synced. */\n  pk: z.string().min(1).max(63),\n  /** Override: contract properties copied INSERT…SELECT from synced (pk included). Empty for revert. */\n  copy: z.array(z.string().min(1).max(63)).default([]),\n  /** Override: overlay properties written by the UPDATE (never the pk). Empty for revert. */\n  set: z.array(z.string().min(1).max(63)).default([]),\n}).superRefine((mutation, ctx) => {\n  if (mutation.kind === 'override') {\n    if (mutation.set.length === 0) {\n      ctx.addIssue({ code: 'custom', path: ['set'], message: 'override mutations must set at least one column' })\n    }\n    if (!mutation.copy.includes(mutation.pk)) {\n      ctx.addIssue({ code: 'custom', path: ['copy'], message: 'override copy list must include the pk' })\n    }\n  } else if (mutation.set.length > 0 || mutation.copy.length > 0) {\n    ctx.addIssue({ code: 'custom', path: ['set'], message: 'revert mutations take no copy/set columns' })\n  }\n  if (mutation.set.includes(mutation.pk)) {\n    ctx.addIssue({ code: 'custom', path: ['set'], message: 'set must not include the pk — identity columns are pinned' })\n  }\n  // Duplicates would reach the executor as a doubled INSERT column or SET\n  // assignment — reject at the schema like the authoring helper does.\n  for (const [field, values] of [['copy', mutation.copy], ['set', mutation.set]] as const) {\n    if (new Set(values).size !== values.length) {\n      ctx.addIssue({ code: 'custom', path: [field], message: `${field} must not contain duplicate columns` })\n    }\n  }\n})\nexport type CanonicalCowMutation = z.infer<typeof canonicalCowMutationSchema>\n\nexport const canonicalTableSchema = z.object({\n  table: identifier,\n  description: z.string().max(2000).optional(),\n  /** Table-level rename hint (new in v2). */\n  renamedFrom: identifier.optional(),\n  /** Synced/reflected read-only tables (`source: gold.*`) — v1 semantics. */\n  source: z.string().regex(/^gold\\.[a-z][a-z0-9_]*$/).optional(),\n  columns: z.array(canonicalColumnSchema).default([]),\n  primaryKey: z.array(identifier).min(1).max(8).optional(),\n  links: z.array(canonicalLinkSchema).default([]),\n  indexes: z.array(canonicalIndexSchema).default([]),\n  policies: canonicalPoliciesSchema.default({}),\n  /**\n   * v1-conversion carry-over only. v2 has no action surface — the runtime\n   * neither compiles nor executes these; writes are mutations. Kept parseable\n   * so stored definitions and their content hashes stay stable.\n   */\n  actions: z.array(canonicalActionSchema).default([]),\n  /** Optional (not defaulted) so pre-CoW canonical documents keep byte-identical hashes. */\n  cowMutations: z.array(canonicalCowMutationSchema).optional(),\n})\nexport type CanonicalTable = z.infer<typeof canonicalTableSchema>\n\nexport const canonicalViewSchema = z.object({\n  view: identifier,\n  description: z.string().max(2000).optional(),\n  columns: z.array(canonicalColumnSchema).min(1),\n  /** Logical identity for GraphQL only; PostgreSQL views have no PK constraint. */\n  primaryKey: z.array(identifier).min(1).max(8).optional(),\n  links: z.array(canonicalLinkSchema).default([]),\n  policies: z.object({ read: policyExpressionSchema }).strict(),\n  query: z.string().min(1).max(100_000).refine(isSingleViewQuerySql, {\n    message: 'view query must be one SELECT/WITH statement without comments or dollar-quoted bodies',\n  }),\n  /** Namespace-local logical relation names, sorted for deterministic hashing. */\n  dependencies: z.array(identifier).max(500),\n}).superRefine((view, ctx) => {\n  for (const [index, column] of view.columns.entries()) {\n    if (column.default !== undefined || column.defaultFn !== undefined) {\n      ctx.addIssue({ code: 'custom', path: ['columns', index], message: `view column '${column.name}' cannot declare a default` })\n    }\n    if (column.unique) {\n      ctx.addIssue({ code: 'custom', path: ['columns', index], message: `view column '${column.name}' cannot declare unique` })\n    }\n    if (column.renamedFrom !== undefined || column.cast !== undefined) {\n      ctx.addIssue({ code: 'custom', path: ['columns', index], message: `view column '${column.name}' cannot declare migration hints` })\n    }\n  }\n  for (const [index, link] of view.links.entries()) {\n    if (link.enforce) {\n      ctx.addIssue({ code: 'custom', path: ['links', index, 'enforce'], message: `view link '${link.name}' cannot enforce a foreign key` })\n    }\n  }\n})\nexport type CanonicalView = z.infer<typeof canonicalViewSchema>\n\nexport const canonicalDefinitionSchema = z.object({\n  definition_format: z.literal(CANONICAL_FORMAT),\n  namespace: identifier.max(41),\n  description: z.string().max(2000).optional(),\n  enums: z.array(canonicalEnumSchema).default([]),\n  tables: z.array(canonicalTableSchema).min(0).max(500),\n  /** Optional to preserve byte-identical hashes for pre-view canonical v2 documents. */\n  views: z.array(canonicalViewSchema).max(500).optional(),\n  /** Verbatim custom-roles grammar (@sequenceholdings/custom-roles-manifest). */\n  capabilities: z.object({\n    roles: z.unknown().optional(),\n    uses: z.array(z.string()).default([]),\n  }).default({ uses: [] }),\n}).superRefine((definition, ctx) => {\n  const seen = new Set<string>()\n  for (const [index, table] of definition.tables.entries()) {\n    if (seen.has(table.table)) {\n      ctx.addIssue({ code: 'custom', path: ['tables', index, 'table'], message: `duplicate relation '${table.table}'` })\n    }\n    seen.add(table.table)\n  }\n\n  // CoW mutations: overlay must be an owned table; synced twin must be a\n  // synced table in this namespace; copy/set columns must exist on both sides.\n  const tableByName = new Map(definition.tables.map((table) => [table.table, table]))\n  for (const [tableIndex, table] of definition.tables.entries()) {\n    const cowMutations = table.cowMutations ?? []\n    if (cowMutations.length === 0) continue\n    const path = (index: number, ...rest: Array<string | number>): Array<string | number> =>\n      ['tables', tableIndex, 'cowMutations', index, ...rest]\n    if (table.source !== undefined) {\n      ctx.addIssue({ code: 'custom', path: path(0), message: `synced table '${table.table}' cannot declare cow mutations — it is read-only` })\n      continue\n    }\n    for (const [index, mutation] of cowMutations.entries()) {\n      const synced = tableByName.get(mutation.synced)\n      if (!synced || synced.source === undefined) {\n        ctx.addIssue({\n          code: 'custom',\n          path: path(index, 'synced'),\n          message: `cow mutation '${mutation.name}' references '${mutation.synced}', which is not a synced table in this namespace`,\n        })\n        continue\n      }\n      // The full helper invariants, mirrored so hand-written canonical cannot\n      // bypass them (the generated conflict/copy SQL depends on every one):\n      // single-column PK identity on both sides, matching scalar types AND\n      // Postgres column names for every copied column, and no nullable-synced\n      // → NOT-NULL-overlay traps.\n      const overlayColumnsByName = new Map(table.columns.map((column) => [column.name, column]))\n      const syncedColumnsByName = new Map(synced.columns.map((column) => [column.name, column]))\n      let columnsExist = true\n      for (const property of [mutation.pk, ...mutation.copy, ...mutation.set]) {\n        if (!overlayColumnsByName.has(property)) {\n          columnsExist = false\n          ctx.addIssue({ code: 'custom', path: path(index), message: `cow mutation '${mutation.name}': column '${property}' does not exist on overlay '${table.table}'` })\n        }\n      }\n      for (const property of [mutation.pk, ...mutation.copy]) {\n        if (!syncedColumnsByName.has(property)) {\n          columnsExist = false\n          ctx.addIssue({ code: 'custom', path: path(index), message: `cow mutation '${mutation.name}': column '${property}' does not exist on synced '${mutation.synced}'` })\n        }\n      }\n      if (!columnsExist) continue\n\n      const overlayPk = table.primaryKey ?? []\n      const syncedPk = synced.primaryKey ?? []\n      if (overlayPk.length !== 1 || overlayPk[0] !== mutation.pk || syncedPk.length !== 1 || syncedPk[0] !== mutation.pk) {\n        ctx.addIssue({\n          code: 'custom',\n          path: path(index, 'pk'),\n          message: `cow mutation '${mutation.name}': pk '${mutation.pk}' must be the single-column primary key on both '${table.table}' and '${mutation.synced}'`,\n        })\n      }\n      for (const property of [mutation.pk, ...mutation.copy]) {\n        const overlayColumn = overlayColumnsByName.get(property)\n        const syncedColumn = syncedColumnsByName.get(property)\n        if (!overlayColumn || !syncedColumn) continue\n        if (JSON.stringify(overlayColumn.type) !== JSON.stringify(syncedColumn.type)) {\n          ctx.addIssue({\n            code: 'custom',\n            path: path(index),\n            message: `cow mutation '${mutation.name}': column '${property}' must have the same type on overlay and synced`,\n          })\n        }\n        if (overlayColumn.columnName !== syncedColumn.columnName) {\n          ctx.addIssue({\n            code: 'custom',\n            path: path(index),\n            message: `cow mutation '${mutation.name}': column '${property}' maps to different Postgres names on overlay ('${overlayColumn.columnName}') and synced ('${syncedColumn.columnName}')`,\n          })\n        }\n        if (syncedColumn.nullable !== false && overlayColumn.nullable === false) {\n          ctx.addIssue({\n            code: 'custom',\n            path: path(index),\n            message: `cow mutation '${mutation.name}': column '${property}' is nullable on synced but NOT NULL on overlay — a NULL synced value would fail the copy`,\n          })\n        }\n      }\n    }\n  }\n  for (const [index, view] of (definition.views ?? []).entries()) {\n    if (seen.has(view.view)) {\n      ctx.addIssue({ code: 'custom', path: ['views', index, 'view'], message: `duplicate relation '${view.view}'` })\n    }\n    seen.add(view.view)\n  }\n\n  const views = definition.views ?? []\n  const viewByName = new Map(views.map((view) => [view.view, view]))\n  for (const [viewIndex, view] of views.entries()) {\n    for (const [dependencyIndex, dependency] of view.dependencies.entries()) {\n      if (!seen.has(dependency)) {\n        ctx.addIssue({\n          code: 'custom',\n          path: ['views', viewIndex, 'dependencies', dependencyIndex],\n          message: `view '${view.view}' depends on unknown relation '${dependency}'`,\n        })\n      }\n    }\n  }\n\n  const visiting = new Set<string>()\n  const visited = new Set<string>()\n  let cycleReported = false\n  const visit = (name: string, path: string[]): void => {\n    if (visited.has(name) || cycleReported) return\n    if (visiting.has(name)) {\n      cycleReported = true\n      ctx.addIssue({\n        code: 'custom',\n        path: ['views'],\n        message: `view dependencies form a cycle: ${[...path, name].join(' -> ')}`,\n      })\n      return\n    }\n    visiting.add(name)\n    const view = viewByName.get(name)\n    for (const dependency of view?.dependencies ?? []) {\n      if (viewByName.has(dependency)) visit(dependency, [...path, name])\n    }\n    visiting.delete(name)\n    visited.add(name)\n  }\n  for (const view of views) visit(view.view, [])\n})\nexport type CanonicalDefinition = z.infer<typeof canonicalDefinitionSchema>\n\n/**\n * Project namespace-local tables and views onto the shared read/query surface.\n * A view deliberately becomes a CanonicalTable-shaped relation with no write\n * policy, indexes, actions, defaults, or constraints. Keeping this adapter at\n * the canonical boundary makes SDL and compiler behavior identical without\n * pretending views are writable tables in the wire contract.\n */\nexport function canonicalRelations(definition: CanonicalDefinition): CanonicalTable[] {\n  const views = (definition.views ?? []).map<CanonicalTable>((view) => ({\n    table: view.view,\n    ...(view.description !== undefined ? { description: view.description } : {}),\n    columns: view.columns,\n    ...(view.primaryKey !== undefined ? { primaryKey: view.primaryKey } : {}),\n    links: view.links,\n    indexes: [],\n    policies: { read: view.policies.read },\n    actions: [],\n  }))\n  return [...definition.tables, ...views].sort((a, b) => a.table.localeCompare(b.table))\n}\n\n/**\n * Deterministic serialization discipline: tables sorted by name, columns in\n * declaration order (order is meaningful for DDL), links/indexes/actions\n * sorted by name, object keys emitted in schema order. `serializeNamespace`\n * (authoring layer) and the server-side re-validation both normalize through\n * this function before hashing so CLI and server hash identical bytes.\n */\nexport function normalizeCanonical(definition: CanonicalDefinition): CanonicalDefinition {\n  const sortByName = <T extends { name: string }>(items: T[]): T[] =>\n    [...items].sort((a, b) => a.name.localeCompare(b.name))\n  const normalized: CanonicalDefinition = {\n    ...definition,\n    enums: sortByName(definition.enums),\n    tables: [...definition.tables]\n      .sort((a, b) => a.table.localeCompare(b.table))\n      .map((t) => {\n        const { cowMutations, ...rest } = t\n        return {\n          ...rest,\n          links: sortByName(t.links),\n          indexes: [...t.indexes].sort((a, b) =>\n            (a.name ?? a.columns.join('_')).localeCompare(b.name ?? b.columns.join('_'))),\n          actions: sortByName(t.actions),\n          // Omitted entirely when absent/empty so pre-CoW documents hash unchanged.\n          ...(cowMutations !== undefined && cowMutations.length > 0 ? { cowMutations: sortByName(cowMutations) } : {}),\n        }\n      }),\n  }\n  if (definition.views !== undefined) {\n    normalized.views = [...definition.views]\n      .sort((a, b) => a.view.localeCompare(b.view))\n      .map((view) => ({\n        ...view,\n        links: sortByName(view.links),\n        dependencies: [...view.dependencies].sort(),\n      }))\n  }\n  return normalized\n}\n","/**\n * Compiled-operation IR — THE frozen contract between the GraphQL compiler\n * (push time, CLI preview + canonical server compile) and the data-plane\n * executor (runtime). The artifact is inert, validated JSON: no generated\n * code ever crosses the registry (plan §4).\n *\n * Design invariants:\n *  - Policies are BAKED IN at compile time: every table-touching node carries\n *    its read policy AND-ed into `where` (or `writePolicy`/`insertCheck` for\n *    mutation targets). Execution needs only (IR, claims, variables).\n *  - §4f dynamic slots: a variable typed with a generated input type\n *    (BoolExp/OrderBy/SelectColumn/InsertInput/SetInput/AppendInput/OnConflict)\n *    marks a dynamic slot. The executor validates the runtime value against\n *    the artifact's per-table whitelist metadata, lowers it to Drizzle, and\n *    ANDs it with the baked policy — the policy is non-negotiable regardless\n *    of what the client sends.\n *  - `capability`/`role` predicate leaves resolve to booleans against the\n *    caller's claims BEFORE execution, pruning dead branches per caller.\n *  - Versioned via `irVersion` + `normalizeIr` (the normalizeSnapshot\n *    pattern): executor upgrades decouple from artifact re-pushes.\n */\nimport { z } from 'zod'\nimport { COLUMN_TYPES, type ColumnType } from '../canonical/v2.js'\n\nexport const IR_VERSION = 1 as const\n\n// ---------------------------------------------------------------------------\n// Values & claims\n// ---------------------------------------------------------------------------\n\n/** The exact claim keys the platform stamps — mirrors claims.ts. */\nexport const CLAIMS_CONTRACT = {\n  sub: 'string',\n  org: 'string?',\n  roles: 'string[]',\n  capabilities: 'string[]',\n} as const\nexport type ClaimKey = 'sub' | 'org'\n\nconst scalarLiteral = z.union([z.string(), z.number(), z.boolean(), z.null()])\n\nexport const valueIrSchema = z.discriminatedUnion('kind', [\n  z.object({ kind: z.literal('literal'), value: z.union([scalarLiteral, z.array(scalarLiteral)]) }),\n  z.object({ kind: z.literal('variable'), name: z.string() }),\n  z.object({ kind: z.literal('claim'), key: z.enum(['sub', 'org']) }),\n])\nexport type ValueIr = z.infer<typeof valueIrSchema>\n\n// ---------------------------------------------------------------------------\n// Predicates\n// ---------------------------------------------------------------------------\n\nexport const CMP_OPS = [\n  'eq', 'neq', 'gt', 'gte', 'lt', 'lte', 'in', 'nin',\n  'like', 'ilike', 'isNull', 'contains', 'hasKey',\n] as const\nexport type CmpOp = (typeof CMP_OPS)[number]\n\nexport type PredIr =\n  | { kind: 'and'; operands: PredIr[] }\n  | { kind: 'or'; operands: PredIr[] }\n  | { kind: 'not'; operand: PredIr }\n  | { kind: 'cmp'; op: CmpOp; column: string; value: ValueIr }\n  /** EXISTS through a declared link; `where` runs against the target table. */\n  | { kind: 'exists'; link: string; where: PredIr }\n  /** Aggregation predicate (Hasura `rel_aggregate: { count: { predicate } }`). */\n  | { kind: 'aggPredicate'; link: string; fn: 'count'; op: Exclude<CmpOp, 'in' | 'nin' | 'like' | 'ilike' | 'isNull' | 'contains' | 'hasKey'>; value: number; where?: PredIr }\n  /** Boolean claims leaves — pre-resolved against claims before execution. */\n  | { kind: 'capability'; key: string }\n  | { kind: 'role'; key: string }\n  /** §4f: a client-supplied BoolExp variable lands here, validated + lowered at runtime. */\n  | { kind: 'dynamicFilter'; slot: string }\n  | { kind: 'const'; value: boolean }\n\nexport const predIrSchema: z.ZodType<PredIr> = z.lazy(() =>\n  z.discriminatedUnion('kind', [\n    z.object({ kind: z.literal('and'), operands: z.array(predIrSchema).min(1) }),\n    z.object({ kind: z.literal('or'), operands: z.array(predIrSchema).min(1) }),\n    z.object({ kind: z.literal('not'), operand: predIrSchema }),\n    z.object({ kind: z.literal('cmp'), op: z.enum(CMP_OPS), column: z.string(), value: valueIrSchema }),\n    z.object({ kind: z.literal('exists'), link: z.string(), where: predIrSchema }),\n    z.object({\n      kind: z.literal('aggPredicate'), link: z.string(), fn: z.literal('count'),\n      op: z.enum(['eq', 'neq', 'gt', 'gte', 'lt', 'lte']), value: z.number(),\n      where: predIrSchema.optional(),\n    }),\n    z.object({ kind: z.literal('capability'), key: z.string() }),\n    z.object({ kind: z.literal('role'), key: z.string() }),\n    z.object({ kind: z.literal('dynamicFilter'), slot: z.string() }),\n    z.object({ kind: z.literal('const'), value: z.boolean() }),\n  ]),\n) as z.ZodType<PredIr>\n\n// ---------------------------------------------------------------------------\n// Ordering / paging\n// ---------------------------------------------------------------------------\n\nexport const orderIrSchema = z.discriminatedUnion('kind', [\n  z.object({\n    kind: z.literal('column'),\n    column: z.string(),\n    /** Order through a to-one link: `link` is set and `column` is on the target. */\n    link: z.string().optional(),\n    direction: z.enum(['asc', 'desc']),\n    nulls: z.enum(['first', 'last']).optional(),\n  }),\n  /** §4f: `$orderBy: [FooOrderBy!]` variable — validated + lowered at runtime. */\n  z.object({ kind: z.literal('dynamic'), slot: z.string() }),\n])\nexport type OrderIr = z.infer<typeof orderIrSchema>\n\nexport const limitIrSchema = z.object({\n  /** Fixed value or a variable, clamped to [1, max]; absent → default. */\n  variable: z.string().optional(),\n  value: z.number().int().positive().optional(),\n  default: z.number().int().positive(),\n  max: z.number().int().positive(),\n})\nexport type LimitIr = z.infer<typeof limitIrSchema>\n\n// ---------------------------------------------------------------------------\n// Selections\n// ---------------------------------------------------------------------------\n\nexport interface SelectionIr {\n  /** GraphQL type name for __typename synthesis + Apollo normalization. */\n  typename: string\n  columns: Array<{ alias: string; column: string }>\n  relations: Array<{\n    alias: string\n    link: string\n    selection: SelectionIr\n    /** Fixed shape from the document; policy for the target table is ALSO\n     *  injected by the compiler into this `where` — never trust it absent. */\n    where?: PredIr\n    orderBy?: OrderIr[]\n    limit?: LimitIr\n    offset?: { variable?: string; value?: number }\n  }>\n  aggregates: Array<{\n    alias: string\n    /** Absent link = same-table aggregate (used by aggregate roots). */\n    link?: string\n    where?: PredIr\n    count?: { columns?: string[]; distinct?: boolean }\n    sum?: string[]\n    avg?: string[]\n    /** `nodes { }` selection inside an aggregate block. */\n    nodes?: SelectionIr\n  }>\n}\n\nconst selectionIrSchema: z.ZodType<SelectionIr> = z.lazy(() =>\n  z.object({\n    typename: z.string(),\n    columns: z.array(z.object({ alias: z.string(), column: z.string() })),\n    relations: z.array(z.object({\n      alias: z.string(),\n      link: z.string(),\n      selection: selectionIrSchema,\n      where: predIrSchema.optional(),\n      orderBy: z.array(orderIrSchema).optional(),\n      limit: limitIrSchema.optional(),\n      offset: z.object({ variable: z.string().optional(), value: z.number().int().optional() }).optional(),\n    })),\n    aggregates: z.array(z.object({\n      alias: z.string(),\n      link: z.string().optional(),\n      where: predIrSchema.optional(),\n      count: z.object({ columns: z.array(z.string()).optional(), distinct: z.boolean().optional() }).optional(),\n      sum: z.array(z.string()).optional(),\n      avg: z.array(z.string()).optional(),\n      nodes: selectionIrSchema.optional(),\n    })),\n  }),\n) as z.ZodType<SelectionIr>\n\nexport { selectionIrSchema }\n\n// ---------------------------------------------------------------------------\n// Roots\n// ---------------------------------------------------------------------------\n\n/** `@include(if: $var)` / `@skip(if: $var)` on a root field. */\nconst includeIfSchema = z.object({ variable: z.string(), negated: z.boolean() })\n\nconst selectRootSchema = z.object({\n  kind: z.literal('select'),\n  alias: z.string(),\n  table: z.string(),\n  selection: selectionIrSchema,\n  /** Composed at compile time: AND(policy, documentWhere?, dynamicFilter?). */\n  where: predIrSchema,\n  orderBy: z.array(orderIrSchema).default([]),\n  distinctOn: z.union([z.array(z.string()), z.object({ slot: z.string() })]).optional(),\n  limit: limitIrSchema,\n  offset: z.object({ variable: z.string().optional(), value: z.number().int().optional() }).optional(),\n  includeIf: includeIfSchema.optional(),\n})\n\nconst byPkRootSchema = z.object({\n  kind: z.literal('byPk'),\n  alias: z.string(),\n  table: z.string(),\n  selection: selectionIrSchema,\n  pk: z.array(z.object({ column: z.string(), value: valueIrSchema })).min(1),\n  /** Policy predicate — ANDed with the PK match. */\n  where: predIrSchema,\n  includeIf: includeIfSchema.optional(),\n})\n\nconst aggregateRootSchema = z.object({\n  kind: z.literal('aggregate'),\n  alias: z.string(),\n  table: z.string(),\n  where: predIrSchema,\n  count: z.object({ columns: z.array(z.string()).optional(), distinct: z.boolean().optional() }).optional(),\n  sum: z.array(z.string()).optional(),\n  avg: z.array(z.string()).optional(),\n  nodes: selectionIrSchema.optional(),\n  includeIf: includeIfSchema.optional(),\n})\n\n/** Column → value map for _set/_append/_inc, or a §4f whole-input slot. */\nconst writeValuesSchema = z.union([\n  z.object({ slot: z.string() }),\n  z.object({ entries: z.array(z.object({ column: z.string(), value: valueIrSchema })) }),\n])\n\nconst onConflictIrSchema = z.union([\n  z.object({ slot: z.string() }),\n  z.object({ constraint: z.string(), updateColumns: z.array(z.string()) }),\n])\n\nconst mutationRootSchema = z.object({\n  kind: z.literal('mutation'),\n  /**\n   * CRUD verbs plus the structured copy-on-write ops. `cowOverride` copies the\n   * synced row into the overlay (INSERT…SELECT, ON CONFLICT DO NOTHING) then\n   * applies `set` — both statements generated by the executor from this\n   * metadata, never authored SQL. `cowRevert` deletes the override so the\n   * coalesce view falls back to synced. Both are gated on a matching synced\n   * row and carry the write policy in `where` like update/delete.\n   */\n  op: z.enum(['insert', 'insertOne', 'update', 'updateByPk', 'delete', 'deleteByPk', 'cowOverride', 'cowRevert']),\n  alias: z.string(),\n  table: z.string(),\n  /** CoW ops: logical name of the synced twin (read through its policy-filtered view). */\n  cowSynced: z.string().optional(),\n  /** cowOverride: logical properties copied INSERT…SELECT from synced (pk included). */\n  cowCopyColumns: z.array(z.string()).optional(),\n  /** cowOverride: insert-policy WITH CHECK evaluated over the copied rows. */\n  cowCopyCheck: predIrSchema.optional(),\n  /** insert/insertOne: rows come from a slot ($object/$objects) or literals. */\n  objects: z.union([\n    z.object({ slot: z.string() }),\n    z.object({ rows: z.array(z.array(z.object({ column: z.string(), value: valueIrSchema }))) }),\n  ]).optional(),\n  /** Server-pinned columns (e.g. author_sub ← claim('sub')) merged into every inserted row. */\n  pinnedColumns: z.array(z.object({ column: z.string(), value: valueIrSchema })).default([]),\n  onConflict: onConflictIrSchema.optional(),\n  set: writeValuesSchema.optional(),\n  append: writeValuesSchema.optional(),\n  inc: writeValuesSchema.optional(),\n  /** update/delete row filter: AND(writePolicy, documentWhere/pk, dynamicFilter?). */\n  where: predIrSchema.optional(),\n  pk: z.array(z.object({ column: z.string(), value: valueIrSchema })).optional(),\n  /** WITH CHECK analogue evaluated against NEW row values (insert/update). */\n  insertCheck: predIrSchema.optional(),\n  returning: selectionIrSchema.nullable(),\n  affectedRows: z.boolean().default(false),\n  includeIf: includeIfSchema.optional(),\n})\n\n// v2 has no action root kind — writes are mutations (CRUD or structured CoW\n// ops above). The former `kind: 'action'` scaffolding was removed before any\n// action operation was ever compiled into a registry artifact.\nexport const rootIrSchema = z.discriminatedUnion('kind', [\n  selectRootSchema, byPkRootSchema, aggregateRootSchema, mutationRootSchema,\n])\nexport type RootIr = z.infer<typeof rootIrSchema>\n\n// ---------------------------------------------------------------------------\n// Variables (§4f dynamic slots) & operations\n// ---------------------------------------------------------------------------\n\nexport const INPUT_REF_KINDS = [\n  'boolExp', 'orderBy', 'selectColumn', 'insertInput', 'setInput', 'appendInput', 'onConflict',\n] as const\nexport type InputRefKind = (typeof INPUT_REF_KINDS)[number]\n\n/**\n * A declared GraphQL variable default, persisted verbatim so an omitted\n * variable resolves to it instead of silently becoming NULL. Wrapped in an\n * object so an explicit `= null` stays distinguishable from \"no default\".\n * Only shapes `ValueIr` can carry are representable — the restrict pass\n * rejects anything else (including §4f slot defaults) at compile time.\n */\nexport const variableDefaultIrSchema = z.object({\n  value: z.union([scalarLiteral, z.array(scalarLiteral)]),\n})\nexport type VariableDefaultIr = z.infer<typeof variableDefaultIrSchema>\n\nexport const variableIrSchema = z.object({\n  name: z.string(),\n  type: z.union([\n    z.object({ kind: z.literal('scalar'), scalar: z.enum(COLUMN_TYPES) }),\n    /** `values` is the declared membership whitelist — the executor validates against it. */\n    z.object({ kind: z.literal('enum'), name: z.string(), values: z.array(z.string()).min(1) }),\n    /** §4f dynamic slot: validated against `tables[table]` whitelists at runtime. */\n    z.object({ kind: z.literal('inputRef'), input: z.enum(INPUT_REF_KINDS), table: z.string() }),\n  ]),\n  nullable: z.boolean(),\n  list: z.boolean(),\n  /** Absent = no default declared; see {@link variableDefaultIrSchema}. */\n  defaultValue: variableDefaultIrSchema.optional(),\n})\nexport type VariableIr = z.infer<typeof variableIrSchema>\n\nexport const compiledOperationSchema = z.object({\n  irVersion: z.literal(IR_VERSION),\n  name: z.string(),\n  opHash: z.string().regex(/^sha256:[0-9a-f]{64}$/),\n  kind: z.enum(['query', 'mutation']),\n  requires: z.object({\n    capability: z.string().optional(),\n    role: z.string().optional(),\n  }).nullable(),\n  variables: z.array(variableIrSchema),\n  /** Every table the op touches — data-token scoping + audit. */\n  tableSet: z.array(z.string()).min(1),\n  roots: z.array(rootIrSchema).min(1),\n})\nexport type CompiledOperation = z.infer<typeof compiledOperationSchema>\n\n// ---------------------------------------------------------------------------\n// Artifact: per-table runtime metadata + the operation set\n// ---------------------------------------------------------------------------\n\n/**\n * Runtime whitelist metadata per table — everything the executor needs to\n * build Drizzle table objects, validate §4f dynamic inputs, and lower them.\n * Derived from the canonical definition at compile time.\n */\nexport const tableMetaIrSchema = z.object({\n  table: z.string(),\n  schema: z.string(),\n  typename: z.string(),\n  /**\n   * True when statements over this relation evaluate a claims-gated synced\n   * view: synced twins (`source: gold.*`) materialize as views whose baked\n   * policy reads `current_setting('request.jwt.claims')`, and namespace views\n   * inherit the gate transitively through their declared dependencies. The\n   * executor must stamp that GUC (transaction-scoped) before any statement\n   * touching such a relation, or the synced arm yields zero rows regardless\n   * of the compiled predicates.\n   */\n  claimsGated: z.boolean().default(false),\n  columns: z.array(z.object({\n    name: z.string(),\n    columnName: z.string(),\n    type: z.union([z.enum(COLUMN_TYPES), z.object({ enum: z.string(), values: z.array(z.string()) })]),\n    nullable: z.boolean(),\n  })),\n  /** Empty for keyless read-only views; keyed tables and views list logical columns. */\n  primaryKey: z.array(z.string()),\n  links: z.array(z.object({\n    name: z.string(),\n    kind: z.enum(['toOne', 'toMany', 'toPlatformUser']),\n    target: z.string(),\n    on: z.string(),\n    references: z.string(),\n  })),\n  /** §4f whitelists: what dynamic inputs may reference. */\n  filterable: z.array(z.string()),\n  orderable: z.array(z.string()),\n  insertable: z.array(z.string()),\n  settable: z.array(z.string()),\n  appendable: z.array(z.string()),\n  constraints: z.array(z.object({ name: z.string(), columns: z.array(z.string()) })),\n  /** Depth/node caps for dynamic filter trees on this table. */\n  dynamicFilterMaxDepth: z.number().int().positive().default(6),\n  dynamicFilterMaxNodes: z.number().int().positive().default(64),\n})\nexport type TableMetaIr = z.infer<typeof tableMetaIrSchema>\n\nexport const compiledArtifactSchema = z.object({\n  irVersion: z.literal(IR_VERSION),\n  namespace: z.string(),\n  schemaHash: z.string(),\n  opsHash: z.string(),\n  tables: z.record(z.string(), tableMetaIrSchema),\n  operations: z.record(z.string(), compiledOperationSchema),\n})\nexport type CompiledArtifact = z.infer<typeof compiledArtifactSchema>\n\n// ---------------------------------------------------------------------------\n// Versioning shim\n// ---------------------------------------------------------------------------\n\nexport class IrVersionError extends Error {\n  constructor(found: unknown) {\n    super(`Unsupported IR version ${String(found)} — this executor supports up to ${IR_VERSION}. ` +\n      'Upgrade @sequenceholdings/orm or re-push the namespace.')\n    this.name = 'IrVersionError'\n  }\n}\n\n/**\n * Validate + normalize a raw registry artifact (the normalizeSnapshot\n * pattern): future IR versions add upgrade branches here so executor\n * upgrades decouple from artifact re-pushes. Never trust registry jsonb —\n * the data plane calls this on every artifact load.\n */\nexport function normalizeIr(raw: unknown): CompiledArtifact {\n  if (!raw || typeof raw !== 'object') throw new IrVersionError(undefined)\n  const version = (raw as { irVersion?: unknown }).irVersion\n  if (version !== IR_VERSION) throw new IrVersionError(version)\n  return compiledArtifactSchema.parse(raw)\n}\n\n/** Index an artifact's operations by opHash (the wire selector). */\nexport function indexByHash(artifact: CompiledArtifact): Map<string, CompiledOperation> {\n  const map = new Map<string, CompiledOperation>()\n  for (const op of Object.values(artifact.operations)) map.set(op.opHash, op)\n  return map\n}\n","/**\n * Policy DSL v2 parser — v1 grammar (and/or/not, comparisons, claim(),\n * capability()) extended with role('k'), dotted to-one paths (`a.b.c = …`),\n * and `exists(<link-path>, <pred>)`. Fresh implementation; the v1 parser at\n * ../predicate/parse.ts stays untouched for the YAML path.\n *\n * Claim keys are validated at parse time against CLAIMS_CONTRACT: only the\n * scalar keys (`sub`, `org`) are reachable via claim() — roles/capabilities\n * are arrays and must be tested with role()/capability(). This kills the\n * v1 silent-NULL class (`claim('team')` compiling to nothing).\n */\nimport { CAPABILITY_KEY_PATTERN } from '../constants.js'\nimport { CLAIMS_CONTRACT, type ClaimKey } from '../ir/index.js'\nimport { POLICY_COMPARE_OPS, type ParsedPolicy, type PolicyCompareOp, type PolicyNode, type PolicyOperand } from './ast.js'\nimport { PolicyParseError } from './errors.js'\n\ntype TokenKind = 'identifier' | 'string' | 'number' | 'operator' | 'lparen' | 'rparen' | 'comma' | 'dot' | 'end'\n\ninterface Token {\n  readonly kind: TokenKind\n  readonly value: string\n  readonly position: number\n}\n\nconst KEYWORDS = new Set(['and', 'or', 'not', 'true', 'false', 'null', 'claim', 'capability', 'role', 'exists'])\nconst OPERATOR_PATTERN = /^(!=|<=|>=|<>|=|<|>)/\nconst IDENTIFIER_START = /[a-zA-Z_]/\nconst IDENTIFIER_CHAR = /[a-zA-Z0-9_]/\nconst NUMBER_PATTERN = /^-?\\d+(\\.\\d+)?/\n\n/** claim() reaches only the scalar contract keys; array-valued keys need role()/capability(). */\nconst SCALAR_CLAIM_KEYS = Object.entries(CLAIMS_CONTRACT)\n  .filter(([, type]) => !type.endsWith('[]'))\n  .map(([key]) => key)\nconst ARRAY_CLAIM_KEYS = Object.entries(CLAIMS_CONTRACT)\n  .filter(([, type]) => type.endsWith('[]'))\n  .map(([key]) => key)\n\nfunction tokenize(source: string): Token[] {\n  const tokens: Token[] = []\n  let position = 0\n\n  while (position < source.length) {\n    const char = source[position] as string\n\n    if (/\\s/.test(char)) {\n      position += 1\n      continue\n    }\n    if (char === '(') {\n      tokens.push({ kind: 'lparen', value: char, position })\n      position += 1\n      continue\n    }\n    if (char === ')') {\n      tokens.push({ kind: 'rparen', value: char, position })\n      position += 1\n      continue\n    }\n    if (char === ',') {\n      tokens.push({ kind: 'comma', value: char, position })\n      position += 1\n      continue\n    }\n    if (char === '.') {\n      tokens.push({ kind: 'dot', value: char, position })\n      position += 1\n      continue\n    }\n    if (char === \"'\") {\n      const { value, end } = readString(source, position)\n      tokens.push({ kind: 'string', value, position })\n      position = end\n      continue\n    }\n\n    const operator = OPERATOR_PATTERN.exec(source.slice(position))\n    if (operator) {\n      const value = operator[0] === '<>' ? '!=' : operator[0]\n      tokens.push({ kind: 'operator', value, position })\n      position += operator[0].length\n      continue\n    }\n\n    const number = NUMBER_PATTERN.exec(source.slice(position))\n    if (number && !IDENTIFIER_START.test(char)) {\n      tokens.push({ kind: 'number', value: number[0], position })\n      position += number[0].length\n      continue\n    }\n\n    if (IDENTIFIER_START.test(char)) {\n      let end = position\n      while (end < source.length && IDENTIFIER_CHAR.test(source[end] as string)) end += 1\n      tokens.push({ kind: 'identifier', value: source.slice(position, end), position })\n      position = end\n      continue\n    }\n\n    throw new PolicyParseError(`unexpected character '${char}'`, position)\n  }\n\n  tokens.push({ kind: 'end', value: '', position: source.length })\n  return tokens\n}\n\nfunction readString(source: string, start: number): { value: string; end: number } {\n  let value = ''\n  let position = start + 1\n  while (position < source.length) {\n    const char = source[position] as string\n    if (char !== \"'\") {\n      value += char\n      position += 1\n      continue\n    }\n    if (source[position + 1] === \"'\") {\n      value += \"'\"\n      position += 2\n      continue\n    }\n    return { value, end: position + 1 }\n  }\n  throw new PolicyParseError('unterminated string literal', start)\n}\n\nclass Parser {\n  private index = 0\n\n  constructor(private readonly tokens: Token[]) {}\n\n  parse(): PolicyNode {\n    const node = this.parseOr()\n    this.expect('end', 'end of expression')\n    return node\n  }\n\n  private parseOr(): PolicyNode {\n    const operands = [this.parseAnd()]\n    while (this.matchKeyword('or')) operands.push(this.parseAnd())\n    return operands.length === 1 ? (operands[0] as PolicyNode) : { kind: 'or', operands }\n  }\n\n  private parseAnd(): PolicyNode {\n    const operands = [this.parseNot()]\n    while (this.matchKeyword('and')) operands.push(this.parseNot())\n    return operands.length === 1 ? (operands[0] as PolicyNode) : { kind: 'and', operands }\n  }\n\n  private parseNot(): PolicyNode {\n    if (this.matchKeyword('not')) return { kind: 'not', operand: this.parseNot() }\n    return this.parsePrimary()\n  }\n\n  private parsePrimary(): PolicyNode {\n    if (this.peek().kind === 'lparen') {\n      this.advance()\n      const inner = this.parseOr()\n      this.expect('rparen', \"')'\")\n      return inner\n    }\n    if (this.peekKeyword('capability') || this.peekKeyword('role')) {\n      const fn = this.peek().value as 'capability' | 'role'\n      const node = this.parseBooleanCall(fn)\n      const next = this.peek()\n      if (next.kind === 'operator') {\n        throw new PolicyParseError(`${fn}() is boolean-valued and cannot appear in a comparison`, next.position)\n      }\n      return node\n    }\n    if (this.peekKeyword('exists')) return this.parseExists()\n    return this.parseComparison()\n  }\n\n  private parseBooleanCall(fn: 'capability' | 'role'): PolicyNode {\n    this.advance()\n    const key = this.parseCallArgument(fn)\n    if (!CAPABILITY_KEY_PATTERN.test(key)) {\n      throw new PolicyParseError(`invalid ${fn} key '${key}'`, this.peek().position)\n    }\n    return { kind: fn, key }\n  }\n\n  private parseExists(): PolicyNode {\n    this.advance()\n    this.expect('lparen', \"'(' after exists\")\n    const path = this.parsePath('a link path in exists(...)')\n    this.expect('comma', \"',' between the exists link path and its predicate\")\n    const where = this.parseOr()\n    this.expect('rparen', \"')' closing exists(...)\")\n    return { kind: 'exists', path, where }\n  }\n\n  private parseComparison(): PolicyNode {\n    const left = this.parseOperand()\n    const operator = this.expect('operator', 'a comparison operator')\n    if (!POLICY_COMPARE_OPS.includes(operator.value as PolicyCompareOp)) {\n      throw new PolicyParseError(`unsupported operator '${operator.value}'`, operator.position)\n    }\n    const right = this.parseOperand()\n    return { kind: 'compare', op: operator.value as PolicyCompareOp, left, right }\n  }\n\n  private parseOperand(): PolicyOperand {\n    const token = this.peek()\n\n    if (token.kind === 'string') {\n      this.advance()\n      return { kind: 'literal', value: token.value }\n    }\n    if (token.kind === 'number') {\n      this.advance()\n      const value = Number(token.value)\n      // A bigint-sized literal would silently round through the JS number and\n      // compile a policy against the wrong identifier — reject; quote it.\n      if (!Number.isFinite(value) || (Number.isInteger(value) && !Number.isSafeInteger(value))) {\n        throw new PolicyParseError(\n          `numeric literal '${token.value}' exceeds safe integer precision — quote it as a string`,\n          token.position,\n        )\n      }\n      return { kind: 'literal', value }\n    }\n    if (token.kind !== 'identifier') {\n      throw new PolicyParseError(`expected an operand, got '${token.value || 'end'}'`, token.position)\n    }\n\n    if (token.value === 'true' || token.value === 'false') {\n      this.advance()\n      return { kind: 'literal', value: token.value === 'true' }\n    }\n    if (token.value === 'null') {\n      this.advance()\n      return { kind: 'literal', value: null }\n    }\n    if (token.value === 'claim') {\n      this.advance()\n      const key = this.parseCallArgument('claim')\n      return { kind: 'claim', key: this.validateClaimKey(key, token.position) }\n    }\n    if (token.value === 'capability' || token.value === 'role') {\n      throw new PolicyParseError(`${token.value}() is boolean-valued and cannot appear in a comparison`, token.position)\n    }\n    return { kind: 'path', segments: this.parsePath('a column or link path') }\n  }\n\n  private validateClaimKey(key: string, position: number): ClaimKey {\n    if (SCALAR_CLAIM_KEYS.includes(key)) return key as ClaimKey\n    if (ARRAY_CLAIM_KEYS.includes(key)) {\n      const fn = key === 'roles' ? \"role('…')\" : \"capability('…')\"\n      throw new PolicyParseError(\n        `claim('${key}') is not reachable — '${key}' is an array claim; use ${fn} instead`,\n        position,\n      )\n    }\n    throw new PolicyParseError(\n      `unknown claim key '${key}' — valid claim() keys are: ${SCALAR_CLAIM_KEYS.map((k) => `'${k}'`).join(', ')}`,\n      position,\n    )\n  }\n\n  /** `ident(.ident)*` — first segment must not be a keyword; later segments may be (e.g. `author.role`). */\n  private parsePath(description: string): string[] {\n    const first = this.peek()\n    if (first.kind !== 'identifier' || KEYWORDS.has(first.value)) {\n      throw new PolicyParseError(`expected ${description}, got '${first.value || 'end'}'`, first.position)\n    }\n    this.advance()\n    const segments = [first.value]\n    while (this.peek().kind === 'dot') {\n      this.advance()\n      const segment = this.expect('identifier', 'a path segment after .')\n      segments.push(segment.value)\n    }\n    return segments\n  }\n\n  private parseCallArgument(fn: 'claim' | 'capability' | 'role'): string {\n    this.expect('lparen', `'(' after ${fn}`)\n    const argument = this.expect('string', `a quoted key in ${fn}(...)`)\n    this.expect('rparen', `')' after ${fn} key`)\n    return argument.value\n  }\n\n  private peek(): Token {\n    return this.tokens[this.index] as Token\n  }\n\n  private peekKeyword(keyword: string): boolean {\n    const token = this.peek()\n    return token.kind === 'identifier' && token.value === keyword\n  }\n\n  private matchKeyword(keyword: string): boolean {\n    if (!this.peekKeyword(keyword)) return false\n    this.advance()\n    return true\n  }\n\n  private advance(): Token {\n    const token = this.peek()\n    if (token.kind !== 'end') this.index += 1\n    return token\n  }\n\n  private expect(kind: TokenKind, description: string): Token {\n    const token = this.peek()\n    if (token.kind !== kind) {\n      throw new PolicyParseError(`expected ${description}, got '${token.value || 'end'}'`, token.position)\n    }\n    return this.advance()\n  }\n}\n\nexport function parsePolicy(source: string): ParsedPolicy {\n  const trimmed = source.trim()\n  if (trimmed.length === 0) throw new PolicyParseError('empty policy expression', 0)\n  return { source: trimmed, ast: new Parser(tokenize(trimmed)).parse() }\n}\n","/**\n * Policy DSL v2 → PredIr compiler. Resolves column/link references against a\n * table resolver (TableMetaIr satisfies the shapes structurally), normalizes\n * everything to LOGICAL column names, and enforces the v2.0 representability\n * rules the frozen IR imposes:\n *\n *  - dotted to-one paths (`deal.org = claim('org')`) lower to nested\n *    `exists(link, …)` with the comparison innermost;\n *  - total link-traversal depth (dotted hops + exists nesting) ≤ 3;\n *  - a comparison must reference exactly ONE column side (column↔column and\n *    claims↔literal comparisons have no PredIr shape in v2.0);\n *  - `col = null` / `col != null` normalize to the isNull operator;\n *  - variant `when` guards are claims-only: capability()/role() under\n *    and/or/not. (claim() comparisons in `when` are not representable in the\n *    v2.0 IR — a targeted error says so.)\n */\nimport type { PolicyExpression } from '../canonical/v2.js'\nimport type { ClaimKey, CmpOp, PredIr, ValueIr } from '../ir/index.js'\nimport { walkPolicy, type ParsedPolicy, type PolicyCompareOp, type PolicyNode, type PolicyOperand } from './ast.js'\nimport { PolicyCompileError } from './errors.js'\nimport { parsePolicy } from './parse.js'\n\nexport const POLICY_MAX_LINK_DEPTH = 3\n\nexport interface PolicyColumnInfo {\n  readonly name: string\n  readonly columnName: string\n}\n\nexport interface PolicyLinkInfo {\n  readonly name: string\n  readonly kind: 'toOne' | 'toMany' | 'toPlatformUser'\n  readonly target: string\n}\n\nexport interface PolicyTableInfo {\n  readonly columns: readonly PolicyColumnInfo[]\n  readonly links: readonly PolicyLinkInfo[]\n}\n\n/** `{ tables }` keyed by table name — TableMetaIr's record is assignable. */\nexport interface PolicyResolver {\n  readonly tables: Record<string, PolicyTableInfo>\n}\n\nconst CMP_BY_OP: Readonly<Record<PolicyCompareOp, CmpOp>> = {\n  '=': 'eq',\n  '!=': 'neq',\n  '<': 'lt',\n  '<=': 'lte',\n  '>': 'gt',\n  '>=': 'gte',\n}\n\n/** Operator when the column lands on the left after flipping `literal op column`. */\nconst FLIPPED: Readonly<Record<PolicyCompareOp, PolicyCompareOp>> = {\n  '=': '=',\n  '!=': '!=',\n  '<': '>',\n  '<=': '>=',\n  '>': '<',\n  '>=': '<=',\n}\n\nfunction resolveTable(resolver: PolicyResolver, table: string): PolicyTableInfo {\n  const info = resolver.tables[table]\n  if (!info) {\n    throw new PolicyCompileError(`unknown table '${table}'`, 'unknown-table', Object.keys(resolver.tables))\n  }\n  return info\n}\n\n/** Match by logical name OR Postgres column name; compile to the logical name. */\nfunction resolveColumn(info: PolicyTableInfo, ref: string): string | undefined {\n  const column = info.columns.find((c) => c.name === ref || c.columnName === ref)\n  return column?.name\n}\n\nfunction resolveLink(info: PolicyTableInfo, ref: string): PolicyLinkInfo | undefined {\n  return info.links.find((l) => l.name === ref)\n}\n\nfunction columnCandidates(info: PolicyTableInfo): string[] {\n  return [...info.columns.map((c) => c.name), ...info.links.map((l) => l.name)]\n}\n\ninterface CompileContext {\n  readonly resolver: PolicyResolver\n  readonly maxLinkDepth: number\n}\n\nclass PolicyCompiler {\n  constructor(private readonly ctx: CompileContext) {}\n\n  compile(node: PolicyNode, table: string, depth: number): PredIr {\n    switch (node.kind) {\n      case 'and':\n      case 'or':\n        return { kind: node.kind, operands: node.operands.map((operand) => this.compile(operand, table, depth)) }\n      case 'not':\n        return { kind: 'not', operand: this.compile(node.operand, table, depth) }\n      case 'capability':\n        return { kind: 'capability', key: node.key }\n      case 'role':\n        return { kind: 'role', key: node.key }\n      case 'exists':\n        return this.compileExists(node.path, node.where, table, depth)\n      case 'compare':\n        return this.compileCompare(node, table, depth)\n    }\n  }\n\n  /** Traverse link path segments (any cardinality), then compile the inner predicate against the final target. */\n  private compileExists(path: readonly string[], where: PolicyNode, table: string, depth: number): PredIr {\n    const { links, finalTable } = this.resolveLinkPath(path, table, depth, { toOneOnly: false })\n    let pred = this.compile(where, finalTable, depth + links.length)\n    for (let i = links.length - 1; i >= 0; i -= 1) {\n      pred = { kind: 'exists', link: (links[i] as PolicyLinkInfo).name, where: pred }\n    }\n    return pred\n  }\n\n  private resolveLinkPath(\n    path: readonly string[],\n    table: string,\n    depth: number,\n    { toOneOnly }: { toOneOnly: boolean },\n  ): { links: PolicyLinkInfo[]; finalTable: string } {\n    const links: PolicyLinkInfo[] = []\n    let current = table\n    for (const segment of path) {\n      const info = resolveTable(this.ctx.resolver, current)\n      const link = resolveLink(info, segment)\n      if (!link) {\n        throw new PolicyCompileError(\n          `unknown link '${segment}' on table '${current}'`,\n          'unknown-link',\n          info.links.map((l) => l.name),\n        )\n      }\n      if (toOneOnly && link.kind === 'toMany') {\n        throw new PolicyCompileError(\n          `dotted paths traverse to-one links only — '${segment}' on '${current}' is to-many; use exists(${path.join('.')}, …)`,\n          'not-to-one',\n        )\n      }\n      links.push(link)\n      current = link.target\n      if (depth + links.length > this.ctx.maxLinkDepth) {\n        throw new PolicyCompileError(\n          `link traversal depth exceeds ${this.ctx.maxLinkDepth} (at '${segment}')`,\n          'link-depth-exceeded',\n        )\n      }\n    }\n    return { links, finalTable: current }\n  }\n\n  private compileCompare(\n    node: Extract<PolicyNode, { kind: 'compare' }>,\n    table: string,\n    depth: number,\n  ): PredIr {\n    const leftIsPath = node.left.kind === 'path'\n    const rightIsPath = node.right.kind === 'path'\n    if (leftIsPath && rightIsPath) {\n      throw new PolicyCompileError(\n        'column-to-column comparisons are not supported in v2.0 policies',\n        'unsupported-comparison',\n      )\n    }\n    if (!leftIsPath && !rightIsPath) {\n      throw new PolicyCompileError(\n        'a comparison must reference a column — claims-to-literal comparisons are not representable in v2.0; use capability() or role()',\n        'unsupported-comparison',\n      )\n    }\n\n    const [pathSide, valueSide, op] = leftIsPath\n      ? [node.left as Extract<PolicyOperand, { kind: 'path' }>, node.right, node.op]\n      : [node.right as Extract<PolicyOperand, { kind: 'path' }>, node.left, FLIPPED[node.op]]\n\n    const segments = pathSide.segments\n    const linkSegments = segments.slice(0, -1)\n    const columnRef = segments[segments.length - 1] as string\n    const { links, finalTable } = this.resolveLinkPath(linkSegments, table, depth, { toOneOnly: true })\n\n    const info = resolveTable(this.ctx.resolver, finalTable)\n    const column = resolveColumn(info, columnRef)\n    if (!column) {\n      throw new PolicyCompileError(\n        `unknown column '${columnRef}' on table '${finalTable}'`,\n        'unknown-column',\n        columnCandidates(info),\n      )\n    }\n\n    let cmp: PredIr = this.buildCmp(op, column, valueSide)\n    for (let i = links.length - 1; i >= 0; i -= 1) {\n      cmp = { kind: 'exists', link: (links[i] as PolicyLinkInfo).name, where: cmp }\n    }\n    return cmp\n  }\n\n  private buildCmp(op: PolicyCompareOp, column: string, valueSide: PolicyOperand): PredIr {\n    if (valueSide.kind === 'literal' && valueSide.value === null) {\n      if (op !== '=' && op !== '!=') {\n        throw new PolicyCompileError(\n          `null only supports = and != comparisons, got '${op}'`,\n          'invalid-null-comparison',\n        )\n      }\n      return { kind: 'cmp', op: 'isNull', column, value: { kind: 'literal', value: op === '=' } }\n    }\n    const value: ValueIr =\n      valueSide.kind === 'claim'\n        ? { kind: 'claim', key: valueSide.key }\n        : { kind: 'literal', value: (valueSide as Extract<PolicyOperand, { kind: 'literal' }>).value }\n    return { kind: 'cmp', op: CMP_BY_OP[op], column, value }\n  }\n}\n\nexport interface CompilePredicateInput {\n  /** DSL source text, or an already-parsed policy. */\n  expression: string | ParsedPolicy\n  table: string\n  resolver: PolicyResolver\n  maxLinkDepth?: number\n}\n\nexport function compilePredicateV2({ expression, table, resolver, maxLinkDepth }: CompilePredicateInput): PredIr {\n  const parsed = typeof expression === 'string' ? parsePolicy(expression) : expression\n  const compiler = new PolicyCompiler({ resolver, maxLinkDepth: maxLinkDepth ?? POLICY_MAX_LINK_DEPTH })\n  return compiler.compile(parsed.ast, table, 0)\n}\n\n/** Variant `when` guards may only test claims: capability()/role() under and/or/not. */\nexport function assertClaimsOnlyWhen(parsed: ParsedPolicy): void {\n  walkPolicy(parsed.ast, (node) => {\n    if (node.kind === 'compare') {\n      const columnRef = [node.left, node.right].find((operand) => operand.kind === 'path')\n      if (columnRef) {\n        throw new PolicyCompileError(\n          `variant 'when' guards are claims-only — column reference '${(columnRef as Extract<PolicyOperand, { kind: 'path' }>).segments.join('.')}' is not allowed`,\n          'when-not-claims-only',\n        )\n      }\n      throw new PolicyCompileError(\n        \"variant 'when' guards support capability() and role() checks only in v2.0\",\n        'when-not-claims-only',\n      )\n    }\n    if (node.kind === 'exists') {\n      throw new PolicyCompileError(\n        \"variant 'when' guards are claims-only — exists() is not allowed\",\n        'when-not-claims-only',\n      )\n    }\n  })\n}\n\nexport interface CompilePolicyInput {\n  expression: PolicyExpression\n  table: string\n  resolver: PolicyResolver\n  maxLinkDepth?: number\n}\n\n/**\n * Policy expression (string or `{default, variants}`) → one PredIr under §4c\n * permissive-union semantics:\n *\n *   OR(default, …variants.map(v => AND(when, v.allow ? const(true) : policy)))\n *\n * Granting a role/capability only ever widens access; `allow: true`\n * short-circuits its branch to the guard alone.\n */\nexport function compilePolicy({ expression, table, resolver, maxLinkDepth }: CompilePolicyInput): PredIr {\n  if (typeof expression === 'string') {\n    return compilePredicateV2({ expression, table, resolver, maxLinkDepth })\n  }\n\n  const defaultPred = compilePredicateV2({ expression: expression.default, table, resolver, maxLinkDepth })\n  if (expression.variants.length === 0) return defaultPred\n\n  const branches = expression.variants.map((variant): PredIr => {\n    const parsedWhen = parsePolicy(variant.when)\n    assertClaimsOnlyWhen(parsedWhen)\n    const when = compilePredicateV2({ expression: parsedWhen, table, resolver, maxLinkDepth })\n    const grant: PredIr =\n      variant.allow === true\n        ? { kind: 'const', value: true }\n        : compilePredicateV2({ expression: variant.policy as string, table, resolver, maxLinkDepth })\n    return { kind: 'and', operands: [when, grant] }\n  })\n\n  return { kind: 'or', operands: [defaultPred, ...branches] }\n}\n"]}