@sequenceholdings/orm 2.1.1 → 2.2.0

package/dist/index.js

@@ -163,8 +163,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}`;
@@ -265,6 +265,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,
@@ -318,51 +321,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
     );
   }
@@ -372,21 +375,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
       );
     }
@@ -397,13 +400,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
       );
     }
@@ -415,7 +418,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,
@@ -424,26 +427,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;
 }
@@ -451,52 +454,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) => uuid(name),
-  text: (name) => text(name),
-  integer: (name) => integer(name),
-  bigint: (name) => bigint(name, { mode: "bigint" }),
-  numeric: (name) => numeric(name),
-  double: (name) => doublePrecision(name),
-  boolean: (name) => boolean(name),
-  timestamptz: (name) => timestamp(name, { withTimezone: true }),
-  date: (name) => date(name),
-  jsonb: (name) => jsonb(name)
+  uuid: (name2) => uuid(name2),
+  text: (name2) => text(name2),
+  integer: (name2) => integer(name2),
+  bigint: (name2) => bigint(name2, { mode: "bigint" }),
+  numeric: (name2) => numeric(name2),
+  double: (name2) => doublePrecision(name2),
+  boolean: (name2) => boolean(name2),
+  timestamptz: (name2) => timestamp(name2, { withTimezone: true }),
+  date: (name2) => date(name2),
+  jsonb: (name2) => jsonb(name2)
 };
 function compileViewQueries(input) {
   const schemaName = `orm_${input.namespace}`;
@@ -552,9 +555,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
         );
       }
@@ -745,8 +748,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({
@@ -765,7 +768,7 @@ function overrideRowMutation(input) {
   });
   return {
     kind: "override",
-    name,
+    name: name2,
     synced: synced.tableName,
     pk,
     copy: [pk, ...sharedProperties],
@@ -774,23 +777,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`
     );
   }
 }
@@ -916,17 +919,35 @@ function scalarColumnType(table, property, helper) {
   }
   return type;
 }
