@sequenceholdings/orm 2.1.1 → 2.2.0

package/dist/index.cjs

@@ -165,8 +165,8 @@ var COLUMN_IDENTIFIER_PATTERN = /^_?[a-z][a-z0-9_]*$/;
 var MAX_IDENTIFIER_LENGTH = 63;
 var CAPABILITY_KEY_PATTERN = /^(?:org\/|app\/[a-z][a-z0-9-]{0,63}\/)?[a-z0-9-]{1,64}$/;
 var CLAIM_KEY_PATTERN = /^[a-z][a-z0-9_]*$/;
-var QUALIFIED_TABLE_PATTERN = /^[a-z][a-z0-9_]*\.[a-z][a-z0-9_]*$/;
-var SYNCED_SOURCE_PATTERN = /^gold\.[a-z][a-z0-9_]*$/;
+var QUALIFIED_TABLE_PATTERN = /^[a-z][a-z0-9_]{0,62}\.[a-z][a-z0-9_]{0,62}$/;
+var SYNCED_SOURCE_PATTERN = QUALIFIED_TABLE_PATTERN;
 var ORM_SCHEMA_PREFIX = "orm_";
 var CONSUMER_ROLE_SUFFIX = "_consumer";
 var ormSchemaName = (namespace) => `${ORM_SCHEMA_PREFIX}${namespace}`;
