@prisma/orm-family-sql 8.0.0-rc.14-dev.29 → 8.0.0-rc.14-dev.30

package/dist/{control-DL9y6GfG.d.mts → control-Bpk8PtSL.d.mts}

@@ -3,22 +3,23 @@ import { a as SqlNamespaceEntries, c as SqlStorage } from "./sql-storage-jJySr7b
 import { O as SqlControlDriverInstance } from "./types-Bl6ohp1g-CL4_GDuc.mjs";
 import "./types-B11MGgKr.mjs";
 import { r as SqlOperationDescriptors } from "./index-DZbfFGBA.mjs";
-import { h as AnyQueryAst } from "./types-Yui2yFf6-DYiGm9ET.mjs";
+import { h as AnyQueryAst } from "./types-Dskga3R1-BtXuRmbf.mjs";
 import { o as SqlExecuteRequest } from "./driver-types-DYGFEcyv-DPaNalPf.mjs";
-import { s as DdlNode } from "./ddl-types-B48YmQSt-DLCUHORB.mjs";
-import { u as LowererContext } from "./ast-dPjHeaNs.mjs";
-import { t as SQL_EXPRESSION_DATA_TYPE_ID } from "./sql-expression-D_hbJOgM.mjs";
-import "./validators-D1wQns12.mjs";
-import { _ as SqlSchemaIR, y as SqlSchemaIRNode } from "./types-BzpC_V7p-DyBYmK1f.mjs";
-import "./types-DdTdsdMn.mjs";
-import { i as SqlControlAdapter } from "./control-adapter-WoXvPNj4-D64oWh9I.mjs";
-import { t as sqlFamilyEnumSpec } from "./authoring-entity-types-CZ-vdwYS-BfyaoH53.mjs";
-import { A as SqlPlannerSuccessResult, C as SqlMigrationRunnerSuccessValue, O as SqlPlannerFailureResult, T as SqlPlannerConflict, _ as SqlMigrationRunner, h as SqlMigrationPlanner, n as CodecControlHooks, r as CreateSqlMigrationPlanOptions, t as AnyRecord, u as SqlMigrationPlan, v as SqlMigrationRunnerErrorCode, x as SqlMigrationRunnerFailure } from "./types-ByKpjyVh-CtYwWrbL.mjs";
-import { t as SqlSchemaDiffFn } from "./schema-differ-DpG_gnur-CUh9eZM-.mjs";
+import { s as DdlNode } from "./ddl-types-BUqZdoZK-vyWnW2PW.mjs";
+import { s as LowererContext } from "./ast-BUbHXpzG.mjs";
+import { s as SqlTypeLookups } from "./data-type-CpqSDmR_.mjs";
+import { t as SQL_EXPRESSION_DATA_TYPE_ID } from "./sql-expression-DE_MTt3T.mjs";
+import "./validators-B-4g3vwP.mjs";
+import { _ as SqlSchemaIR, y as SqlSchemaIRNode } from "./types-Da1Y_OI7-BPyFwdFU.mjs";
+import "./types-DZA5xxDT.mjs";
+import { r as SqlControlAdapter } from "./control-adapter-BVN98SzR-C-H_T7s-.mjs";
+import { t as sqlFamilyEnumSpec } from "./authoring-entity-types-CZ-vdwYS-C25VGQVB.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-CcGO_LSh-BKHiJvvA.mjs";
+import { t as SqlSchemaDiffFn } from "./schema-differ-DpG_gnur-if2KDxZC.mjs";
 import { StructuredError } from "@prisma/orm-framework/utils/structured-error";
 import { PresetStorageTemplate, TIMESTAMP_NOW_GENERATOR_ID } from "@prisma/orm-framework/components/authoring";
-import { ColumnDefault, Contract, ControlPolicy } from "@prisma/orm-framework/contract/types";
 import { CodecLookupWithDescriptors, DataType, DataTypeLookup } from "@prisma/orm-framework/components/codec";
