@sequenceholdings/orm 2.0.0 → 2.1.1

package/dist/index.d.ts

@@ -1,13 +1,15 @@
-export { AuthoringContext, AuthoringRegistration, COLUMN_BRAND, COLUMN_DEFAULT_FNS, ColumnBuilder, ColumnDefaultFn, ColumnDefaultLiteral, ColumnTypeSpec, CowMutationInput, DrizzleRelation, ENUM_BRAND, EnumRef, IndexInput, LINK_BRAND, LinkKind, LoadNamespaceOptions, LoadedNamespaceV2, NAMESPACE_CONFIG_BRAND, NAMESPACE_CONFIG_FILE, NamespaceCapabilitiesInput, NamespaceConfigInput, ORM_TO_PIPELINE_TYPE, OrmContractColumnMap, OrmContractPipelineColumn, OrmSyncedTableContract, OrmToPipelineType, OverlayTableRef, OverlayWinsUnionInput, OverrideRowMutationInput, PolicyInput, PolicyVariantInput, PolicyWithVariantsInput, RelationRef, RevertOverlayMutationInput, SCHEMA_DIR, SYNCED_CONTRACT_HASH_DOMAIN, SeqLink, SeqNamespaceConfig, SeqTable, SeqView, SerializeNamespaceInput, SyncedTableConfig, SyncedTablePoliciesInput, TABLE_BRAND, TableConfig, TablePoliciesInput, TableRef, ToManyOptions, ToOneOptions, ToPlatformUserOptions, TypedSyncedTableConfig, VIEW_BRAND, ViewConfig, ViewPoliciesInput, ViewQueryContext, ViewSelectQuery, activeAuthoringContext, beginAuthoringContext, computeCanonicalHash, computeSyncedContractHash, defineEnum, defineNamespace, defineSyncedTable, defineTable, defineView, deriveColumnName, endAuthoringContext, extractOrmSyncedTableContract, isColumnBuilder, isEnumRef, isSeqLink, isSeqNamespaceConfig, isSeqTable, isSeqView, loadNamespaceFromDir, overlayWinsUnion, overrideRowMutation, revertOverlayMutation, serializeNamespace, syncedContractSurface, t, toMany, toOne, toPlatformUser } from './authoring.js';
+export { AuthoringContext, AuthoringRegistration, COLUMN_BRAND, COLUMN_DEFAULT_FNS, CheckInput, ColumnBuilder, ColumnDefaultFn, ColumnDefaultLiteral, ColumnTypeSpec, Comparator, CowMutationInput, DrizzleRelation, DurationInput, ENUM_BRAND, EnumRef, EtlSourceInput, ForeignKeyInput, FunctionRef, IndexInput, LINK_BRAND, LinkKind, LoadNamespaceOptions, LoadedNamespaceV2, ManualSourceInput, NAMESPACE_CONFIG_BRAND, NAMESPACE_CONFIG_FILE, NamespaceCapabilitiesInput, NamespaceConfigInput, ORM_TO_PIPELINE_TYPE, OrmContractColumnMap, OrmContractPipelineColumn, OrmSyncedTableContract, OrmToPipelineType, OverlayTableRef, OverlayWinsUnionInput, OverrideRowMutationInput, PolicyInput, PolicyVariantInput, PolicyWithVariantsInput, PrefetchSourceInput, ReferentialAction, RelationRef, ResolvedSourceInput, ResolvedTableConfig, ResolvedTablePoliciesInput, RevertOverlayMutationInput, SCHEMA_DIR, SYNCED_CONTRACT_HASH_DOMAIN, SeqLink, SeqNamespaceConfig, SeqTable, SeqView, SerializeNamespaceInput, SyncedTableConfig, SyncedTablePoliciesInput, TABLE_BRAND, TableConfig, TablePoliciesInput, TableRef, ToManyOptions, ToOneOptions, ToPlatformUserOptions, TypedSyncedTableConfig, VIEW_BRAND, ViewConfig, ViewPoliciesInput, ViewQueryContext, ViewSelectQuery, activeAuthoringContext, beginAuthoringContext, computeCanonicalHash, computeSyncedContractHash, custom, defineEnum, defineNamespace, defineResolvedTable, defineSyncedTable, defineTable, defineView, deriveColumnName, endAuthoringContext, etlSource, extractOrmSyncedTableContract, highest, isColumnBuilder, isEnumRef, isSeqLink, isSeqNamespaceConfig, isSeqTable, isSeqView, latest, loadNamespaceFromDir, lowest, managedFn, manualSource, nonNullFirst, overlayWinsUnion, overrideRowMutation, prefetchSource, priority, revertOverlayMutation, serializeNamespace, syncedContractSurface, t, toMany, toOne, toPlatformUser } from './authoring.js';
 import { CanonicalDefinition } from './canonical.js';
-export { CANONICAL_FORMAT, CanonicalColumn, CanonicalEnum, CanonicalLink, CanonicalTable, CanonicalView, IDENTIFIER_RE, PolicyExpression, canonicalActionSchema, canonicalColumnSchema, canonicalDefinitionSchema, canonicalEnumSchema, canonicalIndexSchema, canonicalLinkSchema, canonicalPoliciesSchema, canonicalRelations, canonicalTableSchema, canonicalViewSchema, normalizeCanonical, policyExpressionSchema, policyVariantSchema } from './canonical.js';
+export { CANONICAL_FORMAT, CanonicalColumn, CanonicalEnum, CanonicalLink, CanonicalTable, CanonicalView, IDENTIFIER_RE, canonicalActionSchema, canonicalColumnSchema, canonicalDefinitionSchema, canonicalEnumSchema, canonicalIndexSchema, canonicalLinkSchema, canonicalPoliciesSchema, canonicalRelations, canonicalTableSchema, canonicalViewSchema, normalizeCanonical } from './canonical.js';
 import { CustomRolesBlock } from '@sequenceholdings/custom-roles-manifest';
 export { CustomRolesBlock, capabilityPinsSchema, customRolesBlockSchema, customRolesDeclared, parseCapabilityPin, validateCapabilityPins } from '@sequenceholdings/custom-roles-manifest';
 import { z } from 'zod';
 import { PredIr } from './ir.js';
