@sequenceholdings/orm 0.1.1 → 0.1.3

package/dist/ir.js

@@ -0,0 +1,623 @@
+import { z } from 'zod';
+
+// src/ir/index.ts
+var CANONICAL_FORMAT = 2;
+var IDENTIFIER_RE = /^[a-z][a-z0-9_]*$/;
+var identifier = z.string().min(1).max(63).regex(IDENTIFIER_RE);
+var COLUMN_TYPES = [
+  "uuid",
+  "text",
+  "integer",
+  "bigint",
+  "numeric",
+  "double",
+  "boolean",
+  "timestamptz",
+  "date",
+  "jsonb"
+];
+var columnTypeSchema = z.enum(COLUMN_TYPES);
+var canonicalEnumSchema = z.object({
+  name: identifier,
+  values: z.array(z.string().min(1).max(63)).min(1).max(100)
+});
+var canonicalColumnSchema = z.object({
+  /** Property name in TS (camelCase); columnName is the Postgres name. */
+  name: z.string().min(1).max(63),
+  columnName: identifier,
+  type: z.union([columnTypeSchema, z.object({ enum: identifier })]),
+  nullable: z.boolean().default(true),
+  unique: z.boolean().default(false),
+  /** Literal default, or one of the allowlisted SQL functions. */
+  default: z.union([z.string(), z.number(), z.boolean(), z.null()]).optional(),
+  defaultFn: z.enum(["gen_random_uuid()", "now()"]).optional(),
+  description: z.string().max(500).optional(),
+  /** Migration hints — same semantics as v1. */
+  renamedFrom: identifier.optional(),
+  cast: z.string().max(200).optional(),
+  deprecated: z.boolean().default(false)
+});
+var canonicalLinkSchema = z.object({
+  name: z.string().min(1).max(63),
+  kind: z.enum(["toOne", "toMany", "toPlatformUser"]),
+  /** Target table name (namespace-local). Absent for toPlatformUser. */
+  target: identifier.optional(),
+  /** FK column on the owning side (toOne/toPlatformUser: on this table; toMany: on the target). */
+  on: identifier,
+  /** Referenced column on the target (default: target's PK / platform user `sub`). */
+  references: identifier.optional(),
+  /** enforce: true emits a real FK constraint (same-namespace toOne only). */
+  enforce: z.boolean().default(false),
+  description: z.string().max(500).optional()
+});
+var canonicalIndexSchema = z.object({
+  columns: z.array(identifier).min(1),
+  unique: z.boolean().default(false),
+  name: identifier.optional()
+});
+var policyVariantSchema = z.object({
+  /** Claims-only guard (capability()/role()/claim() comparisons — no columns). */
+  when: z.string().min(1).max(1e3),
+  /** Exactly one of: allow-all bypass, or a row predicate. */
+  allow: z.literal(true).optional(),
+  policy: z.string().min(1).max(2e3).optional()
+}).refine((v) => v.allow === true !== (typeof v.policy === "string"), {
+  message: "A variant declares exactly one of allow: true or policy"
+});
+var policyExpressionSchema = z.union([
+  z.string().min(1).max(2e3),
+  z.object({
+    default: z.string().min(1).max(2e3),
+    variants: z.array(policyVariantSchema).max(10).default([])
+  })
+]);
+var canonicalPoliciesSchema = z.object({
+  read: policyExpressionSchema.optional(),
+  write: policyExpressionSchema.optional(),
+  insert: policyExpressionSchema.optional(),
+  update: policyExpressionSchema.optional()
+});
+function isSingleViewQuerySql(value) {
+  const query = value.trim();
+  if (!/^\(*(?:select|with)\b/i.test(query) || query.includes("\0")) return false;
+  let state = "normal";
+  for (let index = 0; index < query.length; index += 1) {
+    const char = query[index];
+    const next = query[index + 1];
+    if (state === "single") {
+      if (char === "'" && next === "'") index += 1;
+      else if (char === "'") state = "normal";
+      continue;
+    }
+    if (state === "double") {
+      if (char === '"' && next === '"') index += 1;
+      else if (char === '"') state = "normal";
+      continue;
+    }
+    if (char === "'") state = "single";
+    else if (char === '"') state = "double";
+    else if (char === ";" || char === "-" && next === "-" || char === "/" && next === "*") return false;
+  }
+  return state === "normal" && !/\$[a-z_0-9]*\$/i.test(query);
+}
+var canonicalActionSchema = z.object({
+  name: identifier,
+  requires: z.string().max(1e3).optional(),
+  params: z.record(z.string(), z.object({
+    type: columnTypeSchema,
+    nullable: z.boolean().default(false)
+  })).default({}),
+  executes: z.string().min(1).max(1e4),
+  returns: z.enum(["rows", "rowsAffected", "scalar"]).default("rowsAffected"),
+  audit: z.object({ action: z.string(), resource: z.string() }).optional()
+});
+var canonicalCowMutationSchema = z.object({
+  kind: z.enum(["override", "revert"]),
+  name: identifier,
+  /** Synced table (same namespace) the overlay copies from / falls back to. */
+  synced: identifier,
+  /** Single-column primary key PROPERTY (TS camelCase, like column `name`) shared by overlay and synced. */
+  pk: z.string().min(1).max(63),
+  /** Override: contract properties copied INSERT…SELECT from synced (pk included). Empty for revert. */
+  copy: z.array(z.string().min(1).max(63)).default([]),
+  /** Override: overlay properties written by the UPDATE (never the pk). Empty for revert. */
+  set: z.array(z.string().min(1).max(63)).default([])
+}).superRefine((mutation, ctx) => {
+  if (mutation.kind === "override") {
+    if (mutation.set.length === 0) {
+      ctx.addIssue({ code: "custom", path: ["set"], message: "override mutations must set at least one column" });
+    }
+    if (!mutation.copy.includes(mutation.pk)) {
+      ctx.addIssue({ code: "custom", path: ["copy"], message: "override copy list must include the pk" });
+    }
+  } else if (mutation.set.length > 0 || mutation.copy.length > 0) {
+    ctx.addIssue({ code: "custom", path: ["set"], message: "revert mutations take no copy/set columns" });
+  }
+  if (mutation.set.includes(mutation.pk)) {
+    ctx.addIssue({ code: "custom", path: ["set"], message: "set must not include the pk \u2014 identity columns are pinned" });
+  }
+  for (const [field, values] of [["copy", mutation.copy], ["set", mutation.set]]) {
+    if (new Set(values).size !== values.length) {
+      ctx.addIssue({ code: "custom", path: [field], message: `${field} must not contain duplicate columns` });
+    }
+  }
+});
+var canonicalTableSchema = z.object({
+  table: identifier,
+  description: z.string().max(2e3).optional(),
+  /** Table-level rename hint (new in v2). */
+  renamedFrom: identifier.optional(),
+  /** Synced/reflected read-only tables (`source: gold.*`) — v1 semantics. */
+  source: z.string().regex(/^gold\.[a-z][a-z0-9_]*$/).optional(),
+  columns: z.array(canonicalColumnSchema).default([]),
+  primaryKey: z.array(identifier).min(1).max(8).optional(),
+  links: z.array(canonicalLinkSchema).default([]),
+  indexes: z.array(canonicalIndexSchema).default([]),
+  policies: canonicalPoliciesSchema.default({}),
+  /**
+   * v1-conversion carry-over only. v2 has no action surface — the runtime
+   * neither compiles nor executes these; writes are mutations. Kept parseable
+   * so stored definitions and their content hashes stay stable.
+   */
+  actions: z.array(canonicalActionSchema).default([]),
+  /** Optional (not defaulted) so pre-CoW canonical documents keep byte-identical hashes. */
+  cowMutations: z.array(canonicalCowMutationSchema).optional()
+});
+var canonicalViewSchema = z.object({
+  view: identifier,
+  description: z.string().max(2e3).optional(),
+  columns: z.array(canonicalColumnSchema).min(1),
+  /** Logical identity for GraphQL only; PostgreSQL views have no PK constraint. */
+  primaryKey: z.array(identifier).min(1).max(8).optional(),
+  links: z.array(canonicalLinkSchema).default([]),
+  policies: z.object({ read: policyExpressionSchema }).strict(),
+  query: z.string().min(1).max(1e5).refine(isSingleViewQuerySql, {
+    message: "view query must be one SELECT/WITH statement without comments or dollar-quoted bodies"
+  }),
+  /** Namespace-local logical relation names, sorted for deterministic hashing. */
+  dependencies: z.array(identifier).max(500)
+}).superRefine((view, ctx) => {
+  for (const [index, column] of view.columns.entries()) {
+    if (column.default !== void 0 || column.defaultFn !== void 0) {
+      ctx.addIssue({ code: "custom", path: ["columns", index], message: `view column '${column.name}' cannot declare a default` });
+    }
+    if (column.unique) {
+      ctx.addIssue({ code: "custom", path: ["columns", index], message: `view column '${column.name}' cannot declare unique` });
+    }
+    if (column.renamedFrom !== void 0 || column.cast !== void 0) {
+      ctx.addIssue({ code: "custom", path: ["columns", index], message: `view column '${column.name}' cannot declare migration hints` });
+    }
+  }
+  for (const [index, link] of view.links.entries()) {
+    if (link.enforce) {
+      ctx.addIssue({ code: "custom", path: ["links", index, "enforce"], message: `view link '${link.name}' cannot enforce a foreign key` });
+    }
+  }
+});
+z.object({
+  definition_format: z.literal(CANONICAL_FORMAT),
+  namespace: identifier.max(41),
+  description: z.string().max(2e3).optional(),
+  enums: z.array(canonicalEnumSchema).default([]),
+  tables: z.array(canonicalTableSchema).min(0).max(500),
+  /** Optional to preserve byte-identical hashes for pre-view canonical v2 documents. */
+  views: z.array(canonicalViewSchema).max(500).optional(),
+  /** Verbatim custom-roles grammar (@sequenceholdings/custom-roles-manifest). */
+  capabilities: z.object({
+    roles: z.unknown().optional(),
+    uses: z.array(z.string()).default([])
+  }).default({ uses: [] })
+}).superRefine((definition, ctx) => {
+  const seen = /* @__PURE__ */ new Set();
+  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);
+  }
+  const tableByName = new Map(definition.tables.map((table) => [table.table, table]));
+  for (const [tableIndex, table] of definition.tables.entries()) {
+    const cowMutations = table.cowMutations ?? [];
+    if (cowMutations.length === 0) continue;
+    const path = (index, ...rest) => ["tables", tableIndex, "cowMutations", index, ...rest];
+    if (table.source !== void 0) {
+      ctx.addIssue({ code: "custom", path: path(0), message: `synced table '${table.table}' cannot declare cow mutations \u2014 it is read-only` });
+      continue;
+    }
+    for (const [index, mutation] of cowMutations.entries()) {
+      const synced = tableByName.get(mutation.synced);
+      if (!synced || synced.source === void 0) {
+        ctx.addIssue({
+          code: "custom",
+          path: path(index, "synced"),
+          message: `cow mutation '${mutation.name}' references '${mutation.synced}', which is not a synced table in this namespace`
+        });
+        continue;
+      }
+      const overlayColumnsByName = new Map(table.columns.map((column) => [column.name, column]));
+      const syncedColumnsByName = new Map(synced.columns.map((column) => [column.name, column]));
+      let columnsExist = true;
+      for (const property of [mutation.pk, ...mutation.copy, ...mutation.set]) {
+        if (!overlayColumnsByName.has(property)) {
+          columnsExist = false;
+          ctx.addIssue({ code: "custom", path: path(index), message: `cow mutation '${mutation.name}': column '${property}' does not exist on overlay '${table.table}'` });
+        }
+      }
+      for (const property of [mutation.pk, ...mutation.copy]) {
+        if (!syncedColumnsByName.has(property)) {
+          columnsExist = false;
+          ctx.addIssue({ code: "custom", path: path(index), message: `cow mutation '${mutation.name}': column '${property}' does not exist on synced '${mutation.synced}'` });
+        }
+      }
+      if (!columnsExist) continue;
+      const overlayPk = table.primaryKey ?? [];
+      const syncedPk = synced.primaryKey ?? [];
+      if (overlayPk.length !== 1 || overlayPk[0] !== mutation.pk || syncedPk.length !== 1 || syncedPk[0] !== mutation.pk) {
+        ctx.addIssue({
+          code: "custom",
+          path: path(index, "pk"),
+          message: `cow mutation '${mutation.name}': pk '${mutation.pk}' must be the single-column primary key on both '${table.table}' and '${mutation.synced}'`
+        });
+      }
+      for (const property of [mutation.pk, ...mutation.copy]) {
+        const overlayColumn = overlayColumnsByName.get(property);
+        const syncedColumn = syncedColumnsByName.get(property);
+        if (!overlayColumn || !syncedColumn) continue;
+        if (JSON.stringify(overlayColumn.type) !== JSON.stringify(syncedColumn.type)) {
+          ctx.addIssue({
+            code: "custom",
+            path: path(index),
+            message: `cow mutation '${mutation.name}': column '${property}' must have the same type on overlay and synced`
+          });
+        }
+        if (overlayColumn.columnName !== syncedColumn.columnName) {
+          ctx.addIssue({
+            code: "custom",
+            path: path(index),
+            message: `cow mutation '${mutation.name}': column '${property}' maps to different Postgres names on overlay ('${overlayColumn.columnName}') and synced ('${syncedColumn.columnName}')`
+          });
+        }
+        if (syncedColumn.nullable !== false && overlayColumn.nullable === false) {
+          ctx.addIssue({
+            code: "custom",
+            path: path(index),
+            message: `cow mutation '${mutation.name}': column '${property}' is nullable on synced but NOT NULL on overlay \u2014 a NULL synced value would fail the copy`
+          });
+        }
+      }
+    }
+  }
+  for (const [index, view] of (definition.views ?? []).entries()) {
+    if (seen.has(view.view)) {
+      ctx.addIssue({ code: "custom", path: ["views", index, "view"], message: `duplicate relation '${view.view}'` });
+    }
+    seen.add(view.view);
+  }
+  const views = definition.views ?? [];
+  const viewByName = new Map(views.map((view) => [view.view, view]));
+  for (const [viewIndex, view] of views.entries()) {
+    for (const [dependencyIndex, dependency] of view.dependencies.entries()) {
+      if (!seen.has(dependency)) {
+        ctx.addIssue({
+          code: "custom",
+          path: ["views", viewIndex, "dependencies", dependencyIndex],
+          message: `view '${view.view}' depends on unknown relation '${dependency}'`
+        });
+      }
+    }
+  }
+  const visiting = /* @__PURE__ */ new Set();
+  const visited = /* @__PURE__ */ new Set();
+  let cycleReported = false;
+  const visit = (name, path) => {
+    if (visited.has(name) || cycleReported) return;
+    if (visiting.has(name)) {
+      cycleReported = true;
+      ctx.addIssue({
+        code: "custom",
+        path: ["views"],
+        message: `view dependencies form a cycle: ${[...path, name].join(" -> ")}`
+      });
+      return;
+    }
+    visiting.add(name);
+    const view = viewByName.get(name);
+    for (const dependency of view?.dependencies ?? []) {
+      if (viewByName.has(dependency)) visit(dependency, [...path, name]);
+    }
+    visiting.delete(name);
+    visited.add(name);
+  };
+  for (const view of views) visit(view.view, []);
+});
+
+// src/ir/index.ts
+var IR_VERSION = 1;
+var CLAIMS_CONTRACT = {
+  sub: "string",
+  org: "string?",
+  roles: "string[]",
+  capabilities: "string[]"
+};
+var scalarLiteral = z.union([z.string(), z.number(), z.boolean(), z.null()]);
+var valueIrSchema = z.discriminatedUnion("kind", [
+  z.object({ kind: z.literal("literal"), value: z.union([scalarLiteral, z.array(scalarLiteral)]) }),
+  z.object({ kind: z.literal("variable"), name: z.string() }),
+  z.object({ kind: z.literal("claim"), key: z.enum(["sub", "org"]) })
+]);
+var CMP_OPS = [
+  "eq",
+  "neq",
+  "gt",
+  "gte",
+  "lt",
+  "lte",
+  "in",
+  "nin",
+  "like",
+  "ilike",
+  "isNull",
+  "contains",
+  "hasKey"
+];
+var predIrSchema = z.lazy(
+  () => z.discriminatedUnion("kind", [
+    z.object({ kind: z.literal("and"), operands: z.array(predIrSchema).min(1) }),
+    z.object({ kind: z.literal("or"), operands: z.array(predIrSchema).min(1) }),
+    z.object({ kind: z.literal("not"), operand: predIrSchema }),
+    z.object({ kind: z.literal("cmp"), op: z.enum(CMP_OPS), column: z.string(), value: valueIrSchema }),
+    z.object({ kind: z.literal("exists"), link: z.string(), where: predIrSchema }),
+    z.object({
+      kind: z.literal("aggPredicate"),
+      link: z.string(),
+      fn: z.literal("count"),
+      op: z.enum(["eq", "neq", "gt", "gte", "lt", "lte"]),
+      value: z.number(),
+      where: predIrSchema.optional()
+    }),
+    z.object({ kind: z.literal("capability"), key: z.string() }),
+    z.object({ kind: z.literal("role"), key: z.string() }),
+    z.object({ kind: z.literal("dynamicFilter"), slot: z.string() }),
+    z.object({ kind: z.literal("const"), value: z.boolean() })
+  ])
+);
+var orderIrSchema = z.discriminatedUnion("kind", [
+  z.object({
+    kind: z.literal("column"),
+    column: z.string(),
+    /** Order through a to-one link: `link` is set and `column` is on the target. */
+    link: z.string().optional(),
+    direction: z.enum(["asc", "desc"]),
+    nulls: z.enum(["first", "last"]).optional()
+  }),
+  /** §4f: `$orderBy: [FooOrderBy!]` variable — validated + lowered at runtime. */
+  z.object({ kind: z.literal("dynamic"), slot: z.string() })
+]);
+var limitIrSchema = z.object({
+  /** Fixed value or a variable, clamped to [1, max]; absent → default. */
+  variable: z.string().optional(),
+  value: z.number().int().positive().optional(),
+  default: z.number().int().positive(),
+  max: z.number().int().positive()
+});
+var selectionIrSchema = z.lazy(
+  () => z.object({
+    typename: z.string(),
+    columns: z.array(z.object({ alias: z.string(), column: z.string() })),
+    relations: z.array(z.object({
+      alias: z.string(),
+      link: z.string(),
+      selection: selectionIrSchema,
+      where: predIrSchema.optional(),
+      orderBy: z.array(orderIrSchema).optional(),
+      limit: limitIrSchema.optional(),
+      offset: z.object({ variable: z.string().optional(), value: z.number().int().optional() }).optional()
+    })),
+    aggregates: z.array(z.object({
+      alias: z.string(),
+      link: z.string().optional(),
+      where: predIrSchema.optional(),
+      count: z.object({ columns: z.array(z.string()).optional(), distinct: z.boolean().optional() }).optional(),
+      sum: z.array(z.string()).optional(),
+      avg: z.array(z.string()).optional(),
+      nodes: selectionIrSchema.optional()
+    }))
+  })
+);
+var includeIfSchema = z.object({ variable: z.string(), negated: z.boolean() });
+var selectRootSchema = z.object({
+  kind: z.literal("select"),
+  alias: z.string(),
+  table: z.string(),
+  selection: selectionIrSchema,
+  /** Composed at compile time: AND(policy, documentWhere?, dynamicFilter?). */
+  where: predIrSchema,
+  orderBy: z.array(orderIrSchema).default([]),
+  distinctOn: z.union([z.array(z.string()), z.object({ slot: z.string() })]).optional(),
+  limit: limitIrSchema,
+  offset: z.object({ variable: z.string().optional(), value: z.number().int().optional() }).optional(),
+  includeIf: includeIfSchema.optional()
+});
+var byPkRootSchema = z.object({
+  kind: z.literal("byPk"),
+  alias: z.string(),
+  table: z.string(),
+  selection: selectionIrSchema,
+  pk: z.array(z.object({ column: z.string(), value: valueIrSchema })).min(1),
+  /** Policy predicate — ANDed with the PK match. */
+  where: predIrSchema,
+  includeIf: includeIfSchema.optional()
+});
+var aggregateRootSchema = z.object({
+  kind: z.literal("aggregate"),
+  alias: z.string(),
+  table: z.string(),
+  where: predIrSchema,
+  count: z.object({ columns: z.array(z.string()).optional(), distinct: z.boolean().optional() }).optional(),
+  sum: z.array(z.string()).optional(),
+  avg: z.array(z.string()).optional(),
+  nodes: selectionIrSchema.optional(),
+  includeIf: includeIfSchema.optional()
+});
+var writeValuesSchema = z.union([
+  z.object({ slot: z.string() }),
+  z.object({ entries: z.array(z.object({ column: z.string(), value: valueIrSchema })) })
+]);
+var onConflictIrSchema = z.union([
+  z.object({ slot: z.string() }),
+  z.object({ constraint: z.string(), updateColumns: z.array(z.string()) })
+]);
+var mutationRootSchema = z.object({
+  kind: z.literal("mutation"),
+  /**
+   * CRUD verbs plus the structured copy-on-write ops. `cowOverride` copies the
+   * synced row into the overlay (INSERT…SELECT, ON CONFLICT DO NOTHING) then
+   * applies `set` — both statements generated by the executor from this
+   * metadata, never authored SQL. `cowRevert` deletes the override so the
+   * coalesce view falls back to synced. Both are gated on a matching synced
+   * row and carry the write policy in `where` like update/delete.
+   */
+  op: z.enum(["insert", "insertOne", "update", "updateByPk", "delete", "deleteByPk", "cowOverride", "cowRevert"]),
+  alias: z.string(),
+  table: z.string(),
+  /** CoW ops: logical name of the synced twin (read through its policy-filtered view). */
+  cowSynced: z.string().optional(),
+  /** cowOverride: logical properties copied INSERT…SELECT from synced (pk included). */
+  cowCopyColumns: z.array(z.string()).optional(),
+  /** cowOverride: insert-policy WITH CHECK evaluated over the copied rows. */
+  cowCopyCheck: predIrSchema.optional(),
+  /** insert/insertOne: rows come from a slot ($object/$objects) or literals. */
+  objects: z.union([
+    z.object({ slot: z.string() }),
+    z.object({ rows: z.array(z.array(z.object({ column: z.string(), value: valueIrSchema }))) })
+  ]).optional(),
+  /** Server-pinned columns (e.g. author_sub ← claim('sub')) merged into every inserted row. */
+  pinnedColumns: z.array(z.object({ column: z.string(), value: valueIrSchema })).default([]),
+  onConflict: onConflictIrSchema.optional(),
+  set: writeValuesSchema.optional(),
+  append: writeValuesSchema.optional(),
+  inc: writeValuesSchema.optional(),
+  /** update/delete row filter: AND(writePolicy, documentWhere/pk, dynamicFilter?). */
+  where: predIrSchema.optional(),
+  pk: z.array(z.object({ column: z.string(), value: valueIrSchema })).optional(),
+  /** WITH CHECK analogue evaluated against NEW row values (insert/update). */
+  insertCheck: predIrSchema.optional(),
+  returning: selectionIrSchema.nullable(),
+  affectedRows: z.boolean().default(false),
+  includeIf: includeIfSchema.optional()
+});
+var rootIrSchema = z.discriminatedUnion("kind", [
+  selectRootSchema,
+  byPkRootSchema,
+  aggregateRootSchema,
+  mutationRootSchema
+]);
+var INPUT_REF_KINDS = [
+  "boolExp",
+  "orderBy",
+  "selectColumn",
+  "insertInput",
+  "setInput",
+  "appendInput",
+  "onConflict"
+];
+var variableDefaultIrSchema = z.object({
+  value: z.union([scalarLiteral, z.array(scalarLiteral)])
+});
+var variableIrSchema = z.object({
+  name: z.string(),
+  type: z.union([
+    z.object({ kind: z.literal("scalar"), scalar: z.enum(COLUMN_TYPES) }),
+    /** `values` is the declared membership whitelist — the executor validates against it. */
+    z.object({ kind: z.literal("enum"), name: z.string(), values: z.array(z.string()).min(1) }),
+    /** §4f dynamic slot: validated against `tables[table]` whitelists at runtime. */
+    z.object({ kind: z.literal("inputRef"), input: z.enum(INPUT_REF_KINDS), table: z.string() })
+  ]),
+  nullable: z.boolean(),
+  list: z.boolean(),
+  /** Absent = no default declared; see {@link variableDefaultIrSchema}. */
+  defaultValue: variableDefaultIrSchema.optional()
+});
+var compiledOperationSchema = z.object({
+  irVersion: z.literal(IR_VERSION),
+  name: z.string(),
+  opHash: z.string().regex(/^sha256:[0-9a-f]{64}$/),
+  kind: z.enum(["query", "mutation"]),
+  requires: z.object({
+    capability: z.string().optional(),
+    role: z.string().optional()
+  }).nullable(),
+  variables: z.array(variableIrSchema),
+  /** Every table the op touches — data-token scoping + audit. */
+  tableSet: z.array(z.string()).min(1),
+  roots: z.array(rootIrSchema).min(1)
+});
+var tableMetaIrSchema = z.object({
+  table: z.string(),
+  schema: z.string(),
+  typename: z.string(),
+  /**
+   * True when statements over this relation evaluate a claims-gated synced
+   * view: synced twins (`source: gold.*`) materialize as views whose baked
+   * policy reads `current_setting('request.jwt.claims')`, and namespace views
+   * inherit the gate transitively through their declared dependencies. The
+   * executor must stamp that GUC (transaction-scoped) before any statement
+   * touching such a relation, or the synced arm yields zero rows regardless
+   * of the compiled predicates.
+   */
+  claimsGated: z.boolean().default(false),
+  columns: z.array(z.object({
+    name: z.string(),
+    columnName: z.string(),
+    type: z.union([z.enum(COLUMN_TYPES), z.object({ enum: z.string(), values: z.array(z.string()) })]),
+    nullable: z.boolean()
+  })),
+  /** Empty for keyless read-only views; keyed tables and views list logical columns. */
+  primaryKey: z.array(z.string()),
+  links: z.array(z.object({
+    name: z.string(),
+    kind: z.enum(["toOne", "toMany", "toPlatformUser"]),
+    target: z.string(),
+    on: z.string(),
+    references: z.string()
+  })),
+  /** §4f whitelists: what dynamic inputs may reference. */
+  filterable: z.array(z.string()),
+  orderable: z.array(z.string()),
+  insertable: z.array(z.string()),
+  settable: z.array(z.string()),
+  appendable: z.array(z.string()),
+  constraints: z.array(z.object({ name: z.string(), columns: z.array(z.string()) })),
+  /** Depth/node caps for dynamic filter trees on this table. */
+  dynamicFilterMaxDepth: z.number().int().positive().default(6),
+  dynamicFilterMaxNodes: z.number().int().positive().default(64)
+});
+var compiledArtifactSchema = z.object({
+  irVersion: z.literal(IR_VERSION),
+  namespace: z.string(),
+  schemaHash: z.string(),
+  opsHash: z.string(),
+  tables: z.record(z.string(), tableMetaIrSchema),
+  operations: z.record(z.string(), compiledOperationSchema)
+});
+var IrVersionError = class extends Error {
+  constructor(found) {
+    super(`Unsupported IR version ${String(found)} \u2014 this executor supports up to ${IR_VERSION}. Upgrade @sequenceholdings/orm or re-push the namespace.`);
+    this.name = "IrVersionError";
+  }
+};
+function normalizeIr(raw) {
+  if (!raw || typeof raw !== "object") throw new IrVersionError(void 0);
+  const version = raw.irVersion;
+  if (version !== IR_VERSION) throw new IrVersionError(version);
+  return compiledArtifactSchema.parse(raw);
+}
+function indexByHash(artifact) {
+  const map = /* @__PURE__ */ new Map();
+  for (const op of Object.values(artifact.operations)) map.set(op.opHash, op);
+  return map;
+}
+
+export { CLAIMS_CONTRACT, CMP_OPS, INPUT_REF_KINDS, IR_VERSION, IrVersionError, compiledArtifactSchema, compiledOperationSchema, indexByHash, limitIrSchema, normalizeIr, orderIrSchema, predIrSchema, rootIrSchema, selectionIrSchema, tableMetaIrSchema, valueIrSchema, variableDefaultIrSchema, variableIrSchema };
+//# sourceMappingURL=ir.js.map
+//# sourceMappingURL=ir.js.map