+var objectRef2 = 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 = z.string().max(255).regex(/^[a-z][a-z0-9-]*$/, "Expected a function slug");
+var refs = (schema) => z.array(schema).max(256).refine(
+  (values) => new Set(values).size === values.length,
+  "Duplicate dependency reference"
+).default([]);
+var ontologyContractSchema = z.strictObject({
+  version: 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) {
@@ -1259,8 +1280,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;
 }
@@ -1357,7 +1378,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 }) {
@@ -1448,6 +1469,8 @@ var canonicalLinkSchema = z.object({
   kind: 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`). */
@@ -1706,11 +1729,12 @@ var canonicalForeignKeySchema = z.object({
 }).strict();
 var canonicalTableSchema = z.object({
   table: identifier2,
+  displayName: z.string().trim().min(1).max(120).optional(),
   description: 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: z.string().regex(/^gold\.[a-z][a-z0-9_]*$/).optional(),
+  /** Synced/reflected read-only tables (`source: schema.table`) — v1 semantics. */
+  source: z.string().regex(QUALIFIED_TABLE_PATTERN).optional(),
   columns: z.array(canonicalColumnSchema).default([]),
   primaryKey: z.array(columnIdentifier).min(1).max(8).optional(),
   links: z.array(canonicalLinkSchema).default([]),
@@ -1863,7 +1887,9 @@ function validateCellMetadata(table, index3, ctx) {
     }
   }
 }
-var canonicalDefinitionSchema = z.object({
+var exportGateSchema = z.union([z.literal(true), z.object({ capability: z.string().min(1) }).strict(), z.object({ role: z.string().min(1) }).strict()]);
+var relationExportSchema = z.object({ read: exportGateSchema, write: exportGateSchema.optional() }).strict();
+var localDefinitionSchema = z.object({
   definition_format: z.literal(CANONICAL_FORMAT),
   namespace: identifier2.max(41),
   description: z.string().max(2e3).optional(),
@@ -1871,6 +1897,8 @@ var canonicalDefinitionSchema = z.object({
   tables: z.array(canonicalTableSchema).min(0).max(500),
   /** Optional to preserve byte-identical hashes for pre-view canonical v2 documents. */
   views: z.array(canonicalViewSchema).max(500).optional(),
+  /** Target-owned cross-namespace access contract, using existing namespace grants. */
+  exports: z.record(identifier2, relationExportSchema).optional(),
   /** Verbatim custom-roles grammar (@sequenceholdings/custom-roles-manifest). */
   capabilities: z.object({
     roles: z.unknown().optional(),
@@ -1897,7 +1925,16 @@ var canonicalDefinitionSchema = 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`),
@@ -1934,14 +1971,14 @@ var canonicalDefinitionSchema = 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");
@@ -2046,27 +2083,31 @@ var canonicalDefinitionSchema = 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: z.array(localDefinitionSchema).max(32).optional()
+});
 function canonicalRelations(definition) {
   const views = (definition.views ?? []).map((view) => ({
     table: view.view,
@@ -2110,6 +2151,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;
 }
 
@@ -2234,8 +2280,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,
@@ -2245,9 +2291,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];
@@ -2340,7 +2386,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 ? [sql.raw(cell.lateral)] : []);
@@ -2361,7 +2407,7 @@ function buildResolvedQuery({ context, plan }) {
   const system = RESOLVED_VIEW_SYSTEM_COLUMNS;
   selected[system.writebackStatus.name] = sql.raw(`${alias(manual.name)}.${ident(RESOLVED_SOURCE_SYSTEM_COLUMNS.writebackStatus.columnName)}`).as(system.writebackStatus.columnName);
   selected[system.writebackError.name] = 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(sql.raw(hidden.join(" AND "))) : query;
 }
@@ -2387,12 +2433,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`);
@@ -2411,7 +2457,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 ?? []];
@@ -2445,23 +2491,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);
@@ -2488,7 +2534,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}"`);
@@ -2590,8 +2636,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,
@@ -2645,6 +2691,72 @@ function computeDefinitionHash(definition) {
   return 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) {
@@ -2660,6 +2772,8 @@ function defineNamespace(input) {
     namespace: input.namespace,
     description: input.description,
     capabilities: input.capabilities ?? {},
+    imports: input.imports,
+    exports: input.exports,
     file
   };
   registerNamespaceConfig(config);
@@ -2704,15 +2818,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) {
@@ -2753,6 +2867,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);
@@ -2762,7 +2878,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 createHash("sha256").update(HASH_DOMAIN).update(stableJson(definition)).digest("hex");
@@ -2776,6 +2894,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;
@@ -2859,6 +2978,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);
       } });
@@ -3029,6 +3151,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)) {
@@ -3085,11 +3220,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) {
@@ -3135,8 +3270,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 }
       ])
     ),
@@ -3157,7 +3292,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) {
@@ -3304,6 +3439,53 @@ function purgeModuleCache(root) {
     if (key.startsWith(prefix)) delete require2.cache[key];
   }
 }
+var sqlScalarSchema = z.enum(["text", "boolean", "integer", "bigint", "numeric", "double", "uuid", "date", "timestamptz"]);
+var name = z.string().regex(/^[A-Za-z_][A-Za-z0-9_]*$/).max(63).refine((value) => !["__proto__", "prototype", "constructor"].includes(value), "reserved name");
+var base = z.object({
+  name,
+  namespace: name,
+  language: z.literal("sql"),
+  kind: z.literal("query"),
+  requires: z.object({ capability: z.string().min(1).max(128) }).strict(),
+  ontology: z.object({ read: z.array(z.string().regex(/^[A-Za-z_][A-Za-z0-9_]*\/[A-Za-z_][A-Za-z0-9_]*$/)).min(1).max(256) }).strict(),
+  maxRows: z.number().int().min(1).max(1e4).default(1e3)
+});
+var fixed = base.extend({
+  parameters: z.record(name, z.object({ type: sqlScalarSchema, required: z.boolean().default(true) }).strict()).default({}),
+  sql: z.string().min(1).max(65536)
+}).strict();
+var runtime = base.extend({ mode: z.literal("runtime") }).strict();
+var sqlOperationDefinitionSchema = 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 = {
@@ -3335,9 +3517,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("  }");
   }