-export { CLAIMS_CONTRACT, CMP_OPS, ClaimKey, CmpOp, CompiledArtifact, CompiledOperation, INPUT_REF_KINDS, IR_VERSION, InputRefKind, IrVersionError, LimitIr, OrderIr, RootIr, SelectionIr, TableMetaIr, ValueIr, VariableDefaultIr, VariableIr, compiledArtifactSchema, compiledOperationSchema, indexByHash, limitIrSchema, normalizeIr, orderIrSchema, predIrSchema, rootIrSchema, selectionIrSchema, tableMetaIrSchema, valueIrSchema, variableDefaultIrSchema, variableIrSchema } from './ir.js';
+export { CLAIMS_CONTRACT, CMP_OPS, CellSelectionIr, ClaimKey, CmpOp, CompiledArtifact, CompiledOperation, DATE_BUCKETS, DateBucket, GroupByKeyIr, INPUT_REF_KINDS, IR_VERSION, InputRefKind, IrVersionError, LEGACY_IR_VERSION, LimitIr, OrderIr, PrefetchPlanIr, ResolvedMetaIr, ResolvedSourceIr, RootIr, SelectionIr, TableMetaIr, ValueIr, VariableDefaultIr, VariableIr, compiledArtifactSchema, compiledOperationSchema, indexByHash, limitIrSchema, normalizeIr, orderIrSchema, predIrSchema, prefetchPlanIrSchema, requiredArtifactIrVersion, resolvedMetaIrSchema, resolvedSourceIrSchema, rootIrSchema, selectionIrSchema, tableMetaIrSchema, valueIrSchema, variableDefaultIrSchema, variableIrSchema } from './ir.js';
+export { e as CAPABILITY_KEY_PATTERN, C as CELLS_FIELD, a as CELL_PARTS, f as CELL_PART_SUFFIX, g as CLAIM_KEY_PATTERN, h as COLUMN_IDENTIFIER_PATTERN, i as CONSUMER_ROLE_SUFFIX, b as CellPart, D as DEFINITION_FILE_EXTENSIONS, H as HASH_DOMAIN, I as IDENTIFIER_PATTERN, M as MATERIALIZE_ACTOR, j as MATERIALIZE_CLAIMS_JSON, k as MAX_DEFINITION_FILE_BYTES, l as MAX_GENERATED_SDL_BYTES, m as MAX_IDENTIFIER_LENGTH, n as MAX_TRACKED_COLUMN_NAME, o as NAMESPACE_CONFIG_FILENAMES, N as NAMESPACE_PATTERN, O as ORM_DATA_TOKEN_HEADER, p as ORM_REGISTRATION_MAX_BYTES, q as ORM_SCHEMA_PREFIX, d as ORM_SERVICE_DATA_TOKEN_HEADER, Q as QUALIFIED_TABLE_PATTERN, R as RESERVED_COLUMN_NAMES, r as RESERVED_TABLE_NAMES, S as SYNCED_SOURCE_PATTERN, c as cellColumnName, s as consumerRoleName, t as materializeLockKey, u as materializedRefreshFunctionName, v as ormSchemaName } from './constants-YoFGjIBM.js';
 import { generateDrizzleJson } from 'drizzle-kit/api';
 import { PgTableWithColumns } from 'drizzle-orm/pg-core';
+export { P as PolicyExpression, p as policyExpressionSchema, a as policyVariantSchema } from './policy-1iZbGnZZ.js';
 import 'drizzle-orm';
 import 'drizzle-orm/query-builders/query-builder';
 
