@prisma/orm-family-sql 0.16.0-dev.36

package/dist/control-BHmsZudH.d.mts

@@ -0,0 +1,948 @@
+import { r as StorageColumn } from "./storage-table-BBaAmanc-BwR37LMA.mjs";
+import { c as SqlStorage } from "./sql-storage-B0QwiTg6-B8DVctJm.mjs";
+import { C as SqlControlDriverInstance } from "./types-CuDrWc5v-ISVXBmBs.mjs";
+import "./types-BchwQpmO.mjs";
+import { r as SqlOperationDescriptors } from "./index-BgaTJRxj.mjs";
+import { p as AnyQueryAst } from "./types-DIBA80mc-wf5wLmON.mjs";
+import { s as DdlNode } from "./ddl-types-rrMsf77U-DGctYf-T.mjs";
+import { a as LowererContext, y as SqlExecuteRequest } from "./ast-DSuzmsWn.mjs";
+import { g as SqlSchemaIR, v as SqlSchemaIRNode } from "./types-CvbBw1Jo-3KQdErJY.mjs";
+import "./types-TvBZ2Ne9.mjs";
+import { i as SqlControlAdapter } from "./control-adapter-C99J7aEF-C-17lFY8.mjs";
+import { A as SqlPlannerSuccessResult, C as SqlMigrationRunnerSuccessValue, O as SqlPlannerFailureResult, T as SqlPlannerConflict, _ as SqlMigrationRunner, h as SqlMigrationPlanner, n as CodecControlHooks, r as CreateSqlMigrationPlanOptions, t as AnyRecord, u as SqlMigrationPlan, v as SqlMigrationRunnerErrorCode, x as SqlMigrationRunnerFailure } from "./types-IqZMLrFC-DtdJNICr.mjs";
+import { t as SqlSchemaDiffFn } from "./schema-differ-DpG_gnur-g5_iks8G.mjs";
+import { ColumnDefault, Contract, ControlPolicy } from "@prisma/orm-framework/contract/types";
+import { NotOk, Ok } from "@prisma/orm-framework/utils/result";
+import { TargetBoundComponentDescriptor } from "@prisma/orm-framework/components/components";
+import { ContractSerializer, ControlFamilyDescriptor, ControlFamilyInstance, ControlStack, DiffSubjectGranularity, MigratableTargetDescriptor, MigrationOperationClass, MigrationOperationPolicy, MigrationOperationPolicy as MigrationOperationPolicy$1, MigrationPlan as MigrationPlan$1, MigrationPlanOperation, MigrationPlanOperation as MigrationPlanOperation$1, MigrationPlanner, MigrationPlannerConflict, MigrationPlannerConflict as MigrationPlannerConflict$1, MigrationPlannerResult, MutationDefaultGeneratorDescriptor, OpFactoryCall, OperationPreview, OperationPreviewCapable, PslContractInferCapable, SchemaDiffIssue, SchemaVerifier, SchemaViewCapable, SignDatabaseResult, TargetMigrationsCapability, VerifyDatabaseResult, VerifyDatabaseSchemaResult, assembleAuthoringContributions } from "@prisma/orm-framework/components/control";
+import { EmissionSpi, TypesImportSpec } from "@prisma/orm-framework/components/emission";
+import { PslDocumentAst } from "@prisma/orm-framework/components/psl-ast";
+//#region ../../../2-sql/9-family/dist/control.d.mts
+//#region src/core/control-instance.d.ts
+interface SqlTypeMetadata {
+  readonly typeId: string;
+  readonly familyId: 'sql';
+  readonly targetId: string;
+  readonly nativeType?: string;
+}
+type SqlTypeMetadataRegistry = Map<string, SqlTypeMetadata>;
+interface SqlFamilyInstanceState {
+  readonly codecTypeImports: ReadonlyArray<TypesImportSpec>;
+  readonly extensionIds: ReadonlyArray<string>;
+  readonly typeMetadataRegistry: SqlTypeMetadataRegistry;
+}
+interface SqlControlFamilyInstance extends ControlFamilyInstance<'sql', SqlSchemaIRNode>, SchemaViewCapable<SqlSchemaIRNode>, PslContractInferCapable<SqlSchemaIRNode>, OperationPreviewCapable, SqlFamilyInstanceState {
+  /**
+   * The family seam-of-record for on-disk contract reads. Structurally
+   * validates the JSON envelope, then hydrates IR-class instances via
+   * the per-target ContractSerializer. The single named entry point
+   * every CLI on-disk read crosses (TML-2536) — `as Contract` casts
+   * in production package sources are a serializer-bypass smell guarded
+   * by `pnpm lint:no-contract-cast`.
+   */
+  deserializeContract(contractJson: unknown): Contract;
+  verify(options: {
+    readonly driver: SqlControlDriverInstance<string>;
+    readonly contract: unknown;
+    readonly expectedTargetId: string;
+    readonly contractPath: string;
+    readonly configPath?: string;
+  }): Promise<VerifyDatabaseResult>;
+  /**
+   * Verify a contract against an already-introspected schema.
+   *
+   * Callers that need to verify against the live database compose
+   * `introspect({ driver })` + `verifySchema({ contract, schema, ... })`.
+   * The aggregate verifier hands in the full introspected schema and scopes
+   * the returned result to each member's contract space afterwards — so
+   * sibling-space tables never survive as `extras`.
+   */
+  verifySchema(options: {
+    readonly contract: unknown;
+    readonly schema: SqlSchemaIRNode;
+    readonly strict: boolean;
+    readonly frameworkComponents: ReadonlyArray<TargetBoundComponentDescriptor<'sql', string>>;
+  }): VerifyDatabaseSchemaResult;
+  /**
+   * Classifies a diff issue's subject granularity on demand, resolved from
+   * its node's `nodeKind` via the target's classifier. Satisfies the
+   * {@link import('@prisma/orm-framework/components/control').SchemaSubjectClassifierCapable}
+   * capability that framework consumers spanning contract spaces (the
+   * migration aggregate's unclaimed-elements sweep) detect via
+   * `hasSchemaSubjectClassifier` and call instead of reading family/target
+   * node vocabulary. Nothing is stamped on the issue or the node.
+   */
+  classifySubjectGranularity(issue: SchemaDiffIssue): DiffSubjectGranularity | undefined;
+  /**
+   * Classifies a diff issue's subject storage `entityKind` on demand,
+   * resolved from its node's `nodeKind` via the target's classifier —
+   * sibling of `classifySubjectGranularity` above, part of the same
+   * {@link import('@prisma/orm-framework/components/control').SchemaSubjectClassifierCapable}
+   * capability. Nothing is stamped on the issue or the node.
+   */
+  classifyEntityKind(issue: SchemaDiffIssue): string | undefined;
+  sign(options: {
+    readonly driver: SqlControlDriverInstance<string>;
+    readonly contract: unknown;
+    readonly contractPath: string;
+    readonly configPath?: string;
+  }): Promise<SignDatabaseResult>;
+  introspect(options: {
+    readonly driver: SqlControlDriverInstance<string>;
+    readonly contract?: unknown;
+  }): Promise<SqlSchemaIRNode>;
+  inferPslContract(schemaIR: SqlSchemaIRNode): PslDocumentAst;
+  lowerAst(ast: AnyQueryAst | DdlNode, context: LowererContext<unknown>): Promise<SqlExecuteRequest>;
+  /**
+   * Inserts the initial marker row for `space` (upsert on `space`).
+   * Delegates to the target control adapter's write SPI; see
+   * `SqlControlAdapter.initMarker`.
+   */
+  initMarker(options: {
+    readonly driver: SqlControlDriverInstance<string>;
+    readonly space: string;
+    readonly destination: {
+      readonly storageHash: string;
+      readonly profileHash: string;
+      readonly invariants?: readonly string[];
+    };
+  }): Promise<void>;
+  /**
+   * Compare-and-swap advance of the marker row for `space`. Returns `true`
+   * when the swap matched a row; see `SqlControlAdapter.updateMarker`.
+   */
+  updateMarker(options: {
+    readonly driver: SqlControlDriverInstance<string>;
+    readonly space: string;
+    readonly expectedFrom: string;
+    readonly destination: {
+      readonly storageHash: string;
+      readonly profileHash: string;
+      readonly invariants?: readonly string[];
+    };
+  }): Promise<boolean>;
+  /**
+   * Appends a ledger entry for `space`; see
+   * `SqlControlAdapter.writeLedgerEntry`.
+   */
+  writeLedgerEntry(options: {
+    readonly driver: SqlControlDriverInstance<string>;
+    readonly space: string;
+    readonly entry: {
+      readonly edgeId: string;
+      readonly from: string;
+      readonly to: string;
+      readonly migrationName: string;
+      readonly migrationHash: string;
+      readonly operations: readonly unknown[];
+      readonly destinationContractJson?: unknown;
+    };
+  }): Promise<void>;
+  bootstrapControlTableQueries(): readonly DdlNode[];
+  toOperationPreview(operations: readonly MigrationPlanOperation[]): OperationPreview;
+}
+//#endregion
+//#region src/core/control-descriptor.d.ts
+declare class SqlFamilyDescriptor implements ControlFamilyDescriptor<'sql', SqlControlFamilyInstance> {
+  readonly kind: "family";
+  readonly id = "sql";
+  readonly familyId: "sql";
+  readonly version = "0.0.1";
+  readonly emission: EmissionSpi;
+  readonly authoring: {
+    readonly field: {
+      readonly uuidString: {
+        readonly kind: "fieldPreset";
+        readonly output: {
+          readonly codecId: "sql/char@1";
+          readonly nativeType: "character";
+          readonly typeParams: {
+            readonly length: 36;
+          };
+        };
+      };
+      readonly ulid: {
+        readonly kind: "fieldPreset";
+        readonly output: {
+          readonly codecId: "sql/char@1";
+          readonly nativeType: "character";
+          readonly typeParams: {
+            readonly length: 26;
+          };
+        };
+      };
+      readonly nanoid: {
+        readonly kind: "fieldPreset";
+        readonly args: readonly [{
+          readonly kind: "object";
+          readonly optional: true;
+          readonly properties: {
+            readonly size: {
+              readonly kind: "number";
+              readonly optional: true;
+              readonly integer: true;
+              readonly minimum: 2;
+              readonly maximum: 255;
+            };
+          };
+        }];
+        readonly output: {
+          readonly codecId: "sql/char@1";
+          readonly nativeType: "character";
+          readonly typeParams: {
+            readonly length: {
+              readonly kind: "arg";
+              readonly index: 0;
+              readonly path: readonly ["size"];
+              readonly default: 21;
+            };
+          };
+        };
+      };
+      readonly cuid2: {
+        readonly kind: "fieldPreset";
+        readonly output: {
+          readonly codecId: "sql/char@1";
+          readonly nativeType: "character";
+          readonly typeParams: {
+            readonly length: 24;
+          };
+        };
+      };
+      readonly ksuid: {
+        readonly kind: "fieldPreset";
+        readonly output: {
+          readonly codecId: "sql/char@1";
+          readonly nativeType: "character";
+          readonly typeParams: {
+            readonly length: 27;
+          };
+        };
+      };
+      readonly id: {
+        readonly uuidv4String: {
+          readonly kind: "fieldPreset";
+          readonly output: {
+            readonly codecId: "sql/char@1";
+            readonly nativeType: "character";
+            readonly typeParams: {
+              readonly length: 36;
+            };
+            readonly executionDefaults: {
+              readonly onCreate: {
+                readonly kind: "generator";
+                readonly id: "uuidv4";
+              };
+            };
+            readonly id: true;
+          };
+        };
+        readonly uuidv7String: {
+          readonly kind: "fieldPreset";
+          readonly output: {
+            readonly codecId: "sql/char@1";
+            readonly nativeType: "character";
+            readonly typeParams: {
+              readonly length: 36;
+            };
+            readonly executionDefaults: {
+              readonly onCreate: {
+                readonly kind: "generator";
+                readonly id: "uuidv7";
+              };
+            };
+            readonly id: true;
+          };
+        };
+        readonly ulid: {
+          readonly kind: "fieldPreset";
+          readonly output: {
+            readonly codecId: "sql/char@1";
+            readonly nativeType: "character";
+            readonly typeParams: {
+              readonly length: 26;
+            };
+            readonly executionDefaults: {
+              readonly onCreate: {
+                readonly kind: "generator";
+                readonly id: "ulid";
+              };
+            };
+            readonly id: true;
+          };
+        };
+        readonly nanoid: {
+          readonly kind: "fieldPreset";
+          readonly args: readonly [{
+            readonly kind: "object";
+            readonly optional: true;
+            readonly properties: {
+              readonly size: {
+                readonly kind: "number";
+                readonly optional: true;
+                readonly integer: true;
+                readonly minimum: 2;
+                readonly maximum: 255;
+              };
+            };
+          }];
+          readonly output: {
+            readonly codecId: "sql/char@1";
+            readonly nativeType: "character";
+            readonly typeParams: {
+              readonly length: {
+                readonly kind: "arg";
+                readonly index: 0;
+                readonly path: readonly ["size"];
+                readonly default: 21;
+              };
+            };
+            readonly executionDefaults: {
+              readonly onCreate: {
+                readonly kind: "generator";
+                readonly id: "nanoid";
+                readonly params: {
+                  readonly size: {
+                    readonly kind: "arg";
+                    readonly index: 0;
+                    readonly path: readonly ["size"];
+                  };
+                };
+              };
+            };
+            readonly id: true;
+          };
+        };
+        readonly cuid2: {
+          readonly kind: "fieldPreset";
+          readonly output: {
+            readonly codecId: "sql/char@1";
+            readonly nativeType: "character";
+            readonly typeParams: {
+              readonly length: 24;
+            };
+            readonly executionDefaults: {
+              readonly onCreate: {
+                readonly kind: "generator";
+                readonly id: "cuid2";
+              };
+            };
+            readonly id: true;
+          };
+        };
+        readonly ksuid: {
+          readonly kind: "fieldPreset";
+          readonly output: {
+            readonly codecId: "sql/char@1";
+            readonly nativeType: "character";
+            readonly typeParams: {
+              readonly length: 27;
+            };
+            readonly executionDefaults: {
+              readonly onCreate: {
+                readonly kind: "generator";
+                readonly id: "ksuid";
+              };
+            };
+            readonly id: true;
+          };
+        };
+      };
+    };
+    readonly type: {
+      readonly sql: {
+        readonly String: {
+          readonly kind: "typeConstructor";
+          readonly args: readonly [{
+            readonly kind: "number";
+            readonly name: "length";
+            readonly integer: true;
+            readonly minimum: 1;
+            readonly maximum: 10485760;
+          }];
+          readonly output: {
+            readonly codecId: "sql/varchar@1";
+            readonly nativeType: "character varying";
+            readonly typeParams: {
+              readonly length: {
+                readonly kind: "arg";
+                readonly index: 0;
+              };
+            };
+          };
+        };
+      };
+    };
+    readonly entityTypes: import("@prisma/orm-framework/components/authoring").AuthoringEntityTypeNamespace;
+    readonly pslBlockDescriptors: {
+      readonly enum: {
+        readonly kind: "pslBlock";
+        readonly keyword: "enum";
+        readonly discriminator: "enum";
+        readonly name: {
+          readonly required: true;
+        };
+        readonly parameters: {};
+        readonly variadicParameters: true;
+      };
+    };
+  };
+  create<TTargetId extends string>(stack: ControlStack<'sql', TTargetId>): SqlControlFamilyInstance;
+}
+//#endregion
+//#region src/core/assembly.d.ts
+declare function extractCodecControlHooks(descriptors: ReadonlyArray<TargetBoundComponentDescriptor<'sql', string>>): Map<string, CodecControlHooks>;
+//#endregion
+//#region src/core/control-target-descriptor.d.ts
+/**
+ * One stack extension pack's already-assembled contract, paired with the
+ * `spaceId` its extension descriptor was registered under. `contract infer`
+ * needs both: the contract to know which elements the pack describes and to
+ * resolve the domain model a cross-space foreign key targets, the `spaceId`
+ * to qualify the emitted relation type (`<spaceId>:<namespace>.<Model>`).
+ * Neither the contract JSON nor the framework's `ContractSpace` wrapper
+ * self-declares its owning space id — it is only known from the extension
+ * descriptor that carries the `ContractSpace`.
+ */
+interface SqlDescribedContractSpace {
+  readonly spaceId: string;
+  readonly contract: Contract<SqlStorage>;
+}
+interface SqlControlTargetDescriptor<TTargetId extends string, TTargetDetails, TContract extends Contract<SqlStorage> = Contract<SqlStorage>> extends MigratableTargetDescriptor<'sql', TTargetId, SqlControlFamilyInstance> {
+  readonly queryOperations?: () => SqlOperationDescriptors;
+  /**
+   * JSON ⇄ class boundary for the SQL target's contract. The descriptor
+   * composes a concrete `SqlContractSerializerBase` subclass; the rest
+   * of the control stack reaches `descriptor.contractSerializer` rather
+   * than importing a per-target deserialization function.
+   */
+  readonly contractSerializer: ContractSerializer<TContract>;
+  /**
+   * Per-target schema verifier walking the contract against
+   * `SqlSchemaIR`. The descriptor composes a concrete
+   * `SqlSchemaVerifierBase` subclass; the family-shared walk lives on
+   * the base, the target-specific dispatch on the subclass.
+   */
+  readonly schemaVerifier: SchemaVerifier<TContract, SqlSchemaIR>;
+  /**
+   * Database→PSL inference for `contract infer`. Target logic (owns the dialect
+   * maps), so it lives on the descriptor. Optional: targets without `contract
+   * infer` (Mongo) omit it, and the family instance throws when it is absent.
+   * `describedContracts` carries the stack's extension packs' already-assembled
+   * contracts (each paired with its `spaceId`) so the inferrer can omit elements
+   * they already describe, and can qualify a cross-space relation with the
+   * owning pack's space id.
+   */
+  readonly inferPslContract?: (schema: SqlSchemaIRNode, describedContracts?: readonly SqlDescribedContractSpace[]) => PslDocumentAst;
+  /**
+   * The full-tree node diff the family verify verdict derives from —
+   * expected-tree derivation, pre-diff normalization, the generic differ,
+   * and ownership scoping, all target-side. The family applies strict
+   * gating + control-policy disposition over the returned issues; verify
+   * rejects when a surviving issue is a failure.
+   */
+  readonly diffSchema: SqlSchemaDiffFn;
+  /**
+   * Classifies a diff-tree node's `nodeKind` into its framework-neutral
+   * {@link DiffSubjectGranularity} — the target owns the full node vocabulary
+   * that appears in its diff tree (its own kinds plus the relational kinds it
+   * delegates to), so it is the one place that can resolve this. The family
+   * verdict calls it inline per issue (never stamping the result); the
+   * framework aggregate's unclaimed-elements sweep reaches the same
+   * classifier via the family instance's `classifySubjectGranularity`
+   * capability.
+   */
+  readonly classifySubjectGranularity: (nodeKind: string) => DiffSubjectGranularity;
+  /**
+   * Classifies a diff-tree node's `nodeKind` into its storage `entityKind` —
+   * the same vocabulary the contract storage's `entries` dictionary keys use
+   * (e.g. `'table'`). Sibling of `classifySubjectGranularity`, resolved the
+   * same way: the target owns the full node vocabulary, so it is the one
+   * place that can resolve this. `undefined` for a node kind with no
+   * storage entity of its own (a column, an index, …). The framework
+   * aggregate's unclaimed-elements sweep reaches this via the family
+   * instance's `classifyEntityKind` capability, so it never hardcodes a
+   * family entity kind.
+   */
+  readonly classifyEntityKind: (nodeKind: string) => string | undefined;
+  createPlanner(adapter: SqlControlAdapter<TTargetId>): SqlMigrationPlanner<TTargetDetails>;
+  createRunner(family: SqlControlFamilyInstance): SqlMigrationRunner<TTargetDetails>;
+}
+//#endregion
+//#region src/core/migrations/contract-to-schema-ir.d.ts
+/**
+ * Target-specific callback that expands a column's base `nativeType` and optional
+ * `typeParams` into the fully-qualified type string used by the database
+ * (e.g. `character` + `{ length: 36 }` → `character(36)`).
+ *
+ * This lives in the family layer as a callback rather than importing a concrete
+ * implementation because each target (Postgres, MySQL, SQLite, …) has its own
+ * parameterization syntax. The target wires its expander when calling
+ * `contractToSchemaIR`, keeping the family layer target-agnostic.
+ */
+type NativeTypeExpander = (input: {
+  readonly nativeType: string;
+  readonly codecId?: string;
+  readonly typeParams?: Record<string, unknown>;
+}) => string;
+/**
+ * Target-specific callback that renders a `ColumnDefault` into the raw SQL literal
+ * string stored in `SqlColumnIR.default`.
+ *
+ * Default value serialization is target-specific (quoting, casting, type syntax vary
+ * between Postgres, MySQL, SQLite, …). This callback follows the same IoC pattern as
+ * `NativeTypeExpander`: the target provides its renderer when calling
+ * `contractToSchemaIR`, keeping the family layer target-agnostic.
+ */
+type DefaultRenderer = (def: ColumnDefault, column: StorageColumn) => string;
+/**
+ * Target-supplied hook (same IoC seam as `NativeTypeExpander`/`DefaultRenderer`)
+ * that normalizes a contract-declared `ColumnDefault` into the resolved shape
+ * the target's introspection parses from the live database — e.g. a
+ * `dbgenerated("'{}'::jsonb")` function call and the literal Postgres reports
+ * are the same value in different shapes, and `resolvedDefaultsEqual`
+ * compares `kind` before content. When omitted, the contract's raw default
+ * is the resolved default unchanged.
+ */
+type DefaultResolver = (def: ColumnDefault, resolvedNativeType: string) => ColumnDefault;
+/**
+ * Target-supplied callback that resolves a contract namespace to the live
+ * database schema its enums are stored under.
+ *
+ * The projected enum annotations are nested by schema
+ * (`storageTypes[schema][nativeType]`) so two namespaces holding an enum with
+ * the same native type resolve to distinct live-database types. Mapping a
+ * namespace to its DDL schema is target-specific (Postgres schemas;
+ * SQLite/MySQL differ), so the target injects it here rather than the family
+ * importing a concrete `ddlSchemaName`. This keeps the family layer
+ * target-agnostic while the projection nests under the same schema the
+ * target's read side (`readExistingEnumValues`) looks up.
+ */
+type EnumNamespaceSchemaResolver = (storage: SqlStorage, namespaceId: string) => string;
+declare function resolveValueSetValues(ref: {
+  readonly namespaceId: string;
+  readonly entityName: string;
+}, storage: SqlStorage, contextLabel: string): readonly string[];
+/**
+ * Detects destructive changes between two contract storages.
+ *
+ * The additive-only planner silently ignores removals (tables, columns).
+ * This function detects those removals so callers can report them as conflicts
+ * rather than silently producing an empty plan.
+ *
+ * Returns an empty array if no destructive changes are found.
+ */
+declare function detectDestructiveChanges(from: SqlStorage | null, to: SqlStorage): readonly MigrationPlannerConflict[];
+interface ContractToSchemaIROptions {
+  readonly annotationNamespace: string;
+  readonly expandNativeType?: NativeTypeExpander;
+  readonly renderDefault?: DefaultRenderer;
+  readonly resolveDefault?: DefaultResolver;
+  /**
+   * Target-supplied resolver mapping a namespace to the live database schema
+   * its enums are stored under. When provided (Postgres), namespace-scoped
+   * enums are nested by that schema in `enumTypes` so the projection matches
+   * the target's `readExistingEnumValues` lookup. Targets without
+   * schema-scoped enum storage (SQLite) omit it; enums are absent there.
+   */
+  readonly resolveEnumNamespaceSchema?: EnumNamespaceSchemaResolver;
+}
+/**
+ * Converts a `Contract` to `SqlSchemaIR`.
+ *
+ * Reads `contract.storage` for tables and `contract.storage.types` for type
+ * annotations. Storage-type annotations are written under
+ * `options.annotationNamespace`.
+ *
+ * Drops codec metadata (`codecId`, `typeRef`) since the schema IR only represents
+ * structural information. When `expandNativeType` is provided, parameterized types
+ * are expanded (e.g. `character` + `{ length: 36 }` → `character(36)`) so the
+ * resulting IR compares correctly against the "to" contract during planning.
+ *
+ * Returns an empty schema IR when `contract` is `null` (new project).
+ */
+/**
+ * Converts the tables of a single namespace into a `SqlSchemaIR`, keyed by
+ * table name within that namespace. Unlike {@link contractToSchemaIR}, which
+ * flattens every namespace's tables into one bare-keyed record (and throws on a
+ * cross-namespace name collision), this scopes the table iteration to one
+ * namespace so the same table name can exist in two schemas.
+ *
+ * The full `storage` is still passed to `convertTable`, so value-set / enum /
+ * type resolution that legitimately spans namespaces is unaffected. Foreign
+ * keys are built purely from the FK descriptor (`fk.target`), so cross-namespace
+ * FKs survive per-namespace conversion. The `annotations` block (storage-type
+ * derived) is omitted here — the per-namespace tree consumer reads only the
+ * per-table fields.
+ */
+declare function contractNamespaceToSchemaIR(storage: SqlStorage, namespaceId: string, options: ContractToSchemaIROptions): SqlSchemaIR;
+declare function contractToSchemaIR(contract: Contract<SqlStorage> | null, options: ContractToSchemaIROptions): SqlSchemaIR;
+//#endregion
+//#region src/core/migrations/control-policy.d.ts
+/**
+ * The target object a control policy governs for a single planner call,
+ * resolved from the target's own IR. `undefined` means the call's target
+ * object could not be positively established — a fail-closed signal: any
+ * policy stricter than `managed` drops such a call rather than emitting it.
+ *
+ * The object identity is a generic storage coordinate — `(entityKind,
+ * entityName)`, absent for a whole-namespace subject — never a target-specific
+ * `table`/`typeName` field. The family reasons about the coordinate for policy
+ * and deduplication; the target owns any vocabulary (table vs enum) when it
+ * renders a suppression.
+ */
+interface ControlPolicySubject {
+  readonly namespaceId: string;
+  readonly entityKind?: string;
+  readonly entityName?: string;
+  readonly column?: string;
+  /**
+   * Names the RLS policy when the suppressed thing is a policy-level unit
+   * on the subject's table (mirrors `column`) — the report must say which
+   * policy, not just which table.
+   */
+  readonly rlsPolicy?: string;
+  readonly explicitNodeControlPolicy?: ControlPolicy;
+  /**
+   * Whether the call creates a whole, previously-absent top-level storage
+   * object (e.g. a table or an enum/type), as opposed to modifying an
+   * existing object. This is the only thing `tolerated` permits: it is a
+   * create-if-absent policy, so an op that touches an existing object — add
+   * column, add index/constraint, alter, drop — is never allowed under it.
+   */
+  readonly createsNewObject: boolean;
+}
+/**
+ * The structured record a control-policy partition emits for one suppressed
+ * subject or call. It carries only raw data — no strings, no vocabulary — so
+ * the consumer (the target) renders the user-facing message itself:
+ *
+ * - `subject` — the suppressed subject (its coordinate + namespace), or
+ *   `undefined` when the subject could not be resolved (fail-closed).
+ * - `policy` — the effective control policy that caused the suppression.
+ * - `factoryName` — the resolved creation factory name if the suppressed thing
+ *   was a whole-object creation (e.g. `createTable`), else `undefined`. The
+ *   family never invents a verb for a modification that produced no call.
+ * - `createsNewObject` — whether the suppressed thing was object creation.
+ */
+interface SuppressionRecord {
+  readonly subject: ControlPolicySubject | undefined;
+  readonly policy: ControlPolicy;
+  readonly factoryName: string | undefined;
+  readonly createsNewObject: boolean;
+}
+/**
+ * The control policy that governs a single call. The `external` default is an
+ * un-overridable namespace floor: when the contract default is `external`, no
+ * per-object `managed` override can escalate DDL above the floor, so the
+ * policy is forced to `external` regardless of the node's own declaration.
+ * Every other default defers to the node's effective control policy.
+ */
+declare function controlPolicyForCall(subject: ControlPolicySubject | undefined, defaultControlPolicy: ControlPolicy | undefined): ControlPolicy;
+/**
+ * Partition the calls produced for a single set of subjects into those the
+ * effective control policy permits (`kept`) and a list of
+ * {@link SuppressionRecord}s describing the suppressed calls.
+ *
+ * **Prefer {@link partitionIssuesByControlPolicy}** for the schema-issue
+ * pipeline: it filters subjects out of the planner's *input* so the planner
+ * never has to reason about un-modeled state on `external`/`observed`
+ * subjects. This call-level helper remains for paths that bypass the issue
+ * pipeline — currently the codec-emitted field-event ops, which originate
+ * from declared contract fields rather than from introspected schema state
+ * and therefore cannot trip the diff engine.
+ */
+declare function partitionCallsByControlPolicy<TCall>(options: {
+  readonly calls: readonly TCall[];
+  readonly contract: Contract<SqlStorage>;
+  readonly resolveControlPolicySubject: (call: TCall) => ControlPolicySubject | undefined;
+  readonly resolveFactoryName: (call: TCall) => string;
+}): {
+  readonly kept: readonly TCall[];
+  readonly suppressions: readonly SuppressionRecord[];
+};
+/**
+ * Partition a list of schema-issue-shaped inputs by the effective control
+ * policy of each issue's subject *before* the planner is invoked.
+ *
+ * `plannable` is the list of issues whose subject's effective policy permits
+ * the planner to act on them (`managed`, or `tolerated` for whole-object
+ * creation issues only). Issues for `external`/`observed` subjects, and
+ * non-creation issues for `tolerated` subjects, are dropped from the planner's
+ * input entirely — they never enter introspection-driven planning, never feed
+ * the diff engine, and never produce DDL calls that would have to be
+ * post-filtered. This sidesteps a class of failure where the diff engine
+ * cannot reason about the live shape of a subject the user marked as
+ * out-of-scope (`external`).
+ *
+ * `suppressions` is one {@link SuppressionRecord} per suppressed subject (not
+ * per suppressed issue). Its `factoryName` is the creation factory name when any
+ * of the subject's issues is whole-object creation (e.g. `createTable`), else
+ * `undefined` — the family never invents a modification verb for an op that
+ * produced no call; the target renders the message.
+ *
+ * Unresolved-subject issues (`resolveControlPolicySubject` returns
+ * `undefined`) emit one record each; they cannot be deduplicated because they
+ * carry no subject coordinate.
+ */
+declare function partitionIssuesByControlPolicy<TIssue>(options: {
+  readonly issues: readonly TIssue[];
+  readonly contract: Contract<SqlStorage>;
+  /**
+   * Resolve the subject targeted by this issue (or `undefined` to fail-closed:
+   * any policy stricter than `managed` drops the issue).
+   */
+  readonly resolveControlPolicySubject: (issue: TIssue) => ControlPolicySubject | undefined;
+  /**
+   * Resolve a creation factoryName for this issue if it represents the
+   * absence of the whole top-level object (e.g. `'createTable'` for a
+   * missing-table issue). When the issue describes a modification to an
+   * existing object, return `undefined`. Both decisions feed off this signal:
+   *
+   * 1. Under `tolerated`, only issues whose `resolveCreationFactoryName`
+   *    returns a value flow into the planner (create-if-absent).
+   * 2. A suppressed subject's record carries the resolved creation factoryName
+   *    when it has at least one creation-flavoured issue, else `undefined`.
+   */
+  readonly resolveCreationFactoryName: (issue: TIssue) => string | undefined;
+}): {
+  readonly plannable: readonly TIssue[];
+  readonly suppressions: readonly SuppressionRecord[];
+};
+//#endregion
+//#region src/core/migrations/field-event-planner.d.ts
+interface PlanFieldEventOperationsOptions {
+  /**
+   * Prior contract the planner is diffing against. `null` for first emits
+   * (every field is treated as added).
+   */
+  readonly priorContract: Contract<SqlStorage> | null;
+  /**
+   * New contract the user just authored.
+   */
+  readonly newContract: Contract<SqlStorage>;
+  /**
+   * Codec-id keyed map of control hooks, as produced by
+   * {@link import('./assembly').extractCodecControlHooks}. Hooks carry
+   * `unknown` target details after extraction; the caller casts the
+   * helper's returned ops to its target's `SqlMigrationPlanOperation`
+   * specialisation at the integration boundary, mirroring how
+   * `storageTypePlanCallStrategy` lifts `planTypeOperations` results into
+   * `RawSqlCall`.
+   */
+  readonly codecHooks: ReadonlyMap<string, CodecControlHooks>;
+}
+declare function planFieldEventOperations(options: PlanFieldEventOperationsOptions): readonly OpFactoryCall[];
+//#endregion
+//#region src/core/migrations/native-type-expander.d.ts
+/**
+ * Builds the codec-hook-composed `expandNativeType` callback the contract→IR
+ * derivation uses to expand parameterized native types (e.g. `character` +
+ * `{ length: 36 }` → `character(36)`). Returns `undefined` when no framework
+ * components are supplied, so callers can omit the option entirely.
+ */
+declare function buildNativeTypeExpander(frameworkComponents?: ReadonlyArray<TargetBoundComponentDescriptor<'sql', string>>): ((input: {
+  readonly nativeType: string;
+  readonly codecId?: string;
+  readonly typeParams?: Record<string, unknown>;
+}) => string) | undefined;
+//#endregion
+//#region src/core/migrations/plan-helpers.d.ts
+declare function createMigrationPlan<TTargetDetails>(options: CreateSqlMigrationPlanOptions<TTargetDetails>): SqlMigrationPlan<TTargetDetails>;
+declare function plannerSuccess<TTargetDetails>(plan: SqlMigrationPlan<TTargetDetails>, warnings?: readonly SqlPlannerConflict[]): SqlPlannerSuccessResult<TTargetDetails>;
+declare function plannerFailure(conflicts: readonly SqlPlannerConflict[]): SqlPlannerFailureResult;
+/**
+ * Creates a successful migration runner result.
+ */
+declare function runnerSuccess(value: {
+  operationsPlanned: number;
+  operationsExecuted: number;
+}): Ok<SqlMigrationRunnerSuccessValue>;
+/**
+ * Creates a failed migration runner result.
+ */
+declare function runnerFailure(code: SqlMigrationRunnerErrorCode, summary: string, options?: {
+  why?: string;
+  meta?: AnyRecord;
+}): NotOk<SqlMigrationRunnerFailure>;
+//#endregion
+//#region src/core/migrations/policies.d.ts
+/**
+ * Policy used by `db init`: additive-only operations, no widening/destructive steps.
+ */
+declare const INIT_ADDITIVE_POLICY: MigrationOperationPolicy;
+//#endregion
+//#region src/core/timestamp-now-generator.d.ts
+/**
+ * Builds the canonical control-plane descriptor for the wall-clock-now
+ * mutation default generator. The descriptor's `id` and `buildPhases`
+ * are target-agnostic so PSL `temporal.updatedAt()` and TS
+ * `field.temporal.updatedAt()` lower to byte-identical contracts.
+ *
+ * `applicableCodecIds` is omitted: `timestampNow` is preset-only (not
+ * reachable via `@default(timestampNow())` lowering), and the codec is
+ * co-registered by the preset descriptor itself, so the
+ * `@default(...)` compatibility check has no role to play here.
+ */
+declare function timestampNowControlDescriptor(): MutationDefaultGeneratorDescriptor;
+/**
+ * Builds the canonical `temporal.{createdAt,updatedAt}` field-preset pair
+ * for a SQL target. `createdAt` lowers to a `now()` storage default;
+ * `updatedAt` lowers to the `timestampNow` execution generator on both
+ * `onCreate` and `onUpdate` (RD: "last modified time", non-null). Targets
+ * supply the codec/native-type pair that matches their timestamp column;
+ * everything else is shared so PSL `temporal.updatedAt()` and TS
+ * `field.temporal.updatedAt()` lower to byte-identical contracts across
+ * targets by construction.
+ */
+declare function temporalAuthoringPresets<const CodecId extends string, const NativeType extends string>(input: {
+  readonly codecId: CodecId;
+  readonly nativeType: NativeType;
+}): {
+  readonly createdAt: {
+    readonly kind: "fieldPreset";
+    readonly output: {
+      readonly codecId: CodecId;
+      readonly nativeType: NativeType;
+      readonly default: {
+        readonly kind: "function";
+        readonly expression: "now()";
+      };
+    };
+  };
+  readonly updatedAt: {
+    readonly kind: "fieldPreset";
+    readonly output: {
+      readonly codecId: CodecId;
+      readonly nativeType: NativeType;
+      readonly executionDefaults: {
+        readonly onCreate: {
+          readonly kind: "generator";
+          readonly id: "timestampNow";
+        };
+        readonly onUpdate: {
+          readonly kind: "generator";
+          readonly id: "timestampNow";
+        };
+      };
+    };
+  };
+};
+/**
+ * Builds a `temporal.<codec>` field preset for a codec that takes a precision
+ * parameter (`pg/timestamp@1`, `pg/timestamptz@1`). Arguments change field
+ * properties only — never the codec, which the caller fixes here.
+ *
+ * All three arguments are optional: omitting `precision` omits `typeParams`
+ * entirely, and omitting a phase omits that phase (both omitted omits
+ * `executionDefaults`).
+ */
+declare function temporalCodecPresetWithPrecision<const CodecId extends string, const NativeType extends string>(input: {
+  readonly codecId: CodecId;
+  readonly nativeType: NativeType;
+}): {
+  readonly kind: "fieldPreset";
+  readonly args: readonly [{
+    readonly name: "precision";
+    readonly kind: "number";
+    readonly optional: true;
+    readonly integer: true;
+    readonly minimum: 0;
+  }, {
+    readonly name: "onCreate";
+    readonly kind: "option";
+    readonly values: readonly ["now"];
+    readonly optional: true;
+  }, {
+    readonly name: "onUpdate";
+    readonly kind: "option";
+    readonly values: readonly ["now"];
+    readonly optional: true;
+  }];
+  readonly output: {
+    readonly codecId: CodecId;
+    readonly nativeType: NativeType;
+    readonly typeParams: {
+      readonly precision: {
+        readonly kind: "arg";
+        readonly index: 0;
+      };
+    };
+    readonly executionDefaults: {
+      readonly onCreate: {
+        readonly kind: "select";
+        readonly index: 1;
+        readonly cases: {
+          readonly now: {
+            readonly kind: "generator";
+            readonly id: "timestampNow";
+          };
+        };
+      };
+      readonly onUpdate: {
+        readonly kind: "select";
+        readonly index: 2;
+        readonly cases: {
+          readonly now: {
+            readonly kind: "generator";
+            readonly id: "timestampNow";
+          };
+        };
+      };
+    };
+  };
+};
+/**
+ * Builds a `temporal.<codec>` field preset for a codec with no type
+ * parameters (`sqlite/datetime@1`). As with the precision-bearing variant,
+ * both phase arguments are optional and omitting one omits that phase.
+ */
+declare function temporalCodecPreset<const CodecId extends string, const NativeType extends string>(input: {
+  readonly codecId: CodecId;
+  readonly nativeType: NativeType;
+}): {
+  readonly kind: "fieldPreset";
+  readonly args: readonly [{
+    readonly name: "onCreate";
+    readonly kind: "option";
+    readonly values: readonly ["now"];
+    readonly optional: true;
+  }, {
+    readonly name: "onUpdate";
+    readonly kind: "option";
+    readonly values: readonly ["now"];
+    readonly optional: true;
+  }];
+  readonly output: {
+    readonly codecId: CodecId;
+    readonly nativeType: NativeType;
+    readonly executionDefaults: {
+      readonly onCreate: {
+        readonly kind: "select";
+        readonly index: 0;
+        readonly cases: {
+          readonly now: {
+            readonly kind: "generator";
+            readonly id: "timestampNow";
+          };
+        };
+      };
+      readonly onUpdate: {
+        readonly kind: "select";
+        readonly index: 1;
+        readonly cases: {
+          readonly now: {
+            readonly kind: "generator";
+            readonly id: "timestampNow";
+          };
+        };
+      };
+    };
+  };
+};
+//#endregion
+//#region src/exports/control.d.ts
+declare const _default: SqlFamilyDescriptor;
+//#endregion
+export { partitionCallsByControlPolicy as A, temporalCodecPresetWithPrecision as B, buildNativeTypeExpander as C, createMigrationPlan as D, controlPolicyForCall as E, resolveValueSetValues as F, runnerFailure as I, runnerSuccess as L, planFieldEventOperations as M, plannerFailure as N, detectDestructiveChanges as O, plannerSuccess as P, temporalAuthoringPresets as R, assembleAuthoringContributions as S, contractToSchemaIR as T, timestampNowControlDescriptor as V, SqlControlTargetDescriptor as _, EnumNamespaceSchemaResolver as a, TargetMigrationsCapability as b, MigrationOperationPolicy$1 as c, MigrationPlanner as d, MigrationPlannerConflict$1 as f, SqlControlFamilyInstance as g, PlanFieldEventOperationsOptions as h, DefaultResolver as i, partitionIssuesByControlPolicy as j, extractCodecControlHooks as k, MigrationPlan$1 as l, NativeTypeExpander as m, ControlPolicySubject as n, INIT_ADDITIVE_POLICY as o, MigrationPlannerResult as p, DefaultRenderer as r, MigrationOperationClass as s, ContractToSchemaIROptions as t, MigrationPlanOperation$1 as u, SqlDescribedContractSpace as v, contractNamespaceToSchemaIR as w, _default as x, SuppressionRecord as y, temporalCodecPreset as z };
+//# sourceMappingURL=control-BHmsZudH.d.mts.map