@@ -3348,8 +3530,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;
@@ -3357,17 +3539,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("; ")} }> }`;
 }
@@ -3381,9 +3563,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
@@ -3848,7 +4030,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;
 }
@@ -3923,19 +4105,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 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));
 }
@@ -3986,10 +4168,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(
@@ -4008,7 +4192,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":
@@ -4092,22 +4277,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;
@@ -4128,9 +4313,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(", ");
@@ -4150,7 +4335,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$`
   ) : (
@@ -4164,7 +4349,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
@@ -4176,13 +4361,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;`
     );
   }
@@ -4234,7 +4419,7 @@ var tableFileSchema = z.strictObject({
   table: identifierSchema,
   description: z.string().optional(),
   columns: z.record(identifierSchema, columnSchema).optional(),
-  source: z.string().regex(SYNCED_SOURCE_PATTERN, "source must reference a gold-layer table").optional(),
+  source: z.string().regex(SYNCED_SOURCE_PATTERN, "source must be a qualified lowercase schema.table identifier").optional(),
   links: z.record(identifierSchema, linkSchema).optional(),
   indexes: z.array(indexSchema).optional(),
   policies: policiesSchema.optional(),
@@ -4243,12 +4428,12 @@ var tableFileSchema = 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]
       });
     }
   }
@@ -4281,41 +4466,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);
@@ -4323,10 +4508,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) {
@@ -4336,27 +4521,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"]
       });
     }
   }
@@ -4381,22 +4566,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"]
       });
     }
   }
@@ -4411,32 +4596,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]
       });
     }
   }
@@ -4529,7 +4714,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) {
@@ -4592,12 +4777,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}`
@@ -4613,8 +4805,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)) {
@@ -4668,21 +4860,21 @@ function syncedBackingRevokeStatements({
   return statements;
 }
 var FACTORIES = {
-  uuid: (name) => uuid(name),
-  text: (name) => text(name),
-  integer: (name) => integer(name),
+  uuid: (name2) => uuid(name2),
+  text: (name2) => text(name2),
+  integer: (name2) => 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) => bigint(name, { mode: "bigint" }),
-  numeric: (name) => numeric(name),
-  double: (name) => doublePrecision(name),
-  boolean: (name) => boolean(name),
-  timestamptz: (name) => timestamp(name, { withTimezone: true }),
-  date: (name) => date(name),
-  jsonb: (name) => jsonb(name)
+  bigint: (name2) => bigint(name2, { mode: "bigint" }),
+  numeric: (name2) => numeric(name2),
+  double: (name2) => doublePrecision(name2),
+  boolean: (name2) => boolean(name2),
+  timestamptz: (name2) => timestamp(name2, { withTimezone: true }),
+  date: (name2) => date(name2),
+  jsonb: (name2) => 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();
@@ -4713,7 +4905,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),
@@ -4723,21 +4915,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 ? uniqueIndex(name) : index(name);
+    const name2 = indexName(table.table, definition);
+    const factory = definition.unique ? uniqueIndex(name2) : 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 foreignKey({
-      name: foreignKeyName(table.table, name),
+      name: foreignKeyName(table.table, name2),
       columns: [self[link.on]],
       foreignColumns: [targetColumn]
     });
@@ -4794,21 +4986,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`
       );
     }
   }
@@ -4827,33 +5019,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;
         }
@@ -4894,8 +5086,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(", ");
@@ -4904,7 +5096,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
@@ -4942,12 +5134,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;
@@ -4955,21 +5147,21 @@ function refreshFunctionStatements({ namespace, previous, current }) {
 
 // src/engine/canonical2.ts
 var FACTORIES2 = {
-  uuid: (name) => uuid(name),
-  text: (name) => text(name),
-  integer: (name) => integer(name),
+  uuid: (name2) => uuid(name2),
+  text: (name2) => text(name2),
+  integer: (name2) => 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) => bigint(name, { mode: "bigint" }),
-  numeric: (name) => numeric(name),
-  double: (name) => doublePrecision(name),
-  boolean: (name) => boolean(name),
-  timestamptz: (name) => timestamp(name, { withTimezone: true }),
-  date: (name) => date(name),
-  jsonb: (name) => jsonb(name)
+  bigint: (name2) => bigint(name2, { mode: "bigint" }),
+  numeric: (name2) => numeric(name2),
+  double: (name2) => doublePrecision(name2),
+  boolean: (name2) => boolean(name2),
+  timestamptz: (name2) => timestamp(name2, { withTimezone: true }),
+  date: (name2) => date(name2),
+  jsonb: (name2) => 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);
@@ -5271,9 +5463,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;
@@ -5359,8 +5551,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 ? uniqueIndex(name) : index(name);
+    const name2 = indexName(table.table, definition);
+    const factory = definition.unique ? uniqueIndex(name2) : index(name2);
     const columns = definition.columns.map((column) => self[column]);
     return factory.on(...columns);
   });
@@ -5439,33 +5631,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;
         }
@@ -5476,8 +5668,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)) {
@@ -5562,11 +5754,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({
@@ -5583,14 +5775,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({
@@ -5620,9 +5812,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,
@@ -5764,7 +5956,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"]);
@@ -5813,8 +6005,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])
@@ -5840,22 +6032,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;
       }
     }
@@ -5866,13 +6058,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;
@@ -5890,18 +6082,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;
 }
@@ -6147,9 +6339,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 = z.union([z.literal(LEGACY_IR_VERSION), 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 = z.union([z.literal(LEGACY_IR_VERSION), z.literal(GUARDED_IR_VERSION), z.literal(COMPOSED_IR_VERSION), z.literal(SQL_IR_VERSION), z.literal(RUNTIME_SQL_IR_VERSION)]);
 var operationVersionSchema = z.object({ irVersion: irVersionSchema });
 function requiredArtifactIrVersion(operations) {
   let required = LEGACY_IR_VERSION;
@@ -6201,8 +6397,8 @@ var predIrSchema = z.lazy(
       value: z.number(),
       where: predIrSchema.optional()
     }),
-    z.object({ kind: z.literal("capability"), key: z.string() }),
-    z.object({ kind: z.literal("role"), key: z.string() }),
+    z.object({ kind: z.literal("capability"), key: z.string(), namespace: z.string().optional() }),
+    z.object({ kind: z.literal("role"), key: z.string(), namespace: z.string().optional() }),
     z.object({ kind: z.literal("dynamicFilter"), slot: z.string() }),
     z.object({ kind: z.literal("const"), value: z.boolean() })
   ])
@@ -6429,7 +6625,31 @@ var variableIrSchema = z.object({
   /** Absent = no default declared; see {@link variableDefaultIrSchema}. */
   defaultValue: variableDefaultIrSchema.optional()
 });
+var sqlColumnSchema = z.object({ name: z.string(), type: z.enum(["text", "boolean", "integer", "bigint", "numeric", "double", "uuid", "date", "timestamptz"]), nullable: z.boolean() });
 var compiledOperationSchema = z.object({
+  language: z.literal("sql").optional(),
+  /** Server-compiled object catalog and permission ceiling, never caller SQL. */
+  sqlQuery: z.object({
+    catalog: z.object({
+      identity: z.string(),
+      objects: z.array(z.object({
+        ref: z.string(),
+        table: z.string(),
+        columns: z.array(sqlColumnSchema.extend({ type: z.string() })).min(1),
+        scan: z.string().min(1),
+        read: z.array(z.string()).min(1)
+      }).strict()).min(1).max(256)
+    }).strict(),
+    read: z.array(z.string()).min(1).max(256),
+    maxRows: z.number().int().min(1).max(1e4)
+  }).strict().optional(),
+  sql: z.object({
+    text: z.string().min(1).max(1048576),
+    columns: z.array(sqlColumnSchema).min(1).max(256),
+    parameters: z.array(z.string()).max(128),
+    read: z.array(z.string()).min(1).max(256),
+    maxRows: z.number().int().min(1).max(1e4)
+  }).strict().optional(),
   irVersion: irVersionSchema,
   name: z.string(),
   opHash: z.string().regex(/^sha256:[0-9a-f]{64}$/),
@@ -6441,8 +6661,16 @@ var compiledOperationSchema = z.object({
   variables: z.array(variableIrSchema),
   /** Every table the op touches — data-token scoping + audit. */
   tableSet: z.array(z.string()).min(1),
-  roots: z.array(rootIrSchema).min(1)
+  roots: 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) {
@@ -6489,11 +6717,16 @@ var resolvedMetaIrSchema = z.object({
 });
 var tableMetaIrSchema = z.object({
   table: z.string(),
+  namespace: z.string().optional(),
+  dependencies: z.array(z.string()).optional(),
+  foreignReferences: z.array(z.object({ column: z.string(), target: z.string(), targetColumn: z.string() })).optional(),
+  exportRead: z.union([z.literal(true), z.object({ capability: z.string() }), z.object({ role: z.string() })]).optional(),
+  exportWrite: z.union([z.literal(true), z.object({ capability: z.string() }), z.object({ role: z.string() })]).optional(),
   schema: z.string(),
   typename: z.string(),
   /**
    * True when statements over this relation evaluate a claims-gated synced
-   * view: synced twins (`source: gold.*`) materialize as views whose baked
+   * 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
@@ -6552,13 +6785,21 @@ var compiledArtifactSchema = z.object({
   irVersion: irVersionSchema,
   namespace: z.string(),
   schemaHash: z.string(),
+  ownSchemaHash: z.string().optional(),
+  dependencies: z.record(z.string(), z.string()).optional(),
+  readPolicies: z.record(z.string(), predIrSchema).optional(),
   opsHash: z.string(),
+  /** Apply-observed synced objects without a serving backing; not part of the authored schema hash. */
+  unbackedTables: z.array(z.string()).optional(),
   tables: z.record(z.string(), tableMetaIrSchema),
   operations: z.record(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" });
     }
   }
 });
@@ -6571,7 +6812,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) {
@@ -6604,10 +6845,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;
@@ -6650,12 +6891,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);
@@ -6663,9 +6904,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);
       }
     }
   }
@@ -6677,20 +6918,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
         );
       }
@@ -6770,7 +7011,7 @@ function parseYaml(file, contents) {
     throw new OrmDefinitionError(error instanceof Error ? error.message : "invalid YAML", file);
   }
 }
-var isDefinitionFile = (name) => DEFINITION_FILE_EXTENSIONS.some((extension) => extname(name) === extension);
+var isDefinitionFile = (name2) => DEFINITION_FILE_EXTENSIONS.some((extension) => extname(name2) === extension);
 async function listDefinitionFiles(dir) {
   const entries = await readdir(dir, { withFileTypes: true });
   return entries.filter((entry) => entry.isFile() && isDefinitionFile(entry.name)).map((entry) => entry.name).sort();
@@ -6864,13 +7105,13 @@ async function readMigrationSql(dir, entry) {
 var checksumOf = (text4) => 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"
@@ -6886,13 +7127,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 = join(dir, MIGRATIONS_DIRNAME, META_DIRNAME);
   await mkdir(metaDir, { recursive: true });
   const snapshotText = `${JSON.stringify(plan.snapshot, null, 2)}
 `;
-  await writeFile(join(dir, MIGRATIONS_DIRNAME, `${name}.sql`), sql7);
+  await writeFile(join(dir, MIGRATIONS_DIRNAME, `${name2}.sql`), sql7);
   await writeFile(join(metaDir, `${pad(ordinal)}.snapshot.json`), snapshotText);
   const journal = {
     ...workspace.journal,
@@ -6900,7 +7141,7 @@ async function writeMigration({
       ...workspace.journal.entries,
       {
         ordinal,
-        name,
+        name: name2,
         content_hash: contentHash,
         previous_content_hash: tip?.content_hash ?? null,
         checksum: checksumOf(sql7),
@@ -6911,7 +7152,7 @@ async function writeMigration({
   };
   await writeFile(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) {
@@ -7085,15 +7326,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,
@@ -7110,11 +7351,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,
@@ -7128,14 +7369,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,
@@ -7164,29 +7405,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`,
@@ -7260,8 +7501,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,
@@ -7274,7 +7515,527 @@ function canonicalActions(value) {
     ])
   );
 }
