@prisma/orm-family-sql 8.0.0-rc.2-dev.2 → 8.0.0-rc.20

package/dist/control-ChAUdOOu.d.mts

@@ -0,0 +1,1416 @@
+import { r as StorageTable } from "./storage-table-Bf1ZjnxO-pUj6pyP0.mjs";
+import { l as SqlStorage } from "./sql-storage-DeCAh5Hi-CEM-m8cs.mjs";
+import { j as SqlControlDriverInstance } from "./types-DfKvtJwS-CrpWTGBJ.mjs";
+import "./types-CkAd8SWm.mjs";
+import { r as SqlOperationDescriptors } from "./index-Nqc3OHR_.mjs";
+import { h as AnyQueryAst } from "./types-DriMIMNQ-BkbsW7w3.mjs";
+import { o as SqlExecuteRequest } from "./driver-types-DRsYeq3j-BimeCnUk.mjs";
+import { a as DdlNode } from "./ddl-types-By5mT2_S-CdaaFvsX.mjs";
+import { p as LowererContext } from "./ast-YEMe_B8z.mjs";
+import { a as EnumMemberListDefault, i as EnumMemberDefault, n as DefaultFunctionCall, o as ParsedNullLiteral } from "./attribute-specs-DA_RwQFB.mjs";
+import { S as SqlSchemaIRNode, b as SqlSchemaIR, p as SqlDefaultValue } from "./types-CuCxAQat-Dz8P4xyt.mjs";
+import "./types-ljUNyiWe.mjs";
+import "./validators-FJs8HvFr.mjs";
+import { r as SqlControlAdapter } from "./control-adapter-Bn0uhplA-BzP2uPqJ.mjs";
+import { t as sqlFamilyEnumSpec } from "./authoring-entity-types-CgKIgWq5-pEdfjam5.mjs";
+import { C as SqlPlannerConflict, E as SqlPlannerFailureResult, O as SqlPlannerSuccessResult, c as SqlMigrationPlan, d as SqlMigrationPlanOperationStep, g as SqlMigrationRunnerErrorCode, h as SqlMigrationRunner, n as CreateSqlMigrationPlanOptions, p as SqlMigrationPlanner, t as CodecControlHooks, x as SqlMigrationRunnerSuccessValue, y as SqlMigrationRunnerFailure } from "./types-Cq6ImLAB-RlU4jJAX.mjs";
+import { t as SqlSchemaDiffFn } from "./schema-differ-DmP74bB8-tqHKiJ88.mjs";
+import { StructuredError } from "@prisma/orm-framework/utils/structured-error";
+import { DataTypeSupport } from "@prisma/orm-framework/components/authoring";
+import { Codec, CodecLookupWithDescriptors, CodecRef, DataType, DataTypeLookup, TypeLookups } from "@prisma/orm-framework/components/codec";
+import { ColumnDefault, Contract, ContractWithDomain, ControlPolicy } from "@prisma/orm-framework/contract/types";
+import { GeneratorFunctionRegistry, TargetBoundComponentDescriptor } from "@prisma/orm-framework/components/components";
+import { PslDocumentAst } from "@prisma/orm-framework/components/psl-ast";
+import { NotOk, Ok, Result } from "@prisma/orm-framework/utils/result";
+import { AppliedMigrationStatement, AssembledAuthoringContributions, ContractSerializer, ControlFamilyDescriptor, ControlFamilyInstance, ControlMutationDefaultEntry, ControlStack, DiffSubjectGranularity, FieldCoordinate, ImportRequirement, MigratableTargetDescriptor, MigrationDataLossKind, MigrationOperationClass, MigrationOperationClass as MigrationOperationClass$1, MigrationOperationPolicy, MigrationOperationPolicy as MigrationOperationPolicy$1, MigrationPlan as MigrationPlan$1, MigrationPlanOperation, MigrationPlanOperation as MigrationPlanOperation$1, MigrationPlanSubjects, MigrationPlanner, MigrationPlannerConflict, MigrationPlannerConflict as MigrationPlannerConflict$1, MigrationPlannerResult, MigrationRunnerFailureMeta, MigrationSubject, ModelCoordinate, OpFactoryCall, OperationPreview, OperationPreviewCapable, PslContractBuildCapable, PslContractInferCapable, ResolvedFieldRenameStatement, ResolvedMigrationStatement, ResolvedModelRenameStatement, ResolvedRenameStatement, RowsWithoutValue, SchemaDiffIssue, SchemaOwnership, SchemaVerifier, SchemaViewCapable, TargetMigrationsCapability, VerifyDatabaseResult, VerifyDatabaseSchemaResult, assembleAuthoringContributions as assembleAuthoringContributions$1 } from "@prisma/orm-framework/components/control";
+import { EmissionSpi, TypesImportSpec } from "@prisma/orm-framework/components/emission";
+//#region ../../../2-sql-family/9-family/dist/control.d.mts
+//#region src/core/control-instance.d.ts
+interface SqlFamilyInstanceState {
+  readonly codecTypeImports: ReadonlyArray<TypesImportSpec>;
+  readonly extensionIds: ReadonlyArray<string>;
+}
+interface SqlControlFamilyInstance extends ControlFamilyInstance<'sql', SqlSchemaIRNode>, SchemaViewCapable<SqlSchemaIRNode>, PslContractInferCapable<SqlSchemaIRNode>, PslContractBuildCapable<Contract<SqlStorage>>, 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;
+  introspect(options: {
+    readonly driver: SqlControlDriverInstance<string>;
+    readonly contract?: unknown;
+  }): Promise<SqlSchemaIRNode>;
+  inferPslContract(schemaIR: SqlSchemaIRNode): Promise<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;
+  storageNameOf(operation: MigrationPlanOperation): string;
+}
+//#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 dataTypes: readonly DataType[];
+  readonly authoring: {
+    readonly field: {
+      readonly uuidString: {
+        readonly kind: "fieldPreset";
+        readonly output: {
+          readonly codecId: "sql/char@1";
+          readonly typeParams: {
+            readonly length: 36;
+          };
+        };
+      };
+      readonly ulid: {
+        readonly kind: "fieldPreset";
+        readonly output: {
+          readonly codecId: "sql/char@1";
+          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 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 typeParams: {
+            readonly length: 24;
+          };
+        };
+      };
+      readonly ksuid: {
+        readonly kind: "fieldPreset";
+        readonly output: {
+          readonly codecId: "sql/char@1";
+          readonly typeParams: {
+            readonly length: 27;
+          };
+        };
+      };
+      readonly id: {
+        readonly uuidv4String: {
+          readonly kind: "fieldPreset";
+          readonly output: {
+            readonly codecId: "sql/char@1";
+            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 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 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 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 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 typeParams: {
+              readonly length: 27;
+            };
+            readonly executionDefaults: {
+              readonly onCreate: {
+                readonly kind: "generator";
+                readonly id: "ksuid";
+              };
+            };
+            readonly id: true;
+          };
+        };
+      };
+    };
+    readonly type: {
+      readonly Raw: {
+        readonly kind: "typeConstructor";
+        readonly documentation: "A column of a type no other column type covers, written exactly as the database catalog prints it, such as Raw(sql`tsvector`). Its values are typed unknown, and its default is a sql expression.";
+        readonly args: readonly [{
+          readonly kind: "value";
+          readonly dataType: "sql/expression";
+          readonly name: "sql";
+        }];
+        readonly output: {
+          readonly codecId: "sql/raw@1";
+          readonly typeParams: {
+            readonly sql: {
+              readonly kind: "arg";
+              readonly index: 0;
+            };
+          };
+        };
+      };
+    };
+    readonly entityTypes: import("@prisma/orm-framework/components/authoring").AuthoringEntityTypeNamespace;
+    readonly pslBlockDescriptors: {
+      readonly enum: {
+        kind: "pslBlock";
+        keyword: string;
+        documentation: string;
+        discriminator: string;
+        name: {
+          required: true;
+        };
+        spec: typeof sqlFamilyEnumSpec;
+        attributes: {
+          type: () => import("@prisma/orm-framework/psl-parser").AttributeSpec<{
+            codecId: string;
+          }, import("@prisma/orm-framework/psl-parser").BlockAttributeCtx>;
+        };
+      };
+    };
+    readonly attributeSpecs: {
+      readonly model: {
+        readonly map: (_ctx: import("@prisma/orm-framework/psl-parser").AttributeSpecContext) => import("@prisma/orm-framework/psl-parser").AttributeSpec<{
+          name: string;
+        }, import("@prisma/orm-framework/psl-parser").ModelAttributeCtx>;
+        readonly id: (_ctx: import("@prisma/orm-framework/psl-parser").AttributeSpecContext) => import("@prisma/orm-framework/psl-parser").AttributeSpec<{
+          fields: string[];
+          readonly map?: string;
+        }, import("@prisma/orm-framework/psl-parser").ModelAttributeCtx>;
+        readonly unique: (_ctx: import("@prisma/orm-framework/psl-parser").AttributeSpecContext) => import("@prisma/orm-framework/psl-parser").AttributeSpec<{
+          fields: string[];
+          readonly map?: string;
+        }, import("@prisma/orm-framework/psl-parser").ModelAttributeCtx>;
+        readonly index: (ctx: import("@prisma/orm-framework/psl-parser").AttributeSpecContext) => import("@prisma/orm-framework/psl-parser").AttributeSpec<{
+          fields?: string[];
+          readonly expression?: import("@prisma/orm-framework/psl-parser").ParsedTypedValue;
+          readonly where?: import("@prisma/orm-framework/psl-parser").ParsedTypedValue;
+          readonly unique?: boolean;
+          readonly name?: string;
+          readonly map?: string;
+          readonly type?: string;
+          readonly options?: Record<string, string>;
+        }, import("@prisma/orm-framework/psl-parser").ModelAttributeCtx>;
+        readonly check: (ctx: import("@prisma/orm-framework/psl-parser").AttributeSpecContext) => import("@prisma/orm-framework/psl-parser").AttributeSpec<{
+          readonly expression: import("@prisma/orm-framework/psl-parser").ParsedTypedValue;
+          readonly name?: string;
+          readonly map?: string;
+        }, import("@prisma/orm-framework/psl-parser").ModelAttributeCtx>;
+        readonly control: (_ctx: import("@prisma/orm-framework/psl-parser").AttributeSpecContext) => import("@prisma/orm-framework/psl-parser").AttributeSpec<{
+          policy: "managed" | "tolerated" | "external" | "observed";
+        }, import("@prisma/orm-framework/psl-parser").ModelAttributeCtx>;
+        readonly discriminator: (_ctx: import("@prisma/orm-framework/psl-parser").AttributeSpecContext) => import("@prisma/orm-framework/psl-parser").AttributeSpec<{
+          field: string;
+        }, import("@prisma/orm-framework/psl-parser").ModelAttributeCtx>;
+        readonly base: (_ctx: import("@prisma/orm-framework/psl-parser").AttributeSpecContext) => import("@prisma/orm-framework/psl-parser").AttributeSpec<{
+          base: import("@prisma/orm-framework/psl-parser").ResolvedEntityReference<import("@prisma/orm-framework/psl-parser").ModelSymbol>;
+          value: import("@prisma/orm-framework/psl-parser").ParsedWrittenScalar;
+        }, import("@prisma/orm-framework/psl-parser").ModelAttributeCtx>;
+      };
+      readonly field: {
+        readonly map: (_ctx: import("@prisma/orm-framework/psl-parser").FieldAttributeSpecContext) => import("@prisma/orm-framework/psl-parser").AttributeSpec<{
+          name: string;
+        }, import("@prisma/orm-framework/psl-parser").FieldAttributeCtx>;
+        readonly id: (_ctx: import("@prisma/orm-framework/psl-parser").FieldAttributeSpecContext) => import("@prisma/orm-framework/psl-parser").AttributeSpec<{
+          readonly map?: string;
+        }, import("@prisma/orm-framework/psl-parser").FieldAttributeCtx>;
+        readonly unique: (_ctx: import("@prisma/orm-framework/psl-parser").FieldAttributeSpecContext) => import("@prisma/orm-framework/psl-parser").AttributeSpec<{
+          readonly map?: string;
+        }, import("@prisma/orm-framework/psl-parser").FieldAttributeCtx>;
+        readonly relation: (_ctx: import("@prisma/orm-framework/psl-parser").FieldAttributeSpecContext) => import("@prisma/orm-framework/psl-parser").AttributeSpec<{
+          name?: string;
+          readonly fields?: string[];
+          readonly references?: string[];
+          readonly map?: string;
+          readonly onDelete?: "NoAction" | "Restrict" | "Cascade" | "SetNull" | "SetDefault";
+          readonly onUpdate?: "NoAction" | "Restrict" | "Cascade" | "SetNull" | "SetDefault";
+          readonly index?: string | boolean;
+        }, import("@prisma/orm-framework/psl-parser").FieldAttributeCtx>;
+        readonly default: (ctx: import("@prisma/orm-framework/psl-parser").FieldAttributeSpecContext) => import("@prisma/orm-framework/psl-parser").AttributeSpec<{
+          value: import("@prisma/orm-framework/psl-parser").ParsedWrittenScalar | ParsedNullLiteral | import("@prisma/orm-framework/psl-parser").ParsedWrittenList<import("@prisma/orm-framework/psl-parser").ParsedWrittenScalar | ParsedNullLiteral> | DefaultFunctionCall | EnumMemberDefault | EnumMemberListDefault;
+        }, import("@prisma/orm-framework/psl-parser").AttributeCtx>;
+        readonly onCreate: (ctx: import("@prisma/orm-framework/psl-parser").FieldAttributeSpecContext) => import("@prisma/orm-framework/psl-parser").AttributeSpec<{
+          value: import("@prisma/orm-framework/psl-parser").TypedFuncCall;
+        }, import("@prisma/orm-framework/psl-parser").AttributeCtx>;
+        readonly onUpdate: (ctx: import("@prisma/orm-framework/psl-parser").FieldAttributeSpecContext) => import("@prisma/orm-framework/psl-parser").AttributeSpec<{
+          value: import("@prisma/orm-framework/psl-parser").TypedFuncCall;
+        }, import("@prisma/orm-framework/psl-parser").AttributeCtx>;
+      };
+    };
+    readonly dataTypes: Readonly<Record<string, import("@prisma/orm-framework/components/authoring").DataTypeAuthoringEntry>>;
+  };
+  readonly generatorFunctions: readonly [{
+    readonly name: "now";
+    readonly signature: {
+      readonly documentation: "Writes the current time, as the column's codec represents it.";
+    };
+    readonly bindings: readonly [];
+  }, {
+    readonly name: "uuid";
+    readonly bindings: readonly import("@prisma/orm-framework/components/components").GeneratorFunctionBinding[];
+  }, {
+    readonly name: "cuid";
+    readonly bindings: readonly import("@prisma/orm-framework/components/components").GeneratorFunctionBinding[];
+  }, {
+    readonly name: "ulid";
+    readonly signature: {
+      readonly documentation: "Generates a ULID when a value is not supplied.";
+    };
+    readonly bindings: readonly import("@prisma/orm-framework/components/components").GeneratorFunctionBinding[];
+  }, {
+    readonly name: "nanoid";
+    readonly bindings: readonly import("@prisma/orm-framework/components/components").GeneratorFunctionBinding[];
+  }, {
+    readonly name: "ksuid";
+    readonly signature: {
+      readonly documentation: "Generates a KSUID when a value is not supplied.";
+    };
+    readonly bindings: readonly import("@prisma/orm-framework/components/components").GeneratorFunctionBinding[];
+  }];
+  readonly controlMutationDefaults: {
+    defaultFunctionRegistry: Map<any, any>;
+    generatorDescriptors: readonly import("@prisma/orm-framework/components/control").MutationDefaultGeneratorDescriptor[];
+  };
+  readonly fieldLength: NonNullable<ControlFamilyDescriptor<'sql'>['fieldLength']>;
+  readonly pslDiagnostics: {
+    readonly describeUnsupportedAttribute: unknown;
+    readonly describeUnresolvedType: unknown;
+  };
+  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>;
+}
+/**
+ * The parts of the composed stack a target builds a PSL document with. The PSL contract source reads the document with the same parts, so the target writes a column type as a type constructor the stack contributes, a literal default through the data type of the column's codec, and a generated value as a default function or field preset the stack contributes, and all of them read back.
+ */
+interface SqlPslBuildContext {
+  readonly authoringContributions: Pick<AssembledAuthoringContributions, 'type' | 'field'>;
+  readonly codecLookup: CodecLookupWithDescriptors;
+  readonly dataTypes: DataTypeSupport;
+  /** The generator functions of the stack, which write each generator as `@onCreate(fn(...))` or `@onUpdate(fn(...))`. */
+  readonly generatorFunctions: GeneratorFunctionRegistry;
+  /** For each generator id the stack registers, the id of the component that registers it, when that component has one. */
+  readonly componentIdsByGenerator: ReadonlyMap<string, string | undefined>;
+}
+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.
+   * `context` is the stack `contract emit` reads the inferred schema with, so a
+   * default is written in the form the codec of the column's type constructor
+   * reads back. `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, context: SqlPslBuildContext, describedContracts?: readonly SqlDescribedContractSpace[]) => Promise<PslDocumentAst>;
+  /**
+   * Builds the PSL document of a contract, which `contract print` renders as text. `contract` must be one `contractSerializer.deserializeContract` accepted; the hook does not check its structure again. Like {@link inferPslContract} it produces a PSL document, but from an assembled contract and the stack parts in `context`. The document reads back as the same contract; the hook throws `CONTRACT.PRINT_UNSUPPORTED` for a contract PSL cannot express. The implementation sits in the target, though most of it inverts this family's PSL reader; only its column types, defaults, native enums, derived checks and row-level security are dialect logic. Optional: targets without `contract print` omit it, and the family instance throws when it is absent.
+   */
+  readonly buildPslContract?: (contract: TContract, context: SqlPslBuildContext) => 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/default-functions.d.ts
+type SqlDefaultFunctionName = 'autoincrement' | 'now';
+/**
+ * The SQL family's default functions, each a database default: `autoincrement()` and `now()`. A value the client generates is a generator function, written `@onCreate(...)`.
+ */
+declare function sqlDefaultFunctions(): Readonly<Record<SqlDefaultFunctionName, ControlMutationDefaultEntry>>;
+//#endregion
+//#region src/core/migrations/contract-to-schema-ir.d.ts
+/**
+ * Target-supplied hook that names a contract's expression default the way the target's introspection names the same database function, such as `now()` for `CURRENT_TIMESTAMP`, so the two compare equal. When omitted, the contract's default is the resolved default unchanged.
+ */
+type DefaultResolver = (def: ColumnDefault, column: DefaultResolverColumn) => ColumnDefault;
+/** The column a {@link DefaultResolver} names a default for: its type as written, and whether it is a list. */
+interface DefaultResolverColumn {
+  readonly typeText: string;
+  readonly many: boolean;
+}
+/**
+ * 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[];
+/** Each column's type is written from the data type its codec represents, found through the lookups. */
+interface ContractToSchemaIROptions extends TypeLookups {
+  readonly annotationNamespace: string;
+  readonly resolveDefault?: DefaultResolver;
+}
+/**
+ * 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;
+/**
+ * Converts a `Contract` to `SqlSchemaIR`.
+ *
+ * Reads `contract.storage` for tables.
+ *
+ * Drops codec metadata (`codecId`) since the schema IR only represents
+ * structural information. Each column's type is written from the data type its codec
+ * represents, with its parameters (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).
+ */
+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;
+}
+/**
+ * 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/schema-tables.d.ts
+/**
+ * The tables a schema has, addressed by the contract's namespace ids: the schema a plan starts
+ * from, or the schema a migration's earlier renames leave behind.
+ */
+interface SchemaTables {
+  hasTable(namespaceId: string, table: string): boolean;
+  hasColumn(namespaceId: string, table: string, column: string): boolean;
+  /**
+   * The namespace's tables the database takes for `table`: the table itself where names compare
+   * exactly, and every table whose name differs only in case where the database ignores case.
+   */
+  tablesNamed(namespaceId: string, table: string): readonly string[];
+  /**
+   * The table's columns the database takes for `column`: the column itself where names compare
+   * exactly, and every column whose name differs only in case where the database ignores case.
+   */
+  columnsNamed(namespaceId: string, table: string, column: string): readonly string[];
+  namespacesWithTable(table: string): readonly string[];
+  hasNamespace(namespaceId: string): boolean;
+}
+//#endregion
+//#region src/core/migrations/resolve-column-rename.d.ts
+declare const COLUMN_RENAME_UNMATCHED_CODE = "MIGRATION.COLUMN_RENAME_UNMATCHED";
+/**
+ * A column rename as a `renameColumn` call states it: `namespaceId` is `undefined` when the
+ * namespace is left to the contracts.
+ */
+interface ColumnRenameRequest {
+  readonly namespaceId: string | undefined;
+  readonly table: string;
+  readonly from: string;
+  readonly to: string;
+}
+/** A column rename on a table in a known namespace. */
+interface ColumnRename {
+  readonly namespaceId: string;
+  readonly table: string;
+  readonly from: string;
+  readonly to: string;
+}
+/**
+ * Refuses a `renameColumn` call that does not match the migration's contracts, with
+ * `MIGRATION.COLUMN_RENAME_UNMATCHED`.
+ */
+declare function unmatchedColumnRename(rename: ColumnRenameRequest, reason: string): StructuredError;
+/**
+ * Resolves a column a migration renames with {@link checkColumnRename}, refusing a mismatch with
+ * `MIGRATION.COLUMN_RENAME_UNMATCHED`.
+ */
+declare function resolveColumnRenameAgainst(previous: SchemaTables, endContract: Contract<SqlStorage>, rename: ColumnRenameRequest): Result<ColumnRename, StructuredError>;
+//#endregion
+//#region src/core/migrations/resolve-table-rename.d.ts
+/**
+ * A table rename as a `renameTable` call or a guard's advice states it: `namespaceId` is
+ * `undefined` when the namespace is left to the contracts.
+ */
+interface TableRenameRequest {
+  readonly namespaceId: string | undefined;
+  readonly from: string;
+  readonly to: string;
+}
+/** A table rename in a known namespace. */
+interface TableRename {
+  readonly namespaceId: string;
+  readonly from: string;
+  readonly to: string;
+}
+/**
+ * Refuses a `renameTable` call that does not match the migration's contracts, with
+ * `MIGRATION.TABLE_RENAME_UNMATCHED`.
+ */
+declare function unmatchedTableRename(rename: TableRenameRequest, reason: string): StructuredError;
+/**
+ * Resolves a table a migration renames with {@link checkTableRename}, refusing a mismatch with
+ * `MIGRATION.TABLE_RENAME_UNMATCHED`.
+ */
+declare function resolveTableRenameAgainst(previous: SchemaTables, endContract: Contract<SqlStorage>, rename: TableRenameRequest): Result<TableRename, StructuredError>;
+//#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>;
+  /** The stack's data types, which say what each column is stored as. */
+  readonly dataTypes: Pick<DataTypeLookup, 'get'>;
+  /**
+   * The table renames the plan applies. A column under a renamed table's old name is the same
+   * column under its new name, so a rename alone fires no event.
+   */
+  readonly tableRenames: readonly TableRename[];
+  /**
+   * The column renames the plan applies, each on the table under the name it has after the table
+   * renames. A column under its old name is the same column under its new name.
+   */
+  readonly columnRenames: readonly ColumnRename[];
+}
+/** A call a codec hook returned, with the column of the field event it was returned for. */
+interface FieldEventCall {
+  readonly call: OpFactoryCall;
+  readonly namespaceId: string;
+  /** The table and column as the new contract names them. */
+  readonly tableName: string;
+  readonly columnName: string;
+}
+declare function planFieldEventOperations(options: PlanFieldEventOperationsOptions): readonly OpFactoryCall[];
+/** The calls the codec hooks return, each with the field event's column. */
+declare function planFieldEventCalls(options: PlanFieldEventOperationsOptions): readonly FieldEventCall[];
+//#endregion
+//#region src/core/migrations/field-of-column.d.ts
+/**
+ * The field of `contract` that stores `column` of `table`, or undefined when no field stores it or
+ * tables of two storage namespaces share the table's name.
+ */
+declare function fieldOfColumn(contract: ContractWithDomain, table: string, column: string): MigrationSubject | undefined;
+//#endregion
+//#region src/core/migrations/operation-storage-name.d.ts
+/**
+ * The name the database knows an operation's object by, read from the operation's target
+ * details: `schema.table.column` for a column, `schema.name` for anything else, without the
+ * schema in the unbound namespace. An operation without details is named by its id.
+ */
+declare function storageNameOfOperation(operation: MigrationPlanOperation): string;
+//#endregion
+//#region src/core/migrations/statement-planning.d.ts
+/** Where a model's rows live: a table in a storage namespace. */
+interface ModelTable {
+  readonly namespaceId: string;
+  readonly table: string;
+}
+/** What a model rename does to storage. */
+type ModelStorageEffect = {
+  readonly kind: 'unchanged';
+} | {
+  readonly kind: 'renameTable';
+  readonly rename: TableRename;
+} | {
+  readonly kind: 'moveNamespace';
+  readonly from: ModelTable;
+  readonly to: ModelTable;
+};
+/** What a field rename does to storage. */
+type FieldStorageEffect = {
+  readonly kind: 'unchanged';
+} | {
+  readonly kind: 'renameColumn';
+  /** The origin model's table, as the origin contract names it. */
+  readonly table: ModelTable;
+  readonly from: string;
+  readonly to: string;
+};
+/** A model the contract stores in no table, so a statement on it has no storage effect. */
+interface NoTable {
+  readonly kind: 'noTable';
+  readonly model: ModelCoordinate;
+}
+/** A field stored in a column on one side of a statement only, which no rename can map. */
+interface ColumnOnOneSide {
+  readonly kind: 'columnOnOneSide';
+}
+/**
+ * The storage effect of a model rename: the origin model's table compared with the destination
+ * model's. Equal tables mean the rename needs no storage change.
+ */
+declare function modelRenameStorageEffect(statement: ResolvedModelRenameStatement, fromContract: ContractWithDomain, contract: ContractWithDomain): Result<ModelStorageEffect, NoTable>;
+/**
+ * The storage effect of a field rename: the origin field's column compared with the destination
+ * field's. A relation field has no column on either side, and equal columns need no change.
+ */
+declare function fieldRenameStorageEffect(statement: ResolvedFieldRenameStatement, fromContract: ContractWithDomain, contract: ContractWithDomain): Result<FieldStorageEffect, NoTable | ColumnOnOneSide>;
+/** A call that lowers to one operation, such as a companion of a rename. */
+interface SingleOperationCall {
+  readonly operationClass: MigrationOperationClass;
+}
+/**
+ * A call that lowers to its own operation, then each companion's, in that order: a table or column
+ * rename, whether a statement plans it or a hand-written migration calls it. A table move has none.
+ */
+interface CallWithCompanions extends SingleOperationCall {
+  readonly companions: readonly SingleOperationCall[];
+}
+/** A namespace renamed: `from` names it in the origin contract and `to` in the destination. */
+interface NamespaceRename {
+  readonly from: string;
+  readonly to: string;
+}
+/** Why a target cannot carry out a statement, in its words. */
+interface TargetRefusal {
+  readonly reason: string;
+  readonly fix: string;
+}
+/** A table moving, under its own name, from one storage namespace to another. */
+interface TableMove {
+  readonly table: string;
+  readonly from: string;
+  readonly to: string;
+}
+/** How a user renames a table by hand, written for the target. */
+interface TableRenameByHand {
+  /** The `renameTable` call a user writes in `migration.ts` to make `rename` by hand. */
+  renderTableRename(rename: TableRename): string;
+  /** The SQL statements a user runs against the database to make `rename` by hand. */
+  tableRenameByHand(rename: TableRename): readonly string[];
+}
+/** What a target with several namespaces supplies for namespace renames and model moves. */
+interface NamespaceStatementTarget<TCall extends CallWithCompanions> {
+  /**
+   * The calls a table moving into `namespaceId` needs first, such as creating the namespace: none
+   * when the working schema has it.
+   */
+  createNamespaceCalls(namespaceId: string): readonly TCall[];
+  /** The call that moves a table to another namespace, computed against the working schema. */
+  moveTableCall(move: TableMove): TCall;
+  /** Why the target cannot rename the namespace, or `undefined` when it can. */
+  namespaceRenameRefusal(rename: NamespaceRename): TargetRefusal | undefined;
+  /** The call that renames a namespace, computed against the working schema. */
+  renameNamespaceCall(rename: NamespaceRename): TCall;
+}
+/** What a target supplies for planning statements against its working schema. */
+interface StatementPlanningTarget<TCall extends CallWithCompanions> extends TableRenameByHand {
+  /** The tables of the working schema as earlier statements have left it. */
+  tables(): SchemaTables;
+  /** The call that renames a table, with its companions, computed against the working schema. */
+  renameTableCall(rename: TableRename): TCall;
+  /** Namespace renames and model moves; a target that keeps every table in one namespace has none. */
+  readonly namespaces?: NamespaceStatementTarget<TCall> | undefined;
+  /** The call that renames a column, with its companions, computed against the working schema. */
+  renameColumnCall(rename: ColumnRename): TCall;
+  /** Applies a call to the working schema. */
+  apply(call: TCall): void;
+}
+/**
+ * Where a table or column of the working schema came from in the origin contract, after the
+ * statements' renames and moves: the statement planner records it, and the questions name a
+ * subject through it.
+ */
+interface WorkingSchemaOrigins {
+  /** The origin place of a table of the working schema. */
+  originTable(current: ModelTable): ModelTable;
+  /** The origin name of a column, now named `column`, of the origin table `origin`. */
+  originColumn(origin: ModelTable, column: string): string;
+}
+/** The origins of a plan whose statements renamed and moved nothing. */
+declare const NO_RENAMED_ORIGINS: WorkingSchemaOrigins;
+interface PlannedStatements<TCall extends CallWithCompanions> {
+  /**
+   * The calls, which a target puts first in its plan: each statement's `operationIndexes` count
+   * from the first operation of the first call.
+   */
+  readonly calls: readonly TCall[];
+  readonly tableRenames: readonly TableRename[];
+  readonly columnRenames: readonly ColumnRename[];
+  readonly appliedStatements: readonly AppliedMigrationStatement[];
+  readonly origins: WorkingSchemaOrigins;
+}
+/** The contract space planned, and the oracle that says which spaces declare a namespace. */
+interface StatementOwnership {
+  readonly oracle: SchemaOwnership | undefined;
+  readonly spaceId: string;
+}
+/** A contract space other than the one planned that declares the namespace, if any. */
+declare function otherSpaceDeclaring(ownership: StatementOwnership, namespaceId: string): string | undefined;
+/**
+ * Plans the statements against a target's working schema, namespace renames first and the rest in
+ * the order given: model and field statements name the origin and destination contracts, so the
+ * namespace renames' place among them does not matter. Each model rename becomes a table rename
+ * and each field rename a column rename, computed against the schema earlier statements left, then
+ * applied to it. The first statement that cannot be planned fails the whole
+ * plan with a `statementRefused` conflict that carries the statement.
+ */
+declare function planStatements<TCall extends CallWithCompanions>(input: {
+  readonly statements: readonly ResolvedRenameStatement[];
+  readonly fromContract: Contract<SqlStorage> | null;
+  readonly contract: Contract<SqlStorage>;
+  readonly policy: MigrationOperationPolicy;
+  readonly target: StatementPlanningTarget<TCall>;
+  readonly ownership?: StatementOwnership;
+}): Result<PlannedStatements<TCall>, SqlPlannerConflict>;
+/**
+ * A column a statement names, in a table of a storage namespace, as the destination contract stores
+ * it, with the field the statement names.
+ */
+interface StatementColumn {
+  readonly namespaceId: string;
+  readonly table: string;
+  readonly column: string;
+  readonly field: FieldCoordinate;
+  /** The field as the statement names it, which also names the statement's slots. */
+  readonly text: string;
+}
+/** The columns of the fields that convert and backfill statements name. */
+interface FieldStatementColumns {
+  readonly convert: readonly StatementColumn[];
+  readonly backfill: readonly StatementColumn[];
+}
+/**
+ * The column of each field a convert or backfill statement names, as the destination contract
+ * stores it. These statements rename nothing, so the strategies that plan a field's change read
+ * them instead of the working schema. A field with no column has none to list.
+ */
+declare function fieldStatementColumns(statements: readonly ResolvedMigrationStatement[], contract: ContractWithDomain): FieldStatementColumns;
+/**
+ * A conflict for the first backfill statement that names a field the origin model does not have and
+ * whose column has a default: the default fills the existing rows when the column is added, so the
+ * statement has nothing to fill. A field already in the origin keeps its backfill, since a default
+ * does not fill the rows that hold NULL when the column becomes required.
+ */
+declare function backfillOfDefaultedField(statements: readonly ResolvedMigrationStatement[], fromContract: ContractWithDomain | null, contract: Contract<SqlStorage>): SqlPlannerConflict | undefined;
+/**
+ * Every statement of a plan in the order given, with the operations it accounts for: a rename's
+ * from `renames`, and none yet for any other statement.
+ */
+declare function appliedStatementsInOrder(statements: readonly ResolvedMigrationStatement[], renames: readonly AppliedMigrationStatement[]): readonly AppliedMigrationStatement[];
+//#endregion
+//#region src/core/migrations/operation-subjects.d.ts
+/**
+ * What an operation is about, as the plan names it after its rename statements: a table, or a
+ * column of one, in a storage namespace, or neither, such as a type. `storageName` names the
+ * subject when no model of the origin contract stores it.
+ */
+interface SubjectStorage {
+  readonly storageName: string;
+  readonly table: {
+    readonly namespaceId: string;
+    readonly table: string;
+    readonly column: string | undefined;
+  } | undefined;
+}
+/** What a codec hook's call is about: the column of the field event it was returned for. */
+declare function fieldEventStorage(field: {
+  readonly namespaceId: string;
+  readonly tableName: string;
+  readonly columnName: string;
+}): SubjectStorage;
+/**
+ * Names for destructive calls a target cannot map to storage: each call's factory name, with a
+ * `#n` ordinal when several calls of the plan share it, so each name picks out one call.
+ */
+declare function unknownCallNames<TCall extends {
+  readonly factoryName: string;
+}>(calls: readonly TCall[]): ReadonlyMap<TCall, string>;
+/** A call of a plan: how many operations it lowers to, and what the first of them is about. */
+interface CallSubjects {
+  readonly operationCount: number;
+  /** The call's label, which names its operation before the plan's slots are filled. */
+  readonly label: string;
+  /** What the call's operation loses, one entry per model, field or storage name, and how. */
+  readonly dataLoss: readonly (SubjectStorage & {
+    readonly loss: MigrationDataLossKind;
+  })[];
+  /** What the call's operation changes access to, and whether it widens it. */
+  readonly accessChanges: readonly (SubjectStorage & {
+    readonly widens: boolean;
+  })[];
+  /** The new required columns the call's operation gives a temporary value in existing rows, and the value. */
+  readonly temporaryValues: readonly TemporaryColumnValue[];
+}
+/** A new required column of `table` in the destination, and the temporary value its existing rows get. */
+interface TemporaryColumnValue {
+  readonly table: string;
+  readonly column: string;
+  readonly value: string;
+}
+interface SubjectContext {
+  readonly fromContract: ContractWithDomain | null;
+  readonly contract: ContractWithDomain;
+  /** Where the plan's statements put the origin's tables and columns. */
+  readonly origins: WorkingSchemaOrigins;
+  readonly byHand: TableRenameByHand;
+}
+/**
+ * The subject of each operation that loses data and each that changes access, at its position in
+ * the plan. A subject is a model or a field of the origin contract when one stores it, found under
+ * its origin name when a rename statement renamed its table or column earlier in the plan.
+ */
+declare function subjectsOfCalls(calls: readonly CallSubjects[], context: SubjectContext): MigrationPlanSubjects;
+//#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>, appliedStatements: readonly AppliedMigrationStatement[], subjects: MigrationPlanSubjects, 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?: {
+  readonly why?: string | undefined;
+  readonly meta?: MigrationRunnerFailureMeta;
+}): 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/migrations/required-column.d.ts
+/** Where a column that is to become required finds no value. */
+interface RequiredColumn {
+  readonly table: string;
+  readonly column: string;
+  readonly reason: RowsWithoutValue['reason'];
+}
+/**
+ * The meta of a step that fails when rows have no value for a column that is to become required:
+ * rows hold NULL in it, or, for a new column that can be added to an empty table only, the table
+ * has rows. When the step fails, the runner counts those rows.
+ */
+declare function requiredColumnMeta(table: string, column: string, reason: RowsWithoutValue['reason']): {
+  readonly requiredColumn: RequiredColumn;
+};
+/** The column a step checks before it becomes required, as {@link requiredColumnMeta} marks it. */
+declare function requiredColumnOf(step: SqlMigrationPlanOperationStep): RequiredColumn | undefined;
+/** What a runner failure says of the rows a column that is to become required has no value in. */
+declare function rowsWithoutValueSummary(required: RequiredColumn, rows: number): string;
+/** A step of a plan that marks a column as becoming required. */
+interface RequiredColumnMark<TOperation> {
+  readonly operation: TOperation;
+  readonly operationIndex: number;
+  readonly required: RequiredColumn;
+}
+/**
+ * The marks of the steps of `operations` that belong to the same migration as the operation at
+ * `operationIndex`, in plan order: `edges` say how many operations each migration of the plan has.
+ */
+declare function requiredColumnsOfMigration<TOperation extends {
+  readonly precheck: readonly SqlMigrationPlanOperationStep[];
+  readonly execute: readonly SqlMigrationPlanOperationStep[];
+  readonly postcheck: readonly SqlMigrationPlanOperationStep[];
+}>(operations: readonly TOperation[], edges: readonly {
+  readonly operationCount: number;
+}[], operationIndex: number): readonly RequiredColumnMark<TOperation>[];
+/**
+ * A runner failure's summary and reports for the rows that columns becoming required have no value
+ * in. The failed operation's marks are counted first, and the first of them with such rows is the
+ * one the summary names; undefined when none has any. The other marks of the same migration are
+ * counted after it, until a count fails, such as for a column an earlier operation adds, so that
+ * the advice can name every field that needs a value.
+ */
+declare function rowsWithoutValueFailure<TOperation>(input: {
+  readonly failed: readonly RequiredColumnMark<TOperation>[];
+  readonly others: readonly RequiredColumnMark<TOperation>[];
+  readonly count: (mark: RequiredColumnMark<TOperation>) => Promise<number>;
+  readonly contract: ContractWithDomain;
+}): Promise<{
+  readonly summary: string;
+  readonly reports: readonly RowsWithoutValue[];
+} | undefined>;
+//#endregion
+//#region src/core/migrations/sql-expression-text.d.ts
+/**
+ * One way a target's SQL quotes a literal or an identifier. Inside the quote, the closing text
+ * written twice stands for itself when `doubledCloseEscapes` is set, and a backslash escapes the
+ * next character when `backslashEscapes` is set.
+ */
+interface SqlQuote {
+  readonly open: string;
+  readonly close: string;
+  readonly doubledCloseEscapes: boolean;
+  readonly backslashEscapes: boolean;
+}
+/** The quotes a target's SQL knows. Letters in an opening text, such as the `E` of `E'`, match either case. */
+type SqlQuotingRules = readonly SqlQuote[];
+/**
+ * Returns what in `text` could end or extend the statement a migration writes it into, such as the
+ * conversion of an `ALTER COLUMN … USING` clause or a column of an `INSERT … SELECT` list, or
+ * undefined when it finds nothing. Text inside the quotes of `quoting` may hold anything; outside
+ * them the text may not hold a semicolon, a SQL comment, dollar quoting, or, outside parentheses
+ * and brackets, a comma or a keyword that would end the expression. `FROM` directly after
+ * `DISTINCT`, as in `IS DISTINCT FROM`, belongs to the expression. It checks for these mistakes
+ * only; it does not parse the SQL.
+ */
+declare function checkSqlExpressionText(text: string, quoting: SqlQuotingRules): string | undefined;
+//#endregion
+//#region src/core/migrations/sql-text-sources.d.ts
+/**
+ * Writes the SQL texts of one generated migration-file call. Each text becomes a `sql` template where the tag reads it
+ * back unchanged, else a string literal. `imports()` holds the `sql` import exactly when a written text used the tag.
+ */
+interface SqlTextSources {
+  source(text: string): string;
+  imports(): readonly ImportRequirement[];
+}
+/** `moduleSpecifier` is the module the generated file imports `sql` from. */
+declare function createSqlTextSources(moduleSpecifier: string): SqlTextSources;
+//#endregion
+//#region src/core/migrations/sql-slot.d.ts
+/**
+ * SQL a planned call writes into a statement: written SQL, or a placeholder slot the user fills in
+ * `migration.ts`. While a slot is unfilled, the call lowers to no operation.
+ */
+type SqlSlot = {
+  readonly kind: 'sql';
+  readonly sql: string;
+} | {
+  readonly kind: 'placeholder';
+  readonly slot: string;
+};
+/** Whether `slot` is a placeholder the user has not filled yet. */
+declare function isUnfilledSlot(slot: SqlSlot | undefined): slot is Extract<SqlSlot, {
+  readonly kind: 'placeholder';
+}>;
+/** The SQL of a written slot; undefined for an unfilled one or none. */
+declare function sqlOfSlot(slot: SqlSlot | undefined): string | undefined;
+/** The slot as `migration.ts` writes it: SQL text written through `sql`, or a `placeholder(...)` call. */
+declare function slotSource(slot: SqlSlot, sql: SqlTextSources): string;
+//#endregion
+//#region src/core/migrations/sql-type-lookups.d.ts
+/** The codecs and data types a set of composed components registers. */
+declare function sqlTypeLookupsOf(frameworkComponents: ReadonlyArray<TargetBoundComponentDescriptor<'sql', string>>): TypeLookups;
+//#endregion
+//#region src/core/migrations/table-name-case-guard.d.ts
+declare const TABLE_NAME_CASE_CHANGED_CODE = "MIGRATION.TABLE_NAME_CASE_CHANGED";
+/** The one fact the guard needs about a table the plan would drop or create. */
+interface TableNameCaseGuardTable {
+  readonly name: string;
+}
+/**
+ * Finds every (drop `X`, create `Y`) pair in the same namespace where `X` is
+ * `Y` with its first letter lowered. That shape is the signature of a schema
+ * upgraded across the release in which a model with no `@@map` stopped
+ * lowering the first letter of its table name: planning it would drop the
+ * user's table and recreate it empty. Columns are deliberately not compared,
+ * so a user who also changed a field in the same upgrade is still protected.
+ *
+ * Returns one conflict per pair, carrying `MIGRATION.TABLE_NAME_CASE_CHANGED`
+ * in `meta.code`, or an empty array when the plan has no such pair.
+ */
+declare function detectTableNameCaseChanges(input: {
+  readonly issues: readonly SchemaDiffIssue[];
+  readonly tableOf: (issue: SchemaDiffIssue) => TableNameCaseGuardTable | undefined;
+  readonly namespaceIdOf: (issue: SchemaDiffIssue) => string;
+  readonly renameByHandStatements: (rename: TableRename) => readonly string[];
+  readonly renameTableCall: (rename: TableRenameRequest) => string;
+  readonly contract: Contract<SqlStorage>;
+  readonly defaultNamespaceId: string;
+}): SqlPlannerConflict[];
+//#endregion
+//#region src/core/migrations/temporary-value.d.ts
+/**
+ * Whether a required column the plan adds to a table with rows may take one temporary value in
+ * every row. Not when it is in the primary key, a unique constraint or a foreign key, which one
+ * value in every row would break, and not when its values come from a value set, since no one value
+ * stands for every member. Such a column is added for an empty table only.
+ */
+declare function columnTakesTemporaryValue(table: StorageTable, column: string): boolean;
+//#endregion
+//#region src/core/migrations/unconverted-field.d.ts
+/**
+ * A column whose values a step converts to the column's new type, or checks that it did: `by` says
+ * who converts them, the database's own cast or the migration's own conversion.
+ */
+interface ConvertedColumn {
+  readonly table: string;
+  readonly column: string;
+  readonly by: 'cast' | 'conversion';
+}
+/**
+ * The meta of a step that converts the values of `column` in `table` to the column's new type, or
+ * checks that it did. When the step fails, the runner names the field that stores the column.
+ */
+declare function convertedColumnMeta(table: string, column: string, by: ConvertedColumn['by']): {
+  readonly convertedColumn: ConvertedColumn;
+};
+/** The column a step converts to its new type, as {@link convertedColumnMeta} marks it. */
+declare function convertedColumnOf(step: SqlMigrationPlanOperationStep): ConvertedColumn | undefined;
+/**
+ * The field of `contract` whose column a failed step converts, or undefined when the step
+ * converts no column, no field stores the column, or tables of two storage namespaces share its name.
+ */
+declare function unconvertedFieldOf(step: SqlMigrationPlanOperationStep, contract: ContractWithDomain): MigrationSubject | undefined;
+//#endregion
+//#region src/core/reported-defaults.d.ts
+/**
+ * A reported literal default with the target's quoting, casts and escapes taken off: one body, or a list's element bodies with `null` for SQL NULL. A body is what the target's driver hands `fromWire` for a row of the column: text, a number where the driver returns one, or bytes.
+ */
+type ReportedLiteralDefault = {
+  readonly kind: 'value';
+  readonly body: ReportedBody;
+} | {
+  readonly kind: 'list';
+  readonly elements: readonly (ReportedBody | null)[];
+};
+/** One literal's body, as the driver would hand it over for a row: text, a number, or the bytes of a blob. */
+type ReportedBody = string | number | Uint8Array;
+/** What the column's codec made of a reported literal default: the value, or the codec's reason it could not read it. */
+type ReadReportedDefault = {
+  readonly resolvedDefault: ColumnDefault;
+  readonly defaultValue: SqlDefaultValue;
+} | {
+  readonly defaultUnreadable: string;
+};
+/** Reads a reported literal default with the column's codec. `raw` is the reported text, which a refusal quotes. */
+declare function readReportedDefault(codec: Codec, literal: ReportedLiteralDefault, raw: string): Promise<ReadReportedDefault>;
+/** What introspection holds of a reported literal default: the codec's reading, and the value of the literal the contract's expression default writes, when it writes one the codec reads. */
+type ReadColumnDefault = ReadReportedDefault & {
+  readonly defaultExpressionValue?: SqlDefaultValue;
+};
+/**
+ * Reads a reported literal default with the column's codec, and, when the contract's default is an expression that writes a literal, that literal too, so the diff compares the two as values.
+ */
+declare function readColumnDefault(codec: Codec, reported: {
+  readonly literal: ReportedLiteralDefault;
+  readonly raw: string;
+}, written: {
+  readonly literal: ReportedLiteralDefault;
+  readonly expression: string;
+} | undefined): Promise<ReadColumnDefault>;
+/** What introspection needs of a column the contract declares: its codec, and its default when that is an expression. */
+interface ContractColumn {
+  readonly codecRef: CodecRef;
+  readonly defaultExpression: string | undefined;
+}
+/** The columns a contract declares, for introspection to read each column's reported default with the column's codec. */
+interface ContractColumns {
+  /** `table.column` in one of `namespaceIds`, or in any namespace when `undefined`. */
+  columnOf(namespaceIds: readonly string[] | undefined, table: string, column: string): ContractColumn | undefined;
+}
+/**
+ * The columns `contract` declares. `contract` is a contract, or the namespaces of several contract spaces merged with each space's contract under `contracts`, as multi-space introspection receives them.
+ */
+declare function contractColumns(contract: unknown): ContractColumns;
+//#endregion
+//#region src/exports/control.d.ts
+declare const _default: SqlFamilyDescriptor;
+//#endregion
+export { SubjectStorage as $, sqlOfSlot as $t, NoTable as A, isUnfilledSlot as At, SingleOperationCall as B, readColumnDefault as Bt, MigrationPlannerConflict$1 as C, detectDestructiveChanges as Ct, NO_RENAMED_ORIGINS as D, fieldOfColumn as Dt, ModelTable as E, fieldEventStorage as Et, ReportedBody as F, planFieldEventCalls as Ft, SqlPslBuildContext as G, resolveColumnRenameAgainst as Gt, SqlControlTargetDescriptor as H, requiredColumnMeta as Ht, ReportedLiteralDefault as I, planFieldEventOperations as It, SqlSlot as J, rowsWithoutValueSummary as Jt, SqlQuote as K, resolveTableRenameAgainst as Kt, RequiredColumn as L, planStatements as Lt, PlannedStatements as M, otherSpaceDeclaring as Mt, ReadColumnDefault as N, partitionCallsByControlPolicy as Nt, NamespaceRename as O, fieldRenameStorageEffect as Ot, ReadReportedDefault as P, partitionIssuesByControlPolicy as Pt, StatementPlanningTarget as Q, sqlDefaultFunctions as Qt, RequiredColumnMark as R, plannerFailure as Rt, MigrationPlanner as S, createSqlTextSources as St, ModelStorageEffect as T, extractCodecControlHooks as Tt, SqlDefaultFunctionName as U, requiredColumnOf as Ut, SqlControlFamilyInstance as V, readReportedDefault as Vt, SqlDescribedContractSpace as W, requiredColumnsOfMigration as Wt, StatementColumn as X, runnerSuccess as Xt, SqlTextSources as Y, runnerFailure as Yt, StatementOwnership as Z, slotSource as Zt, INIT_ADDITIVE_POLICY as _, contractNamespaceToSchemaIR as _t, ColumnRename as a, unmatchedColumnRename as an, TableRenameByHand as at, MigrationPlan$1 as b, convertedColumnOf as bt, ContractColumns as c, TargetRefusal as ct, ConvertedColumn as d, appliedStatementsInOrder as dt, sqlTypeLookupsOf as en, SuppressionRecord as et, DefaultResolver as f, assembleAuthoringContributions$1 as ft, FieldStorageEffect as g, contractColumns as gt, FieldStatementColumns as h, columnTakesTemporaryValue as ht, ColumnOnOneSide as i, unknownCallNames as in, TableRename as it, PlanFieldEventOperationsOptions as j, modelRenameStorageEffect as jt, NamespaceStatementTarget as k, fieldStatementColumns as kt, ContractToSchemaIROptions as l, WorkingSchemaOrigins as lt, FieldEventCall as m, checkSqlExpressionText as mt, CallSubjects as n, subjectsOfCalls as nn, TableMove as nt, ColumnRenameRequest as o, unmatchedTableRename as on, TableRenameRequest as ot, DefaultResolverColumn as p, backfillOfDefaultedField as pt, SqlQuotingRules as q, rowsWithoutValueFailure as qt, CallWithCompanions as r, unconvertedFieldOf as rn, TableNameCaseGuardTable as rt, ContractColumn as s, TargetMigrationsCapability as st, COLUMN_RENAME_UNMATCHED_CODE as t, storageNameOfOperation as tn, TABLE_NAME_CASE_CHANGED_CODE as tt, ControlPolicySubject as u, _default as ut, MigrationOperationClass$1 as v, contractToSchemaIR as vt, MigrationPlannerResult as w, detectTableNameCaseChanges as wt, MigrationPlanOperation$1 as x, createMigrationPlan as xt, MigrationOperationPolicy$1 as y, convertedColumnMeta as yt, SchemaTables as z, plannerSuccess as zt };
+//# sourceMappingURL=control-ChAUdOOu.d.mts.map