+import { ColumnDefault, Contract, 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, SignDatabaseResult, TargetMigrationsCapability, VerifyDatabaseResult, VerifyDatabaseSchemaResult, assembleAuthoringContributions } from "@prisma/orm-framework/components/control";
 import { NotOk, Ok, Result } from "@prisma/orm-framework/utils/result";
@@ -26,17 +27,9 @@ import { PslDocumentAst } from "@prisma/orm-framework/components/psl-ast";
 import { EmissionSpi, TypesImportSpec } from "@prisma/orm-framework/components/emission";
 //#region ../../../2-sql/9-family/dist/control.d.mts
 //#region src/core/control-instance.d.ts
-interface SqlTypeMetadata {
-  readonly typeId: string;
-  readonly familyId: 'sql';
-  readonly targetId: string;
-  readonly nativeType?: string;
-}
-type SqlTypeMetadataRegistry = Map<string, SqlTypeMetadata>;
 interface SqlFamilyInstanceState {
   readonly codecTypeImports: ReadonlyArray<TypesImportSpec>;
   readonly extensionIds: ReadonlyArray<string>;
-  readonly typeMetadataRegistry: SqlTypeMetadataRegistry;
 }
 interface SqlControlFamilyInstance extends ControlFamilyInstance<'sql', SqlSchemaIRNode>, SchemaViewCapable<SqlSchemaIRNode>, PslContractInferCapable<SqlSchemaIRNode>, PslContractBuildCapable<Contract<SqlStorage>>, OperationPreviewCapable, SqlFamilyInstanceState {
   /**
@@ -163,7 +156,6 @@ declare class SqlFamilyDescriptor implements ControlFamilyDescriptor<'sql', SqlC
         readonly kind: "fieldPreset";
         readonly output: {
           readonly codecId: "sql/char@1";
-          readonly nativeType: "character";
           readonly typeParams: {
             readonly length: 36;
           };
@@ -173,7 +165,6 @@ declare class SqlFamilyDescriptor implements ControlFamilyDescriptor<'sql', SqlC
         readonly kind: "fieldPreset";
         readonly output: {
           readonly codecId: "sql/char@1";
-          readonly nativeType: "character";
           readonly typeParams: {
             readonly length: 26;
           };
@@ -196,7 +187,6 @@ declare class SqlFamilyDescriptor implements ControlFamilyDescriptor<'sql', SqlC
         }];
         readonly output: {
           readonly codecId: "sql/char@1";
-          readonly nativeType: "character";
           readonly typeParams: {
             readonly length: {
               readonly kind: "arg";
@@ -211,7 +201,6 @@ declare class SqlFamilyDescriptor implements ControlFamilyDescriptor<'sql', SqlC
         readonly kind: "fieldPreset";
         readonly output: {
           readonly codecId: "sql/char@1";
-          readonly nativeType: "character";
           readonly typeParams: {
             readonly length: 24;
           };
@@ -221,7 +210,6 @@ declare class SqlFamilyDescriptor implements ControlFamilyDescriptor<'sql', SqlC
         readonly kind: "fieldPreset";
         readonly output: {
           readonly codecId: "sql/char@1";
-          readonly nativeType: "character";
           readonly typeParams: {
             readonly length: 27;
           };
@@ -232,7 +220,6 @@ declare class SqlFamilyDescriptor implements ControlFamilyDescriptor<'sql', SqlC
           readonly kind: "fieldPreset";
           readonly output: {
             readonly codecId: "sql/char@1";
-            readonly nativeType: "character";
             readonly typeParams: {
               readonly length: 36;
             };
@@ -249,7 +236,6 @@ declare class SqlFamilyDescriptor implements ControlFamilyDescriptor<'sql', SqlC
           readonly kind: "fieldPreset";
           readonly output: {
             readonly codecId: "sql/char@1";
-            readonly nativeType: "character";
             readonly typeParams: {
               readonly length: 36;
             };
@@ -266,7 +252,6 @@ declare class SqlFamilyDescriptor implements ControlFamilyDescriptor<'sql', SqlC
           readonly kind: "fieldPreset";
           readonly output: {
             readonly codecId: "sql/char@1";
-            readonly nativeType: "character";
             readonly typeParams: {
               readonly length: 26;
             };
@@ -296,7 +281,6 @@ declare class SqlFamilyDescriptor implements ControlFamilyDescriptor<'sql', SqlC
           }];
           readonly output: {
             readonly codecId: "sql/char@1";
-            readonly nativeType: "character";
             readonly typeParams: {
               readonly length: {
                 readonly kind: "arg";
@@ -325,7 +309,6 @@ declare class SqlFamilyDescriptor implements ControlFamilyDescriptor<'sql', SqlC
           readonly kind: "fieldPreset";
           readonly output: {
             readonly codecId: "sql/char@1";
-            readonly nativeType: "character";
             readonly typeParams: {
               readonly length: 24;
             };
@@ -342,7 +325,6 @@ declare class SqlFamilyDescriptor implements ControlFamilyDescriptor<'sql', SqlC
           readonly kind: "fieldPreset";
           readonly output: {
             readonly codecId: "sql/char@1";
-            readonly nativeType: "character";
             readonly typeParams: {
               readonly length: 27;
             };
@@ -366,12 +348,9 @@ declare class SqlFamilyDescriptor implements ControlFamilyDescriptor<'sql', SqlC
             readonly kind: "number";
             readonly name: "length";
             readonly integer: true;
-            readonly minimum: 1;
-            readonly maximum: 10485760;
           }];
           readonly output: {
             readonly codecId: "sql/varchar@1";
-            readonly nativeType: "character varying";
             readonly typeParams: {
               readonly length: {
                 readonly kind: "arg";
@@ -605,46 +584,19 @@ interface AppliedTableRename {
  */
 declare function applyTableRename(input: ApplyTableRenameInput): Result<AppliedTableRename, StructuredError>;
 //#endregion
-//#region src/core/migrations/data-type-resolver.d.ts
-/** The data type a codec represents, or `undefined` when no component registers it. */
-type DataTypeResolver = (codecId: string) => DataType | undefined;
-/**
- * Builds the resolver the contract→IR derivation uses to give each column its data type (ADR 254):
- * the codec's descriptor names the type, and the composed components register it. Codecs and
- * data types from extension packs are found the same way as the target's own, and a codec id two
- * components contribute is refused, as everywhere else in the stack. Returns `undefined` when no
- * framework components are supplied, so callers can omit the option.
- */
-declare function buildDataTypeResolver(frameworkComponents?: ReadonlyArray<TargetBoundComponentDescriptor<'sql', string>>): DataTypeResolver | undefined;
-//#endregion
 //#region src/core/migrations/contract-to-schema-ir.d.ts
-/**
- * Target-specific callback that expands a column's base `nativeType` and optional
- * `typeParams` into the fully-qualified type string used by the database
- * (e.g. `character` + `{ length: 36 }` → `character(36)`).
- *
- * This lives in the family layer as a callback rather than importing a concrete
- * implementation because each target (Postgres, MySQL, SQLite, …) has its own
- * parameterization syntax. The target wires its expander when calling
- * `contractToSchemaIR`, keeping the family layer target-agnostic.
- */
-type NativeTypeExpander = (input: {
-  readonly nativeType: string;
-  readonly codecId?: string;
-  readonly typeParams?: Record<string, unknown>;
-}) => string;
 /**
  * Target-specific callback that renders a `ColumnDefault` into the raw SQL literal
  * string stored in `SqlColumnIR.default`.
  *
  * Default value serialization is target-specific (quoting, casting, type syntax vary
- * between Postgres, MySQL, SQLite, …). This callback follows the same IoC pattern as
- * `NativeTypeExpander`: the target provides its renderer when calling
- * `contractToSchemaIR`, keeping the family layer target-agnostic.
+ * between Postgres, MySQL, SQLite, …). The target provides its renderer when calling
+ * `contractToSchemaIR`, keeping the family layer target-agnostic. `dataType` is the id of the
+ * data type the column's codec represents.
  */
-type DefaultRenderer = (def: ColumnDefault, column: StorageColumn) => string;
+type DefaultRenderer = (def: ColumnDefault, column: StorageColumn, dataType: string) => string;
 /**
- * Target-supplied hook (same IoC seam as `NativeTypeExpander`/`DefaultRenderer`)
+ * Target-supplied hook (same IoC seam as `DefaultRenderer`)
  * that normalizes a contract-declared `ColumnDefault` into the resolved shape
  * the target's introspection parses from the live database — e.g. a
  * sql`'{}'::jsonb` raw default and the literal Postgres reports
@@ -653,20 +605,6 @@ type DefaultRenderer = (def: ColumnDefault, column: StorageColumn) => string;
  * is the resolved default unchanged.
  */
 type DefaultResolver = (def: ColumnDefault, resolvedNativeType: string) => ColumnDefault;
-/**
- * Target-supplied callback that resolves a contract namespace to the live
- * database schema its enums are stored under.
- *
- * The projected enum annotations are nested by schema
- * (`storageTypes[schema][nativeType]`) so two namespaces holding an enum with
- * the same native type resolve to distinct live-database types. Mapping a
- * namespace to its DDL schema is target-specific (Postgres schemas;
- * SQLite/MySQL differ), so the target injects it here rather than the family
- * importing a concrete `ddlSchemaName`. This keeps the family layer
- * target-agnostic while the projection nests under the same schema the
- * target's read side (`readExistingEnumValues`) looks up.
- */
-type EnumNamespaceSchemaResolver = (storage: SqlStorage, namespaceId: string) => string;
 /**
  * Detects destructive changes between two contract storages.
  *
@@ -677,39 +615,12 @@ type EnumNamespaceSchemaResolver = (storage: SqlStorage, namespaceId: string) =>
  * Returns an empty array if no destructive changes are found.
  */
 declare function detectDestructiveChanges(from: SqlStorage | null, to: SqlStorage): readonly MigrationPlannerConflict[];
-interface ContractToSchemaIROptions {
+/** Each column's type is written from the data type its codec represents, found through the lookups. */
+interface ContractToSchemaIROptions extends SqlTypeLookups {
   readonly annotationNamespace: string;
-  readonly expandNativeType?: NativeTypeExpander;
   readonly renderDefault?: DefaultRenderer;
   readonly resolveDefault?: DefaultResolver;
-  /**
-   * Gives each column the data type its codec represents, so a literal default compares through
-   * the type's canonical form. Build it with `buildDataTypeResolver(frameworkComponents)`.
-   */
-  readonly dataTypeOf?: DataTypeResolver;
-  /**
-   * Target-supplied resolver mapping a namespace to the live database schema
-   * its enums are stored under. When provided (Postgres), namespace-scoped
-   * enums are nested by that schema in `enumTypes` so the projection matches
-   * the target's `readExistingEnumValues` lookup. Targets without
-   * schema-scoped enum storage (SQLite) omit it; enums are absent there.
-   */
-  readonly resolveEnumNamespaceSchema?: EnumNamespaceSchemaResolver;
 }
-/**
- * Converts a `Contract` to `SqlSchemaIR`.
- *
- * Reads `contract.storage` for tables and `contract.storage.types` for type
- * annotations. Storage-type annotations are written under
- * `options.annotationNamespace`.
- *
- * Drops codec metadata (`codecId`, `typeRef`) since the schema IR only represents
- * structural information. When `expandNativeType` is provided, parameterized types
- * are expanded (e.g. `character` + `{ length: 36 }` → `character(36)`) so the
- * resulting IR compares correctly against the "to" contract during planning.
- *
- * Returns an empty schema IR when `contract` is `null` (new project).
- */
 /**
  * Converts the tables of a single namespace into a `SqlSchemaIR`, keyed by
  * table name within that namespace. Unlike {@link contractToSchemaIR}, which
@@ -725,6 +636,19 @@ interface ContractToSchemaIROptions {
  * per-table fields.
  */
 declare function contractNamespaceToSchemaIR(storage: SqlStorage, namespaceId: string, options: ContractToSchemaIROptions): SqlSchemaIR;
+/**
+ * Converts a `Contract` to `SqlSchemaIR`.
+ *
+ * Reads `contract.storage` for tables, and `contract.storage.types` for the
+ * types `typeRef` columns name.
+ *
+ * Drops codec metadata (`codecId`, `typeRef`) 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
@@ -883,19 +807,6 @@ interface PlanFieldEventOperationsOptions {
 }
 declare function planFieldEventOperations(options: PlanFieldEventOperationsOptions): readonly OpFactoryCall[];
 //#endregion
-//#region src/core/migrations/native-type-expander.d.ts
-/**
- * Builds the codec-hook-composed `expandNativeType` callback the contract→IR
- * derivation uses to expand parameterized native types (e.g. `character` +
- * `{ length: 36 }` → `character(36)`). Returns `undefined` when no framework
- * components are supplied, so callers can omit the option entirely.
- */
-declare function buildNativeTypeExpander(frameworkComponents?: ReadonlyArray<TargetBoundComponentDescriptor<'sql', string>>): ((input: {
-  readonly nativeType: string;
-  readonly codecId?: string;
-  readonly typeParams?: Record<string, unknown>;
-}) => string) | undefined;
-//#endregion
 //#region src/core/migrations/plan-helpers.d.ts
 declare function createMigrationPlan<TTargetDetails>(options: CreateSqlMigrationPlanOptions<TTargetDetails>): SqlMigrationPlan<TTargetDetails>;
 declare function plannerSuccess<TTargetDetails>(plan: SqlMigrationPlan<TTargetDetails>, warnings?: readonly SqlPlannerConflict[]): SqlPlannerSuccessResult<TTargetDetails>;
@@ -921,6 +832,10 @@ declare function runnerFailure(code: SqlMigrationRunnerErrorCode, summary: strin
  */
 declare const INIT_ADDITIVE_POLICY: MigrationOperationPolicy;
 //#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>>): SqlTypeLookups;
+//#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. */
@@ -1004,9 +919,8 @@ declare function temporalStringAuthoringPresets<const Storage extends PresetStor
  * entirely, and omitting a phase omits that phase (both omitted omits
  * `executionDefaults`).
  */
-declare function temporalCodecPresetWithPrecision<const CodecId extends string, const NativeType extends string, const GeneratorId extends string = typeof TIMESTAMP_NOW_GENERATOR_ID>(input: {
+declare function temporalCodecPresetWithPrecision<const CodecId extends string, const GeneratorId extends string = typeof TIMESTAMP_NOW_GENERATOR_ID>(input: {
   readonly codecId: CodecId;
-  readonly nativeType: NativeType;
   readonly generatorId?: GeneratorId;
 }): {
   readonly kind: "fieldPreset";
@@ -1015,7 +929,6 @@ declare function temporalCodecPresetWithPrecision<const CodecId extends string,
     readonly kind: "number";
     readonly optional: true;
     readonly integer: true;
-    readonly minimum: 0;
   }, {
     readonly name: "onCreate";
     readonly kind: "option";
@@ -1029,7 +942,6 @@ declare function temporalCodecPresetWithPrecision<const CodecId extends string,
   }];
   readonly output: {
     readonly codecId: CodecId;
-    readonly nativeType: NativeType;
     readonly typeParams: {
       readonly precision: {
         readonly kind: "arg";
@@ -1064,5 +976,5 @@ declare function temporalCodecPresetWithPrecision<const CodecId extends string,
 //#region src/exports/control.d.ts
 declare const _default: SqlFamilyDescriptor;
 //#endregion
-export { TableRenameInMigration as A, createMigrationPlan as B, SqlDescribedContractSpace as C, TableNameCaseGuardTable as D, TABLE_NAME_CASE_CHANGED_CODE as E, buildDataTypeResolver as F, partitionIssuesByControlPolicy as G, detectTableNameCaseChanges as H, buildNativeTypeExpander as I, plannerSuccess as J, planFieldEventOperations as K, contractNamespaceToSchemaIR as L, _default as M, applyTableRename as N, TableRename as O, assembleAuthoringContributions as P, temporalStringAuthoringPresets as Q, contractToSchemaIR as R, SqlControlTargetDescriptor as S, SuppressionRecord as T, extractCodecControlHooks as U, detectDestructiveChanges as V, partitionCallsByControlPolicy as W, runnerSuccess as X, runnerFailure as Y, temporalCodecPresetWithPrecision as Z, NativeTypeExpander as _, DataTypeResolver as a, ResolvedTableRename as b, EnumNamespaceSchemaResolver as c, MigrationOperationPolicy$1 as d, MigrationPlan$1 as f, MigrationPlannerResult as g, MigrationPlannerConflict$1 as h, ControlPolicySubject as i, TargetMigrationsCapability as j, TableRenameByHand as k, INIT_ADDITIVE_POLICY as l, MigrationPlanner as m, ApplyTableRenameInput as n, DefaultRenderer as o, MigrationPlanOperation$1 as p, plannerFailure as q, ContractToSchemaIROptions as r, DefaultResolver as s, AppliedTableRename as t, MigrationOperationClass as u, PlanFieldEventOperationsOptions as v, SqlPslBuildContext as w, SqlControlFamilyInstance as x, RenameTableReferences as y, controlPolicyForCall as z };
-//# sourceMappingURL=control-DL9y6GfG.d.mts.map
+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-Bpk8PtSL.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"control-Bpk8PtSL.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,KAAK;aACM,QAAQ;aACR;aACA;aACA;MACP,QAAQ;EACZ,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;;;;cAIzD,+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;;;a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"}

package/dist/{control-adapter-WoXvPNj4-D64oWh9I.d.mts → control-adapter-BVN98SzR-C-H_T7s-.d.mts}

@@ -1,26 +1,20 @@
 import { O as SqlControlDriverInstance } from "./types-Bl6ohp1g-CL4_GDuc.mjs";
 import "./types-B11MGgKr.mjs";
-import { dt as LoweredStatement, h as AnyQueryAst } from "./types-Yui2yFf6-DYiGm9ET.mjs";
+import { dt as LoweredStatement, h as AnyQueryAst } from "./types-Dskga3R1-BtXuRmbf.mjs";
 import { o as SqlExecuteRequest } from "./driver-types-DYGFEcyv-DPaNalPf.mjs";
-import { r as DdlColumn, s as DdlNode } from "./ddl-types-B48YmQSt-DLCUHORB.mjs";
-import { u as LowererContext } from "./ast-dPjHeaNs.mjs";
-import { y as SqlSchemaIRNode } from "./types-BzpC_V7p-DyBYmK1f.mjs";
-import "./types-DdTdsdMn.mjs";
+import { r as DdlColumn, s as DdlNode } from "./ddl-types-BUqZdoZK-vyWnW2PW.mjs";
+import { s as LowererContext } from "./ast-BUbHXpzG.mjs";
+import { y as SqlSchemaIRNode } from "./types-Da1Y_OI7-BPyFwdFU.mjs";
+import "./types-DZA5xxDT.mjs";
 import { ColumnDefault, ContractMarkerRecord, LedgerEntryRecord } from "@prisma/orm-framework/contract/types";
 import { ControlAdapterInstance, ControlStack } from "@prisma/orm-framework/components/control";
-//#region ../../../2-sql/9-family/dist/control-adapter-WoXvPNj4.d.mts
+//#region ../../../2-sql/9-family/dist/control-adapter-BVN98SzR.d.mts
 //#region src/core/diff/sql-schema-diff.d.ts
 /**
  * Function type for normalizing raw database default expressions into ColumnDefault.
  * Target-specific implementations handle database dialect differences.
  */
 type DefaultNormalizer = (rawDefault: string, nativeType: string) => ColumnDefault | undefined;
-/**
- * Function type for normalizing schema native types to canonical form for comparison.
- * Target-specific implementations handle dialect-specific type name variations
- * (e.g., Postgres 'varchar' → 'character varying', 'timestamptz' normalization).
- */
-type NativeTypeNormalizer = (nativeType: string) => string;
 /**
  * Compares two arrays of strings for equality (order-sensitive).
  */
@@ -159,12 +153,6 @@ interface SqlControlAdapter<TTarget extends string = string> extends ControlAdap
    * with contract defaults (ColumnDefault objects) during schema verification.
    */
   readonly normalizeDefault?: DefaultNormalizer;
-  /**
-   * Optional target-specific normalizer for schema native type names.
-   * When provided, schema native types (from introspection) are normalized
-   * before comparison with contract native types during schema verification.
-   */
-  readonly normalizeNativeType?: NativeTypeNormalizer;
   /**
    * Ordered DDL queries that bootstrap marker/ledger control tables for migration
    * runners. Postgres includes `CREATE SCHEMA`; SQLite does not.
@@ -192,5 +180,5 @@ interface SqlControlAdapterDescriptor<TTarget extends string = string> {
   create(stack: ControlStack<'sql', TTarget>): SqlControlAdapter<TTarget>;
 }
 //#endregion
-export { SqlControlAdapterDescriptor as a, SqlControlAdapter as i, Lowerer as n, arraysEqual as o, NativeTypeNormalizer as r, ExecuteRequestLowerer as t };
-//# sourceMappingURL=control-adapter-WoXvPNj4-D64oWh9I.d.mts.map
+export { arraysEqual as a, SqlControlAdapterDescriptor as i, Lowerer as n, SqlControlAdapter as r, ExecuteRequestLowerer as t };
+//# sourceMappingURL=control-adapter-BVN98SzR-C-H_T7s-.d.mts.map

package/dist/control-adapter-BVN98SzR-C-H_T7s-.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"control-adapter-BVN98SzR-C-H_T7s-.d.mts","names":[],"sources":["../../../../2-sql/9-family/dist/control-adapter-BVN98SzR.d.mts"],"mappings":";;;;;;;;;;;;;;;;KAUK,qBAAqB,oBAAoB,uBAAuB;;;;iBAIpD,YAAY,sBAAsB;;;;;;;;;;UAUzC;EACR,MAAM,KAAK,cAAc,SAAS,SAAS,0BAA0B;;;;;;;;UAQ7D,8BAA8B;EACtC,sBAAsB,KAAK,cAAc,SAAS,UAAU,0BAA0B,QAAQ;;;;EAI9F,oBAAoB,QAAQ,WAAW,gBAAgB;;;;;;;;UAQ/C,kBAAkB,yCAAyC,8BAA8B,UAAU;;;;;;;;;;;;;;;;EAgB3G,WAAW,QAAQ,yBAAyB,UAAU,gBAAgB,QAAQ;;;;;;;;EAQ9E,eAAe,QAAQ,yBAAyB,WAAW,QAAQ,oBAAoB;;;;;EAKvF,WAAW,QAAQ,yBAAyB,UAAU,iBAAiB,iBAAiB;;;;;;;EAOxF,aAAa,QAAQ,yBAAyB,UAAU,eAAe;aAC5D;aACA;aACA;MACP;;;;;;;EAOJ,WAAW,QAAQ,yBAAyB,UAAU,eAAe;aAC1D;aACA;aACA;MACP;;;;;;;;EAQJ,aAAa,QAAQ,yBAAyB,UAAU,eAAe,sBAAsB;aAClF;aACA;aACA;MACP;;;;;;;EAOJ,iBAAiB,QAAQ,yBAAyB,UAAU,eAAe;aAChE;aACA;aACA;aACA;aACA;aACA;aACA;MACP;;;;;;;;;;;;;;;;;;EAkBJ,WAAW,QAAQ,yBAAyB,UAAU,oBAAoB,kBAAkB,QAAQ;;;;;;WAM3F,mBAAmB;;;;;EAK5B,yCAAyC;;;;;EAKzC,uCAAuC;;;;;;;;UAQ/B,4BAA4B;;;;;;;EAOpC,OAAO,OAAO,oBAAoB,WAAW,kBAAkB"}

package/dist/control-adapter-DSGwSagr.d.mts

@@ -0,0 +1 @@
+import "./control-adapter-BVN98SzR-C-H_T7s-.mjs";