@prisma/orm-family-sql 8.0.0-rc.16-dev.6 → 8.0.0-rc.16-dev.8

package/dist/{control-DCt08EpW.d.mts → control-BkyDhucB.d.mts}

@@ -1,5 +1,5 @@
 import { t as StorageColumn } from "./storage-table-BBcKoAuF-CssyCQhM.mjs";
-import { l as SqlStorage, o as SqlNamespaceEntries } from "./sql-storage-DSnnRQAf-DaHPnley.mjs";
+import { l as SqlStorage } from "./sql-storage-DSnnRQAf-DaHPnley.mjs";
 import { O as SqlControlDriverInstance } from "./types-DV040Uuq-Bu8CnbMa.mjs";
 import "./types-DkOYK86-.mjs";
 import { r as SqlOperationDescriptors } from "./index-qOLTnfYz.mjs";
@@ -14,14 +14,14 @@ import { _ as SqlSchemaIR, y as SqlSchemaIRNode } from "./types-CLsPsUiw-Db1BsN9
 import "./types-D6XuABFQ.mjs";
 import { r as SqlControlAdapter } from "./control-adapter-CkFfBVei-Ba9JNrCN.mjs";
 import { t as sqlFamilyEnumSpec } from "./authoring-entity-types-CZ-vdwYS-Bq3LXsCn.mjs";
-import { D as SqlPlannerFailureResult, S as SqlMigrationRunnerSuccessValue, _ as SqlMigrationRunnerErrorCode, b as SqlMigrationRunnerFailure, g as SqlMigrationRunner, k as SqlPlannerSuccessResult, l as SqlMigrationPlan, m as SqlMigrationPlanner, n as CodecControlHooks, r as CreateSqlMigrationPlanOptions, t as AnyRecord, w as SqlPlannerConflict } from "./types-CvuS68sy-ReNXbgpE.mjs";
+import { D as SqlPlannerFailureResult, S as SqlMigrationRunnerSuccessValue, _ as SqlMigrationRunnerErrorCode, b as SqlMigrationRunnerFailure, g as SqlMigrationRunner, k as SqlPlannerSuccessResult, l as SqlMigrationPlan, m as SqlMigrationPlanner, n as CodecControlHooks, r as CreateSqlMigrationPlanOptions, t as AnyRecord, w as SqlPlannerConflict } from "./types-CzxOObSY-CNWyrf87.mjs";
 import { t as SqlSchemaDiffFn } from "./schema-differ-CqWOkoW9--uxNOini.mjs";
 import { StructuredError } from "@prisma/orm-framework/utils/structured-error";
 import { DataTypeSupport, PresetStorageTemplate, TIMESTAMP_NOW_GENERATOR_ID } from "@prisma/orm-framework/components/authoring";
 import { CodecLookupWithDescriptors, DataType } from "@prisma/orm-framework/components/codec";
-import { ColumnDefault, Contract, ControlPolicy } from "@prisma/orm-framework/contract/types";
+import { ColumnDefault, Contract, ContractWithDomain, ControlPolicy } from "@prisma/orm-framework/contract/types";
 import { TargetBoundComponentDescriptor } from "@prisma/orm-framework/components/components";
-import { AssembledAuthoringContributions, 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, OpFactoryCall, OperationPreview, OperationPreviewCapable, PslContractBuildCapable, PslContractInferCapable, SchemaDiffIssue, SchemaVerifier, SchemaViewCapable, TargetMigrationsCapability, VerifyDatabaseResult, VerifyDatabaseSchemaResult, assembleAuthoringContributions } from "@prisma/orm-framework/components/control";
+import { AppliedMigrationStatement, AssembledAuthoringContributions, ContractSerializer, ControlFamilyDescriptor, ControlFamilyInstance, ControlStack, DiffSubjectGranularity, MigratableTargetDescriptor, 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, ModelCoordinate, OpFactoryCall, OperationPreview, OperationPreviewCapable, PslContractBuildCapable, PslContractInferCapable, ResolvedFieldRenameStatement, ResolvedMigrationStatement, ResolvedModelRenameStatement, SchemaDiffIssue, SchemaVerifier, SchemaViewCapable, TargetMigrationsCapability, VerifyDatabaseResult, VerifyDatabaseSchemaResult, assembleAuthoringContributions } from "@prisma/orm-framework/components/control";
 import { NotOk, Ok, Result } from "@prisma/orm-framework/utils/result";
 import { PslDocumentAst } from "@prisma/orm-framework/components/psl-ast";
 import { EmissionSpi, TypesImportSpec } from "@prisma/orm-framework/components/emission";
@@ -134,6 +134,7 @@ interface SqlControlFamilyInstance extends ControlFamilyInstance<'sql', SqlSchem
   }): Promise<void>;
   bootstrapControlTableQueries(): readonly DdlNode[];
   toOperationPreview(operations: readonly MigrationPlanOperation[]): OperationPreview;
+  storageNameOf(operation: MigrationPlanOperation): string;
 }
 //#endregion
 //#region src/core/control-descriptor.d.ts
@@ -543,41 +544,6 @@ interface SqlControlTargetDescriptor<TTargetId extends string, TTargetDetails, T
   createRunner(family: SqlControlFamilyInstance): SqlMigrationRunner<TTargetDetails>;
 }
 //#endregion
-//#region src/core/migrations/apply-table-rename.d.ts
-/** A table a migration renames: `namespaceId` is `undefined` when the migration leaves the namespace to the contracts. */
-interface TableRename {
-  readonly namespaceId: string | undefined;
-  readonly from: string;
-  readonly to: string;
-}
-/** A rename after its table was found in the start contract. */
-interface ResolvedTableRename {
-  readonly namespaceId: string;
-  readonly from: string;
-  readonly to: string;
-}
-/**
- * Renames a target's own references to a renamed table inside one namespace's entries: entity kinds the family does not know, such as a target's row-level-security markers, that name a table.
- */
-type RenameTableReferences = (entries: SqlNamespaceEntries, rename: ResolvedTableRename) => SqlNamespaceEntries;
-interface ApplyTableRenameInput {
-  readonly startContract: Contract<SqlStorage> | null;
-  readonly endContract: Contract<SqlStorage>;
-  readonly rename: TableRename;
-  readonly renameTableReferences: RenameTableReferences | undefined;
-}
-interface AppliedTableRename {
-  /** The start contract with the table under its new name. */
-  readonly contract: Contract<SqlStorage>;
-  readonly rename: ResolvedTableRename;
-}
-/**
- * Resolves the table a migration renames against its start and end contracts and returns the start contract with that table under its new name, so a diff against the end contract sees the table under one name. The table must exist in the start contract (in exactly one namespace when the namespace is not given), and the new name must exist in the end contract and not in the start contract; otherwise the rename is refused with `MIGRATION.TABLE_RENAME_UNMATCHED`.
- *
- * Foreign keys that name the renamed table on either side are retargeted. Index, unique, check and primary-key names are carried unchanged. Target entity kinds that name the table are renamed by the target's `renameTableReferences`.
- */
-declare function applyTableRename(input: ApplyTableRenameInput): Result<AppliedTableRename, StructuredError>;
-//#endregion
 //#region src/core/migrations/contract-to-schema-ir.d.ts
 /**
  * Target-specific callback that renders a `ColumnDefault` into the raw SQL literal
@@ -780,6 +746,84 @@ declare function partitionIssuesByControlPolicy<TIssue>(options: {
   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[];
+}
+//#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 {
   /**
@@ -801,12 +845,90 @@ interface PlanFieldEventOperationsOptions {
    * `RawSqlCall`.
    */
   readonly codecHooks: ReadonlyMap<string, CodecControlHooks>;
+  /**
+   * 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/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/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;
+  /** What the call's operation loses, one entry per model, field or storage name. */
+  readonly dataLoss: readonly SubjectStorage[];
+  /** What the call's operation changes access to, and whether it widens it. */
+  readonly accessWidening: readonly (SubjectStorage & {
+    readonly widens: boolean;
+  })[];
+}
+interface SubjectContext {
+  readonly fromContract: ContractWithDomain | null;
+  readonly contract: ContractWithDomain;
+  /** The rename statements the plan applied, whose renames a target names the new way. */
+  readonly statements: readonly ResolvedMigrationStatement[];
+}
+/**
+ * The subject of each operation that loses data and each that widens 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>, warnings?: readonly SqlPlannerConflict[]): SqlPlannerSuccessResult<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.
@@ -833,24 +955,108 @@ declare const INIT_ADDITIVE_POLICY: MigrationOperationPolicy;
 /** The codecs and data types a set of composed components registers. */
 declare function sqlTypeLookupsOf(frameworkComponents: ReadonlyArray<TargetBoundComponentDescriptor<'sql', string>>): SqlTypeLookups;
 //#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.