@@ -49,14 +51,14 @@ declare const actionParamSchema: z.ZodObject<{
     type: z.ZodEnum<{
         bigint: "bigint";
         boolean: "boolean";
-        uuid: "uuid";
         text: "text";
+        date: "date";
+        timestamptz: "timestamptz";
+        jsonb: "jsonb";
+        uuid: "uuid";
         integer: "integer";
         numeric: "numeric";
         double: "double";
-        timestamptz: "timestamptz";
-        date: "date";
-        jsonb: "jsonb";
     }>;
     optional: z.ZodOptional<z.ZodBoolean>;
     description: z.ZodOptional<z.ZodString>;
@@ -74,14 +76,14 @@ declare const actionSchema: z.ZodObject<{
         type: z.ZodEnum<{
             bigint: "bigint";
             boolean: "boolean";
-            uuid: "uuid";
             text: "text";
+            date: "date";
+            timestamptz: "timestamptz";
+            jsonb: "jsonb";
+            uuid: "uuid";
             integer: "integer";
             numeric: "numeric";
             double: "double";
-            timestamptz: "timestamptz";
-            date: "date";
-            jsonb: "jsonb";
         }>;
         optional: z.ZodOptional<z.ZodBoolean>;
         description: z.ZodOptional<z.ZodString>;
@@ -91,14 +93,14 @@ declare const actionSchema: z.ZodObject<{
     returns: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodEnum<{
         bigint: "bigint";
         boolean: "boolean";
-        uuid: "uuid";
         text: "text";
+        date: "date";
+        timestamptz: "timestamptz";
+        jsonb: "jsonb";
+        uuid: "uuid";
         integer: "integer";
         numeric: "numeric";
         double: "double";
-        timestamptz: "timestamptz";
-        date: "date";
-        jsonb: "jsonb";
     }>>>;
     audit: z.ZodOptional<z.ZodObject<{
         action: z.ZodEnum<{
@@ -126,14 +128,14 @@ type ColumnType = (typeof COLUMN_TYPES)[number];
 declare const columnTypeSchema: z.ZodEnum<{
     bigint: "bigint";
     boolean: "boolean";
-    uuid: "uuid";
     text: "text";
+    date: "date";
+    timestamptz: "timestamptz";
+    jsonb: "jsonb";
+    uuid: "uuid";
     integer: "integer";
     numeric: "numeric";
     double: "double";
-    timestamptz: "timestamptz";
-    date: "date";
-    jsonb: "jsonb";
 }>;
 /**
  * True when the default is one of the allowlisted SQL function calls for its
@@ -158,14 +160,14 @@ declare const columnSchema: z.ZodObject<{
     type: z.ZodEnum<{
         bigint: "bigint";
         boolean: "boolean";
-        uuid: "uuid";
         text: "text";
+        date: "date";
+        timestamptz: "timestamptz";
+        jsonb: "jsonb";
+        uuid: "uuid";
         integer: "integer";
         numeric: "numeric";
         double: "double";
-        timestamptz: "timestamptz";
-        date: "date";
-        jsonb: "jsonb";
     }>;
     primary_key: z.ZodOptional<z.ZodBoolean>;
     nullable: z.ZodOptional<z.ZodBoolean>;
@@ -208,14 +210,14 @@ declare const tableFileSchema: z.ZodObject<{
         type: z.ZodEnum<{
             bigint: "bigint";
             boolean: "boolean";
-            uuid: "uuid";
             text: "text";
+            date: "date";
+            timestamptz: "timestamptz";
+            jsonb: "jsonb";
+            uuid: "uuid";
             integer: "integer";
             numeric: "numeric";
             double: "double";
-            timestamptz: "timestamptz";
-            date: "date";
-            jsonb: "jsonb";
         }>;
         primary_key: z.ZodOptional<z.ZodBoolean>;
         nullable: z.ZodOptional<z.ZodBoolean>;
@@ -259,14 +261,14 @@ declare const tableFileSchema: z.ZodObject<{
             type: z.ZodEnum<{
                 bigint: "bigint";
                 boolean: "boolean";
-                uuid: "uuid";
                 text: "text";
+                date: "date";
+                timestamptz: "timestamptz";
+                jsonb: "jsonb";
+                uuid: "uuid";
                 integer: "integer";
                 numeric: "numeric";
                 double: "double";
-                timestamptz: "timestamptz";
-                date: "date";
-                jsonb: "jsonb";
             }>;
             optional: z.ZodOptional<z.ZodBoolean>;
             description: z.ZodOptional<z.ZodString>;
@@ -276,14 +278,14 @@ declare const tableFileSchema: z.ZodObject<{
         returns: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodEnum<{
             bigint: "bigint";
             boolean: "boolean";
-            uuid: "uuid";
             text: "text";
+            date: "date";
+            timestamptz: "timestamptz";
+            jsonb: "jsonb";
+            uuid: "uuid";
             integer: "integer";
             numeric: "numeric";
             double: "double";
-            timestamptz: "timestamptz";
-            date: "date";
-            jsonb: "jsonb";
         }>>>;
         audit: z.ZodOptional<z.ZodObject<{
             action: z.ZodEnum<{
@@ -428,65 +430,6 @@ declare const capabilityExpression: (key: string) => string;
 /** NULL claims (or a missing roles array) coalesce to false — role checks fail closed. */
 declare const roleExpression: (key: string) => string;
 
-/** Namespace names become Postgres identifiers (`orm_<ns>` schema, `orm_<ns>_consumer` role) — the tight grammar is a security control, not cosmetics. */
-declare const NAMESPACE_PATTERN: RegExp;
-declare const IDENTIFIER_PATTERN: RegExp;
-declare const MAX_IDENTIFIER_LENGTH = 63;
-/**
- * The Data API carries a delegated, attenuated data token on this header (not
- * `Authorization`, which stays the app-user/session bearer). One definition
- * shared by the client transport, the server's caller resolver, and the
- * function-invoke minter, so all three agree.
- */
-declare const ORM_DATA_TOKEN_HEADER = "x-sequence-data-token";
-/**
- * The SEPARATE header the invoke proxy uses to hand a managed function its
- * *service* data token — the escalation path. A function receives BOTH this and
- * `ORM_DATA_TOKEN_HEADER`; the default `createOrmClient` reads the user token,
- * the deliberately-named `createServiceOrmClient` reads THIS one. Two distinct
- * headers so reaching for the service identity is always an explicit act, never
- * an accidental default. Both are sent to the Data API on `ORM_DATA_TOKEN_HEADER`
- * — the server stays mode-agnostic and resolves whatever sub the token carries.
- */
-declare const ORM_SERVICE_DATA_TOKEN_HEADER = "x-sequence-data-token-service";
-/**
- * Custom Roles & Capabilities claim keys as policies reference them: a
- * host-scoped registry key, or an org pin's `org/<key>`. Matches the registry
- * key grammar EXACTLY (`[a-z0-9-]`, 1–64 chars, no `_` — the FGA object-id
- * delimiter) so any capability that's declarable/attachable in namespace.yaml
- * can also be referenced here — a stricter pattern would let a valid key
- * register yet fail at apply (e.g. `org/2fa`, a one-char or digit-led key).
- */
-declare const CAPABILITY_KEY_PATTERN: RegExp;
-declare const CLAIM_KEY_PATTERN: RegExp;
-/** Qualified reference to a table outside the defining file: `<schema>.<table>`. */
-declare const QUALIFIED_TABLE_PATTERN: RegExp;
-/** Synced reflected sources are restricted to the gold layer. */
-declare const SYNCED_SOURCE_PATTERN: RegExp;
-declare const ORM_SCHEMA_PREFIX = "orm_";
-declare const CONSUMER_ROLE_SUFFIX = "_consumer";
-declare const ormSchemaName: (namespace: string) => string;
-declare const consumerRoleName: (namespace: string) => string;
-declare const DEFINITION_FILE_EXTENSIONS: readonly [".yml", ".yaml"];
-/** Reserved basenames for the namespace-level config file (description, org capability pins). */
-declare const NAMESPACE_CONFIG_FILENAMES: Set<string>;
-declare const HASH_DOMAIN = "sequence-orm-definitions\0";
-/**
- * The one size guard the package owns: a per-file byte cap where the loader
- * reads untrusted YAML into memory — a real failure mode, not a product
- * limit. Counts of tables/indexes/params and policy/SQL lengths are
- * deliberately uncapped; Postgres enforces its own limits loudly at apply.
- */
-declare const MAX_DEFINITION_FILE_BYTES: number;
-/** `/api/data/<ns>/actions/…` and `/api/data/<ns>/query` share the table path segment. */
-declare const RESERVED_TABLE_NAMES: Set<string>;
-/**
- * The Data API's query-string grammar owns these parameter names — a column
- * with one of them could never be filtered over the wire, so definitions
- * refuse it up front ("validate rejects only what can never work").
- */
-declare const RESERVED_COLUMN_NAMES: Set<string>;
-
 /** drizzle-kit's serialized schema — the diff/replay artifact the registry stores. */
 type NamespaceSnapshot = ReturnType<typeof generateDrizzleJson>;
 declare function generateSnapshot(definition: NamespaceDefinition, previousId?: string): NamespaceSnapshot;
@@ -626,11 +569,11 @@ interface SyncedBacking {
  */
 /**
  * Atlas reassigns every relation in `orm_<ns>` to this role after apply.
- * Synced views resolve backing access as their owner, so the emitter must
- * grant this role narrow SELECT on each physical relation before CREATE VIEW.
+ * Synced views resolve backing access as their owner. Grant this role narrow
+ * SELECT before CREATE VIEW, or preserve a separately verified publisher grant.
  */
 declare const SYNCED_VIEW_EXECUTION_OWNER_ROLE = "orm_exec";
-declare function syncedViewStatements({ definition, backings, readPolicyIrByTable, columnNamesByTable, columnTypesByTable, executionOwnerRole, }: {
+declare function syncedViewStatements({ definition, backings, readPolicyIrByTable, columnNamesByTable, columnTypesByTable, executionOwnerRole, backingPrivileges, }: {
     definition: NamespaceDefinition;
     backings: readonly SyncedBacking[];
     /** v2 compiled read policies (preserves capability/role variants). */
@@ -645,6 +588,11 @@ declare function syncedViewStatements({ definition, backings, readPolicyIrByTabl
     columnTypesByTable?: ReadonlyMap<string, SyncedPredicateColumnTypes>;
     /** Role that will own the view after ensureExecutionOwner (default orm_exec). */
     executionOwnerRole?: string;
+    /** Preserve privileges managed by a separate immutable backing publisher.
+     * The caller must verify the owner's existing SELECT/USAGE grants and create
+     * the views as that owner. This option does not grant backing access.
+     */
+    backingPrivileges?: 'grant' | 'preserve';
 }): string[];
 /**
  * Drop synced views — idempotent cleanup for apply retries and removal.
@@ -696,7 +644,9 @@ declare const compileNamespace: (definition: NamespaceDefinition) => Promise<Pla
  * Canonical v2 → the in-memory schema bag drizzle-kit snapshots plus typed
  * table handles — the same `DrizzleEntities` shape engine/snapshot.ts consumes.
  */
-declare function buildDrizzleEntitiesV2(definition: CanonicalDefinition): DrizzleEntities;
+declare function buildDrizzleEntitiesV2(definition: CanonicalDefinition, options?: {
+    introspection?: boolean;
+}): DrizzleEntities;
 declare function rewriteSyncedSourceRelationsInViewQuery({ query, canonical, schemaName, dependencies, }: {
     query: string;
     canonical: CanonicalDefinition;
@@ -729,11 +679,32 @@ declare function applyMigrationHintsV2(previous: NamespaceSnapshot, definition:
  * action function statements. v2 enforces row policies inside compiled
  * operations (no PG RLS policies) and executes actions on the data plane
  * (no plpgsql functions), so a v2 plan is hints + kit DDL only.
+ *
+ * Managed views are dropped and recreated only when the migration reaches
+ * them: their own definition changed, they read a relation whose change is not
+ * provably view-safe, or they depend on a view that is recreated. Every other
+ * view stays in place, keeping its grants, owner, and outside dependents.
  */
-declare function planMigrationV2({ canonical, previousSnapshot, }: {
+declare function planMigrationV2(input: {
     canonical: CanonicalDefinition;
     previousSnapshot?: NamespaceSnapshot;
 }): Promise<PlannedMigration>;
+/**
+ * The plan a committed (reviewed) migration was authored as: the current
+ * planner when it reproduces the migration, otherwise the legacy one for a
+ * migration written before view recreation was narrowed. `reproduces` decides
+ * a match — rendered SQL for the CLI's tip gate, statement lists for Atlas's
+ * replay gate. When neither reproduces it, the current plan comes back with
+ * `reproduced: false`, so callers report the mismatch exactly as before.
+ */
+declare function planCommittedMigrationV2({ canonical, previousSnapshot, reproduces, }: {
+    canonical: CanonicalDefinition;
+    previousSnapshot?: NamespaceSnapshot;
+    reproduces: (plan: PlannedMigration) => boolean;
+}): Promise<{
+    plan: PlannedMigration;
+    reproduced: boolean;
+}>;
 /**
  * Drizzle's manual-view snapshot stores declared columns, but PostgreSQL names
  * and types the live view from the SELECT itself. Assert the live catalog in
@@ -769,6 +740,409 @@ declare function stableJson(value: unknown): string;
 declare function canonicalizeDefinition(definition: NamespaceDefinition): JsonValue;
 declare function computeDefinitionHash(definition: NamespaceDefinition): string;
 
+declare const ORM_MIGRATION_EXPORT_FILE = "orm.migration.json";
+declare const ORM_MIGRATION_EXPORT_MAX_BYTES: number;
+declare const ormMigrationExportSchema: z.ZodObject<{
+    schema_version: z.ZodLiteral<1>;
+    schema_hash: z.ZodString;
+    payload: z.ZodObject<{
+        canonical_definition: z.ZodObject<{
+            definition_format: z.ZodLiteral<2>;
+            namespace: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+            enums: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                values: z.ZodArray<z.ZodString>;
+            }, z.core.$strip>>>;
+            tables: z.ZodArray<z.ZodObject<{
+                table: z.ZodString;
+                description: z.ZodOptional<z.ZodString>;
+                renamedFrom: z.ZodOptional<z.ZodString>;
+                source: z.ZodOptional<z.ZodString>;
+                columns: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                    name: z.ZodString;
+                    columnName: z.ZodString;
+                    type: z.ZodUnion<readonly [z.ZodEnum<{
+                        bigint: "bigint";
+                        boolean: "boolean";
+                        text: "text";
+                        date: "date";
+                        timestamptz: "timestamptz";
+                        jsonb: "jsonb";
+                        uuid: "uuid";
+                        integer: "integer";
+                        numeric: "numeric";
+                        double: "double";
+                    }>, z.ZodObject<{
+                        enum: z.ZodString;
+                    }, z.core.$strip>]>;
+                    nullable: z.ZodDefault<z.ZodBoolean>;
+                    unique: z.ZodDefault<z.ZodBoolean>;
+                    default: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>>;
+                    defaultFn: z.ZodOptional<z.ZodEnum<{
+                        "gen_random_uuid()": "gen_random_uuid()";
+                        "now()": "now()";
+                    }>>;
+                    onUpdateFn: z.ZodOptional<z.ZodEnum<{
+                        "now()": "now()";
+                    }>>;
+                    description: z.ZodOptional<z.ZodString>;
+                    renamedFrom: z.ZodOptional<z.ZodString>;
+                    cast: z.ZodOptional<z.ZodString>;
+                    deprecated: z.ZodDefault<z.ZodBoolean>;
+                    cell: z.ZodOptional<z.ZodObject<{
+                        of: z.ZodString;
+                        part: z.ZodEnum<{
+                            at: "at";
+                            by: "by";
+                            rev: "rev";
+                            source: "source";
+                            conflicts: "conflicts";
+                        }>;
+                    }, z.core.$strict>>;
+                }, z.core.$strip>>>;
+                primaryKey: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                links: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                    name: z.ZodString;
+                    kind: z.ZodEnum<{
+                        toOne: "toOne";
+                        toMany: "toMany";
+                        toPlatformUser: "toPlatformUser";
+                    }>;
+                    target: z.ZodOptional<z.ZodString>;
+                    on: z.ZodString;
+                    references: z.ZodOptional<z.ZodString>;
+                    enforce: z.ZodDefault<z.ZodBoolean>;
+                    onDelete: z.ZodOptional<z.ZodEnum<{
+                        cascade: "cascade";
+                        restrict: "restrict";
+                        "no action": "no action";
+                        "set null": "set null";
+                        "set default": "set default";
+                    }>>;
+                    onUpdate: z.ZodOptional<z.ZodEnum<{
+                        cascade: "cascade";
+                        restrict: "restrict";
+                        "no action": "no action";
+                        "set null": "set null";
+                        "set default": "set default";
+                    }>>;
+                    description: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>>;
+                indexes: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                    columns: z.ZodArray<z.ZodString>;
+                    unique: z.ZodDefault<z.ZodBoolean>;
+                    name: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>>;
+                checks: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    name: z.ZodString;
+                    expression: z.ZodString;
+                }, z.core.$strict>>>;
+                policies: z.ZodDefault<z.ZodObject<{
+                    read: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                        default: z.ZodString;
+                        variants: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                            when: z.ZodString;
+                            allow: z.ZodOptional<z.ZodLiteral<true>>;
+                            policy: z.ZodOptional<z.ZodString>;
+                        }, z.core.$strip>>>;
+                    }, z.core.$strip>]>>;
+                    write: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                        default: z.ZodString;
+                        variants: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                            when: z.ZodString;
+                            allow: z.ZodOptional<z.ZodLiteral<true>>;
+                            policy: z.ZodOptional<z.ZodString>;
+                        }, z.core.$strip>>>;
+                    }, z.core.$strip>]>>;
+                    insert: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                        default: z.ZodString;
+                        variants: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                            when: z.ZodString;
+                            allow: z.ZodOptional<z.ZodLiteral<true>>;
+                            policy: z.ZodOptional<z.ZodString>;
+                        }, z.core.$strip>>>;
+                    }, z.core.$strip>]>>;
+                    update: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                        default: z.ZodString;
+                        variants: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                            when: z.ZodString;
+                            allow: z.ZodOptional<z.ZodLiteral<true>>;
+                            policy: z.ZodOptional<z.ZodString>;
+                        }, z.core.$strip>>>;
+                    }, z.core.$strip>]>>;
+                }, z.core.$strip>>;
+                actions: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                    name: z.ZodString;
+                    requires: z.ZodOptional<z.ZodString>;
+                    params: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+                        type: z.ZodEnum<{
+                            bigint: "bigint";
+                            boolean: "boolean";
+                            text: "text";
+                            date: "date";
+                            timestamptz: "timestamptz";
+                            jsonb: "jsonb";
+                            uuid: "uuid";
+                            integer: "integer";
+                            numeric: "numeric";
+                            double: "double";
+                        }>;
+                        nullable: z.ZodDefault<z.ZodBoolean>;
+                    }, z.core.$strip>>>;
+                    executes: z.ZodString;
+                    returns: z.ZodDefault<z.ZodEnum<{
+                        rows: "rows";
+                        rowsAffected: "rowsAffected";
+                        scalar: "scalar";
+                    }>>;
+                    audit: z.ZodOptional<z.ZodObject<{
+                        action: z.ZodString;
+                        resource: z.ZodString;
+                    }, z.core.$strip>>;
+                }, z.core.$strip>>>;
+                cowMutations: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    kind: z.ZodEnum<{
+                        override: "override";
+                        revert: "revert";
+                    }>;
+                    name: z.ZodString;
+                    synced: z.ZodString;
+                    pk: z.ZodString;
+                    copy: z.ZodDefault<z.ZodArray<z.ZodString>>;
+                    set: z.ZodDefault<z.ZodArray<z.ZodString>>;
+                }, z.core.$strip>>>;
+                foreignKeys: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    name: z.ZodString;
+                    columns: z.ZodArray<z.ZodString>;
+                    target: z.ZodString;
+                    references: z.ZodArray<z.ZodString>;
+                    deferrable: z.ZodOptional<z.ZodEnum<{
+                        "initially-immediate": "initially-immediate";
+                        "initially-deferred": "initially-deferred";
+                    }>>;
+                    onDelete: z.ZodOptional<z.ZodEnum<{
+                        cascade: "cascade";
+                        restrict: "restrict";
+                        "no action": "no action";
+                        "set null": "set null";
+                        "set default": "set default";
+                    }>>;
+                    onUpdate: z.ZodOptional<z.ZodEnum<{
+                        cascade: "cascade";
+                        restrict: "restrict";
+                        "no action": "no action";
+                        "set null": "set null";
+                        "set default": "set default";
+                    }>>;
+                }, z.core.$strict>>>;
+                cellMetadata: z.ZodOptional<z.ZodLiteral<true>>;
+                internal: z.ZodOptional<z.ZodLiteral<true>>;
+                materializes: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+            views: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                view: z.ZodString;
+                description: z.ZodOptional<z.ZodString>;
+                columns: z.ZodArray<z.ZodObject<{
+                    name: z.ZodString;
+                    columnName: z.ZodString;
+                    type: z.ZodUnion<readonly [z.ZodEnum<{
+                        bigint: "bigint";
+                        boolean: "boolean";
+                        text: "text";
+                        date: "date";
+                        timestamptz: "timestamptz";
+                        jsonb: "jsonb";
+                        uuid: "uuid";
+                        integer: "integer";
+                        numeric: "numeric";
+                        double: "double";
+                    }>, z.ZodObject<{
+                        enum: z.ZodString;
+                    }, z.core.$strip>]>;
+                    nullable: z.ZodDefault<z.ZodBoolean>;
+                    unique: z.ZodDefault<z.ZodBoolean>;
+                    default: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>>;
+                    defaultFn: z.ZodOptional<z.ZodEnum<{
+                        "gen_random_uuid()": "gen_random_uuid()";
+                        "now()": "now()";
+                    }>>;
+                    onUpdateFn: z.ZodOptional<z.ZodEnum<{
+                        "now()": "now()";
+                    }>>;
+                    description: z.ZodOptional<z.ZodString>;
+                    renamedFrom: z.ZodOptional<z.ZodString>;
+                    cast: z.ZodOptional<z.ZodString>;
+                    deprecated: z.ZodDefault<z.ZodBoolean>;
+                    cell: z.ZodOptional<z.ZodObject<{
+                        of: z.ZodString;
+                        part: z.ZodEnum<{
+                            at: "at";
+                            by: "by";
+                            rev: "rev";
+                            source: "source";
+                            conflicts: "conflicts";
+                        }>;
+                    }, z.core.$strict>>;
+                }, z.core.$strip>>;
+                primaryKey: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                links: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                    name: z.ZodString;
+                    kind: z.ZodEnum<{
+                        toOne: "toOne";
+                        toMany: "toMany";
+                        toPlatformUser: "toPlatformUser";
+                    }>;
+                    target: z.ZodOptional<z.ZodString>;
+                    on: z.ZodString;
+                    references: z.ZodOptional<z.ZodString>;
+                    enforce: z.ZodDefault<z.ZodBoolean>;
+                    onDelete: z.ZodOptional<z.ZodEnum<{
+                        cascade: "cascade";
+                        restrict: "restrict";
+                        "no action": "no action";
+                        "set null": "set null";
+                        "set default": "set default";
+                    }>>;
+                    onUpdate: z.ZodOptional<z.ZodEnum<{
+                        cascade: "cascade";
+                        restrict: "restrict";
+                        "no action": "no action";
+                        "set null": "set null";
+                        "set default": "set default";
+                    }>>;
+                    description: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>>;
+                policies: z.ZodObject<{
+                    read: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                        default: z.ZodString;
+                        variants: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                            when: z.ZodString;
+                            allow: z.ZodOptional<z.ZodLiteral<true>>;
+                            policy: z.ZodOptional<z.ZodString>;
+                        }, z.core.$strip>>>;
+                    }, z.core.$strip>]>;
+                }, z.core.$strict>;
+                query: z.ZodString;
+                dependencies: z.ZodArray<z.ZodString>;
+                resolved: z.ZodOptional<z.ZodObject<{
+                    sources: z.ZodArray<z.ZodObject<{
+                        name: z.ZodString;
+                        kind: z.ZodEnum<{
+                            manual: "manual";
+                            prefetch: "prefetch";
+                            etl: "etl";
+                        }>;
+                        table: z.ZodString;
+                        columns: z.ZodArray<z.ZodString>;
+                        updatedAt: z.ZodOptional<z.ZodString>;
+                        key: z.ZodOptional<z.ZodString>;
+                        fetch: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+                            shape: z.ZodLiteral<"single">;
+                        }, z.core.$strict>, z.ZodObject<{
+                            shape: z.ZodLiteral<"batch">;
+                            maxKeys: z.ZodNumber;
+                        }, z.core.$strict>]>>;
+                        function: z.ZodOptional<z.ZodObject<{
+                            kind: z.ZodEnum<{
+                                managed: "managed";
+                                native: "native";
+                            }>;
+                            id: z.ZodString;
+                        }, z.core.$strict>>;
+                        prefetchDefaults: z.ZodOptional<z.ZodObject<{
+                            maxStalenessMs: z.ZodNumber;
+                            timeoutMs: z.ZodNumber;
+                            onError: z.ZodEnum<{
+                                fallback: "fallback";
+                                fail: "fail";
+                            }>;
+                        }, z.core.$strict>>;
+                        writeback: z.ZodOptional<z.ZodObject<{
+                            columns: z.ZodArray<z.ZodString>;
+                            defaultMode: z.ZodEnum<{
+                                sync: "sync";
+                                async: "async";
+                            }>;
+                            timeoutMs: z.ZodNumber;
+                            clearManualOnConfirm: z.ZodBoolean;
+                        }, z.core.$strict>>;
+                    }, z.core.$strict>>;
+                    resolve: z.ZodArray<z.ZodObject<{
+                        column: z.ZodString;
+                        comparator: z.ZodEnum<{
+                            custom: "custom";
+                            latest: "latest";
+                            highest: "highest";
+                            lowest: "lowest";
+                            priority: "priority";
+                            nonNullFirst: "nonNullFirst";
+                        }>;
+                        candidates: z.ZodArray<z.ZodString>;
+                        orderBy: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strict>>;
+                    deletedBy: z.ZodDefault<z.ZodArray<z.ZodString>>;
+                    materialized: z.ZodOptional<z.ZodObject<{
+                        table: z.ZodString;
+                        compute: z.ZodString;
+                    }, z.core.$strict>>;
+                    policies: z.ZodDefault<z.ZodObject<{
+                        write: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                            default: z.ZodString;
+                            variants: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                                when: z.ZodString;
+                                allow: z.ZodOptional<z.ZodLiteral<true>>;
+                                policy: z.ZodOptional<z.ZodString>;
+                            }, z.core.$strip>>>;
+                        }, z.core.$strip>]>>;
+                        insert: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                            default: z.ZodString;
+                            variants: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                                when: z.ZodString;
+                                allow: z.ZodOptional<z.ZodLiteral<true>>;
+                                policy: z.ZodOptional<z.ZodString>;
+                            }, z.core.$strip>>>;
+                        }, z.core.$strip>]>>;
+                        update: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                            default: z.ZodString;
+                            variants: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                                when: z.ZodString;
+                                allow: z.ZodOptional<z.ZodLiteral<true>>;
+                                policy: z.ZodOptional<z.ZodString>;
+                            }, z.core.$strip>>>;
+                        }, z.core.$strip>]>>;
+                    }, z.core.$strict>>;
+                }, z.core.$strict>>;
+                internal: z.ZodOptional<z.ZodLiteral<true>>;
+            }, z.core.$strip>>>;
+            capabilities: z.ZodDefault<z.ZodObject<{
+                roles: z.ZodOptional<z.ZodUnknown>;
+                uses: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
+        documents: z.ZodArray<z.ZodObject<{
+            path: z.ZodString;
+            contents: z.ZodString;
+        }, z.core.$strict>>;
+        client_manifest: z.ZodObject<{
+            ops_hash: z.ZodString;
+            operations: z.ZodRecord<z.ZodString, z.ZodString>;
+        }, z.core.$strict>;
+        sdl: z.ZodString;
+        schema_snapshot: z.ZodJSONSchema;
+        migration: z.ZodOptional<z.ZodJSONSchema>;
+    }, z.core.$strict>;
+    checksum: z.ZodString;
+}, z.core.$strict>;
+type OrmMigrationExport = z.infer<typeof ormMigrationExportSchema>;
+declare function createOrmMigrationExport({ schemaHash, payload }: {
+    schemaHash: string;
+    payload: unknown;
+}): OrmMigrationExport;
+/** Git pins provenance; this checksum detects inconsistent bytes, not authorship. */
+declare function parseOrmMigrationExport(text: string): OrmMigrationExport;
+declare function renderOrmMigrationExport(exported: OrmMigrationExport): string;
+
 interface LoadedNamespace {
     readonly definition: NamespaceDefinition;
     readonly contentHash: string;
@@ -1013,4 +1387,4 @@ declare function parseCanonicalDefinition(value: unknown): NamespaceDefinition;
 
 declare const parsedPredicateSchema: z.ZodPipe<z.ZodString, z.ZodTransform<ParsedPredicate, string>>;
 
-export { ACTION_REQUIRES_DENIED_SQLSTATE, ACTION_VALIDATES_FAILED_SQLSTATE, AUDIT_ACTIONS, type ActionDefinition, CAPABILITIES_CLAIM_KEY, CAPABILITY_KEY_PATTERN, CLAIMS_SETTING, CLAIM_KEY_PATTERN, COLUMN_TYPES, COMPARE_OPS, CONSUMER_ROLE_SUFFIX, CanonicalDefinition, type ColumnDefault, type ColumnDefinition, type ColumnType, type CommittedChainEntry, type CommittedMigration, type CompareOp, type CompilePredIrToSqlOptions, type CompiledStatement, DEFINITION_FILE_EXTENSIONS, type DefinitionFile, type DefinitionSource, type DestructiveStatement, type DiffOptions, type DrizzleEntities, HASH_DOMAIN, IDENTIFIER_PATTERN, type IndexDefinition, type JournalEntry, type LinkDefinition, type LoadedNamespace, MAX_DEFINITION_FILE_BYTES, MAX_IDENTIFIER_LENGTH, MIGRATIONS_DIRNAME, type MigrationJournal, type MigrationWorkspace, NAMESPACE_CONFIG_FILENAMES, NAMESPACE_PATTERN, type NamespaceCapabilities, type NamespaceConfig, type NamespaceDefinition, type NamespaceSnapshot, ORM_DATA_TOKEN_HEADER, ORM_SCHEMA_PREFIX, ORM_SERVICE_DATA_TOKEN_HEADER, type Operand, OrmDefinitionError, type ParsedPredicate, type PlannedMigration, PredIr, type Predicate, type PredicateColumnTypes, PredicateParseError, QUALIFIED_TABLE_PATTERN, RESERVED_COLUMN_NAMES, RESERVED_TABLE_NAMES, ROLES_CLAIM_KEY, type RebaseEntry, type RebaseEntryInput, type RebaseNoopOptions, STATEMENT_KINDS, SYNCED_SOURCE_PATTERN, SYNCED_VIEW_EXECUTION_OWNER_ROLE, type StatementKind, type SyncedBacking, type SyncedColumnType, type SyncedPredicateColumnTypes, type TableFile, type ValidatesEntry, type WrittenMigration, actionFunctionName, actionFunctionStatements, actionParamArg, actionParamOrder, actionParamSchema, actionPrepareChecks, actionSchema, actionWriteTargets, actionsInterfaceName, applyMigrationHints, applyMigrationHintsV2, buildActionParamsSchema, buildDrizzleEntities, buildDrizzleEntitiesV2, buildNamespaceDefinition, buildRebaseJournalEntry, canonicalizeDefinition, capabilityExpression, castParts, checksumOf, claimExpression, classifyDestructive, columnSchema, columnTypeSchema, compileActionRequires, compileActionStatements, compileNamespace, compilePredIrToSql, compilePredicate, computeDefinitionHash, consumerRoleName, convertV1DefinitionToCanonical, declaredCapabilityKeys, diffCommand, diffStatements, emptyJournal, emptySnapshot, extractNamedParams, generateNamespaceTypes, generateSnapshot, generateSnapshotV2, identifierSchema, isFunctionDefault, isOwnedStatement, isOwnedStatementV2, isQualifiedReference, loadCommittedMigrations, loadCommittedTipMigration, loadNamespaceDefinition, migrationName, namespaceConfigSchema, namespaceSchema, normalizeSnapshot, ormSchemaName, parseCanonicalDefinition, parseDefinitionSources, parsePredicate, parseTableFile, parsedPredicateSchema, pendingKitStatements, pendingKitStatementsV2, planMigration, planMigrationV2, predicateOperands, quoteIdentifier, quoteLiteral, readMigrationSql, readMigrationWorkspace, readSnapshot, rebaseViolations, referencedCapabilities, referencedColumns, renderMigrationSql, rewriteSyncedSourceRelationsInViewQuery, roleExpression, securityStatements, sqlTypeName, stableJson, syncedBackingRevokeStatements, syncedTables, syncedViewDropStatements, syncedViewStatements, tableFileSchema, tableReferenceSchema, typesInterfaceName, validateViewCatalogStatement, verifyRebaseIsNoop, walkPredicate, writeMigration };
+export { ACTION_REQUIRES_DENIED_SQLSTATE, ACTION_VALIDATES_FAILED_SQLSTATE, AUDIT_ACTIONS, type ActionDefinition, CAPABILITIES_CLAIM_KEY, CLAIMS_SETTING, COLUMN_TYPES, COMPARE_OPS, CanonicalDefinition, type ColumnDefault, type ColumnDefinition, type ColumnType, type CommittedChainEntry, type CommittedMigration, type CompareOp, type CompilePredIrToSqlOptions, type CompiledStatement, type DefinitionFile, type DefinitionSource, type DestructiveStatement, type DiffOptions, type DrizzleEntities, type IndexDefinition, type JournalEntry, type LinkDefinition, type LoadedNamespace, MIGRATIONS_DIRNAME, type MigrationJournal, type MigrationWorkspace, type NamespaceCapabilities, type NamespaceConfig, type NamespaceDefinition, type NamespaceSnapshot, ORM_MIGRATION_EXPORT_FILE, ORM_MIGRATION_EXPORT_MAX_BYTES, type Operand, OrmDefinitionError, type OrmMigrationExport, type ParsedPredicate, type PlannedMigration, PredIr, type Predicate, type PredicateColumnTypes, PredicateParseError, ROLES_CLAIM_KEY, type RebaseEntry, type RebaseEntryInput, type RebaseNoopOptions, STATEMENT_KINDS, SYNCED_VIEW_EXECUTION_OWNER_ROLE, type StatementKind, type SyncedBacking, type SyncedColumnType, type SyncedPredicateColumnTypes, type TableFile, type ValidatesEntry, type WrittenMigration, actionFunctionName, actionFunctionStatements, actionParamArg, actionParamOrder, actionParamSchema, actionPrepareChecks, actionSchema, actionWriteTargets, actionsInterfaceName, applyMigrationHints, applyMigrationHintsV2, buildActionParamsSchema, buildDrizzleEntities, buildDrizzleEntitiesV2, buildNamespaceDefinition, buildRebaseJournalEntry, canonicalizeDefinition, capabilityExpression, castParts, checksumOf, claimExpression, classifyDestructive, columnSchema, columnTypeSchema, compileActionRequires, compileActionStatements, compileNamespace, compilePredIrToSql, compilePredicate, computeDefinitionHash, convertV1DefinitionToCanonical, createOrmMigrationExport, declaredCapabilityKeys, diffCommand, diffStatements, emptyJournal, emptySnapshot, extractNamedParams, generateNamespaceTypes, generateSnapshot, generateSnapshotV2, identifierSchema, isFunctionDefault, isOwnedStatement, isOwnedStatementV2, isQualifiedReference, loadCommittedMigrations, loadCommittedTipMigration, loadNamespaceDefinition, migrationName, namespaceConfigSchema, namespaceSchema, normalizeSnapshot, ormMigrationExportSchema, parseCanonicalDefinition, parseDefinitionSources, parseOrmMigrationExport, parsePredicate, parseTableFile, parsedPredicateSchema, pendingKitStatements, pendingKitStatementsV2, planCommittedMigrationV2, planMigration, planMigrationV2, predicateOperands, quoteIdentifier, quoteLiteral, readMigrationSql, readMigrationWorkspace, readSnapshot, rebaseViolations, referencedCapabilities, referencedColumns, renderMigrationSql, renderOrmMigrationExport, rewriteSyncedSourceRelationsInViewQuery, roleExpression, securityStatements, sqlTypeName, stableJson, syncedBackingRevokeStatements, syncedTables, syncedViewDropStatements, syncedViewStatements, tableFileSchema, tableReferenceSchema, typesInterfaceName, validateViewCatalogStatement, verifyRebaseIsNoop, walkPredicate, writeMigration };