+var IMPORT_CONFLICT_MODES = ["error", "skip", "update"];
+var columnMapSchema = z.object({
+  /** ORM property name or Postgres column name. */
+  target: z.string().min(1).max(63),
+  /** Column on the source relation. Identifiers only — never an expression. */
+  source: 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: z.union([z.string().max(1e4), z.number(), z.boolean()]).optional()
+}).strict();
+var importSpecSchema = z.object({
+  table: z.string().min(1).max(63),
+  from: z.string().regex(QUALIFIED_TABLE_PATTERN),
+  columns: z.array(columnMapSchema).min(1).max(500),
+  onConflict: z.enum(IMPORT_CONFLICT_MODES).default("skip"),
+  batchSize: 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 = 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];
+}
 
-export { ACTION_REQUIRES_DENIED_SQLSTATE, ACTION_VALIDATES_FAILED_SQLSTATE, AUDIT_ACTIONS, CANONICAL_FORMAT, CAPABILITIES_CLAIM_KEY, CAPABILITY_KEY_PATTERN, CELLS_FIELD, CELL_PARTS, CELL_PART_SUFFIX, CLAIMS_CONTRACT, CLAIMS_SETTING, CLAIM_KEY_PATTERN, CMP_OPS, COLUMN_BRAND, COLUMN_DEFAULT_FNS, COLUMN_IDENTIFIER_PATTERN, COLUMN_TYPES2 as COLUMN_TYPES, COMPARE_OPS, CONSUMER_ROLE_SUFFIX, ColumnBuilder, DATE_BUCKETS, DEFINITION_FILE_EXTENSIONS, ENUM_BRAND, HASH_DOMAIN, IDENTIFIER_PATTERN, IDENTIFIER_RE, INPUT_REF_KINDS, IR_VERSION, IrVersionError, LEGACY_IR_VERSION, LINK_BRAND, MATERIALIZE_ACTOR, MATERIALIZE_CLAIMS_JSON, MAX_DEFINITION_FILE_BYTES, MAX_GENERATED_SDL_BYTES, MAX_IDENTIFIER_LENGTH, MAX_TRACKED_COLUMN_NAME, MIGRATIONS_DIRNAME, NAMESPACE_CONFIG_BRAND, NAMESPACE_CONFIG_FILE, NAMESPACE_CONFIG_FILENAMES, NAMESPACE_PATTERN, ORM_DATA_TOKEN_HEADER, ORM_MIGRATION_EXPORT_FILE, ORM_MIGRATION_EXPORT_MAX_BYTES, ORM_REGISTRATION_MAX_BYTES, ORM_SCHEMA_PREFIX, ORM_SERVICE_DATA_TOKEN_HEADER, ORM_TO_PIPELINE_TYPE, OrmDefinitionError, PredicateParseError, QUALIFIED_TABLE_PATTERN, RESERVED_COLUMN_NAMES, RESERVED_TABLE_NAMES, ROLES_CLAIM_KEY, SCHEMA_DIR, STATEMENT_KINDS, SYNCED_CONTRACT_HASH_DOMAIN, SYNCED_SOURCE_PATTERN, SYNCED_VIEW_EXECUTION_OWNER_ROLE, TABLE_BRAND, VIEW_BRAND, actionFunctionName, actionFunctionStatements, actionParamArg, actionParamOrder, actionParamSchema, actionPrepareChecks, actionSchema, actionWriteTargets, actionsInterfaceName, activeAuthoringContext, applyMigrationHints, applyMigrationHintsV2, beginAuthoringContext, buildActionParamsSchema, buildDrizzleEntities, buildDrizzleEntitiesV2, buildNamespaceDefinition, buildRebaseJournalEntry, canonicalActionSchema, canonicalColumnSchema, canonicalDefinitionSchema, canonicalEnumSchema, canonicalIndexSchema, canonicalLinkSchema, canonicalPoliciesSchema, canonicalRelations, canonicalTableSchema, canonicalViewSchema, canonicalizeDefinition, capabilityExpression, castParts, cellColumnName, checksumOf, claimExpression, classifyDestructive, columnSchema, columnTypeSchema2 as columnTypeSchema, compileActionRequires, compileActionStatements, compileNamespace, compilePredIrToSql, compilePredicate, compiledArtifactSchema, compiledOperationSchema, computeCanonicalHash, computeDefinitionHash, computeSyncedContractHash, consumerRoleName, convertV1DefinitionToCanonical, createOrmMigrationExport, custom, declaredCapabilityKeys, defineEnum, defineNamespace, defineResolvedTable, defineSyncedTable, defineTable, defineView, deriveColumnName, diffCommand, diffStatements, emptyJournal, emptySnapshot, endAuthoringContext, etlSource, extractNamedParams, extractOrmSyncedTableContract, generateNamespaceTypes, generateSnapshot, generateSnapshotV2, highest, identifierSchema, indexByHash, isColumnBuilder, isEnumRef, isFunctionDefault, isOwnedStatement, isOwnedStatementV2, isQualifiedReference, isSeqLink, isSeqNamespaceConfig, isSeqTable, isSeqView, latest, limitIrSchema, loadCommittedMigrations, loadCommittedTipMigration, loadNamespaceDefinition, loadNamespaceFromDir, lowest, managedFn, manualSource, materializeLockKey, materializedRefreshFunctionName, migrationName, namespaceConfigSchema, namespaceSchema, nonNullFirst, normalizeCanonical, normalizeIr, normalizeSnapshot, orderIrSchema, ormMigrationExportSchema, ormSchemaName, overlayWinsUnion, overrideRowMutation, parseCanonicalDefinition, parseDefinitionSources, parseOrmMigrationExport, parsePredicate, parseTableFile, parsedPredicateSchema, pendingKitStatements, pendingKitStatementsV2, planCommittedMigrationV2, planMigration, planMigrationV2, policyExpressionSchema, policyVariantSchema, predIrSchema, predicateOperands, prefetchPlanIrSchema, prefetchSource, priority, quoteIdentifier, quoteLiteral, readMigrationSql, readMigrationWorkspace, readSnapshot, rebaseViolations, referencedCapabilities, referencedColumns, renderMigrationSql, renderOrmMigrationExport, requiredArtifactIrVersion, resolvedMetaIrSchema, resolvedSourceIrSchema, revertOverlayMutation, rewriteSyncedSourceRelationsInViewQuery, roleExpression, rootIrSchema, securityStatements, selectionIrSchema, serializeNamespace, sqlTypeName, stableJson, syncedBackingRevokeStatements, syncedContractSurface, syncedTables, syncedViewDropStatements, syncedViewStatements, t, tableFileSchema, tableMetaIrSchema, tableReferenceSchema, toMany, toOne, toPlatformUser, typesInterfaceName, validateViewCatalogStatement, valueIrSchema, variableDefaultIrSchema, variableIrSchema, verifyRebaseIsNoop, walkPredicate, writeMigration };
+export { ACTION_REQUIRES_DENIED_SQLSTATE, ACTION_VALIDATES_FAILED_SQLSTATE, AUDIT_ACTIONS, CANONICAL_FORMAT, CAPABILITIES_CLAIM_KEY, CAPABILITY_KEY_PATTERN, CELLS_FIELD, CELL_PARTS, CELL_PART_SUFFIX, CLAIMS_CONTRACT, CLAIMS_SETTING, CLAIM_KEY_PATTERN, CMP_OPS, COLUMN_BRAND, COLUMN_DEFAULT_FNS, COLUMN_IDENTIFIER_PATTERN, COLUMN_TYPES2 as COLUMN_TYPES, COMPARE_OPS, COMPOSED_IR_VERSION, CONSUMER_ROLE_SUFFIX, ColumnBuilder, DATE_BUCKETS, DEFINITION_FILE_EXTENSIONS, ENUM_BRAND, GUARDED_IR_VERSION, HASH_DOMAIN, IDENTIFIER_PATTERN, IDENTIFIER_RE, IMPORT_CONFLICT_MODES, INPUT_REF_KINDS, IR_VERSION, IrVersionError, LEGACY_IR_VERSION, LINK_BRAND, MATERIALIZE_ACTOR, MATERIALIZE_CLAIMS_JSON, MAX_DEFINITION_FILE_BYTES, MAX_GENERATED_SDL_BYTES, MAX_IDENTIFIER_LENGTH, MAX_TRACKED_COLUMN_NAME, MIGRATIONS_DIRNAME, NAMESPACE_CONFIG_BRAND, NAMESPACE_CONFIG_FILE, NAMESPACE_CONFIG_FILENAMES, NAMESPACE_PATTERN, ORM_DATA_TOKEN_HEADER, ORM_MIGRATION_EXPORT_FILE, ORM_MIGRATION_EXPORT_MAX_BYTES, ORM_REGISTRATION_MAX_BYTES, ORM_SCHEMA_PREFIX, ORM_SERVICE_DATA_TOKEN_HEADER, ORM_TO_PIPELINE_TYPE, OrmDefinitionError, PredicateParseError, QUALIFIED_TABLE_PATTERN, RESERVED_COLUMN_NAMES, RESERVED_TABLE_NAMES, ROLES_CLAIM_KEY, RUNTIME_SQL_IR_VERSION, SCHEMA_DIR, SQL_IR_VERSION, STATEMENT_KINDS, SYNCED_CONTRACT_HASH_DOMAIN, SYNCED_SOURCE_PATTERN, SYNCED_VIEW_EXECUTION_OWNER_ROLE, TABLE_BRAND, VIEW_BRAND, actionFunctionName, actionFunctionStatements, actionParamArg, actionParamOrder, actionParamSchema, actionPrepareChecks, actionSchema, actionWriteTargets, actionsInterfaceName, activeAuthoringContext, applyMigrationHints, applyMigrationHintsV2, beginAuthoringContext, buildActionParamsSchema, buildDrizzleEntities, buildDrizzleEntitiesV2, buildNamespaceDefinition, buildRebaseJournalEntry, canonicalActionSchema, canonicalColumnSchema, canonicalDefinitionSchema, canonicalEnumSchema, canonicalIndexSchema, canonicalLinkSchema, canonicalPoliciesSchema, canonicalRelations, canonicalTableSchema, canonicalViewSchema, canonicalizeDefinition, capabilityExpression, castParts, cellColumnName, checksumOf, claimExpression, classifyDestructive, columnSchema, columnTypeSchema2 as columnTypeSchema, compileActionRequires, compileActionStatements, compileNamespace, compilePredIrToSql, compilePredicate, compiledArtifactSchema, compiledOperationSchema, computeCanonicalHash, computeDefinitionHash, computeSyncedContractHash, consumerRoleName, convertV1DefinitionToCanonical, createOrmMigrationExport, custom, declaredCapabilityKeys, defineEnum, defineNamespace, defineOperation, defineResolvedTable, defineSyncedTable, defineTable, defineView, deriveColumnName, diffCommand, diffStatements, emptyJournal, emptySnapshot, endAuthoringContext, etlSource, extractNamedParams, extractOrmSyncedTableContract, generateNamespaceTypes, generateSnapshot, generateSnapshotV2, highest, identifierSchema, importSpecSchema, indexByHash, isColumnBuilder, isEnumRef, isFunctionDefault, isOwnedStatement, isOwnedStatementV2, isQualifiedReference, isSeqLink, isSeqNamespaceConfig, isSeqTable, isSeqView, latest, limitIrSchema, loadCommittedMigrations, loadCommittedTipMigration, loadNamespaceDefinition, loadNamespaceFromDir, lowest, managedFn, manualSource, materializeLockKey, materializedRefreshFunctionName, migrationName, namespaceConfigSchema, namespaceSchema, nonNullFirst, normalizeCanonical, normalizeIr, normalizeSnapshot, objectRef, ontologyContractSchema, orderIrSchema, ormMigrationExportSchema, ormSchemaName, overlayWinsUnion, overrideRowMutation, parseCanonicalDefinition, parseDefinitionSources, parseOrmMigrationExport, parsePredicate, parseTableFile, parsedPredicateSchema, pendingKitStatements, pendingKitStatementsV2, planCommittedMigrationV2, planMigration, planMigrationV2, planTableImport, policyExpressionSchema, policyVariantSchema, predIrSchema, predicateOperands, prefetchPlanIrSchema, prefetchSource, priority, quoteIdentifier, quoteLiteral, readMigrationSql, readMigrationWorkspace, readOntologyContract, readSnapshot, rebaseViolations, referencedCapabilities, referencedColumns, renderMigrationSql, renderOrmMigrationExport, requiredArtifactIrVersion, resolvedMetaIrSchema, resolvedSourceIrSchema, revertOverlayMutation, rewriteSyncedSourceRelationsInViewQuery, roleExpression, rootIrSchema, securityStatements, selectionIrSchema, serializeNamespace, sqlTypeName, stableJson, syncedBackingRevokeStatements, syncedContractSurface, syncedTables, syncedViewDropStatements, syncedViewStatements, t, tableFileSchema, tableMetaIrSchema, tableReferenceSchema, toMany, toOne, toPlatformUser, typesInterfaceName, validateNamespaceCatalog, validateViewCatalogStatement, valueIrSchema, variableDefaultIrSchema, variableIrSchema, verifyRebaseIsNoop, walkPredicate, writeMigration };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map