+ */
+interface CallWithCompanions extends SingleOperationCall {
+  readonly companions: readonly SingleOperationCall[];
+}
+/** What a target supplies for planning statements against its working schema. */
+interface StatementPlanningTarget<TCall extends CallWithCompanions> {
+  /** 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;
+  /** 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;
+  /** 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[];
+}
+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[];
+}
+/**
+ * Plans the statements in order against a target's working schema: 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 ResolvedMigrationStatement[];
+  readonly fromContract: Contract<SqlStorage> | null;
+  readonly contract: Contract<SqlStorage>;
+  readonly policy: MigrationOperationPolicy;
+  readonly target: StatementPlanningTarget<TCall>;
+}): Result<PlannedStatements<TCall>, SqlPlannerConflict>;
+//#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;
 }
-/** A table rename the operator performs by hand, for the target to write the statements of. */
-interface TableRenameByHand {
-  readonly namespaceId: string;
-  readonly from: string;
-  readonly to: string;
-}
-/** A table rename to write as a migration call; `namespaceId` is `undefined` when the call does not need to name the namespace. */
-interface TableRenameInMigration {
-  readonly namespaceId: string | undefined;
-  readonly from: string;
-  readonly to: 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
@@ -866,8 +1072,8 @@ declare function detectTableNameCaseChanges(input: {
   readonly issues: readonly SchemaDiffIssue[];
   readonly tableOf: (issue: SchemaDiffIssue) => TableNameCaseGuardTable | undefined;
   readonly namespaceIdOf: (issue: SchemaDiffIssue) => string;
-  readonly renameByHandStatements: (rename: TableRenameByHand) => readonly string[];
-  readonly renameTableCall: (rename: TableRenameInMigration) => string;
+  readonly renameByHandStatements: (rename: TableRename) => readonly string[];
+  readonly renameTableCall: (rename: TableRenameRequest) => string;
   readonly contract: Contract<SqlStorage>;
   readonly defaultNamespaceId: string;
 }): SqlPlannerConflict[];
@@ -973,5 +1179,5 @@ declare function temporalCodecPresetWithPrecision<const CodecId extends string,
 //#region src/exports/control.d.ts
 declare const _default: SqlFamilyDescriptor;
 //#endregion
-export { applyTableRename as A, partitionIssuesByControlPolicy as B, TABLE_NAME_CASE_CHANGED_CODE as C, TableRenameInMigration as D, TableRenameByHand as E, createMigrationPlan as F, runnerSuccess as G, plannerFailure as H, detectDestructiveChanges as I, temporalStringAuthoringPresets as J, sqlTypeLookupsOf as K, detectTableNameCaseChanges as L, contractNamespaceToSchemaIR as M, contractToSchemaIR as N, TargetMigrationsCapability as O, controlPolicyForCall as P, extractCodecControlHooks as R, SuppressionRecord as S, TableRename as T, plannerSuccess as U, planFieldEventOperations as V, runnerFailure as W, ResolvedTableRename as _, DefaultRenderer as a, SqlDescribedContractSpace as b, MigrationOperationClass as c, MigrationPlanOperation$1 as d, MigrationPlanner as f, RenameTableReferences as g, PlanFieldEventOperationsOptions as h, ControlPolicySubject as i, assembleAuthoringContributions as j, _default as k, MigrationOperationPolicy$1 as l, MigrationPlannerResult as m, ApplyTableRenameInput as n, DefaultResolver as o, MigrationPlannerConflict$1 as p, temporalCodecPresetWithPrecision as q, ContractToSchemaIROptions as r, INIT_ADDITIVE_POLICY as s, AppliedTableRename as t, MigrationPlan$1 as u, SqlControlFamilyInstance as v, TableNameCaseGuardTable as w, SqlPslBuildContext as x, SqlControlTargetDescriptor as y, partitionCallsByControlPolicy as z };
-//# sourceMappingURL=control-DCt08EpW.d.mts.map
+export { partitionIssuesByControlPolicy as $, SqlDescribedContractSpace as A, _default as B, NoTable as C, SingleOperationCall as D, SchemaTables as E, TABLE_NAME_CASE_CHANGED_CODE as F, createMigrationPlan as G, contractNamespaceToSchemaIR as H, TableNameCaseGuardTable as I, extractCodecControlHooks as J, detectDestructiveChanges as K, TableRename as L, StatementPlanningTarget as M, SubjectStorage as N, SqlControlFamilyInstance as O, SuppressionRecord as P, partitionCallsByControlPolicy as Q, TableRenameRequest as R, ModelTable as S, PlannedStatements as T, contractToSchemaIR as U, assembleAuthoringContributions as V, controlPolicyForCall as W, fieldRenameStorageEffect as X, fieldEventStorage as Y, modelRenameStorageEffect as Z, MigrationPlanOperation$1 as _, ColumnRename as a, resolveColumnRenameAgainst as at, MigrationPlannerResult as b, ControlPolicySubject as c, runnerSuccess as ct, FieldEventCall as d, subjectsOfCalls as dt, planFieldEventCalls as et, FieldStorageEffect as f, temporalCodecPresetWithPrecision as ft, MigrationPlan$1 as g, unmatchedTableRename as gt, MigrationOperationPolicy$1 as h, unmatchedColumnRename as ht, ColumnOnOneSide as i, plannerSuccess as it, SqlPslBuildContext as j, SqlControlTargetDescriptor as k, DefaultRenderer as l, sqlTypeLookupsOf as lt, MigrationOperationClass$1 as m, unknownCallNames as mt, CallSubjects as n, planStatements as nt, ColumnRenameRequest as o, resolveTableRenameAgainst as ot, INIT_ADDITIVE_POLICY as p, temporalStringAuthoringPresets as pt, detectTableNameCaseChanges as q, CallWithCompanions as r, plannerFailure as rt, ContractToSchemaIROptions as s, runnerFailure as st, COLUMN_RENAME_UNMATCHED_CODE as t, planFieldEventOperations as tt, DefaultResolver as u, storageNameOfOperation as ut, MigrationPlanner as v, PlanFieldEventOperationsOptions as w, ModelStorageEffect as x, MigrationPlannerConflict$1 as y, TargetMigrationsCapability as z };
+//# sourceMappingURL=control-BkyDhucB.d.mts.map

package/dist/control-BkyDhucB.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"control-BkyDhucB.d.mts","names":[],"sources":["../../../../2-sql/9-family/dist/control.d.mts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAqBU;WACC,kBAAkB,cAAc;WAChC,cAAc;;UAEf,iCAAiC,6BAA6B,kBAAkB,kBAAkB,kBAAkB,wBAAwB,kBAAkB,wBAAwB,SAAS,cAAc,yBAAyB;;;;;;;;;EAS9O,oBAAoB,wBAAwB;EAC5C,OAAO;aACI,QAAQ;aACR;aACA;aACA;aACA;MACP,QAAQ;;;;;;;;;;EAUZ,aAAa;aACF;aACA,QAAQ;aACR;aACA,qBAAqB,cAAc;MAC1C;;;;;;;;;;EAUJ,2BAA2B,OAAO,kBAAkB;;;;;;;;EAQpD,mBAAmB,OAAO;EAC1B,WAAW;aACA,QAAQ;aACR;MACP,QAAQ;EACZ,iBAAiB,UAAU,kBAAkB;EAC7C,SAAS,KAAK,cAAc,SAAS,SAAS,0BAA0B,QAAQ;;;;;;EAMhF,WAAW;aACA,QAAQ;aACR;aACA;eACE;eACA;eACA;;MAET;;;;;EAKJ,aAAa;aACF,QAAQ;aACR;aACA;aACA;eACE;eACA;eACA;;MAET;;;;;EAKJ,iBAAiB;aACN,QAAQ;aACR;aACA;eACE;eACA;eACA;eACA;eACA;eACA;eACA;;MAET;EACJ,yCAAyC;EACzC,mBAAmB,qBAAqB,2BAA6B;EACrE,cAAc,WAAW;;;;cAIb,+BAA+B,+BAA+B;WACjE;WACA;WACA;WACA;WACA,UAAU;WACV,oBAAoB;WACpB;aACE;eACE;iBACE;iBACA;mBACE;mBACA;qBACE;;;;eAIN;iBACE;iBACA;mBACE;mBACA;qBACE;;;;eAIN;iBACE;iBACA;mBACE;mBACA;mBACA;qBACE;uBACE;uBACA;uBACA;uBACA;uBACA;;;;iBAIN;mBACE;mBACA;qBACE;uBACE;uBACA;uBACA;uBACA;;;;;eAKR;iBACE;iBACA;mBACE;mBACA;qBACE;;;;eAIN;iBACE;iBACA;mBACE;mBACA;qBACE;;;;eAIN;iBACE;mBACE;mBACA;qBACE;qBACA;uBACE;;qBAEF;uBACE;yBACE;yBACA;;;qBAGJ;;;iBAGJ;mBACE;mBACA;qBACE;qBACA;uBACE;;qBAEF;uBACE;yBACE;yBACA;;;qBAGJ;;;iBAGJ;mBACE;mBACA;qBACE;qBACA;uBACE;;qBAEF;uBACE;yBACE;yBACA;;;qBAGJ;;;iBAGJ;mBACE;mBACA;qBACE;qBACA;qBACA;uBACE;yBACE;yBACA;yBACA;yBACA;yBACA;;;;mBAIN;qBACE;qBACA;uBACE;yBACE;yBACA;yBACA;yBACA;;;qBAGJ;uBACE;yBACE;yBACA;yBACA;2BACE;6BACE;6BACA;6BACA;;;;;qBAKR;;;iBAGJ;mBACE;mBACA;qBACE;qBACA;uBACE;;qBAEF;uBACE;yBACE;yBACA;;;qBAGJ;;;iBAGJ;mBACE;mBACA;qBACE;qBACA;uBACE;;qBAEF;uBACE;yBACE;yBACA;;;qBAGJ;;;;;aAKR;eACE;iBACE;mBACE;mBACA;mBACA;qBACE;qBACA;qBACA;;mBAEF;qBACE;qBACA;uBACE;yBACE;yBACA;;;;;;;aAOZ,gEAAgE;aAChE;eACE;QACP;QACA;QACA;QACA;QACA;UACE;;QAEF,aAAa;QACb;UACE,2CAA2C;YACzC;4CACgC;;;;aAI/B;eACE;iBACE,0CAA0C;UACjD;0CACgC;iBACzB,yCAAyC;UAChD;mBACS;0CACuB;iBACzB,6CAA6C;UACpD;mBACS;0CACuB;iBACzB,4CAA4C;UACnD;mBACS;mBACA;mBACA;mBACA;mBACA;mBACA;mBACA,UAAU;0CACa;iBACzB,4CAA4C;mBAC1C;mBACA;mBACA;0CACuB;iBACzB,8CAA8C;UACrD;0CACgC;iBACzB,oDAAoD;UAC3D;0CACgC;iBACzB,2CAA2C;UAClD,qCAAqC,uDAAuD;UAC5F;0CACgC;;eAE3B;iBACE,0CAA0C;UACjD;0CACgC;iBACzB,yCAAyC;mBACvC;0CACuB;iBACzB,6CAA6C;mBAC3C;0CACuB;iBACzB,8CAA8C;UACrD;UACA;0CACgC;iBACzB,+CAA+C;UACtD;mBACS;mBACA;mBACA;mBACA;mBACA;mBACA;0CACuB;iBACzB,UAAU,oCAAoC,6DAA6D;UAClH,sCAAsC,mEAAmE,4CAA4C,iFAAiF,4CAA4C;0CAClP;;;aAG7B;gBACG,iFAAiF;;;WAGtF;aACE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"}

package/dist/{diff-3tfqwWS7.d.mts → diff-DMOqiT2h.d.mts}

@@ -3,7 +3,7 @@ import "./types-DkOYK86-.mjs";
 import { y as SqlSchemaIRNode } from "./types-CLsPsUiw-Db1BsN9R.mjs";
 import "./types-D6XuABFQ.mjs";
 import "./control-adapter-CkFfBVei-Ba9JNrCN.mjs";
-import { n as CodecControlHooks } from "./types-CvuS68sy-ReNXbgpE.mjs";
+import { n as CodecControlHooks } from "./types-CzxOObSY-CNWyrf87.mjs";
 import { t as SqlSchemaDiffFn } from "./schema-differ-CqWOkoW9--uxNOini.mjs";
 import { Contract, ControlPolicy } from "@prisma/orm-framework/contract/types";
 import { TargetBoundComponentDescriptor } from "@prisma/orm-framework/components/components";
@@ -101,4 +101,4 @@ interface VerifySqlSchemaByDiffInput {
 declare function verifySqlSchemaByDiff(input: VerifySqlSchemaByDiffInput): VerifyDatabaseSchemaResult;
 //#endregion
 export { VerifySqlSchemaByDiffInput as a, computeSqlDiffVerdict as c, StorageTypeVerdictInput as i, computeStorageTypeVerdict as l, SqlDiffVerdictInput as n, classifyDiffSubjectGranularity as o, StorageTypeVerdict as r, classifySqlDiffIssue as s, SqlDiffVerdict as t, verifySqlSchemaByDiff as u };
-//# sourceMappingURL=diff-3tfqwWS7.d.mts.map
+//# sourceMappingURL=diff-DMOqiT2h.d.mts.map

package/dist/{diff-3tfqwWS7.d.mts.map → diff-DMOqiT2h.d.mts.map}

@@ -1 +1 @@
-{"version":3,"file":"diff-3tfqwWS7.d.mts","names":[],"sources":["../../../../2-sql/9-family/dist/diff.d.mts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;iBAmBiB,+BAA+B,OAAO,iBAAiB,gBAAgB,qBAAqB,yBAAyB;;;;;;;;;;;;;iBAarH,qBAAqB,OAAO,iBAAiB,gBAAgB,qBAAqB,yBAAyB;UAClH;;WAEC,iBAAiB;;WAEjB,uBAAuB,OAAO,oBAAoB;WAClD;WACA,sBAAsB;;WAEtB,gBAAgB,qBAAqB;;UAEtC;WACC,mBAAmB;WACnB,mBAAmB;;;;;;;;;iBASb,sBAAsB,OAAO,sBAAsB;UAC1D;WACC,UAAU,SAAS;;;;;;;WAOnB,gBAAgB;aACd,QAAQ;;WAEV,YAAY,oBAAoB;;;;;;;;;UASjC;WACC,mBAAmB;WACnB,mBAAmB;;iBAEb,0BAA0B,OAAO,0BAA0B;UAClE;WACC,UAAU,SAAS;WACnB,QAAQ;WACR;WACA,qBAAqB,cAAc;;WAEnC,YAAY;;WAEZ,gBAAgB,qBAAqB;;;;;;;;;iBAS/B,sBAAsB,OAAO,6BAA6B"}
+{"version":3,"file":"diff-DMOqiT2h.d.mts","names":[],"sources":["../../../../2-sql/9-family/dist/diff.d.mts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;iBAmBiB,+BAA+B,OAAO,iBAAiB,gBAAgB,qBAAqB,yBAAyB;;;;;;;;;;;;;iBAarH,qBAAqB,OAAO,iBAAiB,gBAAgB,qBAAqB,yBAAyB;UAClH;;WAEC,iBAAiB;;WAEjB,uBAAuB,OAAO,oBAAoB;WAClD;WACA,sBAAsB;;WAEtB,gBAAgB,qBAAqB;;UAEtC;WACC,mBAAmB;WACnB,mBAAmB;;;;;;;;;iBASb,sBAAsB,OAAO,sBAAsB;UAC1D;WACC,UAAU,SAAS;;;;;;;WAOnB,gBAAgB;aACd,QAAQ;;WAEV,YAAY,oBAAoB;;;;;;;;;UASjC;WACC,mBAAmB;WACnB,mBAAmB;;iBAEb,0BAA0B,OAAO,0BAA0B;UAClE;WACC,UAAU,SAAS;WACnB,QAAQ;WACR;WACA,qBAAqB,cAAc;;WAEnC,YAAY;;WAEZ,gBAAgB,qBAAqB;;;;;;;;;iBAS/B,sBAAsB,OAAO,6BAA6B"}

package/dist/family.d.mts

@@ -1,17 +1,17 @@
 import { n as resolveStorageTable, t as ResolvedStorageTable } from "./resolve-storage-table-Ba33K41A.mjs";
 import { h as checkSqlDefaultText } from "./validators-BAa0JKuB.mjs";
 import { a as arraysEqual, n as Lowerer, r as SqlControlAdapter, t as ExecuteRequestLowerer } from "./control-adapter-CkFfBVei-Ba9JNrCN.mjs";
-import { A as StorageTypePlanResult, C as SqlPlanTargetDetails, D as SqlPlannerFailureResult, E as SqlPlannerConflictLocation, O as SqlPlannerResult, S as SqlMigrationRunnerSuccessValue, T as SqlPlannerConflictKind, _ as SqlMigrationRunnerErrorCode, a as FieldEventContext, b as SqlMigrationRunnerFailure, c as SqlControlExtensionDescriptor, d as SqlMigrationPlanOperation, f as SqlMigrationPlanOperationStep, g as SqlMigrationRunner, h as SqlMigrationPlannerPlanOptions, i as FieldEvent, k as SqlPlannerSuccessResult, l as SqlMigrationPlan, m as SqlMigrationPlanner, n as CodecControlHooks, o as ResolveIdentityValueInput, p as SqlMigrationPlanOperationTarget, r as CreateSqlMigrationPlanOptions, s as SqlControlAdapterDescriptor, u as SqlMigrationPlanContractInfo, v as SqlMigrationRunnerExecuteCallbacks, w as SqlPlannerConflict, x as SqlMigrationRunnerResult, y as SqlMigrationRunnerExecuteOptions } from "./types-CvuS68sy-ReNXbgpE.mjs";
+import { A as StorageTypePlanResult, C as SqlPlanTargetDetails, D as SqlPlannerFailureResult, E as SqlPlannerConflictLocation, O as SqlPlannerResult, S as SqlMigrationRunnerSuccessValue, T as SqlPlannerConflictKind, _ as SqlMigrationRunnerErrorCode, a as FieldEventContext, b as SqlMigrationRunnerFailure, c as SqlControlExtensionDescriptor, d as SqlMigrationPlanOperation, f as SqlMigrationPlanOperationStep, g as SqlMigrationRunner, h as SqlMigrationPlannerPlanOptions, i as FieldEvent, k as SqlPlannerSuccessResult, l as SqlMigrationPlan, m as SqlMigrationPlanner, n as CodecControlHooks, o as ResolveIdentityValueInput, p as SqlMigrationPlanOperationTarget, r as CreateSqlMigrationPlanOptions, s as SqlControlAdapterDescriptor, u as SqlMigrationPlanContractInfo, v as SqlMigrationRunnerExecuteCallbacks, w as SqlPlannerConflict, x as SqlMigrationRunnerResult, y as SqlMigrationRunnerExecuteOptions } from "./types-CzxOObSY-CNWyrf87.mjs";
 import { n as SqlSchemaDiffInput, r as SqlSchemaDiffResult, t as SqlSchemaDiffFn } from "./schema-differ-CqWOkoW9--uxNOini.mjs";
-import { A as applyTableRename, B as partitionIssuesByControlPolicy, C as TABLE_NAME_CASE_CHANGED_CODE, D as TableRenameInMigration, E as TableRenameByHand, F as createMigrationPlan, G as runnerSuccess, H as plannerFailure, I as detectDestructiveChanges, J as temporalStringAuthoringPresets, K as sqlTypeLookupsOf, L as detectTableNameCaseChanges, M as contractNamespaceToSchemaIR, N as contractToSchemaIR, O as TargetMigrationsCapability, P as controlPolicyForCall, R as extractCodecControlHooks, S as SuppressionRecord, T as TableRename, U as plannerSuccess, V as planFieldEventOperations, W as runnerFailure, _ as ResolvedTableRename, a as DefaultRenderer, b as SqlDescribedContractSpace, c as MigrationOperationClass, d as MigrationPlanOperation, f as MigrationPlanner, g as RenameTableReferences, h as PlanFieldEventOperationsOptions, i as ControlPolicySubject, j as assembleAuthoringContributions, l as MigrationOperationPolicy, m as MigrationPlannerResult, n as ApplyTableRenameInput, o as DefaultResolver, p as MigrationPlannerConflict, q as temporalCodecPresetWithPrecision, r as ContractToSchemaIROptions, s as INIT_ADDITIVE_POLICY, t as AppliedTableRename, u as MigrationPlan, v as SqlControlFamilyInstance, w as TableNameCaseGuardTable, x as SqlPslBuildContext, y as SqlControlTargetDescriptor, z as partitionCallsByControlPolicy } from "./control-DCt08EpW.mjs";
+import { $ as partitionIssuesByControlPolicy, A as SqlDescribedContractSpace, C as NoTable, D as SingleOperationCall, E as SchemaTables, F as TABLE_NAME_CASE_CHANGED_CODE, G as createMigrationPlan, H as contractNamespaceToSchemaIR, I as TableNameCaseGuardTable, J as extractCodecControlHooks, K as detectDestructiveChanges, L as TableRename, M as StatementPlanningTarget, N as SubjectStorage, O as SqlControlFamilyInstance, P as SuppressionRecord, Q as partitionCallsByControlPolicy, R as TableRenameRequest, S as ModelTable, T as PlannedStatements, U as contractToSchemaIR, V as assembleAuthoringContributions, W as controlPolicyForCall, X as fieldRenameStorageEffect, Y as fieldEventStorage, Z as modelRenameStorageEffect, _ as MigrationPlanOperation, a as ColumnRename, at as resolveColumnRenameAgainst, b as MigrationPlannerResult, c as ControlPolicySubject, ct as runnerSuccess, d as FieldEventCall, dt as subjectsOfCalls, et as planFieldEventCalls, f as FieldStorageEffect, ft as temporalCodecPresetWithPrecision, g as MigrationPlan, gt as unmatchedTableRename, h as MigrationOperationPolicy, ht as unmatchedColumnRename, i as ColumnOnOneSide, it as plannerSuccess, j as SqlPslBuildContext, k as SqlControlTargetDescriptor, l as DefaultRenderer, lt as sqlTypeLookupsOf, m as MigrationOperationClass, mt as unknownCallNames, n as CallSubjects, nt as planStatements, o as ColumnRenameRequest, ot as resolveTableRenameAgainst, p as INIT_ADDITIVE_POLICY, pt as temporalStringAuthoringPresets, q as detectTableNameCaseChanges, r as CallWithCompanions, rt as plannerFailure, s as ContractToSchemaIROptions, st as runnerFailure, t as COLUMN_RENAME_UNMATCHED_CODE, tt as planFieldEventOperations, u as DefaultResolver, ut as storageNameOfOperation, v as MigrationPlanner, w as PlanFieldEventOperationsOptions, x as ModelStorageEffect, y as MigrationPlannerConflict, z as TargetMigrationsCapability } from "./control-BkyDhucB.mjs";
 import "./control-adapter-CD_gz6TI.mjs";
-import { a as VerifySqlSchemaByDiffInput, c as computeSqlDiffVerdict, i as StorageTypeVerdictInput, l as computeStorageTypeVerdict, n as SqlDiffVerdictInput, o as classifyDiffSubjectGranularity, r as StorageTypeVerdict, s as classifySqlDiffIssue, t as SqlDiffVerdict, u as verifySqlSchemaByDiff } from "./diff-3tfqwWS7.mjs";
+import { a as VerifySqlSchemaByDiffInput, c as computeSqlDiffVerdict, i as StorageTypeVerdictInput, l as computeStorageTypeVerdict, n as SqlDiffVerdictInput, o as classifyDiffSubjectGranularity, r as StorageTypeVerdict, s as classifySqlDiffIssue, t as SqlDiffVerdict, u as verifySqlSchemaByDiff } from "./diff-DMOqiT2h.mjs";
 import { i as SqlSchemaVerifierBase, n as SqlContractSerializerBase, r as SqlEntityHydrationFactory, t as SqlContractSerializer } from "./ir-BYHqe2mj.mjs";
-import { t as SqlMigration } from "./migration-D6NJlA6-.mjs";
+import { t as SqlMigration } from "./migration-C5HGygKM.mjs";
 import "./pack-l0vLQrO8.mjs";
 import { a as PslTypeResolution, i as PslTypeReference, n as DefaultMappingResult, o as mapDefault, r as PslTypeMap, t as DefaultMappingOptions } from "./type-map-3w0ieDAb-DiMpKEc2.mjs";
 import { t as toEnumMemberName } from "./psl-build-C_n5uPZH.mjs";
 import { a as buildChildRelationField, c as inferRelations, d as toFieldName, f as toModelName, i as RelationField, l as pluralize, n as InferredRelations, o as deriveBackRelationFieldName, r as PslPrinterOptions, s as deriveRelationFieldName, t as EnumInfo, u as toEnumName } from "./psl-infer-Cm7eDSA-.mjs";
 import { a as timestampNowRuntimeGenerator, n as UNBOUND_DOMAIN_NAMESPACE_ID, r as resolveDomainModel, t as ResolvedDomainModel } from "./runtime-BUemUdMk.mjs";
 import { n as parseContractMarkerRow, t as ContractMarkerRow } from "./verify-zDRnw0Rn.mjs";
-export { type AppliedTableRename, type ApplyTableRenameInput, type CodecControlHooks, type ContractMarkerRow, type ContractToSchemaIROptions, type ControlPolicySubject, type CreateSqlMigrationPlanOptions, type DefaultMappingOptions, type DefaultMappingResult, type DefaultRenderer, type DefaultResolver, type EnumInfo, type ExecuteRequestLowerer, type FieldEvent, type FieldEventContext, INIT_ADDITIVE_POLICY, type InferredRelations, type Lowerer, SqlMigration as Migration, type MigrationOperationClass, type MigrationOperationPolicy, type MigrationPlan, type MigrationPlanOperation, type MigrationPlanner, type MigrationPlannerConflict, type MigrationPlannerResult, type PlanFieldEventOperationsOptions, type PslPrinterOptions, type PslTypeMap, type PslTypeReference, type PslTypeResolution, type RelationField, type RenameTableReferences, type ResolveIdentityValueInput, type ResolvedDomainModel, type ResolvedStorageTable, type ResolvedTableRename, SqlContractSerializer, SqlContractSerializerBase, type SqlControlAdapter, type SqlControlExtensionDescriptor, type SqlControlFamilyInstance, type SqlControlTargetDescriptor, type SqlDescribedContractSpace, type SqlDiffVerdict, type SqlDiffVerdictInput, type SqlEntityHydrationFactory, type SqlMigrationPlan, type SqlMigrationPlanContractInfo, type SqlMigrationPlanOperation, type SqlMigrationPlanOperationStep, type SqlMigrationPlanOperationTarget, type SqlMigrationPlanner, type SqlMigrationPlannerPlanOptions, type SqlMigrationRunner, type SqlMigrationRunnerErrorCode, type SqlMigrationRunnerExecuteCallbacks, type SqlMigrationRunnerExecuteOptions, type SqlMigrationRunnerFailure, type SqlMigrationRunnerResult, type SqlMigrationRunnerSuccessValue, type SqlPlanTargetDetails, type SqlPlannerConflict, type SqlPlannerConflictKind, type SqlPlannerConflictLocation, type SqlPlannerFailureResult, type SqlPlannerResult, type SqlPlannerSuccessResult, type SqlPslBuildContext, type SqlSchemaDiffFn, type SqlSchemaDiffInput, type SqlSchemaDiffResult, SqlSchemaVerifierBase, type StorageTypePlanResult, type StorageTypeVerdict, type StorageTypeVerdictInput, type SuppressionRecord, TABLE_NAME_CASE_CHANGED_CODE, type TableNameCaseGuardTable, type TableRename, type TableRenameByHand, type TableRenameInMigration, type TargetMigrationsCapability, UNBOUND_DOMAIN_NAMESPACE_ID, type VerifySqlSchemaByDiffInput, applyTableRename, arraysEqual, assembleAuthoringContributions, buildChildRelationField, checkSqlDefaultText, classifyDiffSubjectGranularity, classifySqlDiffIssue, computeSqlDiffVerdict, computeStorageTypeVerdict, contractNamespaceToSchemaIR, contractToSchemaIR, controlPolicyForCall, createMigrationPlan, deriveBackRelationFieldName, deriveRelationFieldName, detectDestructiveChanges, detectTableNameCaseChanges, extractCodecControlHooks, inferRelations, mapDefault, parseContractMarkerRow, partitionCallsByControlPolicy, partitionIssuesByControlPolicy, planFieldEventOperations, plannerFailure, plannerSuccess, pluralize, resolveDomainModel, resolveStorageTable, runnerFailure, runnerSuccess, sqlTypeLookupsOf, temporalCodecPresetWithPrecision, temporalStringAuthoringPresets, timestampNowRuntimeGenerator, toEnumMemberName, toEnumName, toFieldName, toModelName, verifySqlSchemaByDiff };
+export { COLUMN_RENAME_UNMATCHED_CODE, type CallSubjects, type CallWithCompanions, type CodecControlHooks, type ColumnOnOneSide, type ColumnRename, type ColumnRenameRequest, type ContractMarkerRow, type ContractToSchemaIROptions, type ControlPolicySubject, type CreateSqlMigrationPlanOptions, type DefaultMappingOptions, type DefaultMappingResult, type DefaultRenderer, type DefaultResolver, type EnumInfo, type ExecuteRequestLowerer, type FieldEvent, type FieldEventCall, type FieldEventContext, type FieldStorageEffect, INIT_ADDITIVE_POLICY, type InferredRelations, type Lowerer, SqlMigration as Migration, type MigrationOperationClass, type MigrationOperationPolicy, type MigrationPlan, type MigrationPlanOperation, type MigrationPlanner, type MigrationPlannerConflict, type MigrationPlannerResult, type ModelStorageEffect, type ModelTable, type NoTable, type PlanFieldEventOperationsOptions, type PlannedStatements, type PslPrinterOptions, type PslTypeMap, type PslTypeReference, type PslTypeResolution, type RelationField, type ResolveIdentityValueInput, type ResolvedDomainModel, type ResolvedStorageTable, type SchemaTables, type SingleOperationCall, SqlContractSerializer, SqlContractSerializerBase, type SqlControlAdapter, type SqlControlExtensionDescriptor, type SqlControlFamilyInstance, type SqlControlTargetDescriptor, type SqlDescribedContractSpace, type SqlDiffVerdict, type SqlDiffVerdictInput, type SqlEntityHydrationFactory, type SqlMigrationPlan, type SqlMigrationPlanContractInfo, type SqlMigrationPlanOperation, type SqlMigrationPlanOperationStep, type SqlMigrationPlanOperationTarget, type SqlMigrationPlanner, type SqlMigrationPlannerPlanOptions, type SqlMigrationRunner, type SqlMigrationRunnerErrorCode, type SqlMigrationRunnerExecuteCallbacks, type SqlMigrationRunnerExecuteOptions, type SqlMigrationRunnerFailure, type SqlMigrationRunnerResult, type SqlMigrationRunnerSuccessValue, type SqlPlanTargetDetails, type SqlPlannerConflict, type SqlPlannerConflictKind, type SqlPlannerConflictLocation, type SqlPlannerFailureResult, type SqlPlannerResult, type SqlPlannerSuccessResult, type SqlPslBuildContext, type SqlSchemaDiffFn, type SqlSchemaDiffInput, type SqlSchemaDiffResult, SqlSchemaVerifierBase, type StatementPlanningTarget, type StorageTypePlanResult, type StorageTypeVerdict, type StorageTypeVerdictInput, type SubjectStorage, type SuppressionRecord, TABLE_NAME_CASE_CHANGED_CODE, type TableNameCaseGuardTable, type TableRename, type TableRenameRequest, type TargetMigrationsCapability, UNBOUND_DOMAIN_NAMESPACE_ID, type VerifySqlSchemaByDiffInput, arraysEqual, assembleAuthoringContributions, buildChildRelationField, checkSqlDefaultText, classifyDiffSubjectGranularity, classifySqlDiffIssue, computeSqlDiffVerdict, computeStorageTypeVerdict, contractNamespaceToSchemaIR, contractToSchemaIR, controlPolicyForCall, createMigrationPlan, deriveBackRelationFieldName, deriveRelationFieldName, detectDestructiveChanges, detectTableNameCaseChanges, extractCodecControlHooks, fieldEventStorage, fieldRenameStorageEffect, inferRelations, mapDefault, modelRenameStorageEffect, parseContractMarkerRow, partitionCallsByControlPolicy, partitionIssuesByControlPolicy, planFieldEventCalls, planFieldEventOperations, planStatements, plannerFailure, plannerSuccess, pluralize, resolveColumnRenameAgainst, resolveDomainModel, resolveStorageTable, resolveTableRenameAgainst, runnerFailure, runnerSuccess, sqlTypeLookupsOf, storageNameOfOperation, subjectsOfCalls, temporalCodecPresetWithPrecision, temporalStringAuthoringPresets, timestampNowRuntimeGenerator, toEnumMemberName, toEnumName, toFieldName, toModelName, unknownCallNames, unmatchedColumnRename, unmatchedTableRename, verifySqlSchemaByDiff };

package/dist/family.mjs

@@ -3,12 +3,12 @@ import { n as checkSqlDefaultText } from "./validators-Xx-TKcx3.mjs";
 import { a as computeStorageTypeVerdict, c as verifySqlSchemaByDiff, i as computeSqlDiffVerdict, n as classifyDiffSubjectGranularity, r as classifySqlDiffIssue, s as extractCodecControlHooks } from "./schema-verify-DIfHSB4I-CjYnmUuD.mjs";
 import { n as SqlContractSerializerBase, t as SqlContractSerializer } from "./sql-contract-serializer-DDaAVCQr-CLDkZLXO.mjs";
 import { n as parseContractMarkerRow } from "./verify-BVk5bjdH-dq5M4iIh.mjs";
-import { _ as runnerFailure, a as contractNamespaceToSchemaIR, b as temporalCodecPresetWithPrecision, d as detectTableNameCaseChanges, f as partitionCallsByControlPolicy, g as plannerSuccess, h as plannerFailure, i as assembleAuthoringContributions, l as createMigrationPlan, m as planFieldEventOperations, n as TABLE_NAME_CASE_CHANGED_CODE, o as contractToSchemaIR, p as partitionIssuesByControlPolicy, r as applyTableRename, s as controlPolicyForCall, t as INIT_ADDITIVE_POLICY, u as detectDestructiveChanges, v as runnerSuccess, x as temporalStringAuthoringPresets, y as sqlTypeLookupsOf } from "./control-DxvOSmwF.mjs";
+import { A as temporalStringAuthoringPresets, C as resolveTableRenameAgainst, D as storageNameOfOperation, E as sqlTypeLookupsOf, M as unmatchedColumnRename, N as unmatchedTableRename, O as subjectsOfCalls, S as resolveColumnRenameAgainst, T as runnerSuccess, _ as planFieldEventCalls, a as contractNamespaceToSchemaIR, b as plannerFailure, d as detectTableNameCaseChanges, f as fieldEventStorage, g as partitionIssuesByControlPolicy, h as partitionCallsByControlPolicy, i as assembleAuthoringContributions, j as unknownCallNames, k as temporalCodecPresetWithPrecision, l as createMigrationPlan, m as modelRenameStorageEffect, n as INIT_ADDITIVE_POLICY, o as contractToSchemaIR, p as fieldRenameStorageEffect, r as TABLE_NAME_CASE_CHANGED_CODE, s as controlPolicyForCall, t as COLUMN_RENAME_UNMATCHED_CODE, u as detectDestructiveChanges, v as planFieldEventOperations, w as runnerFailure, x as plannerSuccess, y as planStatements } from "./control-BRbds4vn.mjs";
 import { t as arraysEqual } from "./diff-B16bL_IR.mjs";
 import { t as SqlSchemaVerifierBase } from "./ir-I-xciGUH.mjs";
-import { t as SqlMigration } from "./migration-CK4oePIo.mjs";
+import { t as SqlMigration } from "./migration-Dy_4Wmiy.mjs";
 import { s as toEnumMemberName } from "./psl-names-C3cwe0rg-CsuHOV7E.mjs";
 import { t as mapDefault } from "./psl-build-Di-cBOCv.mjs";
 import { a as pluralize, c as toModelName, i as inferRelations, n as deriveBackRelationFieldName, o as toEnumName, r as deriveRelationFieldName, s as toFieldName, t as buildChildRelationField } from "./psl-infer-fU7LRjTx.mjs";
 import { i as timestampNowRuntimeGenerator, n as resolveDomainModel, t as UNBOUND_DOMAIN_NAMESPACE_ID } from "./runtime-Z3nD7ix1.mjs";
-export { INIT_ADDITIVE_POLICY, SqlMigration as Migration, SqlContractSerializer, SqlContractSerializerBase, SqlSchemaVerifierBase, TABLE_NAME_CASE_CHANGED_CODE, UNBOUND_DOMAIN_NAMESPACE_ID, applyTableRename, arraysEqual, assembleAuthoringContributions, buildChildRelationField, checkSqlDefaultText, classifyDiffSubjectGranularity, classifySqlDiffIssue, computeSqlDiffVerdict, computeStorageTypeVerdict, contractNamespaceToSchemaIR, contractToSchemaIR, controlPolicyForCall, createMigrationPlan, deriveBackRelationFieldName, deriveRelationFieldName, detectDestructiveChanges, detectTableNameCaseChanges, extractCodecControlHooks, inferRelations, mapDefault, parseContractMarkerRow, partitionCallsByControlPolicy, partitionIssuesByControlPolicy, planFieldEventOperations, plannerFailure, plannerSuccess, pluralize, resolveDomainModel, resolveStorageTable, runnerFailure, runnerSuccess, sqlTypeLookupsOf, temporalCodecPresetWithPrecision, temporalStringAuthoringPresets, timestampNowRuntimeGenerator, toEnumMemberName, toEnumName, toFieldName, toModelName, verifySqlSchemaByDiff };
+export { COLUMN_RENAME_UNMATCHED_CODE, INIT_ADDITIVE_POLICY, SqlMigration as Migration, SqlContractSerializer, SqlContractSerializerBase, SqlSchemaVerifierBase, TABLE_NAME_CASE_CHANGED_CODE, UNBOUND_DOMAIN_NAMESPACE_ID, arraysEqual, assembleAuthoringContributions, buildChildRelationField, checkSqlDefaultText, classifyDiffSubjectGranularity, classifySqlDiffIssue, computeSqlDiffVerdict, computeStorageTypeVerdict, contractNamespaceToSchemaIR, contractToSchemaIR, controlPolicyForCall, createMigrationPlan, deriveBackRelationFieldName, deriveRelationFieldName, detectDestructiveChanges, detectTableNameCaseChanges, extractCodecControlHooks, fieldEventStorage, fieldRenameStorageEffect, inferRelations, mapDefault, modelRenameStorageEffect, parseContractMarkerRow, partitionCallsByControlPolicy, partitionIssuesByControlPolicy, planFieldEventCalls, planFieldEventOperations, planStatements, plannerFailure, plannerSuccess, pluralize, resolveColumnRenameAgainst, resolveDomainModel, resolveStorageTable, resolveTableRenameAgainst, runnerFailure, runnerSuccess, sqlTypeLookupsOf, storageNameOfOperation, subjectsOfCalls, temporalCodecPresetWithPrecision, temporalStringAuthoringPresets, timestampNowRuntimeGenerator, toEnumMemberName, toEnumName, toFieldName, toModelName, unknownCallNames, unmatchedColumnRename, unmatchedTableRename, verifySqlSchemaByDiff };

package/dist/family__control.d.mts

@@ -1,5 +1,5 @@
 import { h as checkSqlDefaultText } from "./validators-BAa0JKuB.mjs";
-import { A as StorageTypePlanResult, C as SqlPlanTargetDetails, D as SqlPlannerFailureResult, E as SqlPlannerConflictLocation, O as SqlPlannerResult, S as SqlMigrationRunnerSuccessValue, T as SqlPlannerConflictKind, _ as SqlMigrationRunnerErrorCode, a as FieldEventContext, b as SqlMigrationRunnerFailure, c as SqlControlExtensionDescriptor, d as SqlMigrationPlanOperation, f as SqlMigrationPlanOperationStep, g as SqlMigrationRunner, h as SqlMigrationPlannerPlanOptions, i as FieldEvent, k as SqlPlannerSuccessResult, l as SqlMigrationPlan, m as SqlMigrationPlanner, n as CodecControlHooks, o as ResolveIdentityValueInput, p as SqlMigrationPlanOperationTarget, r as CreateSqlMigrationPlanOptions, s as SqlControlAdapterDescriptor, u as SqlMigrationPlanContractInfo, v as SqlMigrationRunnerExecuteCallbacks, w as SqlPlannerConflict, x as SqlMigrationRunnerResult, y as SqlMigrationRunnerExecuteOptions } from "./types-CvuS68sy-ReNXbgpE.mjs";
+import { A as StorageTypePlanResult, C as SqlPlanTargetDetails, D as SqlPlannerFailureResult, E as SqlPlannerConflictLocation, O as SqlPlannerResult, S as SqlMigrationRunnerSuccessValue, T as SqlPlannerConflictKind, _ as SqlMigrationRunnerErrorCode, a as FieldEventContext, b as SqlMigrationRunnerFailure, c as SqlControlExtensionDescriptor, d as SqlMigrationPlanOperation, f as SqlMigrationPlanOperationStep, g as SqlMigrationRunner, h as SqlMigrationPlannerPlanOptions, i as FieldEvent, k as SqlPlannerSuccessResult, l as SqlMigrationPlan, m as SqlMigrationPlanner, n as CodecControlHooks, o as ResolveIdentityValueInput, p as SqlMigrationPlanOperationTarget, r as CreateSqlMigrationPlanOptions, s as SqlControlAdapterDescriptor, u as SqlMigrationPlanContractInfo, v as SqlMigrationRunnerExecuteCallbacks, w as SqlPlannerConflict, x as SqlMigrationRunnerResult, y as SqlMigrationRunnerExecuteOptions } from "./types-CzxOObSY-CNWyrf87.mjs";
 import { n as SqlSchemaDiffInput, r as SqlSchemaDiffResult, t as SqlSchemaDiffFn } from "./schema-differ-CqWOkoW9--uxNOini.mjs";
-import { A as applyTableRename, B as partitionIssuesByControlPolicy, C as TABLE_NAME_CASE_CHANGED_CODE, D as TableRenameInMigration, E as TableRenameByHand, F as createMigrationPlan, G as runnerSuccess, H as plannerFailure, I as detectDestructiveChanges, J as temporalStringAuthoringPresets, K as sqlTypeLookupsOf, L as detectTableNameCaseChanges, M as contractNamespaceToSchemaIR, N as contractToSchemaIR, O as TargetMigrationsCapability, P as controlPolicyForCall, R as extractCodecControlHooks, S as SuppressionRecord, T as TableRename, U as plannerSuccess, V as planFieldEventOperations, W as runnerFailure, _ as ResolvedTableRename, a as DefaultRenderer, b as SqlDescribedContractSpace, c as MigrationOperationClass, d as MigrationPlanOperation, f as MigrationPlanner, g as RenameTableReferences, h as PlanFieldEventOperationsOptions, i as ControlPolicySubject, j as assembleAuthoringContributions, k as _default, l as MigrationOperationPolicy, m as MigrationPlannerResult, n as ApplyTableRenameInput, o as DefaultResolver, p as MigrationPlannerConflict, q as temporalCodecPresetWithPrecision, r as ContractToSchemaIROptions, s as INIT_ADDITIVE_POLICY, t as AppliedTableRename, u as MigrationPlan, v as SqlControlFamilyInstance, w as TableNameCaseGuardTable, x as SqlPslBuildContext, y as SqlControlTargetDescriptor, z as partitionCallsByControlPolicy } from "./control-DCt08EpW.mjs";
-export { type AppliedTableRename, type ApplyTableRenameInput, type CodecControlHooks, type ContractToSchemaIROptions, type ControlPolicySubject, type CreateSqlMigrationPlanOptions, type DefaultRenderer, type DefaultResolver, type FieldEvent, type FieldEventContext, INIT_ADDITIVE_POLICY, type MigrationOperationClass, type MigrationOperationPolicy, type MigrationPlan, type MigrationPlanOperation, type MigrationPlanner, type MigrationPlannerConflict, type MigrationPlannerResult, type PlanFieldEventOperationsOptions, type RenameTableReferences, type ResolveIdentityValueInput, type ResolvedTableRename, type SqlControlAdapterDescriptor, type SqlControlExtensionDescriptor, type SqlControlFamilyInstance, type SqlControlTargetDescriptor, type SqlDescribedContractSpace, type SqlMigrationPlan, type SqlMigrationPlanContractInfo, type SqlMigrationPlanOperation, type SqlMigrationPlanOperationStep, type SqlMigrationPlanOperationTarget, type SqlMigrationPlanner, type SqlMigrationPlannerPlanOptions, type SqlMigrationRunner, type SqlMigrationRunnerErrorCode, type SqlMigrationRunnerExecuteCallbacks, type SqlMigrationRunnerExecuteOptions, type SqlMigrationRunnerFailure, type SqlMigrationRunnerResult, type SqlMigrationRunnerSuccessValue, type SqlPlanTargetDetails, type SqlPlannerConflict, type SqlPlannerConflictKind, type SqlPlannerConflictLocation, type SqlPlannerFailureResult, type SqlPlannerResult, type SqlPlannerSuccessResult, type SqlPslBuildContext, type SqlSchemaDiffFn, type SqlSchemaDiffInput, type SqlSchemaDiffResult, type StorageTypePlanResult, type SuppressionRecord, TABLE_NAME_CASE_CHANGED_CODE, type TableNameCaseGuardTable, type TableRename, type TableRenameByHand, type TableRenameInMigration, type TargetMigrationsCapability, applyTableRename, assembleAuthoringContributions, checkSqlDefaultText, contractNamespaceToSchemaIR, contractToSchemaIR, controlPolicyForCall, createMigrationPlan, _default as default, detectDestructiveChanges, detectTableNameCaseChanges, extractCodecControlHooks, partitionCallsByControlPolicy, partitionIssuesByControlPolicy, planFieldEventOperations, plannerFailure, plannerSuccess, runnerFailure, runnerSuccess, sqlTypeLookupsOf, temporalCodecPresetWithPrecision, temporalStringAuthoringPresets };
+import { $ as partitionIssuesByControlPolicy, A as SqlDescribedContractSpace, B as _default, C as NoTable, D as SingleOperationCall, E as SchemaTables, F as TABLE_NAME_CASE_CHANGED_CODE, G as createMigrationPlan, H as contractNamespaceToSchemaIR, I as TableNameCaseGuardTable, J as extractCodecControlHooks, K as detectDestructiveChanges, L as TableRename, M as StatementPlanningTarget, N as SubjectStorage, O as SqlControlFamilyInstance, P as SuppressionRecord, Q as partitionCallsByControlPolicy, R as TableRenameRequest, S as ModelTable, T as PlannedStatements, U as contractToSchemaIR, V as assembleAuthoringContributions, W as controlPolicyForCall, X as fieldRenameStorageEffect, Y as fieldEventStorage, Z as modelRenameStorageEffect, _ as MigrationPlanOperation, a as ColumnRename, at as resolveColumnRenameAgainst, b as MigrationPlannerResult, c as ControlPolicySubject, ct as runnerSuccess, d as FieldEventCall, dt as subjectsOfCalls, et as planFieldEventCalls, f as FieldStorageEffect, ft as temporalCodecPresetWithPrecision, g as MigrationPlan, gt as unmatchedTableRename, h as MigrationOperationPolicy, ht as unmatchedColumnRename, i as ColumnOnOneSide, it as plannerSuccess, j as SqlPslBuildContext, k as SqlControlTargetDescriptor, l as DefaultRenderer, lt as sqlTypeLookupsOf, m as MigrationOperationClass, mt as unknownCallNames, n as CallSubjects, nt as planStatements, o as ColumnRenameRequest, ot as resolveTableRenameAgainst, p as INIT_ADDITIVE_POLICY, pt as temporalStringAuthoringPresets, q as detectTableNameCaseChanges, r as CallWithCompanions, rt as plannerFailure, s as ContractToSchemaIROptions, st as runnerFailure, t as COLUMN_RENAME_UNMATCHED_CODE, tt as planFieldEventOperations, u as DefaultResolver, ut as storageNameOfOperation, v as MigrationPlanner, w as PlanFieldEventOperationsOptions, x as ModelStorageEffect, y as MigrationPlannerConflict, z as TargetMigrationsCapability } from "./control-BkyDhucB.mjs";
+export { COLUMN_RENAME_UNMATCHED_CODE, type CallSubjects, type CallWithCompanions, type CodecControlHooks, type ColumnOnOneSide, type ColumnRename, type ColumnRenameRequest, type ContractToSchemaIROptions, type ControlPolicySubject, type CreateSqlMigrationPlanOptions, type DefaultRenderer, type DefaultResolver, type FieldEvent, type FieldEventCall, type FieldEventContext, type FieldStorageEffect, INIT_ADDITIVE_POLICY, type MigrationOperationClass, type MigrationOperationPolicy, type MigrationPlan, type MigrationPlanOperation, type MigrationPlanner, type MigrationPlannerConflict, type MigrationPlannerResult, type ModelStorageEffect, type ModelTable, type NoTable, type PlanFieldEventOperationsOptions, type PlannedStatements, type ResolveIdentityValueInput, type SchemaTables, type SingleOperationCall, type SqlControlAdapterDescriptor, type SqlControlExtensionDescriptor, type SqlControlFamilyInstance, type SqlControlTargetDescriptor, type SqlDescribedContractSpace, type SqlMigrationPlan, type SqlMigrationPlanContractInfo, type SqlMigrationPlanOperation, type SqlMigrationPlanOperationStep, type SqlMigrationPlanOperationTarget, type SqlMigrationPlanner, type SqlMigrationPlannerPlanOptions, type SqlMigrationRunner, type SqlMigrationRunnerErrorCode, type SqlMigrationRunnerExecuteCallbacks, type SqlMigrationRunnerExecuteOptions, type SqlMigrationRunnerFailure, type SqlMigrationRunnerResult, type SqlMigrationRunnerSuccessValue, type SqlPlanTargetDetails, type SqlPlannerConflict, type SqlPlannerConflictKind, type SqlPlannerConflictLocation, type SqlPlannerFailureResult, type SqlPlannerResult, type SqlPlannerSuccessResult, type SqlPslBuildContext, type SqlSchemaDiffFn, type SqlSchemaDiffInput, type SqlSchemaDiffResult, type StatementPlanningTarget, type StorageTypePlanResult, type SubjectStorage, type SuppressionRecord, TABLE_NAME_CASE_CHANGED_CODE, type TableNameCaseGuardTable, type TableRename, type TableRenameRequest, type TargetMigrationsCapability, assembleAuthoringContributions, checkSqlDefaultText, contractNamespaceToSchemaIR, contractToSchemaIR, controlPolicyForCall, createMigrationPlan, _default as default, detectDestructiveChanges, detectTableNameCaseChanges, extractCodecControlHooks, fieldEventStorage, fieldRenameStorageEffect, modelRenameStorageEffect, partitionCallsByControlPolicy, partitionIssuesByControlPolicy, planFieldEventCalls, planFieldEventOperations, planStatements, plannerFailure, plannerSuccess, resolveColumnRenameAgainst, resolveTableRenameAgainst, runnerFailure, runnerSuccess, sqlTypeLookupsOf, storageNameOfOperation, subjectsOfCalls, temporalCodecPresetWithPrecision, temporalStringAuthoringPresets, unknownCallNames, unmatchedColumnRename, unmatchedTableRename };

package/dist/family__control.mjs

@@ -1,4 +1,4 @@
 import { n as checkSqlDefaultText } from "./validators-Xx-TKcx3.mjs";
 import { s as extractCodecControlHooks } from "./schema-verify-DIfHSB4I-CjYnmUuD.mjs";
-import { _ as runnerFailure, a as contractNamespaceToSchemaIR, b as temporalCodecPresetWithPrecision, c as control_default, d as detectTableNameCaseChanges, f as partitionCallsByControlPolicy, g as plannerSuccess, h as plannerFailure, i as assembleAuthoringContributions, l as createMigrationPlan, m as planFieldEventOperations, n as TABLE_NAME_CASE_CHANGED_CODE, o as contractToSchemaIR, p as partitionIssuesByControlPolicy, r as applyTableRename, s as controlPolicyForCall, t as INIT_ADDITIVE_POLICY, u as detectDestructiveChanges, v as runnerSuccess, x as temporalStringAuthoringPresets, y as sqlTypeLookupsOf } from "./control-DxvOSmwF.mjs";
-export { INIT_ADDITIVE_POLICY, TABLE_NAME_CASE_CHANGED_CODE, applyTableRename, assembleAuthoringContributions, checkSqlDefaultText, contractNamespaceToSchemaIR, contractToSchemaIR, controlPolicyForCall, createMigrationPlan, control_default as default, detectDestructiveChanges, detectTableNameCaseChanges, extractCodecControlHooks, partitionCallsByControlPolicy, partitionIssuesByControlPolicy, planFieldEventOperations, plannerFailure, plannerSuccess, runnerFailure, runnerSuccess, sqlTypeLookupsOf, temporalCodecPresetWithPrecision, temporalStringAuthoringPresets };
+import { A as temporalStringAuthoringPresets, C as resolveTableRenameAgainst, D as storageNameOfOperation, E as sqlTypeLookupsOf, M as unmatchedColumnRename, N as unmatchedTableRename, O as subjectsOfCalls, S as resolveColumnRenameAgainst, T as runnerSuccess, _ as planFieldEventCalls, a as contractNamespaceToSchemaIR, b as plannerFailure, c as control_default, d as detectTableNameCaseChanges, f as fieldEventStorage, g as partitionIssuesByControlPolicy, h as partitionCallsByControlPolicy, i as assembleAuthoringContributions, j as unknownCallNames, k as temporalCodecPresetWithPrecision, l as createMigrationPlan, m as modelRenameStorageEffect, n as INIT_ADDITIVE_POLICY, o as contractToSchemaIR, p as fieldRenameStorageEffect, r as TABLE_NAME_CASE_CHANGED_CODE, s as controlPolicyForCall, t as COLUMN_RENAME_UNMATCHED_CODE, u as detectDestructiveChanges, v as planFieldEventOperations, w as runnerFailure, x as plannerSuccess, y as planStatements } from "./control-BRbds4vn.mjs";
+export { COLUMN_RENAME_UNMATCHED_CODE, INIT_ADDITIVE_POLICY, TABLE_NAME_CASE_CHANGED_CODE, assembleAuthoringContributions, checkSqlDefaultText, contractNamespaceToSchemaIR, contractToSchemaIR, controlPolicyForCall, createMigrationPlan, control_default as default, detectDestructiveChanges, detectTableNameCaseChanges, extractCodecControlHooks, fieldEventStorage, fieldRenameStorageEffect, modelRenameStorageEffect, partitionCallsByControlPolicy, partitionIssuesByControlPolicy, planFieldEventCalls, planFieldEventOperations, planStatements, plannerFailure, plannerSuccess, resolveColumnRenameAgainst, resolveTableRenameAgainst, runnerFailure, runnerSuccess, sqlTypeLookupsOf, storageNameOfOperation, subjectsOfCalls, temporalCodecPresetWithPrecision, temporalStringAuthoringPresets, unknownCallNames, unmatchedColumnRename, unmatchedTableRename };

package/dist/family__diff.d.mts

@@ -1,3 +1,3 @@
 import { a as arraysEqual } from "./control-adapter-CkFfBVei-Ba9JNrCN.mjs";
-import { a as VerifySqlSchemaByDiffInput, c as computeSqlDiffVerdict, i as StorageTypeVerdictInput, l as computeStorageTypeVerdict, n as SqlDiffVerdictInput, o as classifyDiffSubjectGranularity, r as StorageTypeVerdict, s as classifySqlDiffIssue, t as SqlDiffVerdict, u as verifySqlSchemaByDiff } from "./diff-3tfqwWS7.mjs";
+import { a as VerifySqlSchemaByDiffInput, c as computeSqlDiffVerdict, i as StorageTypeVerdictInput, l as computeStorageTypeVerdict, n as SqlDiffVerdictInput, o as classifyDiffSubjectGranularity, r as StorageTypeVerdict, s as classifySqlDiffIssue, t as SqlDiffVerdict, u as verifySqlSchemaByDiff } from "./diff-DMOqiT2h.mjs";
 export { type SqlDiffVerdict, type SqlDiffVerdictInput, type StorageTypeVerdict, type StorageTypeVerdictInput, type VerifySqlSchemaByDiffInput, arraysEqual, classifyDiffSubjectGranularity, classifySqlDiffIssue, computeSqlDiffVerdict, computeStorageTypeVerdict, verifySqlSchemaByDiff };

package/dist/family__migration.d.mts

@@ -1,2 +1,2 @@
-import { t as SqlMigration } from "./migration-D6NJlA6-.mjs";
+import { t as SqlMigration } from "./migration-C5HGygKM.mjs";
 export { SqlMigration as Migration };

package/dist/family__migration.mjs

@@ -1,2 +1,2 @@
-import { t as SqlMigration } from "./migration-CK4oePIo.mjs";
+import { t as SqlMigration } from "./migration-Dy_4Wmiy.mjs";
 export { SqlMigration as Migration };

package/dist/{migration-D6NJlA6-.d.mts → migration-C5HGygKM.d.mts}

@@ -1,6 +1,6 @@
 import { l as SqlStorage } from "./sql-storage-DSnnRQAf-DaHPnley.mjs";
 import "./types-DkOYK86-.mjs";
-import { C as SqlPlanTargetDetails, d as SqlMigrationPlanOperation } from "./types-CvuS68sy-ReNXbgpE.mjs";
+import { C as SqlPlanTargetDetails, d as SqlMigrationPlanOperation } from "./types-CzxOObSY-CNWyrf87.mjs";
 import { Contract } from "@prisma/orm-framework/contract/types";
 import { Migration } from "@prisma/orm-toolchain/migration-tools/migration";
 //#region ../../../2-sql/9-family/dist/migration.d.mts
@@ -29,7 +29,7 @@ import { Migration } from "@prisma/orm-toolchain/migration-tools/migration";
 declare abstract class SqlMigration<TDetails extends SqlPlanTargetDetails, TTargetId extends string = string, Start extends Contract<SqlStorage> = Contract<SqlStorage>, End extends Contract<SqlStorage> = Contract<SqlStorage>> extends Migration<SqlMigrationPlanOperation<TDetails>, 'sql', TTargetId, Start, End> {
   /**
    * Sorted, deduplicated invariant ids declared by this migration's
-   * data-transform ops. Derived from `this.operations` so the field remains
+   * data-transform ops. Derived from a fresh read of the operations (`Migration.readOperations`) so the field remains
    * consistent with the operation list — planner-built plans (`db init`,
    * `db update`) yield `[]` because they emit no data-transform ops.
    *
@@ -41,4 +41,4 @@ declare abstract class SqlMigration<TDetails extends SqlPlanTargetDetails, TTarg
 }
 //#endregion
 export { SqlMigration as t };
-//# sourceMappingURL=migration-D6NJlA6-.d.mts.map
+//# sourceMappingURL=migration-C5HGygKM.d.mts.map

package/dist/{migration-D6NJlA6-.d.mts.map → migration-C5HGygKM.d.mts.map}

@@ -1 +1 @@
-{"version":3,"file":"migration-D6NJlA6-.d.mts","names":[],"sources":["../../../../2-sql/9-family/dist/migration.d.mts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;uBA0BuB,aAAa,iBAAiB,sBAAsB,mCAAmC,cAAc,SAAS,cAAc,SAAS,aAAa,YAAY,SAAS,cAAc,SAAS,qBAAqB,UAAU,0BAA0B,kBAAkB,WAAW,OAAO;;;;;;;;;;;MAW5S"}
+{"version":3,"file":"migration-C5HGygKM.d.mts","names":[],"sources":["../../../../2-sql/9-family/dist/migration.d.mts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;uBA0BuB,aAAa,iBAAiB,sBAAsB,mCAAmC,cAAc,SAAS,cAAc,SAAS,aAAa,YAAY,SAAS,cAAc,SAAS,qBAAqB,UAAU,0BAA0B,kBAAkB,WAAW,OAAO;;;;;;;;;;;MAW5S"}