@@ -267,6 +267,9 @@ function registerNamespaceConfig(value) {
 // src/authoring/table.ts
 var TABLE_BRAND = "seq-table";
 var LINK_BRAND = "seq-link";
+function objectRef(namespace, table) {
+  return { kind: "seq-external-object", namespace, table };
+}
 function toOne(target, options) {
   return {
     kind: LINK_BRAND,
@@ -320,51 +323,51 @@ function assertIdentifier({ value, what, file, pattern = IDENTIFIER_PATTERN }) {
     );
   }
 }
-function defineTable(name, columns, config = {}) {
+function defineTable(name2, columns, config = {}) {
   const file = activeAuthoringContext()?.currentFile;
-  assertIdentifier({ value: name, what: "table name", file });
+  assertIdentifier({ value: name2, what: "table name", file });
   const entries = Object.entries(columns);
   if (entries.length === 0) {
-    throw new OrmDefinitionError(`table "${name}" declares no columns`, file);
+    throw new OrmDefinitionError(`table "${name2}" declares no columns`, file);
   }
   const seenColumnNames = /* @__PURE__ */ new Map();
   for (const [propertyName, builder] of entries) {
     if (!isColumnBuilder(builder)) {
       throw new OrmDefinitionError(
-        `table "${name}": column "${propertyName}" is not a column builder \u2014 use the t.* factories (t.uuid(), t.text(), \u2026)`,
+        `table "${name2}": column "${propertyName}" is not a column builder \u2014 use the t.* factories (t.uuid(), t.text(), \u2026)`,
         file
       );
     }
     const columnName = builder.columnNameFor(propertyName);
-    assertIdentifier({ value: columnName, what: `table "${name}": column "${propertyName}" column name`, file, pattern: COLUMN_IDENTIFIER_PATTERN });
+    assertIdentifier({ value: columnName, what: `table "${name2}": column "${propertyName}" column name`, file, pattern: COLUMN_IDENTIFIER_PATTERN });
     if (config.materializes === void 0 && (propertyName === CELLS_FIELD || Object.values(CELL_PART_SUFFIX).some((suffix) => columnName.endsWith(suffix) || propertyName.endsWith(suffix)))) {
       throw new OrmDefinitionError(
-        `table "${name}": "${propertyName}" collides with the reserved cell-metadata names ('${CELLS_FIELD}', or a ${Object.values(CELL_PART_SUFFIX).join("/")} suffix)`,
+        `table "${name2}": "${propertyName}" collides with the reserved cell-metadata names ('${CELLS_FIELD}', or a ${Object.values(CELL_PART_SUFFIX).join("/")} suffix)`,
         file
       );
     }
     const existing = seenColumnNames.get(columnName);
     if (existing !== void 0) {
       throw new OrmDefinitionError(
-        `table "${name}": columns "${existing}" and "${propertyName}" both map to Postgres column "${columnName}"`,
+        `table "${name2}": columns "${existing}" and "${propertyName}" both map to Postgres column "${columnName}"`,
         file
       );
     }
     seenColumnNames.set(columnName, propertyName);
   }
-  const table = { kind: TABLE_BRAND, tableName: name, columns, config, source: void 0, file };
+  const table = { kind: TABLE_BRAND, tableName: name2, columns, config, source: void 0, file };
   registerTable(table);
   return table;
 }
-function defineSyncedTable(name, columnsOrConfig, maybeConfig) {
+function defineSyncedTable(name2, columnsOrConfig, maybeConfig) {
   const file = activeAuthoringContext()?.currentFile;
-  assertIdentifier({ value: name, what: "table name", file });
+  assertIdentifier({ value: name2, what: "table name", file });
   const isTyped = maybeConfig !== void 0;
   const columns = isTyped ? columnsOrConfig : {};
   const config = isTyped ? maybeConfig : columnsOrConfig;
   if (!SYNCED_SOURCE_PATTERN.test(config.source)) {
     throw new OrmDefinitionError(
-      `synced table "${name}": source "${config.source}" must match ${SYNCED_SOURCE_PATTERN} (gold layer only)`,
+      `synced table "${name2}": source "${config.source}" must be a qualified lowercase schema.table identifier`,
       file
     );
   }
@@ -374,21 +377,21 @@ function defineSyncedTable(name, columnsOrConfig, maybeConfig) {
   for (const [propertyName, builder] of entries) {
     if (!isColumnBuilder(builder)) {
       throw new OrmDefinitionError(
-        `synced table "${name}": column "${propertyName}" is not a column builder \u2014 use the t.* factories (t.uuid(), t.text(), \u2026)`,
+        `synced table "${name2}": column "${propertyName}" is not a column builder \u2014 use the t.* factories (t.uuid(), t.text(), \u2026)`,
         file
       );
     }
     const columnName = builder.columnNameFor(propertyName);
     assertIdentifier({
       value: columnName,
-      what: `synced table "${name}": column "${propertyName}" column name`,
+      what: `synced table "${name2}": column "${propertyName}" column name`,
       file,
       pattern: COLUMN_IDENTIFIER_PATTERN
     });
     const existing = seenColumnNames.get(columnName);
     if (existing !== void 0) {
       throw new OrmDefinitionError(
-        `synced table "${name}": columns "${existing}" and "${propertyName}" both map to Postgres column "${columnName}"`,
+        `synced table "${name2}": columns "${existing}" and "${propertyName}" both map to Postgres column "${columnName}"`,
         file
       );
     }
@@ -399,13 +402,13 @@ function defineSyncedTable(name, columnsOrConfig, maybeConfig) {
     const hasConfigPk = config.primaryKey !== void 0 && config.primaryKey.length > 0;
     if (columnLevelPk.length === 0 && !hasConfigPk) {
       throw new OrmDefinitionError(
-        `synced table "${name}" declares columns but no primary key \u2014 use .primaryKey() or config.primaryKey`,
+        `synced table "${name2}" declares columns but no primary key \u2014 use .primaryKey() or config.primaryKey`,
         file
       );
     }
     if (columnLevelPk.length > 0 && hasConfigPk) {
       throw new OrmDefinitionError(
-        `synced table "${name}": declare the primary key either with .primaryKey() on columns or with config.primaryKey \u2014 not both`,
+        `synced table "${name2}": declare the primary key either with .primaryKey() on columns or with config.primaryKey \u2014 not both`,
         file
       );
     }
@@ -417,7 +420,7 @@ function defineSyncedTable(name, columnsOrConfig, maybeConfig) {
   if (config.policies !== void 0) tableConfig.policies = { read: config.policies.read };
   const table = {
     kind: TABLE_BRAND,
-    tableName: name,
+    tableName: name2,
     columns,
     config: tableConfig,
     source: config.source,
@@ -426,26 +429,26 @@ function defineSyncedTable(name, columnsOrConfig, maybeConfig) {
   registerTable(table);
   return table;
 }
-function defineEnum(name, values) {
+function defineEnum(name2, values) {
   const file = activeAuthoringContext()?.currentFile;
-  assertIdentifier({ value: name, what: "enum name", file });
+  assertIdentifier({ value: name2, what: "enum name", file });
   if (values.length === 0 || values.length > 100) {
-    throw new OrmDefinitionError(`enum "${name}" must declare between 1 and 100 values`, file);
+    throw new OrmDefinitionError(`enum "${name2}" must declare between 1 and 100 values`, file);
   }
   const seen = /* @__PURE__ */ new Set();
   for (const value of values) {
     if (value.length === 0 || value.length > MAX_IDENTIFIER_LENGTH) {
       throw new OrmDefinitionError(
-        `enum "${name}": value ${JSON.stringify(value)} must be 1-${MAX_IDENTIFIER_LENGTH} characters`,
+        `enum "${name2}": value ${JSON.stringify(value)} must be 1-${MAX_IDENTIFIER_LENGTH} characters`,
         file
       );
     }
     if (seen.has(value)) {
-      throw new OrmDefinitionError(`enum "${name}" declares duplicate value "${value}"`, file);
+      throw new OrmDefinitionError(`enum "${name2}" declares duplicate value "${value}"`, file);
     }
     seen.add(value);
   }
-  const ref = { kind: ENUM_BRAND, name, values: [...values] };
+  const ref = { kind: ENUM_BRAND, name: name2, values: [...values] };
   registerEnum(ref);
   return ref;
 }
@@ -453,52 +456,52 @@ var VIEW_BRAND = "seq-view";
 function isSeqView(value) {
   return typeof value === "object" && value !== null && value.kind === VIEW_BRAND;
 }
-function defineView(name, columns, config) {
+function defineView(name2, columns, config) {
   const file = activeAuthoringContext()?.currentFile;
-  if (!IDENTIFIER_PATTERN.test(name) || name.length > MAX_IDENTIFIER_LENGTH) {
+  if (!IDENTIFIER_PATTERN.test(name2) || name2.length > MAX_IDENTIFIER_LENGTH) {
     throw new OrmDefinitionError(
-      `view name "${name}" must match ${IDENTIFIER_PATTERN} and be at most ${MAX_IDENTIFIER_LENGTH} characters`,
+      `view name "${name2}" must match ${IDENTIFIER_PATTERN} and be at most ${MAX_IDENTIFIER_LENGTH} characters`,
       file
     );
   }
   const entries = Object.entries(columns);
-  if (entries.length === 0) throw new OrmDefinitionError(`view "${name}" declares no columns`, file);
+  if (entries.length === 0) throw new OrmDefinitionError(`view "${name2}" declares no columns`, file);
   const seenColumnNames = /* @__PURE__ */ new Map();
   for (const [propertyName, builder] of entries) {
     if (!isColumnBuilder(builder)) {
       throw new OrmDefinitionError(
-        `view "${name}": column "${propertyName}" is not a column builder \u2014 use the t.* factories`,
+        `view "${name2}": column "${propertyName}" is not a column builder \u2014 use the t.* factories`,
         file
       );
     }
     const columnName = builder.columnNameFor(propertyName);
     if (!COLUMN_IDENTIFIER_PATTERN.test(columnName) || columnName.length > MAX_IDENTIFIER_LENGTH) {
-      throw new OrmDefinitionError(`view "${name}": column "${propertyName}" has invalid column name "${columnName}"`, file);
+      throw new OrmDefinitionError(`view "${name2}": column "${propertyName}" has invalid column name "${columnName}"`, file);
     }
     const existing = seenColumnNames.get(columnName);
     if (existing !== void 0) {
       throw new OrmDefinitionError(
-        `view "${name}": columns "${existing}" and "${propertyName}" both map to Postgres column "${columnName}"`,
+        `view "${name2}": columns "${existing}" and "${propertyName}" both map to Postgres column "${columnName}"`,
         file
       );
     }
     seenColumnNames.set(columnName, propertyName);
   }
-  const view = { kind: VIEW_BRAND, viewName: name, columns, config, file };
+  const view = { kind: VIEW_BRAND, viewName: name2, columns, config, file };
   registerView(view);
   return view;
 }
 var QUERY_COLUMN_FACTORIES = {
-  uuid: (name) => pgCore.uuid(name),
-  text: (name) => pgCore.text(name),
-  integer: (name) => pgCore.integer(name),
-  bigint: (name) => pgCore.bigint(name, { mode: "bigint" }),
-  numeric: (name) => pgCore.numeric(name),
-  double: (name) => pgCore.doublePrecision(name),
-  boolean: (name) => pgCore.boolean(name),
-  timestamptz: (name) => pgCore.timestamp(name, { withTimezone: true }),
-  date: (name) => pgCore.date(name),
-  jsonb: (name) => pgCore.jsonb(name)
+  uuid: (name2) => pgCore.uuid(name2),
+  text: (name2) => pgCore.text(name2),
+  integer: (name2) => pgCore.integer(name2),
+  bigint: (name2) => pgCore.bigint(name2, { mode: "bigint" }),
+  numeric: (name2) => pgCore.numeric(name2),
+  double: (name2) => pgCore.doublePrecision(name2),
+  boolean: (name2) => pgCore.boolean(name2),
+  timestamptz: (name2) => pgCore.timestamp(name2, { withTimezone: true }),
+  date: (name2) => pgCore.date(name2),
+  jsonb: (name2) => pgCore.jsonb(name2)
 };
 function compileViewQueries(input) {
   const schemaName = `orm_${input.namespace}`;
@@ -554,9 +557,9 @@ function compileViewQueries(input) {
       }
       const handle = handles.get(resolved);
       if (!handle) {
-        const name = isSeqTable(resolved) ? resolved.tableName : resolved.viewName;
+        const name2 = isSeqTable(resolved) ? resolved.tableName : resolved.viewName;
         throw new OrmDefinitionError(
-          `view "${authored.viewName}" references relation "${name}" which is not part of this namespace`,
+          `view "${authored.viewName}" references relation "${name2}" which is not part of this namespace`,
           authored.file
         );
       }
@@ -747,8 +750,8 @@ function overlayWinsUnion(input) {
 // src/authoring/cow-mutations.ts
 function overrideRowMutation(input) {
   const { overlay, synced, pk } = input;
-  const name = input.name ?? `override_${overlay.tableName}`;
-  assertMutationName(name, "overrideRowMutation");
+  const name2 = input.name ?? `override_${overlay.tableName}`;
+  assertMutationName(name2, "overrideRowMutation");
   assertOverlayPairPrimaryKey({ overlay, synced, pk, helper: "overrideRowMutation" });
   const sharedProperties = sharedNonPkProperties({ overlay, synced, pk });
   const setProperties = resolveSetProperties({
@@ -767,7 +770,7 @@ function overrideRowMutation(input) {
   });
   return {
     kind: "override",
-    name,
+    name: name2,
     synced: synced.tableName,
     pk,
     copy: [pk, ...sharedProperties],
@@ -776,23 +779,23 @@ function overrideRowMutation(input) {
 }
 function revertOverlayMutation(input) {
   const { overlay, synced, pk } = input;
-  const name = input.name ?? `revert_${overlay.tableName}`;
-  assertMutationName(name, "revertOverlayMutation");
+  const name2 = input.name ?? `revert_${overlay.tableName}`;
+  assertMutationName(name2, "revertOverlayMutation");
   assertOverlayPairPrimaryKey({ overlay, synced, pk, helper: "revertOverlayMutation" });
   assertMatchingColumns({ overlay, synced, properties: [pk], helper: "revertOverlayMutation" });
   return {
     kind: "revert",
-    name,
+    name: name2,
     synced: synced.tableName,
     pk,
     copy: [],
     set: []
   };
 }
-function assertMutationName(name, helper) {
-  if (!IDENTIFIER_PATTERN.test(name) || name.length > MAX_IDENTIFIER_LENGTH) {
+function assertMutationName(name2, helper) {
+  if (!IDENTIFIER_PATTERN.test(name2) || name2.length > MAX_IDENTIFIER_LENGTH) {
     throw new OrmDefinitionError(
-      `${helper}: mutation name "${name}" must match ${IDENTIFIER_PATTERN} and be at most ${MAX_IDENTIFIER_LENGTH} characters`
+      `${helper}: mutation name "${name2}" must match ${IDENTIFIER_PATTERN} and be at most ${MAX_IDENTIFIER_LENGTH} characters`
     );
   }
 }
@@ -918,17 +921,35 @@ function scalarColumnType(table, property, helper) {
   }
   return type;
 }
+var objectRef2 = zod.z.string().max(255).regex(/^[a-z][a-z0-9_]{0,40}\/[A-Za-z_][A-Za-z0-9_]*$/, "Expected an explicit namespace/object reference (no wildcards)");
+var functionRef = zod.z.string().max(255).regex(/^[a-z][a-z0-9-]*$/, "Expected a function slug");
+var refs = (schema) => zod.z.array(schema).max(256).refine(
+  (values) => new Set(values).size === values.length,
+  "Duplicate dependency reference"
+).default([]);
+var ontologyContractSchema = zod.z.strictObject({
+  version: zod.z.literal(1),
+  read: refs(objectRef2),
+  write: refs(objectRef2),
+  produce: refs(objectRef2),
+  invoke: refs(functionRef)
+}).refine((contract) => JSON.stringify(contract).length <= 4096, "Ontology contract exceeds the 4 KiB signed-context budget");
+function readOntologyContract(manifest) {
+  if (!manifest || typeof manifest !== "object" || !("ontology" in manifest) || manifest.ontology === void 0) return void 0;
+  return ontologyContractSchema.parse(manifest.ontology);
+}
 
 // src/compiler/sql.ts
 var CLAIMS_SETTING = "request.jwt.claims";
 var CAPABILITIES_CLAIM_KEY = "capabilities";
 var ROLES_CLAIM_KEY = "roles";
-var quoteIdentifier = (name) => `"${name.replaceAll('"', '""')}"`;
+var quoteIdentifier = (name2) => `"${name2.replaceAll('"', '""')}"`;
 var quoteLiteral = (value) => `'${value.replaceAll("'", "''")}'`;
 var CLAIMS_SOURCE = `nullif(current_setting('${CLAIMS_SETTING}', true), '')::jsonb`;
 var claimExpression = (key) => `(${CLAIMS_SOURCE} ->> ${quoteLiteral(key)})`;
-var capabilityExpression = (key) => `coalesce(${CLAIMS_SOURCE} -> '${CAPABILITIES_CLAIM_KEY}' ? ${quoteLiteral(key)}, false)`;
-var roleExpression = (key) => `coalesce(${CLAIMS_SOURCE} -> '${ROLES_CLAIM_KEY}' ? ${quoteLiteral(key)}, false)`;
+var scopedClaimsSource = (namespace) => namespace ? `(CASE WHEN ${CLAIMS_SOURCE} ? 'namespaces' THEN ${CLAIMS_SOURCE} -> 'namespaces' -> ${quoteLiteral(namespace)} ELSE ${CLAIMS_SOURCE} END)` : CLAIMS_SOURCE;
+var capabilityExpression = (key, namespace) => `coalesce(${scopedClaimsSource(namespace)} -> '${CAPABILITIES_CLAIM_KEY}' ? ${quoteLiteral(key)}, false)`;
+var roleExpression = (key, namespace) => `coalesce(${scopedClaimsSource(namespace)} -> '${ROLES_CLAIM_KEY}' ? ${quoteLiteral(key)}, false)`;
 
 // src/checks/compile.ts
 function tokenize(source) {
@@ -1261,8 +1282,8 @@ function validateResolvedView({ view, tables, views = [] }) {
   validateRules(scope);
   validateViewCells(scope);
   if (resolved.materialized) validateMaterialized({ scope, tableByName, views });
-  for (const name of resolved.deletedBy) {
-    if (scope.sourceByName.get(name)?.kind !== "manual") fail(`deletedBy '${name}' must be the manual source`);
+  for (const name2 of resolved.deletedBy) {
+    if (scope.sourceByName.get(name2)?.kind !== "manual") fail(`deletedBy '${name2}' must be the manual source`);
   }
   return errors;
 }
@@ -1359,7 +1380,7 @@ function validateViewCells({ view, dataColumns, pkColumn, fail }) {
     if (column.type !== VIEW_CELL_TYPES[column.cell.part]) fail(`cell column '${column.name}' must be ${VIEW_CELL_TYPES[column.cell.part]}`);
     expected.delete(column.name);
   }
-  for (const name of expected.keys()) fail(`missing cell column '${name}'`);
+  for (const name2 of expected.keys()) fail(`missing cell column '${name2}'`);
 }
 var columnSignature = (columns) => JSON.stringify(columns.map((column) => [column.name, column.columnName, column.type]));
 function validateMaterialized({ scope, tableByName, views }) {
@@ -1450,6 +1471,8 @@ var canonicalLinkSchema = zod.z.object({
   kind: zod.z.enum(["toOne", "toMany", "toPlatformUser"]),
   /** Target table name (namespace-local). Absent for toPlatformUser. */
   target: identifier2.optional(),
+  /** Owning namespace of an imported target; omitted for local links. */
+  namespace: identifier2.max(41).optional(),
   /** FK column on the owning side (toOne/toPlatformUser: on this table; toMany: on the target). */
   on: columnIdentifier,
   /** Referenced column on the target (default: target's PK / platform user `sub`). */
@@ -1708,11 +1731,12 @@ var canonicalForeignKeySchema = zod.z.object({
 }).strict();
 var canonicalTableSchema = zod.z.object({
   table: identifier2,
+  displayName: zod.z.string().trim().min(1).max(120).optional(),
   description: zod.z.string().max(2e3).optional(),
   /** Table-level rename hint (new in v2). */
   renamedFrom: identifier2.optional(),
-  /** Synced/reflected read-only tables (`source: gold.*`) — v1 semantics. */
-  source: zod.z.string().regex(/^gold\.[a-z][a-z0-9_]*$/).optional(),
+  /** Synced/reflected read-only tables (`source: schema.table`) — v1 semantics. */
+  source: zod.z.string().regex(QUALIFIED_TABLE_PATTERN).optional(),
   columns: zod.z.array(canonicalColumnSchema).default([]),
   primaryKey: zod.z.array(columnIdentifier).min(1).max(8).optional(),
   links: zod.z.array(canonicalLinkSchema).default([]),
@@ -1865,7 +1889,9 @@ function validateCellMetadata(table, index3, ctx) {
     }
   }
 }
-var canonicalDefinitionSchema = zod.z.object({
+var exportGateSchema = zod.z.union([zod.z.literal(true), zod.z.object({ capability: zod.z.string().min(1) }).strict(), zod.z.object({ role: zod.z.string().min(1) }).strict()]);
+var relationExportSchema = zod.z.object({ read: exportGateSchema, write: exportGateSchema.optional() }).strict();
+var localDefinitionSchema = zod.z.object({
   definition_format: zod.z.literal(CANONICAL_FORMAT),
   namespace: identifier2.max(41),
   description: zod.z.string().max(2e3).optional(),
@@ -1873,6 +1899,8 @@ var canonicalDefinitionSchema = zod.z.object({
   tables: zod.z.array(canonicalTableSchema).min(0).max(500),
   /** Optional to preserve byte-identical hashes for pre-view canonical v2 documents. */
   views: zod.z.array(canonicalViewSchema).max(500).optional(),
+  /** Target-owned cross-namespace access contract, using existing namespace grants. */
+  exports: zod.z.record(identifier2, relationExportSchema).optional(),
   /** Verbatim custom-roles grammar (@sequenceholdings/custom-roles-manifest). */
   capabilities: zod.z.object({
     roles: zod.z.unknown().optional(),
@@ -1899,7 +1927,16 @@ var canonicalDefinitionSchema = zod.z.object({
     }
   }
   const fkTables = new Map(definition.tables.map((table) => [table.table, table]));
+  const relations = /* @__PURE__ */ new Set([...fkTables.keys(), ...(definition.views ?? []).map((view) => view.view)]);
+  for (const name2 of Object.keys(definition.exports ?? {})) {
+    if (!relations.has(name2)) ctx.addIssue({ code: "custom", path: ["exports", name2], message: `export '${name2}' is not a local object` });
+  }
   for (const [tableIndex, table] of definition.tables.entries()) {
+    for (const [linkIndex, link] of table.links.entries()) {
+      if (link.enforce && link.namespace !== void 0 && link.namespace !== definition.namespace) {
+        ctx.addIssue({ code: "custom", path: ["tables", tableIndex, "links", linkIndex], message: "physical foreign keys require a local target; use an ORM link without enforce" });
+      }
+    }
     const names = /* @__PURE__ */ new Set([
       ...table.primaryKey?.length ? [`${table.table}_pkey`] : [],
       ...table.columns.filter((column) => column.unique && !(table.primaryKey?.length === 1 && table.primaryKey[0] === column.columnName)).map((column) => `${table.table}_${column.columnName}_unique`),
@@ -1936,14 +1973,14 @@ var canonicalDefinitionSchema = zod.z.object({
       }
       if (fk.columns.length !== fk.references.length) fail("foreign key columns and references must have the same number of columns");
       if (new Set(fk.columns).size !== fk.columns.length || new Set(fk.references).size !== fk.references.length) fail("foreign key columns must not repeat");
-      for (const [position, name] of fk.columns.entries()) {
-        const sourceColumn = table.columns.find((column) => column.columnName === name);
+      for (const [position, name2] of fk.columns.entries()) {
+        const sourceColumn = table.columns.find((column) => column.columnName === name2);
         const targetColumn = target.columns.find((column) => column.columnName === fk.references[position]);
         if (!sourceColumn || !targetColumn) fail("foreign key references an unknown column");
         else if (JSON.stringify(sourceColumn.type) !== JSON.stringify(targetColumn.type)) fail("foreign key column types must match");
       }
       if (fk.onDelete === "set null" || fk.onUpdate === "set null") {
-        if (fk.columns.some((name) => table.columns.find((column) => column.columnName === name)?.nullable === false || table.primaryKey?.includes(name))) fail("SET NULL requires nullable source columns");
+        if (fk.columns.some((name2) => table.columns.find((column) => column.columnName === name2)?.nullable === false || table.primaryKey?.includes(name2))) fail("SET NULL requires nullable source columns");
       }
       const uniqueKeys = [target.primaryKey ?? [], ...target.indexes.filter((index4) => index4.unique).map((index4) => index4.columns), ...target.columns.filter((column) => column.unique).map((column) => [column.columnName])];
       if (!uniqueKeys.some((key) => key.length === fk.references.length && key.every((column) => fk.references.includes(column)))) fail("foreign key target columns must form a unique key");
@@ -2048,27 +2085,31 @@ var canonicalDefinitionSchema = zod.z.object({
   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)) {
+  const visit = (name2, path) => {
+    if (visited.has(name2) || cycleReported) return;
+    if (visiting.has(name2)) {
       cycleReported = true;
       ctx.addIssue({
         code: "custom",
         path: ["views"],
-        message: `view dependencies form a cycle: ${[...path, name].join(" -> ")}`
+        message: `view dependencies form a cycle: ${[...path, name2].join(" -> ")}`
       });
       return;
     }
-    visiting.add(name);
-    const view = viewByName.get(name);
+    visiting.add(name2);
+    const view = viewByName.get(name2);
     for (const dependency of view?.dependencies ?? []) {
-      if (viewByName.has(dependency)) visit(dependency, [...path, name]);
+      if (viewByName.has(dependency)) visit(dependency, [...path, name2]);
     }
-    visiting.delete(name);
-    visited.add(name);
+    visiting.delete(name2);
+    visited.add(name2);
   };
   for (const view of views) visit(view.view, []);
 });
+var canonicalDefinitionSchema = localDefinitionSchema.safeExtend({
+  /** Flattened, pinned snapshots. Imported relations never participate in this namespace's DDL. */
+  imports: zod.z.array(localDefinitionSchema).max(32).optional()
+});
 function canonicalRelations(definition) {
   const views = (definition.views ?? []).map((view) => ({
     table: view.view,
@@ -2112,6 +2153,11 @@ function normalizeCanonical(definition) {
       dependencies: [...view.dependencies].sort()
     }));
   }
+  if (definition.imports?.length) {
+    normalized.imports = definition.imports.map(normalizeCanonical).sort((a, b) => a.namespace.localeCompare(b.namespace));
+  } else {
+    delete normalized.imports;
+  }
   return normalized;
 }
 
@@ -2236,8 +2282,8 @@ var literal = (value) => `'${value.replace(/'/g, "''")}'`;
 var physical = ({ source, property }) => source.table.columns[property].columnNameFor(property);
 function candidateSql({ source, column, pk, pgType }) {
   const a = ident(`s_${source.name}`);
-  const name = physical({ source, property: column });
-  const value = `CAST(${a}.${ident(name)} AS ${pgType})`;
+  const name2 = physical({ source, property: column });
+  const value = `CAST(${a}.${ident(name2)} AS ${pgType})`;
   if (source.kind === "etl") {
     return {
       source: source.name,
@@ -2247,9 +2293,9 @@ function candidateSql({ source, column, pk, pgType }) {
       by: "CAST(NULL AS text)"
     };
   }
-  const at = `${a}.${ident(cellColumnName(name, "at"))}`;
+  const at = `${a}.${ident(cellColumnName(name2, "at"))}`;
   const tombstoned2 = source.kind === "prefetch" ? ` AND NOT ${a}.${ident(RESOLVED_SOURCE_SYSTEM_COLUMNS.tombstoned.columnName)}` : "";
-  return { source: source.name, value, has: `(${at} IS NOT NULL${tombstoned2})`, at, by: `${a}.${ident(cellColumnName(name, "by"))}` };
+  return { source: source.name, value, has: `(${at} IS NOT NULL${tombstoned2})`, at, by: `${a}.${ident(cellColumnName(name2, "by"))}` };
 }
 function outranks({ i, j, key, direction, inclusive }) {
   const ki = i[key];
@@ -2342,7 +2388,7 @@ function buildResolvedQuery({ context, plan }) {
   plan.rules.forEach((rule, index3) => {
     const canonical = plan.columns[rule.column].toCanonicalColumn(rule.column);
     const pgType = typeof canonical.type === "string" ? PG_TYPE[canonical.type] : `${schema === void 0 ? "" : `${ident(schema)}.`}${ident(canonical.type.enum)}`;
-    const candidates = rule.candidates.map((name) => candidateSql({ source: sourceByName.get(name), column: rule.column, pk: plan.pk, pgType }));
+    const candidates = rule.candidates.map((name2) => candidateSql({ source: sourceByName.get(name2), column: rule.column, pk: plan.pk, pgType }));
     cells.set(rule.column, rule.comparator === "custom" ? customCell({ candidates, orderBy: rule.orderBy, index: index3 }) : builtinCell({ comparator: rule.comparator, candidates }));
   });
   const laterals = [...cells.values()].flatMap((cell) => cell.lateral ? [drizzleOrm.sql.raw(cell.lateral)] : []);
@@ -2363,7 +2409,7 @@ function buildResolvedQuery({ context, plan }) {
   const system = RESOLVED_VIEW_SYSTEM_COLUMNS;
   selected[system.writebackStatus.name] = drizzleOrm.sql.raw(`${alias(manual.name)}.${ident(RESOLVED_SOURCE_SYSTEM_COLUMNS.writebackStatus.columnName)}`).as(system.writebackStatus.columnName);
   selected[system.writebackError.name] = drizzleOrm.sql.raw(`${alias(manual.name)}.${ident(RESOLVED_SOURCE_SYSTEM_COLUMNS.writebackError.columnName)}`).as(system.writebackError.columnName);
-  const hidden = plan.deletedBy.map((name) => `NOT COALESCE(${alias(name)}.${ident(tombstoned2)}, false)`);
+  const hidden = plan.deletedBy.map((name2) => `NOT COALESCE(${alias(name2)}.${ident(tombstoned2)}, false)`);
   const query = qb.select(selected).from(from);
   return hidden.length > 0 ? query.where(drizzleOrm.sql.raw(hidden.join(" AND "))) : query;
 }
@@ -2389,12 +2435,12 @@ var SYSTEM_VIEW_COLUMNS = {
   [RESOLVED_VIEW_SYSTEM_COLUMNS.writebackStatus.name]: () => t.text(RESOLVED_VIEW_SYSTEM_COLUMNS.writebackStatus.columnName),
   [RESOLVED_VIEW_SYSTEM_COLUMNS.writebackError.name]: () => t.text(RESOLVED_VIEW_SYSTEM_COLUMNS.writebackError.columnName)
 };
-function defineResolvedTable(name, columns, config) {
+function defineResolvedTable(name2, columns, config) {
   const file = activeAuthoringContext()?.currentFile;
   const fail = (message) => {
-    throw new OrmDefinitionError(`resolved table "${name}": ${message}`, file);
+    throw new OrmDefinitionError(`resolved table "${name2}": ${message}`, file);
   };
-  if (!IDENTIFIER_PATTERN.test(name)) fail(`name must match ${IDENTIFIER_PATTERN}`);
+  if (!IDENTIFIER_PATTERN.test(name2)) fail(`name must match ${IDENTIFIER_PATTERN}`);
   for (const property of Object.keys(columns)) {
     if (RESERVED_RESOLVED_COLUMN_NAMES.has(property) || RESERVED_RESOLVED_COLUMN_NAMES.has(columns[property].columnNameFor(property))) {
       fail(`column "${property}" collides with a reserved system column`);
@@ -2413,7 +2459,7 @@ function defineResolvedTable(name, columns, config) {
   const sourceEntries = Object.entries(config.sources);
   if (sourceEntries.filter(([, source]) => source.kind === "manual").length !== 1) fail("declare exactly one manualSource()");
   const plans = sourceEntries.map(
-    ([sourceName, input]) => planSource({ viewName: name, sourceName, input, columns, pk, pkBuilder, dataColumns, fail })
+    ([sourceName, input]) => planSource({ viewName: name2, sourceName, input, columns, pk, pkBuilder, dataColumns, fail })
   );
   const rules = planRules({ config, plans, dataColumns, fail });
   const deletedBy = [...config.rows?.deletedBy ?? []];
@@ -2447,23 +2493,23 @@ function defineResolvedTable(name, columns, config) {
     policies: { read }
   };
   if (!config.materialize) {
-    return defineView(name, typedColumns, { ...surface, query: (context) => buildResolvedQuery({ context, plan: queryPlan }), resolved });
+    return defineView(name2, typedColumns, { ...surface, query: (context) => buildResolvedQuery({ context, plan: queryPlan }), resolved });
   }
   const materialize = config.materialize === true ? {} : config.materialize;
-  const computeName = `${name}__compute`;
-  const tableName = `${name}__materialized`;
+  const computeName = `${name2}__compute`;
+  const tableName = `${name2}__materialized`;
   const compute = defineView(computeName, typedColumns, {
     policies: { read },
     query: (context) => buildResolvedQuery({ context, plan: queryPlan }),
     internal: true
   });
   const table = defineTable(tableName, viewColumns, {
-    description: `Materialized rows of resolved table "${name}". System-maintained from "${computeName}".`,
+    description: `Materialized rows of resolved table "${name2}". System-maintained from "${computeName}".`,
     internal: true,
-    materializes: name,
+    materializes: name2,
     ...materialize.indexes !== void 0 ? { indexes: materialize.indexes } : {}
   });
-  return defineView(name, typedColumns, {
+  return defineView(name2, typedColumns, {
     ...surface,
     query: (context) => {
       const handle = context.relation(table);
@@ -2490,7 +2536,7 @@ function planRules({ config, plans, dataColumns, fail }) {
   return dataColumns.map((column) => {
     const explicit = config.resolve?.[column];
     const comparator = explicit ?? fallback;
-    const candidates = explicit ? [...explicit.candidates] : comparator.candidates.filter((name) => plans.find((plan) => plan.name === name)?.columns.includes(column));
+    const candidates = explicit ? [...explicit.candidates] : comparator.candidates.filter((name2) => plans.find((plan) => plan.name === name2)?.columns.includes(column));
     for (const candidate of candidates) {
       const plan = plans.find((entry) => entry.name === candidate);
       if (!plan) fail(`column "${column}" names unknown source "${candidate}"`);
@@ -2592,8 +2638,8 @@ function canonicalTable(table) {
     },
     actions: emptyToNull(
       Object.fromEntries(
-        Object.entries(table.actions ?? {}).map(([name, action]) => [
-          name,
+        Object.entries(table.actions ?? {}).map(([name2, action]) => [
+          name2,
           {
             description: action.description ?? null,
             requires: action.requires?.source ?? null,
@@ -2647,6 +2693,72 @@ function computeDefinitionHash(definition) {
   return crypto.createHash("sha256").update(HASH_DOMAIN).update(stableJson(canonicalizeDefinition(definition))).digest("hex");
 }
 
+// src/canonical/composition.ts
+function localContract(definition) {
+  return normalizeCanonical(localDefinitionSchema.parse(definition));
+}
+function flattenNamespaceImports(inputs) {
+  const definitions = /* @__PURE__ */ new Map();
+  const visit = (value, depth) => {
+    if (depth > 16 || definitions.size > 32) throw new OrmDefinitionError("namespace import graph is too large");
+    const definition = localContract(localDefinitionSchema.parse(value));
+    const previous = definitions.get(definition.namespace);
+    if (previous) {
+      if (stableJson(previous) !== stableJson(definition)) throw new OrmDefinitionError(`conflicting contracts for namespace '${definition.namespace}'`);
+    }
+    definitions.set(definition.namespace, definition);
+    if (typeof value === "object" && value !== null && "imports" in value && Array.isArray(value.imports)) {
+      for (const dependency of value.imports) visit(dependency, depth + 1);
+    }
+  };
+  for (const input of inputs) visit(input, 0);
+  return [...definitions.values()].sort((a, b) => a.namespace.localeCompare(b.namespace));
+}
+function composeNamespace(definition) {
+  const all = [localContract(definition), ...definition.imports ?? []];
+  const owners = /* @__PURE__ */ new Map();
+  const namespaces = /* @__PURE__ */ new Set();
+  const enums = /* @__PURE__ */ new Map();
+  for (const owner of all) {
+    if (namespaces.has(owner.namespace)) throw new OrmDefinitionError(`duplicate imported namespace '${owner.namespace}'`);
+    namespaces.add(owner.namespace);
+    for (const value of owner.enums) {
+      const previous = enums.get(value.name);
+      if (previous && stableJson(previous) !== stableJson(value)) {
+        throw new OrmDefinitionError(`conflicting imported enum '${value.name}'`);
+      }
+      enums.set(value.name, value);
+    }
+    for (const relation of canonicalRelations(owner)) {
+      if (owners.has(relation.table)) throw new OrmDefinitionError(`ambiguous imported relation '${relation.table}'`);
+      owners.set(relation.table, owner);
+    }
+  }
+  for (const owner of definition.imports?.length ? all : []) {
+    for (const relation of canonicalRelations(owner)) {
+      for (const link of relation.links) {
+        if (link.kind === "toPlatformUser") continue;
+        const target = owners.get(link.target ?? "");
+        if (!target || target.namespace !== (link.namespace ?? owner.namespace)) {
+          throw new OrmDefinitionError(`link '${owner.namespace}/${relation.table}.${link.name}' has no matching imported target`);
+        }
+        if (target.namespace !== owner.namespace && !target.exports?.[link.target ?? ""]) {
+          throw new OrmDefinitionError(`target '${target.namespace}/${link.target}' is not exported`);
+        }
+      }
+    }
+  }
+  return {
+    owners,
+    definition: {
+      ...localContract(definition),
+      tables: all.flatMap((item) => item.tables),
+      views: all.flatMap((item) => item.views ?? []),
+      enums: [...enums.values()]
+    }
+  };
+}
+
 // src/authoring/namespace.ts
 var NAMESPACE_CONFIG_BRAND = "seq-namespace-config";
 function isSeqNamespaceConfig(value) {
@@ -2662,6 +2774,8 @@ function defineNamespace(input) {
     namespace: input.namespace,
     description: input.description,
     capabilities: input.capabilities ?? {},
+    imports: input.imports,
+    exports: input.exports,
     file
   };
   registerNamespaceConfig(config);
@@ -2706,15 +2820,15 @@ function serializeNamespace(input) {
   }
   const relationsByName = /* @__PURE__ */ new Map();
   for (const relation of [...tables, ...views]) {
-    const name = relationName(relation);
-    const existing = relationsByName.get(name);
+    const name2 = relationName(relation);
+    const existing = relationsByName.get(name2);
     if (existing) {
       throw new OrmDefinitionError(
-        `duplicate relation "${name}" (defined as ${relationKind(existing)} in ${describeFile(existing)} and ${relationKind(relation)} in ${describeFile(relation)})`,
+        `duplicate relation "${name2}" (defined as ${relationKind(existing)} in ${describeFile(existing)} and ${relationKind(relation)} in ${describeFile(relation)})`,
         relation.file
       );
     }
-    relationsByName.set(name, relation);
+    relationsByName.set(name2, relation);
   }
   const enumsByName = /* @__PURE__ */ new Map();
   for (const ref of enums) {
@@ -2755,6 +2869,8 @@ function serializeNamespace(input) {
   };
   if (config.description !== void 0) candidate.description = config.description;
   if (canonicalViews.length > 0) candidate.views = canonicalViews;
+  if (config.imports?.length) candidate.imports = flattenNamespaceImports(config.imports);
+  if (config.exports) candidate.exports = config.exports;
   let parsed;
   try {
     parsed = canonicalDefinitionSchema.parse(candidate);
@@ -2764,7 +2880,9 @@ function serializeNamespace(input) {
     }
     throw error;
   }
-  return normalizeCanonical(parsed);
+  const normalized = normalizeCanonical(parsed);
+  if (normalized.imports?.length) composeNamespace(normalized);
+  return normalized;
 }
 function computeCanonicalHash(definition) {
   return crypto.createHash("sha256").update(HASH_DOMAIN).update(stableJson(definition)).digest("hex");
@@ -2778,6 +2896,7 @@ function buildCanonicalTable({ table, relationsByName, enumsByName }) {
     policies: {},
     actions: []
   };
+  if (table.config.displayName !== void 0) candidate.displayName = table.config.displayName;
   if (table.config.description !== void 0) candidate.description = table.config.description;
   if (table.config.renamedFrom !== void 0) candidate.renamedFrom = table.config.renamedFrom;
   if (table.source !== void 0) candidate.source = table.source;
@@ -2861,6 +2980,9 @@ function buildCanonicalTable({ table, relationsByName, enumsByName }) {
   if (table.config.foreignKeys?.length) {
     if (table.source) throw new OrmDefinitionError(`synced table "${table.tableName}" cannot enforce foreign keys`, table.file);
     candidate.foreignKeys = table.config.foreignKeys.map((fk) => {
+      if (typeof fk.target === "object" && fk.target.kind === "seq-external-object") {
+        throw new OrmDefinitionError("physical foreign keys require a local target; use a cross-namespace ORM link", table.file);
+      }
       const target = resolveRelationRef({ ref: fk.target, fail: (message) => {
         throw new OrmDefinitionError(message, table.file);
       } });
@@ -3031,6 +3153,19 @@ function buildCanonicalLink({
       ...link.description !== void 0 ? { description: link.description } : {}
     };
   }
+  if (typeof link.target === "object" && link.target?.kind === "seq-external-object") {
+    if (link.enforce) return fail("cannot enforce a cross-namespace physical foreign key; use an ORM link without enforce");
+    return {
+      name: linkName,
+      kind: link.linkKind,
+      namespace: link.target.namespace,
+      target: link.target.table,
+      on: link.linkKind === "toOne" ? resolveColumnRef({ relation, ref: link.on, role: "link on" }) : link.on,
+      ...link.references !== void 0 ? { references: link.linkKind === "toMany" ? resolveColumnRef({ relation, ref: link.references, role: "link references" }) : link.references } : {},
+      enforce: false,
+      ...link.description !== void 0 ? { description: link.description } : {}
+    };
+  }
   const target = resolveRelationRef({ ref: link.target, fail });
   const targetName = relationName(target);
   if (!relationsByName.has(targetName)) {
@@ -3087,11 +3222,11 @@ function assertAcyclicViewDependencies(views) {
     views.map((view) => [view.view, new Set(view.dependencies.filter((dependency) => viewNames.has(dependency)))])
   );
   while (remaining.size > 0) {
-    const ready = [...remaining.entries()].filter(([, dependencies]) => [...dependencies].every((dependency) => !remaining.has(dependency))).map(([name]) => name);
+    const ready = [...remaining.entries()].filter(([, dependencies]) => [...dependencies].every((dependency) => !remaining.has(dependency))).map(([name2]) => name2);
     if (ready.length === 0) {
       throw new OrmDefinitionError(`view dependencies form a cycle among: ${[...remaining.keys()].sort().join(", ")}`);
     }
-    for (const name of ready) remaining.delete(name);
+    for (const name2 of ready) remaining.delete(name2);
   }
 }
 function toCanonicalPolicy(policy) {
@@ -3137,8 +3272,8 @@ function syncedContractSurface({
     namespace,
     table,
     columns: Object.fromEntries(
-      Object.entries(columns).map(([name, column]) => [
-        name,
+      Object.entries(columns).map(([name2, column]) => [
+        name2,
         { type: column.type, nullable: column.nullable, key: column.key }
       ])
     ),
@@ -3159,7 +3294,7 @@ function extractOrmSyncedTableContract({
   }
   if (table.source === void 0) {
     throw new OrmDefinitionError(
-      `table "${table.table}" is not a synced table \u2014 extractOrmSyncedTableContract requires source: gold.*`
+      `table "${table.table}" is not a synced table \u2014 extractOrmSyncedTableContract requires a qualified source`
     );
   }
   if (table.columns.length === 0) {
@@ -3306,6 +3441,53 @@ function purgeModuleCache(root) {
     if (key.startsWith(prefix)) delete require2.cache[key];
   }
 }
+var sqlScalarSchema = zod.z.enum(["text", "boolean", "integer", "bigint", "numeric", "double", "uuid", "date", "timestamptz"]);
+var name = zod.z.string().regex(/^[A-Za-z_][A-Za-z0-9_]*$/).max(63).refine((value) => !["__proto__", "prototype", "constructor"].includes(value), "reserved name");
+var base = zod.z.object({
+  name,
+  namespace: name,
+  language: zod.z.literal("sql"),
+  kind: zod.z.literal("query"),
+  requires: zod.z.object({ capability: zod.z.string().min(1).max(128) }).strict(),
+  ontology: zod.z.object({ read: zod.z.array(zod.z.string().regex(/^[A-Za-z_][A-Za-z0-9_]*\/[A-Za-z_][A-Za-z0-9_]*$/)).min(1).max(256) }).strict(),
+  maxRows: zod.z.number().int().min(1).max(1e4).default(1e3)
+});
+var fixed = base.extend({
+  parameters: zod.z.record(name, zod.z.object({ type: sqlScalarSchema, required: zod.z.boolean().default(true) }).strict()).default({}),
+  sql: zod.z.string().min(1).max(65536)
+}).strict();
+var runtime = base.extend({ mode: zod.z.literal("runtime") }).strict();
+var sqlOperationDefinitionSchema = zod.z.union([fixed, runtime]);
+function defineOperation(input) {
+  return sqlOperationDefinitionSchema.parse(input);
+}
+
+// src/authoring/catalog.ts
+var SEGMENT = /^[^./\\\s][^/\\]*[^./\\\s]$|^[^./\\\s]$/;
+function validateNamespaceCatalog(catalog, file) {
+  const paths = /* @__PURE__ */ new Set([""]);
+  function visit(folders, parent) {
+    for (const [name2, children] of Object.entries(folders)) {
+      if (!SEGMENT.test(name2) || ["__proto__", "constructor", "prototype"].includes(name2)) {
+        throw new OrmDefinitionError(`invalid catalog folder name "${name2}"`, file);
+      }
+      const path = parent ? `${parent}/${name2}` : name2;
+      paths.add(path);
+      if (children !== null) {
+        if (typeof children !== "object" || Array.isArray(children)) {
+          throw new OrmDefinitionError(`catalog folder "${path}" must contain folders or null`, file);
+        }
+        visit(children, path);
+      }
+    }
+  }
+  visit(catalog.folders, "");
+  for (const [object, path] of Object.entries(catalog.objects)) {
+    if (!object || !paths.has(path)) {
+      throw new OrmDefinitionError(`catalog object "${object}" references missing folder "${path}"`, file);
+    }
+  }
+}
 
 // src/codegen/types.ts
 var WIRE_TYPES = {
@@ -3337,9 +3519,9 @@ function generateNamespaceTypes(definition) {
       lines.push(`  /** Synced from ${table.source} \u2014 read-only typed contract. */`);
     }
     lines.push(`  ${table.table}: {`);
-    for (const [name, column] of columns) {
+    for (const [name2, column] of columns) {
       if (column.deprecated) continue;
-      lines.push(`    ${name}: ${columnWireType(column)}`);
+      lines.push(`    ${name2}: ${columnWireType(column)}`);
     }
     lines.push("  }");
   }
@@ -3350,8 +3532,8 @@ function generateNamespaceTypes(definition) {
 function actionTypeLines(definition) {
   const actions = definition.tables.flatMap((table) => Object.entries(table.actions ?? {}));
   const lines = [`export type ${actionsInterfaceName(definition.namespace)} = {`];
-  for (const [name, action] of actions.sort(([a], [b]) => a.localeCompare(b))) {
-    lines.push(`  ${name}: { params: ${actionParamsType(action)}; result: ${actionResultType(action)} }`);
+  for (const [name2, action] of actions.sort(([a], [b]) => a.localeCompare(b))) {
+    lines.push(`  ${name2}: { params: ${actionParamsType(action)}; result: ${actionResultType(action)} }`);
   }
   lines.push("}", "");
   return lines;
@@ -3359,17 +3541,17 @@ function actionTypeLines(definition) {
 function actionParamsType(action) {
   const entries = Object.entries(action.params ?? {});
   if (entries.length === 0) return "Record<never, never>";
-  const fields = entries.map(([name, param]) => {
-    const base = WIRE_TYPES[param.type];
-    return param.optional ? `${name}?: ${base} | null` : `${name}: ${base}`;
+  const fields = entries.map(([name2, param]) => {
+    const base2 = WIRE_TYPES[param.type];
+    return param.optional ? `${name2}?: ${base2} | null` : `${name2}: ${base2}`;
   });
   return `{ ${fields.join("; ")} }`;
 }
 function actionResultType(action) {
   if (!action.returns) return "{ rowsAffected: number }";
-  const columns = Object.entries(action.returns).map(([name, type]) => {
-    const base = WIRE_TYPES[type];
-    return base === "unknown" ? `${name}: ${base}` : `${name}: ${base} | null`;
+  const columns = Object.entries(action.returns).map(([name2, type]) => {
+    const base2 = WIRE_TYPES[type];
+    return base2 === "unknown" ? `${name2}: ${base2}` : `${name2}: ${base2} | null`;
   });
   return `{ rows: Array<{ ${columns.join("; ")} }> }`;
 }
@@ -3383,9 +3565,9 @@ function pascalCase(namespace) {
   return namespace.split("_").map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
 }
 function columnWireType(column) {
-  const base = WIRE_TYPES[column.type];
+  const base2 = WIRE_TYPES[column.type];
   const notNull = column.primary_key === true || column.nullable === false;
-  return notNull || base === "unknown" ? base : `${base} | null`;
+  return notNull || base2 === "unknown" ? base2 : `${base2} | null`;
 }
 
 // src/predicate/ast.ts
@@ -3850,7 +4032,7 @@ function executesIssues(executes, declaredParams, hasReturns) {
   if (hasReturns && last && !RETURNING_PATTERN.test(last.replace(QUOTED_STRING_PATTERN, "''"))) {
     issues.push("the last executes statement must use RETURNING to populate the declared returns columns");
   }
-  const undeclared = extractNamedParams(statements.join("\n")).filter((name) => !declaredParams.has(name));
+  const undeclared = extractNamedParams(statements.join("\n")).filter((name2) => !declaredParams.has(name2));
   if (undeclared.length > 0) issues.push(`executes references undeclared params: ${undeclared.join(", ")}`);
   return issues;
 }
@@ -3925,19 +4107,19 @@ var PARAM_SCHEMAS = {
 function buildActionParamsSchema(action) {
   const shape = {};
   const entries = Object.entries(action.params ?? {});
-  for (const [name, param] of entries) {
-    shape[name] = param.optional ? PARAM_SCHEMAS[param.type].nullish() : PARAM_SCHEMAS[param.type];
+  for (const [name2, param] of entries) {
+    shape[name2] = param.optional ? PARAM_SCHEMAS[param.type].nullish() : PARAM_SCHEMAS[param.type];
   }
   return zod.z.strictObject(shape).superRefine((obj, ctx) => {
-    for (const [name, param] of entries) {
-      if (!param.optional && param.type === "jsonb" && obj[name] === void 0) {
-        ctx.addIssue({ code: "custom", message: "Required", path: [name] });
+    for (const [name2, param] of entries) {
+      if (!param.optional && param.type === "jsonb" && obj[name2] === void 0) {
+        ctx.addIssue({ code: "custom", message: "Required", path: [name2] });
       }
     }
   });
 }
 var actionParamOrder = (action) => Object.keys(action.params ?? {});
-var actionParamArg = (name) => `p_${name}`;
+var actionParamArg = (name2) => `p_${name2}`;
 function compileActionStatements(action, renderParam = actionParamArg) {
   return actionStatementSources(action.executes).map((statement) => compileStatement(statement, renderParam));
 }
@@ -3988,10 +4170,12 @@ function compilePredIrToSql(pred, options = {}) {
     case "cmp":
       return compileCmp(pred.op, pred.column, pred.value, options);
     case "capability":
-      return `(${capabilityExpression(pred.key)})`;
+      return `(${capabilityExpression(pred.key, pred.namespace ?? options.namespace)})`;
     case "role":
-      return `(${roleExpression(pred.key)})`;
+      return `(${roleExpression(pred.key, pred.namespace ?? options.namespace)})`;
     case "exists":
+      if (options.exists) return options.exists(pred);
+      throw new OrmDefinitionError("synced view read policy cannot use 'exists' without a relationship resolver");
     case "aggPredicate":
     case "dynamicFilter":
       throw new OrmDefinitionError(
@@ -4010,7 +4194,8 @@ function compileCmp(op, column, value, options) {
   const physical2 = physicalColumn(column, options);
   const declared = options.columnTypes?.[physical2] ?? options.columnTypes?.[column];
   const isEnum = typeof declared === "object" && declared !== null;
-  const col = isEnum ? `${quoteIdentifier(physical2)}::text` : quoteIdentifier(physical2);
+  const qualified = options.alias ? `${quoteIdentifier(options.alias)}.${quoteIdentifier(physical2)}` : quoteIdentifier(physical2);
+  const col = isEnum ? `${qualified}::text` : qualified;
   const columnType = isEnum ? "text" : declared;
   switch (op) {
     case "eq":
@@ -4094,22 +4279,22 @@ function returnProjection(returns, lastStatement) {
   const projection = Object.keys(returns).map(quoteIdentifier).join(", ");
   return `WITH orm_returning AS (${lastStatement}) SELECT ${projection} FROM orm_returning`;
 }
-var allActions = (definition) => definition.tables.flatMap((table) => Object.entries(table.actions ?? {}).map(([name, action]) => ({ name, action }))).sort((a, b) => a.name.localeCompare(b.name));
+var allActions = (definition) => definition.tables.flatMap((table) => Object.entries(table.actions ?? {}).map(([name2, action]) => ({ name: name2, action }))).sort((a, b) => a.name.localeCompare(b.name));
 function actionFunctionStatements(definition) {
   const schema = ormSchemaName(definition.namespace);
-  return [dropAllActionFunctions(schema), ...allActions(definition).flatMap(({ name, action }) => createActionFunction(definition, name, action))];
+  return [dropAllActionFunctions(schema), ...allActions(definition).flatMap(({ name: name2, action }) => createActionFunction(definition, name2, action))];
 }
 function actionPrepareChecks(definition) {
   const actions = allActions(definition);
   if (actions.length === 0) return [];
   const statements = [`SET LOCAL search_path TO ${quoteIdentifier(ormSchemaName(definition.namespace))}`];
-  for (const { name, action } of actions) {
+  for (const { name: name2, action } of actions) {
     const order = actionParamOrder(action);
     const signature = order.length > 0 ? ` (${order.map((param) => sqlTypeName(action.params[param].type)).join(", ")})` : "";
     const compiled = compileActionStatements(action, (param) => `$${order.indexOf(param) + 1}`);
     compiled.forEach((sql7, index3) => {
       const checked = action.returns && index3 === compiled.length - 1 ? returnProjection(action.returns, sql7) : sql7;
-      statements.push(`PREPARE ${quoteIdentifier(`orm_check_${name}_${index3}`)}${signature} AS ${checked}`);
+      statements.push(`PREPARE ${quoteIdentifier(`orm_check_${name2}_${index3}`)}${signature} AS ${checked}`);
     });
   }
   return statements;
@@ -4130,9 +4315,9 @@ BEGIN
 END
 $orm_reconcile_actions$`;
 }
-function createActionFunction(definition, name, action) {
+function createActionFunction(definition, name2, action) {
   const schema = quoteIdentifier(ormSchemaName(definition.namespace));
-  const fn = `${schema}.${quoteIdentifier(actionFunctionName(name))}`;
+  const fn = `${schema}.${quoteIdentifier(actionFunctionName(name2))}`;
   const order = actionParamOrder(action);
   const signature = order.map((paramName) => `${quoteIdentifier(actionParamArg(paramName))} ${sqlTypeName(action.params[paramName].type)}`).join(", ");
   const argTypes = order.map((paramName) => sqlTypeName(action.params[paramName].type)).join(", ");
@@ -4152,7 +4337,7 @@ AS $orm_action$
 -- columns; resolve unqualified names to the column.
 #variable_conflict use_column
 BEGIN
-${[functionGuards(definition, name, action), ...leading, `  RETURN QUERY ${returnProjection(action.returns, last)};`].filter(Boolean).join("\n")}
+${[functionGuards(definition, name2, action), ...leading, `  RETURN QUERY ${returnProjection(action.returns, last)};`].filter(Boolean).join("\n")}
 END
 $orm_action$`
   ) : (
@@ -4166,7 +4351,7 @@ AS $orm_action$
 DECLARE
   v_count bigint;
 BEGIN
-${[functionGuards(definition, name, action), ...leading, `  ${last};`].filter(Boolean).join("\n")}
+${[functionGuards(definition, name2, action), ...leading, `  ${last};`].filter(Boolean).join("\n")}
   GET DIAGNOSTICS v_count = ROW_COUNT;
   RETURN v_count;
 END
@@ -4178,13 +4363,13 @@ $orm_action$`
     `GRANT EXECUTE ON FUNCTION ${fn}(${argTypes}) TO ${role}`
   ];
 }
-function functionGuards(definition, name, action) {
+function functionGuards(definition, name2, action) {
   const lines = [];
   const requires = compileActionRequires(action);
   if (requires) {
     lines.push(
       `  IF NOT (${requires}) THEN`,
-      `    RAISE EXCEPTION 'action ${name} requires a grant the caller does not hold' USING ERRCODE = ${quoteLiteral(ACTION_REQUIRES_DENIED_SQLSTATE)};`,
+      `    RAISE EXCEPTION 'action ${name2} requires a grant the caller does not hold' USING ERRCODE = ${quoteLiteral(ACTION_REQUIRES_DENIED_SQLSTATE)};`,
       `  END IF;`
     );
   }
@@ -4236,7 +4421,7 @@ var tableFileSchema = zod.z.strictObject({
   table: identifierSchema,
   description: zod.z.string().optional(),
   columns: zod.z.record(identifierSchema, columnSchema).optional(),
-  source: zod.z.string().regex(SYNCED_SOURCE_PATTERN, "source must reference a gold-layer table").optional(),
+  source: zod.z.string().regex(SYNCED_SOURCE_PATTERN, "source must be a qualified lowercase schema.table identifier").optional(),
   links: zod.z.record(identifierSchema, linkSchema).optional(),
   indexes: zod.z.array(indexSchema).optional(),
   policies: policiesSchema.optional(),
@@ -4245,12 +4430,12 @@ var tableFileSchema = zod.z.strictObject({
   if (RESERVED_TABLE_NAMES.has(table.table)) {
     ctx.addIssue({ code: "custom", message: `'${table.table}' is a reserved table name`, path: ["table"] });
   }
-  for (const name of Object.keys(table.columns ?? {})) {
-    if (RESERVED_COLUMN_NAMES.has(name)) {
+  for (const name2 of Object.keys(table.columns ?? {})) {
+    if (RESERVED_COLUMN_NAMES.has(name2)) {
       ctx.addIssue({
         code: "custom",
-        message: `column '${name}' collides with the Data API's reserved query parameters (select, order, limit, offset) \u2014 it could never be filtered`,
-        path: ["columns", name]
+        message: `column '${name2}' collides with the Data API's reserved query parameters (select, order, limit, offset) \u2014 it could never be filtered`,
+        path: ["columns", name2]
       });
     }
   }
@@ -4283,41 +4468,41 @@ function validateSyncedTable(table, ctx) {
   const columns = table.columns ?? {};
   const names = Object.keys(columns);
   if (names.length === 0) return;
-  const primaryKeys = names.filter((name) => columns[name]?.primary_key);
+  const primaryKeys = names.filter((name2) => columns[name2]?.primary_key);
   if (primaryKeys.length !== 1) {
     ctx.addIssue({ code: "custom", message: "exactly one column must be primary_key", path: ["columns"] });
   }
   validateRenames(columns, names, ctx);
-  for (const name of names) {
-    const column = columns[name];
+  for (const name2 of names) {
+    const column = columns[name2];
     if (!column) continue;
     const cast = column.cast ? castParts(column.cast) : null;
-    if (column.cast && cast?.column !== name) {
+    if (column.cast && cast?.column !== name2) {
       ctx.addIssue({
         code: "custom",
         message: "cast must reference the column it is declared on",
-        path: ["columns", name, "cast"]
+        path: ["columns", name2, "cast"]
       });
     }
     if (cast && cast.type !== column.type) {
       ctx.addIssue({
         code: "custom",
         message: `cast target '${cast.type}' must match the declared type '${column.type}'`,
-        path: ["columns", name, "cast"]
+        path: ["columns", name2, "cast"]
       });
     }
   }
 }
 function validateRenames(columns, names, ctx) {
   const renameSources = /* @__PURE__ */ new Map();
-  for (const name of names) {
-    const renamedFrom = columns[name]?.renamed_from;
+  for (const name2 of names) {
+    const renamedFrom = columns[name2]?.renamed_from;
     if (!renamedFrom) continue;
-    if (renamedFrom === name || names.includes(renamedFrom)) {
+    if (renamedFrom === name2 || names.includes(renamedFrom)) {
       ctx.addIssue({
         code: "custom",
         message: "renamed_from must name a column that no longer exists",
-        path: ["columns", name, "renamed_from"]
+        path: ["columns", name2, "renamed_from"]
       });
     }
     const claimed = renameSources.get(renamedFrom);
@@ -4325,10 +4510,10 @@ function validateRenames(columns, names, ctx) {
       ctx.addIssue({
         code: "custom",
         message: `renamed_from '${renamedFrom}' is already claimed by '${claimed}'`,
-        path: ["columns", name, "renamed_from"]
+        path: ["columns", name2, "renamed_from"]
       });
     }
-    renameSources.set(renamedFrom, name);
+    renameSources.set(renamedFrom, name2);
   }
 }
 function validateColumnTable(table, ctx) {
@@ -4338,27 +4523,27 @@ function validateColumnTable(table, ctx) {
     ctx.addIssue({ code: "custom", message: "a table must declare columns or a source", path: ["columns"] });
     return;
   }
-  const primaryKeys = names.filter((name) => columns[name]?.primary_key);
+  const primaryKeys = names.filter((name2) => columns[name2]?.primary_key);
   if (primaryKeys.length !== 1) {
     ctx.addIssue({ code: "custom", message: "exactly one column must be primary_key", path: ["columns"] });
   }
   validateRenames(columns, names, ctx);
-  for (const name of names) {
-    const column = columns[name];
+  for (const name2 of names) {
+    const column = columns[name2];
     if (!column) continue;
     const cast = column.cast ? castParts(column.cast) : null;
-    if (column.cast && cast?.column !== name) {
+    if (column.cast && cast?.column !== name2) {
       ctx.addIssue({
         code: "custom",
         message: "cast must reference the column it is declared on",
-        path: ["columns", name, "cast"]
+        path: ["columns", name2, "cast"]
       });
     }
     if (cast && cast.type !== column.type) {
       ctx.addIssue({
         code: "custom",
         message: `cast target '${cast.type}' must match the declared type '${column.type}'`,
-        path: ["columns", name, "cast"]
+        path: ["columns", name2, "cast"]
       });
     }
   }
@@ -4383,22 +4568,22 @@ function validateColumnTable(table, ctx) {
 }
 function validateLinks(table, ctx) {
   const columnNames = Object.keys(table.columns ?? {});
-  for (const [name, link] of Object.entries(table.links ?? {})) {
+  for (const [name2, link] of Object.entries(table.links ?? {})) {
     if (columnNames.length > 0 && !columnNames.includes(link.on)) {
-      ctx.addIssue({ code: "custom", message: `link references unknown column '${link.on}'`, path: ["links", name, "on"] });
+      ctx.addIssue({ code: "custom", message: `link references unknown column '${link.on}'`, path: ["links", name2, "on"] });
     }
     if (link.enforce && link.to.includes(".")) {
       ctx.addIssue({
         code: "custom",
         message: "enforce is only valid for links inside the namespace; cross-boundary links stay soft",
-        path: ["links", name, "enforce"]
+        path: ["links", name2, "enforce"]
       });
     }
     if (link.enforce && table.source) {
       ctx.addIssue({
         code: "custom",
         message: "a synced table cannot enforce foreign keys \u2014 its DDL is owned by the sync",
-        path: ["links", name, "enforce"]
+        path: ["links", name2, "enforce"]
       });
     }
   }
@@ -4413,32 +4598,32 @@ function validateDerivedNameLengths(table, ctx) {
     });
   }
   for (const [position, index3] of (table.indexes ?? []).entries()) {
-    const name = indexName(table.table, index3);
-    if (name.length > MAX_IDENTIFIER_LENGTH) {
+    const name2 = indexName(table.table, index3);
+    if (name2.length > MAX_IDENTIFIER_LENGTH) {
       ctx.addIssue({
         code: "custom",
-        message: `derived index name '${name}' exceeds Postgres's ${MAX_IDENTIFIER_LENGTH}-byte identifier limit \u2014 set a shorter explicit name`,
+        message: `derived index name '${name2}' exceeds Postgres's ${MAX_IDENTIFIER_LENGTH}-byte identifier limit \u2014 set a shorter explicit name`,
         path: ["indexes", position]
       });
     }
   }
-  for (const [name, link] of Object.entries(table.links ?? {})) {
-    const constraint = foreignKeyName(table.table, name);
+  for (const [name2, link] of Object.entries(table.links ?? {})) {
+    const constraint = foreignKeyName(table.table, name2);
     if (link.enforce && constraint.length > MAX_IDENTIFIER_LENGTH) {
       ctx.addIssue({
         code: "custom",
         message: `derived foreign-key name '${constraint}' exceeds Postgres's ${MAX_IDENTIFIER_LENGTH}-byte identifier limit \u2014 shorten the link or table name`,
-        path: ["links", name]
+        path: ["links", name2]
       });
     }
   }
-  for (const name of Object.keys(table.actions ?? {})) {
-    const fnName = `action_${name}`;
+  for (const name2 of Object.keys(table.actions ?? {})) {
+    const fnName = `action_${name2}`;
     if (fnName.length > MAX_IDENTIFIER_LENGTH) {
       ctx.addIssue({
         code: "custom",
         message: `derived action function name '${fnName}' exceeds Postgres's ${MAX_IDENTIFIER_LENGTH}-byte identifier limit \u2014 shorten the action name`,
-        path: ["actions", name]
+        path: ["actions", name2]
       });
     }
   }
@@ -4531,7 +4716,7 @@ function policyStatements(schema, table) {
   const policyName2 = (suffix) => quoteIdentifier(policyName(table.table, suffix));
   const statements = POLICY_SUFFIXES.map((suffix) => `DROP POLICY IF EXISTS ${policyName2(suffix)} ON ${qualified}`);
   const columnTypes = Object.fromEntries(
-    Object.entries(table.columns ?? {}).map(([name, column]) => [name, column.type])
+    Object.entries(table.columns ?? {}).map(([name2, column]) => [name2, column.type])
   );
   const read = table.policies?.read;
   if (read) {
@@ -4594,12 +4779,19 @@ function syncedViewStatements({
     const readPolicyIr = readPolicyIrByTable?.get(table.table);
     const readPolicy = table.policies?.read;
     const whereClause = readPolicyIr ? ` WHERE ${compilePredIrToSql(readPolicyIr, {
+      namespace: definition.namespace,
       columnTypes,
       columnNames: columnNamesByTable?.get(table.table)
     })}` : readPolicy ? ` WHERE ${compilePredicate(readPolicy.ast, narrowToV1ColumnTypes(columnTypes))}` : " WHERE false";
     if (backingPrivileges === "grant") {
       statements.push(`GRANT USAGE ON SCHEMA ${quoteIdentifier(physical2.schema)} TO ${owner}`);
       statements.push(`GRANT SELECT ON ${physicalTarget} TO ${owner}`);
+      statements.push(`DO ${quoteLiteral(`BEGIN
+  IF NOT (pg_catalog.has_schema_privilege(${quoteLiteral(executionOwnerRole)}, ${quoteLiteral(physical2.schema)}, 'USAGE')
+    AND pg_catalog.has_table_privilege(${quoteLiteral(executionOwnerRole)}, ${quoteLiteral(physicalTarget)}, 'SELECT')) THEN
+    RAISE EXCEPTION 'Synced backing owner lacks effective USAGE/SELECT; repair managed serving reader access before ORM apply' USING ERRCODE = '42501';
+  END IF;
+END`)}`);
     }
     statements.push(
       `CREATE OR REPLACE VIEW ${viewName} AS SELECT * FROM ${physicalTarget}${whereClause}`
@@ -4615,8 +4807,8 @@ function mergeSyncedViewColumnTypes({
   columnNames
 }) {
   const fromTable = {};
-  for (const [name, def] of Object.entries(table.columns ?? {})) {
-    if (def?.type) fromTable[name] = def.type;
+  for (const [name2, def] of Object.entries(table.columns ?? {})) {
+    if (def?.type) fromTable[name2] = def.type;
   }
   if (columnNames) {
     for (const [logical, physical2] of Object.entries(columnNames)) {
@@ -4670,21 +4862,21 @@ function syncedBackingRevokeStatements({
   return statements;
 }
 var FACTORIES = {
-  uuid: (name) => pgCore.uuid(name),
-  text: (name) => pgCore.text(name),
-  integer: (name) => pgCore.integer(name),
+  uuid: (name2) => pgCore.uuid(name2),
+  text: (name2) => pgCore.text(name2),
+  integer: (name2) => pgCore.integer(name2),
   // Mode 'bigint' keeps int8 lossless — mode 'number' silently rounds past
   // 2^53. The read executor serializes BigInt to string for JSON.
-  bigint: (name) => pgCore.bigint(name, { mode: "bigint" }),
-  numeric: (name) => pgCore.numeric(name),
-  double: (name) => pgCore.doublePrecision(name),
-  boolean: (name) => pgCore.boolean(name),
-  timestamptz: (name) => pgCore.timestamp(name, { withTimezone: true }),
-  date: (name) => pgCore.date(name),
-  jsonb: (name) => pgCore.jsonb(name)
+  bigint: (name2) => pgCore.bigint(name2, { mode: "bigint" }),
+  numeric: (name2) => pgCore.numeric(name2),
+  double: (name2) => pgCore.doublePrecision(name2),
+  boolean: (name2) => pgCore.boolean(name2),
+  timestamptz: (name2) => pgCore.timestamp(name2, { withTimezone: true }),
+  date: (name2) => pgCore.date(name2),
+  jsonb: (name2) => pgCore.jsonb(name2)
 };
-function buildColumn(name, definition) {
-  let column = FACTORIES[definition.type](name);
+function buildColumn(name2, definition) {
+  let column = FACTORIES[definition.type](name2);
   if (definition.primary_key) column = column.primaryKey();
   if (definition.nullable === false && !definition.primary_key) column = column.notNull();
   if (definition.unique && !definition.primary_key) column = column.unique();
@@ -4715,7 +4907,7 @@ function buildDrizzleEntities(definition) {
 }
 function buildTable(schema, table, built) {
   const columns = Object.fromEntries(
-    Object.entries(table.columns ?? {}).map(([name, column]) => [name, buildColumn(name, column)])
+    Object.entries(table.columns ?? {}).map(([name2, column]) => [name2, buildColumn(name2, column)])
   );
   const drizzleTable = schema.table(table.table, columns, (self) => [
     ...buildIndexes(table, self),
@@ -4725,21 +4917,21 @@ function buildTable(schema, table, built) {
 }
 function buildIndexes(table, self) {
   return (table.indexes ?? []).map((definition) => {
-    const name = indexName(table.table, definition);
-    const factory = definition.unique ? pgCore.uniqueIndex(name) : pgCore.index(name);
+    const name2 = indexName(table.table, definition);
+    const factory = definition.unique ? pgCore.uniqueIndex(name2) : pgCore.index(name2);
     const columns = definition.columns.map((column) => self[column]);
     return factory.on(...columns);
   });
 }
 function buildForeignKeys(table, self, built) {
-  return Object.entries(table.links ?? {}).filter(([, link]) => link.enforce).map(([name, link]) => {
+  return Object.entries(table.links ?? {}).filter(([, link]) => link.enforce).map(([name2, link]) => {
     const target = link.to === table.table ? self : built.get(link.to);
     const targetColumn = target && findPrimaryKeyColumn(target);
     if (!target || !targetColumn) {
-      throw new OrmDefinitionError(`enforced link '${name}' on '${table.table}' has no built target '${link.to}'`);
+      throw new OrmDefinitionError(`enforced link '${name2}' on '${table.table}' has no built target '${link.to}'`);
     }
     return pgCore.foreignKey({
-      name: foreignKeyName(table.table, name),
+      name: foreignKeyName(table.table, name2),
       columns: [self[link.on]],
       foreignColumns: [targetColumn]
     });
@@ -4796,21 +4988,21 @@ function diffStatements(previous, current) {
 function assertUnambiguousDiff(previous, current) {
   const previousTables = tablesOf(previous);
   const currentTables = tablesOf(current);
-  const removedTables = [...previousTables.keys()].filter((name) => !currentTables.has(name));
-  const addedTables = [...currentTables.keys()].filter((name) => !previousTables.has(name));
+  const removedTables = [...previousTables.keys()].filter((name2) => !currentTables.has(name2));
+  const addedTables = [...currentTables.keys()].filter((name2) => !previousTables.has(name2));
   if (removedTables.length > 0 && addedTables.length > 0) {
     throw new OrmDefinitionError(
       `ambiguous diff: table(s) added (${addedTables.join(", ")}) and removed (${removedTables.join(", ")}) in the same change \u2014 ship the add and the drop as separate changes`
     );
   }
-  for (const [name, previousColumns] of previousTables) {
-    const currentColumns = currentTables.get(name);
+  for (const [name2, previousColumns] of previousTables) {
+    const currentColumns = currentTables.get(name2);
     if (!currentColumns) continue;
     const removed = [...previousColumns].filter((column) => !currentColumns.has(column));
     const added = [...currentColumns].filter((column) => !previousColumns.has(column));
     if (removed.length > 0 && added.length > 0) {
       throw new OrmDefinitionError(
-        `ambiguous diff on '${name}': column(s) added (${added.join(", ")}) and removed (${removed.join(", ")}) in the same change \u2014 declare \`renamed_from\` for a rename, or ship the add and the drop as separate changes`
+        `ambiguous diff on '${name2}': column(s) added (${added.join(", ")}) and removed (${removed.join(", ")}) in the same change \u2014 declare \`renamed_from\` for a rename, or ship the add and the drop as separate changes`
       );
     }
   }
@@ -4829,33 +5021,33 @@ function applyMigrationHints(previous, definition) {
   for (const table of columnTables(definition)) {
     const snapshotTable = findTable(adjusted, schemaName, table.table);
     if (!snapshotTable) continue;
-    for (const [name, column] of Object.entries(table.columns ?? {})) {
+    for (const [name2, column] of Object.entries(table.columns ?? {})) {
       if (column.renamed_from) {
         const previousColumn = snapshotTable.columns[column.renamed_from];
-        if (previousColumn && snapshotTable.columns[name]) {
+        if (previousColumn && snapshotTable.columns[name2]) {
           throw new OrmDefinitionError(
-            `'${table.table}.${name}' declares renamed_from '${column.renamed_from}', but both columns exist in the previous schema \u2014 a rename cannot overwrite a live column`
+            `'${table.table}.${name2}' declares renamed_from '${column.renamed_from}', but both columns exist in the previous schema \u2014 a rename cannot overwrite a live column`
           );
         }
         if (previousColumn) {
           statements.push(
-            `ALTER TABLE ${qualified(table.table)} RENAME COLUMN ${quoteIdentifier(column.renamed_from)} TO ${quoteIdentifier(name)}`
+            `ALTER TABLE ${qualified(table.table)} RENAME COLUMN ${quoteIdentifier(column.renamed_from)} TO ${quoteIdentifier(name2)}`
           );
           delete snapshotTable.columns[column.renamed_from];
-          snapshotTable.columns[name] = { ...previousColumn, name };
-        } else if (!snapshotTable.columns[name]) {
+          snapshotTable.columns[name2] = { ...previousColumn, name: name2 };
+        } else if (!snapshotTable.columns[name2]) {
           throw new OrmDefinitionError(
-            `'${table.table}.${name}' declares renamed_from '${column.renamed_from}', but the previous schema has neither column \u2014 check the declared source name`
+            `'${table.table}.${name2}' declares renamed_from '${column.renamed_from}', but the previous schema has neither column \u2014 check the declared source name`
           );
         }
       }
       const cast = column.cast ? castParts(column.cast) : null;
       if (cast) {
-        const current = snapshotTable.columns[name];
+        const current = snapshotTable.columns[name2];
         const targetType = sqlTypeName(column.type);
         if (current && current.type !== targetType) {
           statements.push(
-            `ALTER TABLE ${qualified(table.table)} ALTER COLUMN ${quoteIdentifier(name)} TYPE ${targetType} USING ${quoteIdentifier(name)}::${targetType}`
+            `ALTER TABLE ${qualified(table.table)} ALTER COLUMN ${quoteIdentifier(name2)} TYPE ${targetType} USING ${quoteIdentifier(name2)}::${targetType}`
           );
           current.type = targetType;
         }
@@ -4896,8 +5088,8 @@ function materializedRefreshFunctions(canonical) {
   }
   return functions;
 }
-function refreshFunctionSql({ schema, name, table, compute, columns, pk }) {
-  const fn = `${quoteIdentifier(schema)}.${quoteIdentifier(materializedRefreshFunctionName(name))}`;
+function refreshFunctionSql({ schema, name: name2, table, compute, columns, pk }) {
+  const fn = `${quoteIdentifier(schema)}.${quoteIdentifier(materializedRefreshFunctionName(name2))}`;
   const target = `${quoteIdentifier(schema)}.${quoteIdentifier(table)}`;
   const source = `${quoteIdentifier(schema)}.${quoteIdentifier(compute)}`;
   const list = columns.map(quoteIdentifier).join(", ");
@@ -4906,7 +5098,7 @@ function refreshFunctionSql({ schema, name, table, compute, columns, pk }) {
   const matches = pk.map((column) => `c.${quoteIdentifier(column)} = m.${quoteIdentifier(column)}`).join(" AND ");
   const onConflict = others.length === 0 ? "DO NOTHING" : `DO UPDATE SET ${others.map((column) => `${quoteIdentifier(column)} = EXCLUDED.${quoteIdentifier(column)}`).join(", ")}
       WHERE (${others.map((column) => `m.${quoteIdentifier(column)}`).join(", ")}) IS DISTINCT FROM (${others.map((column) => `EXCLUDED.${quoteIdentifier(column)}`).join(", ")})`;
-  const lockKey = quoteLiteral(materializeLockKey(schema, name));
+  const lockKey = quoteLiteral(materializeLockKey(schema, name2));
   return `CREATE OR REPLACE FUNCTION ${fn}(wait boolean DEFAULT false)
 RETURNS TABLE(upserted bigint, deleted bigint, locked boolean)
 LANGUAGE plpgsql
@@ -4944,12 +5136,12 @@ $orm_refresh$`;
 function refreshFunctionStatements({ namespace, previous, current }) {
   const schema = quoteIdentifier(ormSchemaName(namespace));
   const statements = [];
-  for (const name of Object.keys(previous).sort()) {
-    if (!current.has(name)) statements.push(`DROP FUNCTION IF EXISTS ${schema}.${quoteIdentifier(materializedRefreshFunctionName(name))}(boolean)`);
+  for (const name2 of Object.keys(previous).sort()) {
+    if (!current.has(name2)) statements.push(`DROP FUNCTION IF EXISTS ${schema}.${quoteIdentifier(materializedRefreshFunctionName(name2))}(boolean)`);
   }
-  for (const [name, create] of [...current].sort(([a], [b]) => a.localeCompare(b))) {
-    if (previous[name] === create) continue;
-    const fn = `${schema}.${quoteIdentifier(materializedRefreshFunctionName(name))}(boolean)`;
+  for (const [name2, create] of [...current].sort(([a], [b]) => a.localeCompare(b))) {
+    if (previous[name2] === create) continue;
+    const fn = `${schema}.${quoteIdentifier(materializedRefreshFunctionName(name2))}(boolean)`;
     statements.push(create, `REVOKE ALL ON FUNCTION ${fn} FROM PUBLIC`);
   }
   return statements;
@@ -4957,21 +5149,21 @@ function refreshFunctionStatements({ namespace, previous, current }) {
 
 // src/engine/canonical2.ts
 var FACTORIES2 = {
-  uuid: (name) => pgCore.uuid(name),
-  text: (name) => pgCore.text(name),
-  integer: (name) => pgCore.integer(name),
+  uuid: (name2) => pgCore.uuid(name2),
+  text: (name2) => pgCore.text(name2),
+  integer: (name2) => pgCore.integer(name2),
   // Mode 'bigint' keeps int8 lossless — mode 'number' silently rounds past
   // 2^53. The read executor serializes BigInt to string for JSON.
-  bigint: (name) => pgCore.bigint(name, { mode: "bigint" }),
-  numeric: (name) => pgCore.numeric(name),
-  double: (name) => pgCore.doublePrecision(name),
-  boolean: (name) => pgCore.boolean(name),
-  timestamptz: (name) => pgCore.timestamp(name, { withTimezone: true }),
-  date: (name) => pgCore.date(name),
-  jsonb: (name) => pgCore.jsonb(name)
+  bigint: (name2) => pgCore.bigint(name2, { mode: "bigint" }),
+  numeric: (name2) => pgCore.numeric(name2),
+  double: (name2) => pgCore.doublePrecision(name2),
+  boolean: (name2) => pgCore.boolean(name2),
+  timestamptz: (name2) => pgCore.timestamp(name2, { withTimezone: true }),
+  date: (name2) => pgCore.date(name2),
+  jsonb: (name2) => pgCore.jsonb(name2)
 };
 var SCHEMA_IMPORT_KEY2 = "$schema";
-var enumImportKey = (name) => `$enum_${name}`;
+var enumImportKey = (name2) => `$enum_${name2}`;
 var columnTablesV2 = (definition) => definition.tables.filter((table) => !table.source);
 function buildDrizzleEntitiesV2(definition, options = {}) {
   const schemaName = ormSchemaName(definition.namespace);
@@ -5273,9 +5465,9 @@ function buildTable2(schema, table, built, enums, byName, introspection) {
     throw new OrmDefinitionError(`table '${table.table}' declares no primaryKey`);
   }
   const columnNames = new Set(table.columns.map((column) => column.columnName));
-  for (const name of primaryKeyColumns) {
-    if (!columnNames.has(name)) {
-      throw new OrmDefinitionError(`primaryKey of '${table.table}' references unknown column '${name}'`);
+  for (const name2 of primaryKeyColumns) {
+    if (!columnNames.has(name2)) {
+      throw new OrmDefinitionError(`primaryKey of '${table.table}' references unknown column '${name2}'`);
     }
   }
   const singlePrimaryKey = primaryKeyColumns.length === 1 ? primaryKeyColumns[0] : void 0;
@@ -5361,8 +5553,8 @@ function buildIndexes2(table, self) {
         throw new OrmDefinitionError(`index on '${table.table}' references unknown column '${column}'`);
       }
     }
-    const name = indexName(table.table, definition);
-    const factory = definition.unique ? pgCore.uniqueIndex(name) : pgCore.index(name);
+    const name2 = indexName(table.table, definition);
+    const factory = definition.unique ? pgCore.uniqueIndex(name2) : pgCore.index(name2);
     const columns = definition.columns.map((column) => self[column]);
     return factory.on(...columns);
   });
@@ -5441,33 +5633,33 @@ function applyMigrationHintsV2(previous, definition) {
     const snapshotTable = findTable2(adjusted, schemaName, table.table);
     if (!snapshotTable) continue;
     for (const column of table.columns) {
-      const name = column.columnName;
+      const name2 = column.columnName;
       if (column.renamedFrom) {
         const previousColumn = snapshotTable.columns[column.renamedFrom];
-        if (previousColumn && snapshotTable.columns[name]) {
+        if (previousColumn && snapshotTable.columns[name2]) {
           throw new OrmDefinitionError(
-            `'${table.table}.${name}' declares renamedFrom '${column.renamedFrom}', but both columns exist in the previous schema \u2014 a rename cannot overwrite a live column`
+            `'${table.table}.${name2}' declares renamedFrom '${column.renamedFrom}', but both columns exist in the previous schema \u2014 a rename cannot overwrite a live column`
           );
         }
         if (previousColumn) {
           statements.push(
-            `ALTER TABLE ${qualified(table.table)} RENAME COLUMN ${quoteIdentifier(column.renamedFrom)} TO ${quoteIdentifier(name)}`
+            `ALTER TABLE ${qualified(table.table)} RENAME COLUMN ${quoteIdentifier(column.renamedFrom)} TO ${quoteIdentifier(name2)}`
           );
           delete snapshotTable.columns[column.renamedFrom];
-          snapshotTable.columns[name] = { ...previousColumn, name };
-        } else if (!snapshotTable.columns[name]) {
+          snapshotTable.columns[name2] = { ...previousColumn, name: name2 };
+        } else if (!snapshotTable.columns[name2]) {
           throw new OrmDefinitionError(
-            `'${table.table}.${name}' declares renamedFrom '${column.renamedFrom}', but the previous schema has neither column \u2014 check the declared source name`
+            `'${table.table}.${name2}' declares renamedFrom '${column.renamedFrom}', but the previous schema has neither column \u2014 check the declared source name`
           );
         }
       }
       const cast = column.cast ? castParts(column.cast) : null;
       if (cast) {
-        const current = snapshotTable.columns[name];
+        const current = snapshotTable.columns[name2];
         const { snapshotType, sqlType } = castTargetTypes(column, enumsByName, schemaName, table.table);
         if (current && current.type !== snapshotType) {
           statements.push(
-            `ALTER TABLE ${qualified(table.table)} ALTER COLUMN ${quoteIdentifier(name)} TYPE ${sqlType} USING ${quoteIdentifier(name)}::${sqlType}`
+            `ALTER TABLE ${qualified(table.table)} ALTER COLUMN ${quoteIdentifier(name2)} TYPE ${sqlType} USING ${quoteIdentifier(name2)}::${sqlType}`
           );
           current.type = snapshotType;
         }
@@ -5478,8 +5670,8 @@ function applyMigrationHintsV2(previous, definition) {
 }
 function castTargetTypes(column, enums, schemaName, table) {
   if (typeof column.type === "string") {
-    const name = sqlTypeName(column.type);
-    return { snapshotType: name, sqlType: name };
+    const name2 = sqlTypeName(column.type);
+    return { snapshotType: name2, sqlType: name2 };
   }
   const enumName = column.type.enum;
   if (!enums.has(enumName)) {
@@ -5564,11 +5756,11 @@ async function planWithViewRecreation({
     })
   });
   const dropOrder = topologicalViewNames(
-    new Set([...affected].filter((name) => previousViews.has(name))),
+    new Set([...affected].filter((name2) => previousViews.has(name2))),
     previousDependencies
   ).reverse();
   const createOrder = topologicalViewNames(
-    new Set([...affected].filter((name) => currentViews.has(name))),
+    new Set([...affected].filter((name2) => currentViews.has(name2))),
     currentDependencies
   );
   const dropDdl = await generatedViewStatements({
@@ -5585,14 +5777,14 @@ async function planWithViewRecreation({
   });
   const currentViewDefinitions = new Map((canonical.views ?? []).map((view) => [view.view, view]));
   const statements = [
-    ...dropOrder.map((name) => ({ kind: "ddl", sql: requiredViewStatement(dropDdl, name, schema, "DROP") })),
+    ...dropOrder.map((name2) => ({ kind: "ddl", sql: requiredViewStatement(dropDdl, name2, schema, "DROP") })),
     ...hints.statements.map((statement) => ({ kind: "hint", sql: statement })),
     ...baseDdl.map((statement) => ({ kind: "ddl", sql: statement.replace(/;\s*$/, "") })),
     ...foreignKeyTimingStatements(canonical, previous, baseDdl).map((sql7) => ({ kind: "ddl", sql: sql7 })),
-    ...createOrder.map((name) => ({ kind: "ddl", sql: requiredViewStatement(createDdl, name, schema, "CREATE") })),
-    ...createOrder.map((name) => {
-      const view = currentViewDefinitions.get(name);
-      if (!view) throw new OrmDefinitionError(`missing canonical definition for view '${name}'`);
+    ...createOrder.map((name2) => ({ kind: "ddl", sql: requiredViewStatement(createDdl, name2, schema, "CREATE") })),
+    ...createOrder.map((name2) => {
+      const view = currentViewDefinitions.get(name2);
+      if (!view) throw new OrmDefinitionError(`missing canonical definition for view '${name2}'`);
       return { kind: "ddl", sql: validateViewCatalogStatement({ canonical, view, schema }) };
     }),
     ...refreshFunctionStatements({
@@ -5622,9 +5814,9 @@ function foreignKeyTimingStatements(canonical, previous, baseDdl) {
   }
   return result;
 }
-function foreignKeyTimingSql(schema, table, name, timing) {
+function foreignKeyTimingSql(schema, table, name2, timing) {
   const clause = timing === void 0 ? "NOT DEFERRABLE" : timing === "initially-deferred" ? "DEFERRABLE INITIALLY DEFERRED" : "DEFERRABLE INITIALLY IMMEDIATE";
-  return `ALTER TABLE ${quoteIdentifier(schema)}.${quoteIdentifier(table)} ALTER CONSTRAINT ${quoteIdentifier(name)} ${clause}`;
+  return `ALTER TABLE ${quoteIdentifier(schema)}.${quoteIdentifier(table)} ALTER CONSTRAINT ${quoteIdentifier(name2)} ${clause}`;
 }
 function validateViewCatalogStatement({
   canonical,
@@ -5766,7 +5958,7 @@ function viewReach({
   if (viewRecreation === "all-on-base-change") return "all";
   if (baseDdl.some((statement) => DROPS_TYPE.test(statement))) return "all";
   const dependencies = snapshotViewDependencies(adjusted);
-  if ([...snapshotViews(adjusted).keys()].some((name) => dependencies[name] === void 0)) return "all";
+  if ([...snapshotViews(adjusted).keys()].some((name2) => dependencies[name2] === void 0)) return "all";
   return baseChangesReachingViews({ previous, adjusted, current });
 }
 var SNAPSHOT_BOOKKEEPING = /* @__PURE__ */ new Set(["id", "prevId", "version", "dialect", "_meta", "views", "_sequenceOrm", "enums"]);
@@ -5815,8 +6007,8 @@ function tableChangeReachesViews({ was, is: is2 }) {
     if (field === "columns" || VIEW_SAFE_TABLE_FIELDS.has(field)) continue;
     if (stableJson(was[field]) !== stableJson(is2[field])) return true;
   }
-  return Object.entries(was.columns).some(([name, column]) => {
-    const next = is2.columns[name];
+  return Object.entries(was.columns).some(([name2, column]) => {
+    const next = is2.columns[name2];
     if (!next) return true;
     return [.../* @__PURE__ */ new Set([...Object.keys(column), ...Object.keys(next)])].some(
       (field) => !VIEW_SAFE_COLUMN_FIELDS.has(field) && stableJson(column[field]) !== stableJson(next[field])
@@ -5842,22 +6034,22 @@ function affectedViewNames({
 }) {
   const allNames = /* @__PURE__ */ new Set([...previousViews.keys(), ...currentViews.keys()]);
   if (reach === "all") return allNames;
-  const dependenciesOf = (name) => /* @__PURE__ */ new Set([...previousDependencies[name] ?? [], ...currentDependencies[name] ?? []]);
+  const dependenciesOf = (name2) => /* @__PURE__ */ new Set([...previousDependencies[name2] ?? [], ...currentDependencies[name2] ?? []]);
   const affected = new Set(
-    [...allNames].filter((name) => {
-      const before = previousViews.get(name);
-      const after = currentViews.get(name);
+    [...allNames].filter((name2) => {
+      const before = previousViews.get(name2);
+      const after = currentViews.get(name2);
       if (before === void 0 || after === void 0 || stableJson(before) !== stableJson(after)) return true;
-      return [...dependenciesOf(name)].some((dependency) => reach.has(dependency));
+      return [...dependenciesOf(name2)].some((dependency) => reach.has(dependency));
     })
   );
   let grew = true;
   while (grew) {
     grew = false;
-    for (const name of allNames) {
-      if (affected.has(name)) continue;
-      if ([...dependenciesOf(name)].some((dependency) => affected.has(dependency))) {
-        affected.add(name);
+    for (const name2 of allNames) {
+      if (affected.has(name2)) continue;
+      if ([...dependenciesOf(name2)].some((dependency) => affected.has(dependency))) {
+        affected.add(name2);
         grew = true;
       }
     }
@@ -5868,13 +6060,13 @@ function topologicalViewNames(names, dependencies) {
   const remaining = new Set(names);
   const ordered = [];
   while (remaining.size > 0) {
-    const ready = [...remaining].filter((name) => (dependencies[name] ?? []).every((dependency) => !remaining.has(dependency))).sort();
+    const ready = [...remaining].filter((name2) => (dependencies[name2] ?? []).every((dependency) => !remaining.has(dependency))).sort();
     if (ready.length === 0) {
       throw new OrmDefinitionError(`view dependencies form a cycle among: ${[...remaining].sort().join(", ")}`);
     }
-    for (const name of ready) {
-      ordered.push(name);
-      remaining.delete(name);
+    for (const name2 of ready) {
+      ordered.push(name2);
+      remaining.delete(name2);
     }
   }
   return ordered;
@@ -5892,18 +6084,18 @@ async function generatedViewStatements({
   holder.views = Object.fromEntries(Object.entries(views).filter(([, view]) => !names.has(view.name)));
   const generated = mode === "drop" ? await diffStatements(snapshot, without) : await diffStatements(without, snapshot);
   const statements = /* @__PURE__ */ new Map();
-  for (const name of names) {
-    const qualified = `${quoteIdentifier(schema)}.${quoteIdentifier(name)}`;
+  for (const name2 of names) {
+    const qualified = `${quoteIdentifier(schema)}.${quoteIdentifier(name2)}`;
     const prefix = mode === "drop" ? "DROP VIEW" : "CREATE VIEW";
     const statement = generated.find((candidate) => candidate.trimStart().startsWith(`${prefix} ${qualified}`));
-    if (statement) statements.set(name, statement.replace(/;\s*$/, ""));
+    if (statement) statements.set(name2, statement.replace(/;\s*$/, ""));
   }
   return statements;
 }
-function requiredViewStatement(statements, name, schema, operation) {
-  const statement = statements.get(name);
+function requiredViewStatement(statements, name2, schema, operation) {
+  const statement = statements.get(name2);
   if (!statement) {
-    throw new OrmDefinitionError(`drizzle-kit did not generate ${operation} VIEW for '${schema}.${name}'`);
+    throw new OrmDefinitionError(`drizzle-kit did not generate ${operation} VIEW for '${schema}.${name2}'`);
   }
   return statement;
 }
@@ -6149,9 +6341,13 @@ function renderOrmMigrationExport(exported) {
   if (Buffer.byteLength(text4, "utf8") > ORM_MIGRATION_EXPORT_MAX_BYTES) throw new Error("ORM migration export exceeds the size limit");
   return text4;
 }
-var IR_VERSION = 2;
+var IR_VERSION = 5;
 var LEGACY_IR_VERSION = 1;
-var irVersionSchema = zod.z.union([zod.z.literal(LEGACY_IR_VERSION), zod.z.literal(IR_VERSION)]);
+var GUARDED_IR_VERSION = 2;
+var COMPOSED_IR_VERSION = 3;
+var SQL_IR_VERSION = 4;
+var RUNTIME_SQL_IR_VERSION = 5;
+var irVersionSchema = zod.z.union([zod.z.literal(LEGACY_IR_VERSION), zod.z.literal(GUARDED_IR_VERSION), zod.z.literal(COMPOSED_IR_VERSION), zod.z.literal(SQL_IR_VERSION), zod.z.literal(RUNTIME_SQL_IR_VERSION)]);
 var operationVersionSchema = zod.z.object({ irVersion: irVersionSchema });
 function requiredArtifactIrVersion(operations) {
   let required = LEGACY_IR_VERSION;
@@ -6203,8 +6399,8 @@ var predIrSchema = zod.z.lazy(
       value: zod.z.number(),
       where: predIrSchema.optional()
     }),
-    zod.z.object({ kind: zod.z.literal("capability"), key: zod.z.string() }),
-    zod.z.object({ kind: zod.z.literal("role"), key: zod.z.string() }),
+    zod.z.object({ kind: zod.z.literal("capability"), key: zod.z.string(), namespace: zod.z.string().optional() }),
+    zod.z.object({ kind: zod.z.literal("role"), key: zod.z.string(), namespace: zod.z.string().optional() }),
     zod.z.object({ kind: zod.z.literal("dynamicFilter"), slot: zod.z.string() }),
     zod.z.object({ kind: zod.z.literal("const"), value: zod.z.boolean() })
   ])
@@ -6431,7 +6627,31 @@ var variableIrSchema = zod.z.object({
   /** Absent = no default declared; see {@link variableDefaultIrSchema}. */
   defaultValue: variableDefaultIrSchema.optional()
 });
+var sqlColumnSchema = zod.z.object({ name: zod.z.string(), type: zod.z.enum(["text", "boolean", "integer", "bigint", "numeric", "double", "uuid", "date", "timestamptz"]), nullable: zod.z.boolean() });
 var compiledOperationSchema = zod.z.object({
+  language: zod.z.literal("sql").optional(),
+  /** Server-compiled object catalog and permission ceiling, never caller SQL. */
+  sqlQuery: zod.z.object({
+    catalog: zod.z.object({
+      identity: zod.z.string(),
+      objects: zod.z.array(zod.z.object({
+        ref: zod.z.string(),
+        table: zod.z.string(),
+        columns: zod.z.array(sqlColumnSchema.extend({ type: zod.z.string() })).min(1),
+        scan: zod.z.string().min(1),
+        read: zod.z.array(zod.z.string()).min(1)
+      }).strict()).min(1).max(256)
+    }).strict(),
+    read: zod.z.array(zod.z.string()).min(1).max(256),
+    maxRows: zod.z.number().int().min(1).max(1e4)
+  }).strict().optional(),
+  sql: zod.z.object({
+    text: zod.z.string().min(1).max(1048576),
+    columns: zod.z.array(sqlColumnSchema).min(1).max(256),
+    parameters: zod.z.array(zod.z.string()).max(128),
+    read: zod.z.array(zod.z.string()).min(1).max(256),
+    maxRows: zod.z.number().int().min(1).max(1e4)
+  }).strict().optional(),
   irVersion: irVersionSchema,
   name: zod.z.string(),
   opHash: zod.z.string().regex(/^sha256:[0-9a-f]{64}$/),
@@ -6443,8 +6663,16 @@ var compiledOperationSchema = zod.z.object({
   variables: zod.z.array(variableIrSchema),
   /** Every table the op touches — data-token scoping + audit. */
   tableSet: zod.z.array(zod.z.string()).min(1),
-  roots: zod.z.array(rootIrSchema).min(1)
+  roots: zod.z.array(rootIrSchema)
 }).superRefine((operation, ctx) => {
+  if (operation.language === "sql") {
+    const validPlan = operation.sqlQuery ? !operation.sql && operation.irVersion === RUNTIME_SQL_IR_VERSION : !!operation.sql && operation.irVersion === SQL_IR_VERSION;
+    if (!validPlan || operation.kind !== "query" || operation.roots.length !== 0 || !operation.requires?.capability) {
+      ctx.addIssue({ code: "custom", message: "SQL operations require a query-only v4 plan or v5 runtime contract, capability, and no GraphQL roots" });
+    }
+  } else if (operation.sql || operation.sqlQuery || operation.roots.length === 0) {
+    ctx.addIssue({ code: "custom", message: "GraphQL operations require roots and cannot carry SQL" });
+  }
   for (const [index3, root] of operation.roots.entries()) {
     if (root.kind !== "mutation" || root.assertAffectedRows === void 0) continue;
     if (operation.irVersion < 2 || operation.kind !== "mutation" || root.includeIf !== void 0) {
@@ -6491,11 +6719,16 @@ var resolvedMetaIrSchema = zod.z.object({
 });
 var tableMetaIrSchema = zod.z.object({
   table: zod.z.string(),
+  namespace: zod.z.string().optional(),
+  dependencies: zod.z.array(zod.z.string()).optional(),
+  foreignReferences: zod.z.array(zod.z.object({ column: zod.z.string(), target: zod.z.string(), targetColumn: zod.z.string() })).optional(),
+  exportRead: zod.z.union([zod.z.literal(true), zod.z.object({ capability: zod.z.string() }), zod.z.object({ role: zod.z.string() })]).optional(),
+  exportWrite: zod.z.union([zod.z.literal(true), zod.z.object({ capability: zod.z.string() }), zod.z.object({ role: zod.z.string() })]).optional(),
   schema: zod.z.string(),
   typename: zod.z.string(),
   /**
    * True when statements over this relation evaluate a claims-gated synced
-   * view: synced twins (`source: gold.*`) materialize as views whose baked
+   * view: synced twins (`source: schema.table`) 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
@@ -6554,13 +6787,21 @@ var compiledArtifactSchema = zod.z.object({
   irVersion: irVersionSchema,
   namespace: zod.z.string(),
   schemaHash: zod.z.string(),
+  ownSchemaHash: zod.z.string().optional(),
+  dependencies: zod.z.record(zod.z.string(), zod.z.string()).optional(),
+  readPolicies: zod.z.record(zod.z.string(), predIrSchema).optional(),
   opsHash: zod.z.string(),
+  /** Apply-observed synced objects without a serving backing; not part of the authored schema hash. */
+  unbackedTables: zod.z.array(zod.z.string()).optional(),
   tables: zod.z.record(zod.z.string(), tableMetaIrSchema),
   operations: zod.z.record(zod.z.string(), compiledOperationSchema)
 }).superRefine((artifact, ctx) => {
-  for (const [name, operation] of Object.entries(artifact.operations)) {
+  if (Object.keys(artifact.dependencies ?? {}).length > 0 && artifact.irVersion < COMPOSED_IR_VERSION) {
+    ctx.addIssue({ code: "custom", path: ["irVersion"], message: "cross-namespace dependencies require IR v3" });
+  }
+  for (const [name2, operation] of Object.entries(artifact.operations)) {
     if (operation.irVersion > artifact.irVersion) {
-      ctx.addIssue({ code: "custom", path: ["operations", name, "irVersion"], message: "operation requires a newer IR version than its artifact" });
+      ctx.addIssue({ code: "custom", path: ["operations", name2, "irVersion"], message: "operation requires a newer IR version than its artifact" });
     }
   }
 });
@@ -6573,7 +6814,7 @@ var IrVersionError = class extends Error {
 function normalizeIr(raw) {
   if (!raw || typeof raw !== "object") throw new IrVersionError(void 0);
   const version = raw.irVersion;
-  if (version !== LEGACY_IR_VERSION && version !== IR_VERSION) throw new IrVersionError(version);
+  if (!irVersionSchema.safeParse(version).success) throw new IrVersionError(version);
   return compiledArtifactSchema.parse(raw);
 }
 function indexByHash(artifact) {
@@ -6606,10 +6847,10 @@ function buildNamespaceDefinition(files, config) {
   }
   const actionsSeen = /* @__PURE__ */ new Map();
   for (const { file, table } of files) {
-    for (const name of Object.keys(table.actions ?? {})) {
-      const existing = actionsSeen.get(name);
-      if (existing) throw new OrmDefinitionError(`action '${name}' is already defined in ${existing}`, file);
-      actionsSeen.set(name, file);
+    for (const name2 of Object.keys(table.actions ?? {})) {
+      const existing = actionsSeen.get(name2);
+      if (existing) throw new OrmDefinitionError(`action '${name2}' is already defined in ${existing}`, file);
+      actionsSeen.set(name2, file);
     }
   }
   const capabilities = config?.capabilities ? { roles: config.capabilities.roles ?? EMPTY_CAPABILITIES.roles, uses: config.capabilities.uses ?? [] } : EMPTY_CAPABILITIES;
@@ -6652,12 +6893,12 @@ function validateActionValidates(files, byName) {
 }
 function validateIndexNames(files) {
   const seen = /* @__PURE__ */ new Map();
-  const claim = (name, label, file) => {
-    const existing = seen.get(name);
+  const claim = (name2, label, file) => {
+    const existing = seen.get(name2);
     if (existing) {
-      throw new OrmDefinitionError(`relation name '${name}' (${label}) collides with ${existing}`, file);
+      throw new OrmDefinitionError(`relation name '${name2}' (${label}) collides with ${existing}`, file);
     }
-    seen.set(name, `${label} (${file})`);
+    seen.set(name2, `${label} (${file})`);
   };
   for (const { file, table } of files) {
     claim(table.table, `table '${table.table}'`, file);
@@ -6665,9 +6906,9 @@ function validateIndexNames(files) {
   for (const { file, table } of files) {
     if (table.source) continue;
     claim(`${table.table}_pkey`, `implicit primary-key index of '${table.table}'`, file);
-    for (const [name, column] of Object.entries(table.columns ?? {})) {
+    for (const [name2, column] of Object.entries(table.columns ?? {})) {
       if (column.unique && !column.primary_key) {
-        claim(`${table.table}_${name}_unique`, `implicit unique constraint of '${table.table}.${name}'`, file);
+        claim(`${table.table}_${name2}_unique`, `implicit unique constraint of '${table.table}.${name2}'`, file);
       }
     }
   }
@@ -6679,20 +6920,20 @@ function validateIndexNames(files) {
 }
 function validateLocalLinks(files, byName) {
   for (const { file, table } of files) {
-    for (const [name, link] of Object.entries(table.links ?? {})) {
+    for (const [name2, link] of Object.entries(table.links ?? {})) {
       if (isQualifiedReference(link.to)) continue;
       const target = byName.get(link.to);
       if (!target) {
-        throw new OrmDefinitionError(`link '${name}' references unknown table '${link.to}'`, file);
+        throw new OrmDefinitionError(`link '${name2}' references unknown table '${link.to}'`, file);
       }
       if (link.enforce && target.source) {
-        throw new OrmDefinitionError(`link '${name}' cannot enforce a foreign key onto a synced table`, file);
+        throw new OrmDefinitionError(`link '${name2}' cannot enforce a foreign key onto a synced table`, file);
       }
       const sourceType = table.columns?.[link.on]?.type;
       const targetPrimaryKey = Object.values(target.columns ?? {}).find((column) => column.primary_key);
       if (sourceType && targetPrimaryKey && columnTypeGroup(sourceType) !== columnTypeGroup(targetPrimaryKey.type)) {
         throw new OrmDefinitionError(
-          `link '${name}' can never join: '${link.on}' is ${sourceType} but '${link.to}' has a ${targetPrimaryKey.type} primary key`,
+          `link '${name2}' can never join: '${link.on}' is ${sourceType} but '${link.to}' has a ${targetPrimaryKey.type} primary key`,
           file
         );
       }
@@ -6772,7 +7013,7 @@ function parseYaml(file, contents) {
     throw new OrmDefinitionError(error instanceof Error ? error.message : "invalid YAML", file);
   }
 }
-var isDefinitionFile = (name) => DEFINITION_FILE_EXTENSIONS.some((extension) => path.extname(name) === extension);
+var isDefinitionFile = (name2) => DEFINITION_FILE_EXTENSIONS.some((extension) => path.extname(name2) === extension);
 async function listDefinitionFiles(dir) {
   const entries = await promises.readdir(dir, { withFileTypes: true });
   return entries.filter((entry) => entry.isFile() && isDefinitionFile(entry.name)).map((entry) => entry.name).sort();
@@ -6866,13 +7107,13 @@ async function readMigrationSql(dir, entry) {
 var checksumOf = (text4) => crypto.createHash("sha256").update(text4).digest("hex");
 var migrationName = (ordinal, contentHash) => `${pad(ordinal)}_${contentHash.slice(0, 12)}`;
 function renderMigrationSql({
-  name,
+  name: name2,
   namespace,
   contentHash,
   plan
 }) {
   const header = [
-    `-- ${name}`,
+    `-- ${name2}`,
     `-- namespace: ${namespace}`,
     `-- content hash: ${contentHash}`,
     "-- generated by `seq-studio orm diff` \u2014 review and commit, do not edit"
@@ -6888,13 +7129,13 @@ async function writeMigration({
 }) {
   const tip = workspace.journal.entries.at(-1);
   const ordinal = (tip?.ordinal ?? 0) + 1;
-  const name = migrationName(ordinal, contentHash);
-  const sql7 = renderMigrationSql({ name, namespace: workspace.journal.namespace, contentHash, plan });
+  const name2 = migrationName(ordinal, contentHash);
+  const sql7 = renderMigrationSql({ name: name2, namespace: workspace.journal.namespace, contentHash, plan });
   const metaDir = path.join(dir, MIGRATIONS_DIRNAME, META_DIRNAME);
   await promises.mkdir(metaDir, { recursive: true });
   const snapshotText = `${JSON.stringify(plan.snapshot, null, 2)}
 `;
-  await promises.writeFile(path.join(dir, MIGRATIONS_DIRNAME, `${name}.sql`), sql7);
+  await promises.writeFile(path.join(dir, MIGRATIONS_DIRNAME, `${name2}.sql`), sql7);
   await promises.writeFile(path.join(metaDir, `${pad(ordinal)}.snapshot.json`), snapshotText);
   const journal = {
     ...workspace.journal,
@@ -6902,7 +7143,7 @@ async function writeMigration({
       ...workspace.journal.entries,
       {
         ordinal,
-        name,
+        name: name2,
         content_hash: contentHash,
         previous_content_hash: tip?.content_hash ?? null,
         checksum: checksumOf(sql7),
@@ -6913,7 +7154,7 @@ async function writeMigration({
   };
   await promises.writeFile(path.join(metaDir, JOURNAL_FILENAME), `${JSON.stringify(journal, null, 2)}
 `);
-  return { name, ordinal, destructive };
+  return { name: name2, ordinal, destructive };
 }
 var pad = (ordinal) => String(ordinal).padStart(4, "0");
 function parseJson(path, raw) {
@@ -7087,15 +7328,15 @@ function convertV1DefinitionToCanonical(definition) {
 }
 function convertTable(table) {
   const columns = Object.entries(table.columns ?? {});
-  const primaryKey2 = columns.filter(([, column]) => column.primary_key).map(([name]) => name);
+  const primaryKey2 = columns.filter(([, column]) => column.primary_key).map(([name2]) => name2);
   return {
     table: table.table,
     description: table.description,
     source: table.source,
-    columns: columns.map(([name, column]) => convertColumn(name, column)),
+    columns: columns.map(([name2, column]) => convertColumn(name2, column)),
     // Synced tables may declare a typed column/PK contract; untyped remain empty.
     primaryKey: primaryKey2.length > 0 ? primaryKey2 : void 0,
-    links: Object.entries(table.links ?? {}).map(([name, link]) => convertLink(table.table, name, link)),
+    links: Object.entries(table.links ?? {}).map(([name2, link]) => convertLink(table.table, name2, link)),
     indexes: (table.indexes ?? []).map((index3) => ({
       columns: [...index3.columns],
       unique: index3.unique ?? false,
@@ -7112,11 +7353,11 @@ function convertTable(table) {
     actions: []
   };
 }
-function convertColumn(name, column) {
+function convertColumn(name2, column) {
   const isDefaultFn = column.default !== void 0 && isFunctionDefault(column.default, column.type);
   return {
-    name,
-    columnName: name,
+    name: name2,
+    columnName: name2,
     type: column.type,
     nullable: column.primary_key ? false : column.nullable !== false,
     unique: column.unique === true,
@@ -7130,14 +7371,14 @@ function convertColumn(name, column) {
     deprecated: column.deprecated === true
   };
 }
-function convertLink(table, name, link) {
+function convertLink(table, name2, link) {
   if (link.to.includes(".")) {
     throw new OrmDefinitionError(
-      `link '${name}' on '${table}' targets '${link.to}' \u2014 cross-namespace links have no canonical v2 representation (links are namespace-local in v2)`
+      `link '${name2}' on '${table}' targets '${link.to}' \u2014 cross-namespace links have no canonical v2 representation (links are namespace-local in v2)`
     );
   }
   return {
-    name,
+    name: name2,
     kind: "toOne",
     target: link.to,
     on: link.on,
@@ -7166,29 +7407,29 @@ function buildRebaseJournalEntry({ namespace, previousHash, newHash, ordinal, sn
   if (!Number.isInteger(ordinal) || ordinal < 2) {
     throw new OrmDefinitionError(`rebase ordinal must be an integer \u2265 2 (a rebase sits on an existing journal tip); got ${ordinal}`);
   }
-  const name = migrationName(ordinal, newHash);
-  const sql7 = renderRebaseMigrationSql({ name, namespace, previousHash, newHash });
+  const name2 = migrationName(ordinal, newHash);
+  const sql7 = renderRebaseMigrationSql({ name: name2, namespace, previousHash, newHash });
   const snapshotText = `${JSON.stringify(snapshot, null, 2)}
 `;
   const entry = {
     ordinal,
-    name,
+    name: name2,
     content_hash: newHash,
     previous_content_hash: previousHash,
     checksum: checksumOf(sql7),
     snapshot_checksum: checksumOf(snapshotText),
     destructive: false
   };
-  return { name, entry, sql: sql7, snapshotText };
+  return { name: name2, entry, sql: sql7, snapshotText };
 }
 function renderRebaseMigrationSql({
-  name,
+  name: name2,
   namespace,
   previousHash,
   newHash
 }) {
   return [
-    `-- ${name}`,
+    `-- ${name2}`,
     `-- namespace: ${namespace}`,
     `-- content hash: ${newHash}`,
     `-- rebase: v1 definitions (${previousHash}) converted to canonical v2 \u2014 verified no-op, zero statements`,
@@ -7262,8 +7503,8 @@ function canonicalActions(value) {
   const entries = Object.entries(value);
   if (entries.length === 0) return void 0;
   return Object.fromEntries(
-    entries.map(([name, action]) => [
-      name,
+    entries.map(([name2, action]) => [
+      name2,
       {
         description: action["description"] ?? void 0,
         requires: action["requires"] ?? void 0,
@@ -7276,6 +7517,526 @@ function canonicalActions(value) {
     ])
   );
 }
+var IMPORT_CONFLICT_MODES = ["error", "skip", "update"];
+var columnMapSchema = zod.z.object({
+  /** ORM property name or Postgres column name. */
+  target: zod.z.string().min(1).max(63),
+  /** Column on the source relation. Identifiers only — never an expression. */
+  source: zod.z.string().min(1).max(63),
+  /**
+   * Used when the source value is NULL. Required columns without a database
+   * default fail the load if the source contains nulls and this is omitted.
+   */
+  nullDefault: zod.z.union([zod.z.string().max(1e4), zod.z.number(), zod.z.boolean()]).optional()
+}).strict();
+var importSpecSchema = zod.z.object({
+  table: zod.z.string().min(1).max(63),
+  from: zod.z.string().regex(QUALIFIED_TABLE_PATTERN),
+  columns: zod.z.array(columnMapSchema).min(1).max(500),
+  onConflict: zod.z.enum(IMPORT_CONFLICT_MODES).default("skip"),
+  batchSize: zod.z.number().int().min(1).max(2e4).default(5e3)
+}).strict();
+var UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+var DATE_RE = /^\d{4}-\d{2}-\d{2}$/;
+var TIMESTAMPTZ_RE = /^\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}:\d{2}(\.\d+)?(Z|[+-]\d{2}:?\d{2})$/;
+var INTEGER_RE = /^-?\d+$/;
+var NUMERIC_RE = /^-?\d+(\.\d+)?$/;
+function sourceSchemaAllowed(schema) {
+  return schema !== "information_schema" && !schema.startsWith("pg_");
+}
+function isRelationIdentifier(value) {
+  return value.length <= 63 && IDENTIFIER_PATTERN.test(value);
+}
+function isSourceColumn(value) {
+  return value.length <= 63 && COLUMN_IDENTIFIER_PATTERN.test(value);
+}
+function splitQualifiedRelation(from) {
+  const dot = from.indexOf(".");
+  if (dot <= 0 || dot !== from.lastIndexOf(".")) return null;
+  const schema = from.slice(0, dot);
+  const table = from.slice(dot + 1);
+  if (!isRelationIdentifier(schema) || !isRelationIdentifier(table)) return null;
+  return { schema, table };
+}
+function postgresTypeName(type) {
+  if (type === "double") return "double precision";
+  if (type === "timestamptz") return "timestamp with time zone";
+  return type;
+}
+function columnPostgresType(column, schemaName, enums) {
+  if (typeof column.type === "string") return postgresTypeName(column.type);
+  if (!enums.has(column.type.enum)) return null;
+  return `${quoteIdentifier(schemaName)}.${quoteIdentifier(column.type.enum)}`;
+}
+function quoteQualified(schema, table) {
+  return `${quoteIdentifier(schema)}.${quoteIdentifier(table)}`;
+}
+var INT4_MIN = -2147483648;
+var INT4_MAX = 2147483647;
+function resumeLiteralSql({
+  column,
+  after,
+  schemaName,
+  enums
+}) {
+  const coerced = coerceResumeValue(column, after);
+  if (!coerced.ok) return coerced;
+  return literalSql({ column, value: coerced.value, schemaName, enums });
+}
+function coerceResumeValue(column, after) {
+  const type = typeof column.type === "string" ? column.type : null;
+  if (type === "integer") {
+    if (!INTEGER_RE.test(after)) return { ok: false, error: `${column.name}: after must be an integer` };
+    const parsed = Number(after);
+    if (!Number.isSafeInteger(parsed) || parsed < INT4_MIN || parsed > INT4_MAX) {
+      return { ok: false, error: `${column.name}: after must be an integer` };
+    }
+    return { ok: true, value: parsed };
+  }
+  if (type === "boolean") {
+    if (after !== "true" && after !== "false") return { ok: false, error: `${column.name}: after must be true or false` };
+    return { ok: true, value: after === "true" };
+  }
+  return { ok: true, value: after };
+}
+function literalSql({
+  column,
+  value,
+  schemaName,
+  enums
+}) {
+  const label = column.name;
+  if (typeof value === "string" && value.includes("\0")) {
+    return { ok: false, error: `${label}: null default contains a NUL character` };
+  }
+  if (typeof column.type !== "string") {
+    const enumDef = enums.get(column.type.enum);
+    if (!enumDef) return { ok: false, error: `${label}: enum '${column.type.enum}' is not declared` };
+    if (typeof value !== "string" || !enumDef.values.includes(value)) {
+      return { ok: false, error: `${label}: null default must be one of ${enumDef.values.join(", ")}` };
+    }
+    const typeName = columnPostgresType(column, schemaName, enums);
+    return { ok: true, sql: `${quoteLiteral(value)}::${typeName}` };
+  }
+  return scalarLiteral2({ column, type: column.type, value, label });
+}
+var SCALAR_LITERALS = {
+  text: (value, label) => typeof value === "string" ? { ok: true, sql: quoteLiteral(value) } : { ok: false, error: `${label}: null default must be a string` },
+  uuid: (value, label) => typeof value === "string" && UUID_RE.test(value) ? { ok: true, sql: `${quoteLiteral(value)}::uuid` } : { ok: false, error: `${label}: null default must be a UUID` },
+  boolean: (value, label) => typeof value === "boolean" ? { ok: true, sql: value ? "TRUE" : "FALSE" } : { ok: false, error: `${label}: null default must be true or false` },
+  integer: (value, label) => typeof value === "number" && Number.isSafeInteger(value) ? { ok: true, sql: String(value) } : { ok: false, error: `${label}: null default must be an integer` },
+  bigint: (value, label) => typeof value === "string" && INTEGER_RE.test(value) ? { ok: true, sql: `${value}::bigint` } : { ok: false, error: `${label}: null default must be a base-10 integer string` },
+  numeric: numericLiteral,
+  double: numericLiteral,
+  date: (value, label) => typeof value === "string" && DATE_RE.test(value) ? { ok: true, sql: `${quoteLiteral(value)}::date` } : { ok: false, error: `${label}: null default must be a YYYY-MM-DD date` },
+  timestamptz: (value, label) => typeof value === "string" && TIMESTAMPTZ_RE.test(value) ? { ok: true, sql: `${quoteLiteral(value)}::${postgresTypeName("timestamptz")}` } : { ok: false, error: `${label}: null default must be an ISO-8601 timestamp` },
+  jsonb: jsonbLiteral
+};
+function numericLiteral(value, label) {
+  if (typeof value === "number" && Number.isFinite(value)) return { ok: true, sql: String(value) };
+  if (typeof value === "string" && NUMERIC_RE.test(value)) return { ok: true, sql: value };
+  return { ok: false, error: `${label}: null default must be a finite number` };
+}
+function scalarLiteral2({
+  column,
+  type,
+  value,
+  label
+}) {
+  const encode = SCALAR_LITERALS[type];
+  if (!encode) return { ok: false, error: `${column.name}: unsupported type '${type}'` };
+  return encode(value, label);
+}
+function jsonbLiteral(value, label) {
+  if (typeof value !== "string") return { ok: false, error: `${label}: null default must be a JSON string` };
+  try {
+    JSON.parse(value);
+  } catch {
+    return { ok: false, error: `${label}: null default must be valid JSON` };
+  }
+  return { ok: true, sql: `${quoteLiteral(value)}::jsonb` };
+}
+function dollarQuote(body) {
+  const digest = crypto.createHash("sha256").update(body).digest("hex");
+  const candidates = ["seq_orm_import", `seq_orm_${digest.slice(0, 16)}`, `seq_orm_${digest}`];
+  const tag = candidates.find((candidate) => !body.includes(`$${candidate}$`)) ?? `seq_orm_${digest}_body`;
+  return `$${tag}$${body}$${tag}$`;
+}
+
+// src/import/script.ts
+function renderImportScript({
+  namespace,
+  schemaName,
+  table,
+  source,
+  mapped,
+  primaryKey: primaryKey2,
+  onConflict,
+  batchSize,
+  omitted,
+  resume
+}) {
+  const sourceSql = `${quoteQualified(source.schema, source.table)} AS src`;
+  const targetSql = quoteQualified(schemaName, table.table);
+  const keys = primaryKey2.map((name2) => mapped.find((column) => column.column.columnName === name2)).filter((column) => column !== void 0);
+  const probeSql = renderProbe({ sourceSql, keys, mapped });
+  const procedure = renderProcedure({ targetSql, sourceSql, mapped, keys, onConflict, batchSize });
+  const call = `CALL pg_temp.seq_orm_import(${resume.join(", ")});`;
+  const omittedLine = omitted.length > 0 ? `-- Omitted columns keep their database default or NULL: ${omitted.join(", ")}` : "-- Every column is mapped.";
+  const text4 = [
+    "-- Sequence ORM data import",
+    `-- namespace: ${namespace}`,
+    `-- target: ${schemaName}.${table.table}`,
+    `-- source: ${source.schema}.${source.table}`,
+    `-- conflict: ${onConflict}`,
+    `-- batch size: ${batchSize}`,
+    "--",
+    "-- Runs as the namespace owner. Does not evaluate insert or update policies,",
+    "-- capability gates, or the operation journal. Sync the warehouse table into",
+    "-- this Postgres relation first, review the probe, then run the load.",
+    "-- skip and update are safe to re-run from the start after a failure. error stops on an existing key.",
+    "-- Each batch commits. Do not resume from the maximum key in the target:",
+    "-- a higher key that was already there would skip source rows this run never copied.",
+    "-- --after is only the last key this procedure committed. This script does not print it.",
+    omittedLine,
+    "-- cast_* columns force every mapped value through the target type. An invalid value aborts before any insert.",
+    "",
+    probeSql,
+    "",
+    procedure,
+    call,
+    ""
+  ].join("\n");
+  return { probeSql, text: text4 };
+}
+function renderProbe({
+  sourceSql,
+  keys,
+  mapped
+}) {
+  const nullKey = keys.map((key) => `${key.expression} IS NULL`).join(" OR ");
+  const distinct = keys.length === 1 ? keys[0].expression : `(${keys.map((key) => key.expression).join(", ")})`;
+  const requiredNulls = nullChecked(mapped, keys).map((column) => `count(*) FILTER (WHERE src.${quoteIdentifier(column.source)} IS NULL) AS ${quoteIdentifier(`null_${column.column.columnName}`)}`);
+  const selects = [
+    "count(*) AS source_rows",
+    `count(*) FILTER (WHERE ${nullKey}) AS null_primary_key`,
+    `count(*) FILTER (WHERE NOT (${nullKey})) - count(DISTINCT ${distinct}) AS duplicate_primary_key`,
+    ...requiredNulls,
+    ...mapped.map((column) => `count(${column.expression}) AS ${quoteIdentifier(`cast_${column.column.columnName}`)}`)
+  ];
+  return `SELECT
+  ${selects.join(",\n  ")}
+FROM ${sourceSql};`;
+}
+function renderProcedure({
+  targetSql,
+  sourceSql,
+  mapped,
+  keys,
+  onConflict,
+  batchSize
+}) {
+  const args = keys.map((key, index3) => `IN start_${index3} ${key.pgType} DEFAULT NULL`).join(", ");
+  const declarations = [
+    "DECLARE",
+    "  batch_scanned integer;",
+    "  batch_affected integer;",
+    "  total_rows bigint;",
+    "  null_keys bigint;",
+    "  distinct_keys bigint;",
+    ...keys.map((key, index3) => `  watermark_${index3} ${key.pgType};`),
+    ...requiredNullDeclarations(mapped, keys),
+    ...mapped.map((column) => `  cast_${column.column.columnName} bigint;`)
+  ];
+  const body = [
+    "BEGIN",
+    ...keys.map((_, index3) => `  watermark_${index3} := start_${index3};`),
+    `  ${renderGuard({ sourceSql, keys, mapped })}`,
+    "  LOOP",
+    `    ${renderPage({ targetSql, sourceSql, mapped, keys, onConflict, batchSize })}`,
+    "    EXIT WHEN batch_scanned = 0;",
+    "    RAISE NOTICE 'orm import scanned % affected %', batch_scanned, batch_affected;",
+    "    COMMIT;",
+    "  END LOOP;",
+    "END"
+  ].join("\n");
+  return [
+    `CREATE OR REPLACE PROCEDURE pg_temp.seq_orm_import(${args})`,
+    "LANGUAGE plpgsql",
+    `AS ${dollarQuote(`
+${declarations.join("\n")}
+${body}
+`)}`,
+    ";",
+    ""
+  ].join("\n");
+}
+function nullChecked(mapped, keys) {
+  return mapped.filter((column) => !column.fillsNull && column.column.nullable === false && !keys.includes(column));
+}
+function requiredNullDeclarations(mapped, keys) {
+  return nullChecked(mapped, keys).map((column) => `  null_${column.column.columnName} bigint;`);
+}
+function renderGuard({
+  sourceSql,
+  keys,
+  mapped
+}) {
+  const nullKey = keys.map((key) => `${key.expression} IS NULL`).join(" OR ");
+  const distinct = keys.length === 1 ? keys[0].expression : `(${keys.map((key) => key.expression).join(", ")})`;
+  const nullColumns = nullChecked(mapped, keys);
+  const into = [
+    "total_rows",
+    "null_keys",
+    "distinct_keys",
+    ...nullColumns.map((column) => `null_${column.column.columnName}`),
+    ...mapped.map((column) => `cast_${column.column.columnName}`)
+  ];
+  const selects = [
+    "count(*)::bigint",
+    `count(*) FILTER (WHERE ${nullKey})::bigint`,
+    `count(DISTINCT ${distinct})::bigint`,
+    ...nullColumns.map((column) => `count(*) FILTER (WHERE src.${quoteIdentifier(column.source)} IS NULL)::bigint`),
+    ...mapped.map((column) => `count(${column.expression})::bigint`)
+  ];
+  const checks = [
+    "IF null_keys > 0 THEN RAISE EXCEPTION 'import refused: source primary key has % null values', null_keys; END IF;",
+    "IF total_rows <> distinct_keys THEN RAISE EXCEPTION 'import refused: source primary key has % duplicate values', total_rows - distinct_keys; END IF;",
+    ...nullColumns.map(
+      (column) => `IF null_${column.column.columnName} > 0 THEN RAISE EXCEPTION 'import refused: source column ${column.source} is null on % rows and ${column.column.columnName} is required', null_${column.column.columnName}; END IF;`
+    )
+  ];
+  return [`SELECT ${selects.join(", ")}`, `    INTO ${into.join(", ")}`, `    FROM ${sourceSql};`, ...checks.map((check) => `  ${check}`)].join("\n");
+}
+function renderPage({
+  targetSql,
+  sourceSql,
+  mapped,
+  keys,
+  onConflict,
+  batchSize
+}) {
+  const keyExprs = keys.map((key) => key.expression);
+  const where = `watermark_0 IS NULL OR (${keyExprs.join(", ")}) > (${keys.map((_, index3) => `watermark_${index3}`).join(", ")})`;
+  const order = keyExprs.join(", ");
+  const pageColumns = mapped.map((column) => `${column.expression} AS ${quoteIdentifier(column.column.columnName)}`);
+  const insertColumns = mapped.map((column) => quoteIdentifier(column.column.columnName)).join(", ");
+  const conflict = conflictClause(onConflict, keys, mapped);
+  const keyOrder = keys.map((key) => `${quoteIdentifier(key.column.columnName)} DESC`).join(", ");
+  const lastKeys = keys.map((key) => `(SELECT ${quoteIdentifier(key.column.columnName)} FROM page ORDER BY ${keyOrder} LIMIT 1)`).join(", ");
+  const watermarkTargets = keys.map((_, index3) => `watermark_${index3}`).join(", ");
+  return [
+    "WITH page AS (",
+    `      SELECT ${pageColumns.join(", ")}`,
+    `      FROM ${sourceSql}`,
+    `      WHERE ${where}`,
+    `      ORDER BY ${order}`,
+    `      LIMIT ${batchSize}`,
+    "    ),",
+    "    ins AS (",
+    `      INSERT INTO ${targetSql} (${insertColumns})`,
+    `      SELECT ${insertColumns} FROM page`,
+    `      ${conflict}`,
+    "      RETURNING 1",
+    "    )",
+    `    SELECT (SELECT count(*)::int FROM page), (SELECT count(*)::int FROM ins), ${lastKeys}`,
+    `    INTO batch_scanned, batch_affected, ${watermarkTargets};`
+  ].join("\n");
+}
+function conflictClause(onConflict, keys, mapped) {
+  if (onConflict === "error") return "";
+  const target = keys.map((key) => quoteIdentifier(key.column.columnName)).join(", ");
+  if (onConflict === "skip") return `ON CONFLICT (${target}) DO NOTHING`;
+  const assignments = mapped.filter((column) => !keys.includes(column)).map((column) => `${quoteIdentifier(column.column.columnName)} = EXCLUDED.${quoteIdentifier(column.column.columnName)}`);
+  return `ON CONFLICT (${target}) DO UPDATE SET ${assignments.join(", ")}`;
+}
+
+// src/import/plan.ts
+function planTableImport({
+  definition,
+  spec,
+  after
+}) {
+  const parsedDefinition = canonicalDefinitionSchema.safeParse(definition);
+  if (!parsedDefinition.success) return { ok: false, errors: ["namespace definition is not canonical ORM v2"] };
+  const parsedSpec = importSpecSchema.safeParse(spec);
+  if (!parsedSpec.success) {
+    return { ok: false, errors: parsedSpec.error.issues.map((issue) => `${issue.path.join(".") || "spec"}: ${issue.message}`) };
+  }
+  return planParsed({ definition: parsedDefinition.data, spec: parsedSpec.data, after });
+}
+function planParsed({
+  definition,
+  spec,
+  after
+}) {
+  const source = splitQualifiedRelation(spec.from);
+  const target = resolveTarget(definition, spec.table);
+  const errors = [];
+  if (!source) errors.push(`from '${spec.from}' is not a schema.table identifier`);
+  else if (!sourceSchemaAllowed(source.schema)) errors.push(`from schema '${source.schema}' is not a warehouse relation`);
+  if (!target.table) errors.push(...target.errors);
+  if (!source || !target.table) return { ok: false, errors };
+  const schemaName = ormSchemaName(definition.namespace);
+  if (source.schema === schemaName && source.table === target.table.table) {
+    errors.push(`from '${spec.from}' is the import target`);
+  }
+  const enums = new Map(definition.enums.map((entry) => [entry.name, entry]));
+  const mapped = mapColumns({ table: target.table, spec, schemaName, enums, errors });
+  const primaryKey2 = target.table.primaryKey ?? [];
+  if (primaryKey2.length === 0) errors.push(`table '${target.table.table}' needs a primary key`);
+  for (const key of primaryKey2) {
+    if (!mapped.some((column) => column.column.columnName === key)) {
+      errors.push(`primary key column '${key}' must be mapped so existing identities are preserved`);
+    }
+  }
+  collectUnmapped({ table: target.table, mapped, errors });
+  if (spec.onConflict === "update" && mapped.every((column) => primaryKey2.includes(column.column.columnName))) {
+    errors.push('onConflict "update" needs a mapped column that is not part of the primary key');
+  }
+  const resume = resumeArguments({ mapped, primaryKey: primaryKey2, after, schemaName, enums, errors });
+  if (errors.length > 0) return { ok: false, errors };
+  const omitted = omittedColumns(target.table, mapped);
+  const script = renderImportScript({
+    namespace: definition.namespace,
+    schemaName,
+    table: target.table,
+    source,
+    mapped,
+    primaryKey: primaryKey2,
+    onConflict: spec.onConflict,
+    batchSize: spec.batchSize,
+    omitted,
+    resume
+  });
+  const warnings = [
+    "This load runs as the namespace owner. It does not evaluate insert or update policies.",
+    ...spec.onConflict === "error" ? ['onConflict "error" is not safe to re-run: the first existing key aborts the batch.'] : []
+  ];
+  return {
+    ok: true,
+    plan: { probeSql: script.probeSql, script: script.text, batchSize: spec.batchSize, onConflict: spec.onConflict, warnings }
+  };
+}
+function resolveTarget(definition, name2) {
+  const table = definition.tables.find((candidate) => candidate.table === name2);
+  if (!table) {
+    const view = definition.views?.find((candidate) => candidate.view === name2);
+    return { table: null, errors: [view ? `'${name2}' is a view, not an owned table` : `table '${name2}' is not in this namespace`] };
+  }
+  if (table.source !== void 0) return { table: null, errors: [`'${name2}' is a synced reflection and cannot be imported into`] };
+  if (table.internal || table.materializes !== void 0) {
+    return { table: null, errors: [`'${name2}' is an internal relation, not an import target`] };
+  }
+  return { table, errors: [] };
+}
+function mapColumns({
+  table,
+  spec,
+  schemaName,
+  enums,
+  errors
+}) {
+  const mapped = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const entry of spec.columns) {
+    const column = findColumn(table, entry.target);
+    if (column === "ambiguous") {
+      errors.push(`target '${entry.target}' matches more than one column`);
+      continue;
+    }
+    if (!column) {
+      errors.push(`target '${entry.target}' is not a column of '${table.table}'`);
+      continue;
+    }
+    if (column.cell !== void 0) {
+      errors.push(`target '${entry.target}' is cell metadata and cannot be imported`);
+      continue;
+    }
+    if (seen.has(column.columnName)) {
+      errors.push(`column '${column.columnName}' is mapped more than once`);
+      continue;
+    }
+    if (!isSourceColumn(entry.source)) {
+      errors.push(`source '${entry.source}' is not a column identifier`);
+      continue;
+    }
+    seen.add(column.columnName);
+    const pgType = columnPostgresType(column, schemaName, enums);
+    if (!pgType) {
+      errors.push(`column '${column.name}' references undeclared enum '${typeof column.type === "string" ? column.type : column.type.enum}'`);
+      continue;
+    }
+    const expression = valueExpression({ column, source: entry.source, pgType, nullDefault: entry.nullDefault, schemaName, enums, errors });
+    if (expression) mapped.push({ column, source: entry.source, expression, pgType, fillsNull: entry.nullDefault !== void 0 });
+  }
+  return mapped;
+}
+function findColumn(table, target) {
+  const matches = table.columns.filter((column) => column.name === target || column.columnName === target);
+  if (matches.length > 1) return "ambiguous";
+  return matches[0];
+}
+function valueExpression({
+  column,
+  source,
+  pgType,
+  nullDefault,
+  schemaName,
+  enums,
+  errors
+}) {
+  const cast = `CAST(src.${quoteIdentifier(source)} AS ${pgType})`;
+  if (nullDefault === void 0) return cast;
+  const literal2 = literalSql({ column, value: nullDefault, schemaName, enums });
+  if (!literal2.ok) {
+    errors.push(literal2.error);
+    return null;
+  }
+  return `COALESCE(${cast}, ${literal2.sql})`;
+}
+function collectUnmapped({
+  table,
+  mapped,
+  errors
+}) {
+  const mappedNames = new Set(mapped.map((column) => column.column.columnName));
+  const primaryKey2 = new Set(table.primaryKey ?? []);
+  for (const column of table.columns) {
+    if (mappedNames.has(column.columnName) || column.cell !== void 0) continue;
+    const hasDefault = column.default !== void 0 && column.default !== null || column.defaultFn !== void 0;
+    const required = column.nullable === false && !hasDefault && !primaryKey2.has(column.columnName);
+    if (required) {
+      errors.push(`column '${column.name}' is required and has no default \u2014 map it or set a database default before importing`);
+    }
+  }
+}
+function omittedColumns(table, mapped) {
+  const mappedNames = new Set(mapped.map((column) => column.column.columnName));
+  return table.columns.filter((column) => column.cell === void 0 && !mappedNames.has(column.columnName)).map((column) => column.columnName);
+}
+function resumeArguments({
+  mapped,
+  primaryKey: primaryKey2,
+  after,
+  schemaName,
+  enums,
+  errors
+}) {
+  if (after === void 0) return primaryKey2.map(() => "NULL");
+  if (primaryKey2.length !== 1) {
+    errors.push("after resumes a single-column primary key; re-run from the start for a composite key (skip and update are idempotent)");
+    return [];
+  }
+  const key = mapped.find((column) => column.column.columnName === primaryKey2[0]);
+  if (!key) return [];
+  const literal2 = resumeLiteralSql({ column: key.column, after, schemaName, enums });
+  if (!literal2.ok) {
+    errors.push(`after: ${literal2.error}`);
+    return [];
+  }
+  return [literal2.sql];
+}
 
 Object.defineProperty(exports, "capabilityPinsSchema", {
   enumerable: true,
@@ -7315,14 +8076,17 @@ exports.COLUMN_DEFAULT_FNS = COLUMN_DEFAULT_FNS;
 exports.COLUMN_IDENTIFIER_PATTERN = COLUMN_IDENTIFIER_PATTERN;
 exports.COLUMN_TYPES = COLUMN_TYPES2;
 exports.COMPARE_OPS = COMPARE_OPS;
+exports.COMPOSED_IR_VERSION = COMPOSED_IR_VERSION;
 exports.CONSUMER_ROLE_SUFFIX = CONSUMER_ROLE_SUFFIX;
 exports.ColumnBuilder = ColumnBuilder;
 exports.DATE_BUCKETS = DATE_BUCKETS;
 exports.DEFINITION_FILE_EXTENSIONS = DEFINITION_FILE_EXTENSIONS;
 exports.ENUM_BRAND = ENUM_BRAND;
+exports.GUARDED_IR_VERSION = GUARDED_IR_VERSION;
 exports.HASH_DOMAIN = HASH_DOMAIN;
 exports.IDENTIFIER_PATTERN = IDENTIFIER_PATTERN;
 exports.IDENTIFIER_RE = IDENTIFIER_RE;
+exports.IMPORT_CONFLICT_MODES = IMPORT_CONFLICT_MODES;
 exports.INPUT_REF_KINDS = INPUT_REF_KINDS;
 exports.IR_VERSION = IR_VERSION;
 exports.IrVersionError = IrVersionError;
@@ -7352,7 +8116,9 @@ exports.QUALIFIED_TABLE_PATTERN = QUALIFIED_TABLE_PATTERN;
 exports.RESERVED_COLUMN_NAMES = RESERVED_COLUMN_NAMES;
 exports.RESERVED_TABLE_NAMES = RESERVED_TABLE_NAMES;
 exports.ROLES_CLAIM_KEY = ROLES_CLAIM_KEY;
+exports.RUNTIME_SQL_IR_VERSION = RUNTIME_SQL_IR_VERSION;
 exports.SCHEMA_DIR = SCHEMA_DIR;
+exports.SQL_IR_VERSION = SQL_IR_VERSION;
 exports.STATEMENT_KINDS = STATEMENT_KINDS;
 exports.SYNCED_CONTRACT_HASH_DOMAIN = SYNCED_CONTRACT_HASH_DOMAIN;
 exports.SYNCED_SOURCE_PATTERN = SYNCED_SOURCE_PATTERN;
@@ -7413,6 +8179,7 @@ exports.custom = custom;
 exports.declaredCapabilityKeys = declaredCapabilityKeys;
 exports.defineEnum = defineEnum;
 exports.defineNamespace = defineNamespace;
+exports.defineOperation = defineOperation;
 exports.defineResolvedTable = defineResolvedTable;
 exports.defineSyncedTable = defineSyncedTable;
 exports.defineTable = defineTable;
@@ -7431,6 +8198,7 @@ exports.generateSnapshot = generateSnapshot;
 exports.generateSnapshotV2 = generateSnapshotV2;
 exports.highest = highest;
 exports.identifierSchema = identifierSchema;
+exports.importSpecSchema = importSpecSchema;
 exports.indexByHash = indexByHash;
 exports.isColumnBuilder = isColumnBuilder;
 exports.isEnumRef = isEnumRef;
@@ -7460,6 +8228,8 @@ exports.nonNullFirst = nonNullFirst;
 exports.normalizeCanonical = normalizeCanonical;
 exports.normalizeIr = normalizeIr;
 exports.normalizeSnapshot = normalizeSnapshot;
+exports.objectRef = objectRef;
+exports.ontologyContractSchema = ontologyContractSchema;
 exports.orderIrSchema = orderIrSchema;
 exports.ormMigrationExportSchema = ormMigrationExportSchema;
 exports.ormSchemaName = ormSchemaName;
@@ -7476,6 +8246,7 @@ exports.pendingKitStatementsV2 = pendingKitStatementsV2;
 exports.planCommittedMigrationV2 = planCommittedMigrationV2;
 exports.planMigration = planMigration;
 exports.planMigrationV2 = planMigrationV2;
+exports.planTableImport = planTableImport;
 exports.policyExpressionSchema = policyExpressionSchema;
 exports.policyVariantSchema = policyVariantSchema;
 exports.predIrSchema = predIrSchema;
@@ -7487,6 +8258,7 @@ exports.quoteIdentifier = quoteIdentifier;
 exports.quoteLiteral = quoteLiteral;
 exports.readMigrationSql = readMigrationSql;
 exports.readMigrationWorkspace = readMigrationWorkspace;
+exports.readOntologyContract = readOntologyContract;
 exports.readSnapshot = readSnapshot;
 exports.rebaseViolations = rebaseViolations;
 exports.referencedCapabilities = referencedCapabilities;
@@ -7518,6 +8290,7 @@ exports.toMany = toMany;
 exports.toOne = toOne;
 exports.toPlatformUser = toPlatformUser;
 exports.typesInterfaceName = typesInterfaceName;
+exports.validateNamespaceCatalog = validateNamespaceCatalog;
 exports.validateViewCatalogStatement = validateViewCatalogStatement;
 exports.valueIrSchema = valueIrSchema;
 exports.variableDefaultIrSchema = variableDefaultIrSchema;