@prisma-next/family-sql 0.3.0-pr.99.5 → 0.3.0

package/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [2026] [Prisma Data, Inc]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -5,22 +5,35 @@ SQL family descriptor for Prisma Next.
 ## Purpose
 
 Provides the SQL family descriptor (`ControlFamilyDescriptor`) that includes:
-- The SQL target family hook (`sqlTargetFamilyHook`)
+- The SQL target family hook (`sqlEmission`)
 - Factory method (`create()`) to create family instances
 
 ## Responsibilities
 
 - **Family Descriptor Export**: Exports the SQL `ControlFamilyDescriptor` for use in CLI configuration files
-- **Family Instance Creation**: Creates `SqlFamilyInstance` objects that implement control-plane domain actions (`verify`, `schemaVerify`, `introspect`, `emitContract`, `validateContractIR`)
+- **Family Instance Creation**: Creates `SqlFamilyInstance` objects that implement control-plane domain actions (`verify`, `schemaVerify`, `introspect`, `emitContract`, `validateContract`)
 - **Planner & Runner SPI**: Owns the `MigrationPlanner` / `MigrationRunner` interfaces plus the `SqlControlTargetDescriptor` helper so targets can expose planners and runners (e.g., Postgres init planner/runner)
-- **Family Hook Integration**: Integrates the SQL target family hook (`sqlTargetFamilyHook`) from `@prisma-next/sql-contract-emitter`
+- **Family Hook Integration**: Integrates the SQL target family hook (`sqlEmission`) from `@prisma-next/sql-contract-emitter`
 - **Control Plane Entry Point**: Serves as the control plane entry point for the SQL family, enabling the CLI to select the family hook and create family instances
 - **Component Database Dependencies**: Consumes database dependencies declared by framework components (target/adapter/extension packs). Callers pass the active `frameworkComponents` list into planning/execution/verification; SQL layers structurally narrow to components that declare `databaseDependencies` and use their pure verification hooks (no fuzzy matching against `contract.extensionPacks`).
+- **Contract-to-SchemaIR Conversion**: Converts `SqlStorage` from a contract into `SqlSchemaIR` for offline migration planning, enabling `migration plan` to work without a database connection
+- **Destructive Change Detection**: Compares two `SqlStorage` values and identifies destructive changes (dropped tables/columns) for migration policy enforcement
+- **Storage Type Control Hooks**: Extracts codec-owned control hooks for planning/verification/introspection of `storage.types` without adding enum-specific fields to shared IR
+- **Codec Ownership**: Enforces a single owner per `codecId` for parameterized renderers and control-plane hooks to prevent ambiguous conflicts during assembly
+- **Mutation Default Registry Assembly**: Assembles control-plane default-function entries and generator descriptors from composed components with hard-error collisions
+- **PSL Interpretation Input Assembly**: Assembles target-bound scalar type descriptors plus mutation-default contributions for PSL provider/interpreter inputs
+- **Parameterized Type Verification**: Expands contract `typeParams` into expected native type strings during schema verification and flags missing parameters as type mismatches
+- **Schema Defaults Policy**: Ignores execution mutation defaults during schema verification since they are applied before DB writes
+- **Foreign Key Config Awareness**: Schema verification respects the contract's `foreignKeys` configuration — when `foreignKeys.constraints` is `false`, FK constraint checks are skipped during verification (see [ADR 161](../../../docs/architecture%20docs/adrs/ADR%20161%20-%20Explicit%20foreign%20key%20constraint%20and%20index%20configuration.md))
+- **Referential Action Verification**: When a contract FK specifies `onDelete` or `onUpdate`, the verifier compares them against the introspected schema and reports `foreign_key_mismatch` on mismatch (see [ADR 166](../../../docs/architecture%20docs/adrs/ADR%20166%20-%20Referential%20actions%20for%20foreign%20keys.md))
 
 ## Usage
 
 ```typescript
-import sql from '@prisma-next/family-sql/control';
+import sql, {
+  assembleAuthoringContributions,
+  assemblePslInterpretationContributions,
+} from '@prisma-next/family-sql/control';
 
 // sql is a ControlFamilyDescriptor with:
 // - kind: 'family'
@@ -38,9 +51,9 @@ const familyInstance = sql.create({
 });
 
 // Use instance methods for domain actions
-const contractIR = familyInstance.validateContractIR(contractJson);
-const verifyResult = await familyInstance.verify({ driver, contractIR, ... });
-const emitResult = await familyInstance.emitContract({ contractIR: rawContract }); // Handles stripping mappings and validation internally
+const contract = familyInstance.validateContract(contractJson);
+const verifyResult = await familyInstance.verify({ driver, contract, ... });
+const emitResult = await familyInstance.emitContract({ contract: rawContract }); // Handles stripping mappings and validation internally
 
 // Targets that implement SqlControlTargetDescriptor can build planners
 const planner = postgresTargetDescriptor.migrations.createPlanner(familyInstance);
@@ -62,6 +75,30 @@ const executeResult = await runner.execute({
   frameworkComponents: [postgresTargetDescriptor, postgresAdapterDescriptor, pgVectorExtensionDescriptor],
 });
 
+// Assemble PSL interpretation inputs for sql-contract-psl/provider
+const authoringContributions = assembleAuthoringContributions([
+  sql,
+  postgresTargetDescriptor,
+  postgresAdapterDescriptor,
+  pgVectorExtensionDescriptor,
+]);
+const pslInputs = assemblePslInterpretationContributions([
+  sql,
+  postgresTargetDescriptor,
+  postgresAdapterDescriptor,
+  pgVectorExtensionDescriptor,
+]);
+const providerOptions = {
+  target: postgresTargetDescriptor,
+  authoringContributions,
+  scalarTypeDescriptors: pslInputs.scalarTypeDescriptors,
+  controlMutationDefaults: {
+    defaultFunctionRegistry: pslInputs.defaultFunctionRegistry,
+    generatorDescriptors: pslInputs.generatorDescriptors,
+  },
+  composedExtensionPacks: [pgVectorExtensionDescriptor.id],
+};
+
 // executeResult is a Result<MigrationRunnerSuccessValue, MigrationRunnerFailure>
 if (executeResult.ok) {
   console.log(`Executed ${executeResult.value.operationsExecuted} operations`);
@@ -75,29 +112,30 @@ if (executeResult.ok) {
 This package is the control plane entry point for the SQL family. It composes:
 - `@prisma-next/sql-contract-emitter` - Provides the SQL family hook
 - `@prisma-next/sql-operations` - SQL operation signature types
-- `@prisma-next/sql-contract-ts` - Contract validation
+- `@prisma-next/sql-contract` - SQL contract types and validation
 
 The framework CLI uses this descriptor to:
 1. Create family instances for control-plane operations (via `create()`)
 
 Family instances implement domain actions:
-- **`validateContractIR(contractJson)`**: Validates and normalizes contract, returns ContractIR without mappings
-- **`verify()`**: Verifies database marker against contract (compares target, coreHash, profileHash)
+- **`validateContract(contractJson)`**: Validates and normalizes contract, returns `Contract` without mappings
+- **`verify()`**: Verifies database marker against contract (compares target, storageHash, profileHash)
 - **`schemaVerify()`**: Verifies database schema against contract (compares contract requirements vs live schema)
 - **`introspect()`**: Introspects database schema and returns `SqlSchemaIR`
 - **`toSchemaView(schema)`**: Projects `SqlSchemaIR` into `CoreSchemaView` for human-readable display. Always displays native database types (e.g., `int4`, `text`) rather than mapped codec IDs (e.g., `pg/int4@1`) to reflect actual database state.
-- **`emitContract({ contractIR })`**: Emits contract JSON and DTS as strings. Handles stripping mappings and validation internally. Uses preassembled state (operation registry, type imports, extension IDs).
+- **`emitContract({ contract })`**: Emits contract JSON and DTS as strings. Handles stripping mappings and validation internally. Uses preassembled state (operation registry, type imports, extension IDs).
 
 The descriptor is "pure data + factory" - it only provides the hook and factory method. All family-specific logic lives on the instance.
 
 ## Package Structure
 
-- **`src/core/descriptor.ts`**: `SqlFamilyDescriptor` class implementing `ControlFamilyDescriptor` interface (pure data + factory)
-- **`src/core/instance.ts`**: `createSqlFamilyInstance` function that creates `SqlFamilyInstance` with domain action methods (`validateContractIR`, `verify`, `schemaVerify`, `introspect`, `toSchemaView`, `emitContract`). Contains `convertOperationManifest` function used internally by instance creation and test utilities in the same package.
-- **`src/core/assembly.ts`**: Assembly helpers for building operation registries and extracting type imports from descriptors. Test utilities import `convertOperationManifest` from the same package via relative path.
+- **`src/core/control-descriptor.ts`**: `SqlFamilyDescriptor` class implementing `ControlFamilyDescriptor` interface (pure data + factory)
+- **`src/core/control-instance.ts`**: `createSqlFamilyInstance` function that creates `SqlFamilyInstance` with domain action methods (`validateContract`, `verify`, `schemaVerify`, `introspect`, `toSchemaView`, `emitContract`). Contains `convertOperationManifest` function used internally by instance creation and test utilities in the same package.
+- **`src/core/assembly.ts`**: Assembly helpers for extracting type imports, collecting codec-owned storage type control hooks, and composing mutation-default registries with duplicate detection.
 - **`src/core/verify.ts`**: Verification helpers (`readMarker`, `collectSupportedCodecTypeIds`)
 - **`src/core/control-adapter.ts`**: SQL control adapter interface (`SqlControlAdapter`) for control-plane operations
 - **`src/core/migrations/`**: Migration IR helpers plus planner and runner SPI types (`MigrationPlanner`, `MigrationRunner`, `SqlControlTargetDescriptor`). Runners return `MigrationRunnerResult` which is a union of success/failure.
+- **`src/core/migrations/contract-to-schema-ir.ts`**: `contractToSchemaIR(contract, { annotationNamespace, ... })` converts a contract to `SqlSchemaIR` for offline migration planning (used by `migration plan` to synthesize the "from" schema without a database connection). Also exports `detectDestructiveChanges(from, to)` which compares two `SqlStorage` values and returns a list of destructive changes (dropped tables, dropped columns) for migration policy enforcement.
 
 ### Migration Runner Error Codes
 
@@ -111,22 +149,21 @@ The runner returns structured errors with the following codes:
 - **`SCHEMA_VERIFY_FAILED`**: Resulting schema doesn't satisfy the destination contract
 - **`EXECUTION_FAILED`**: SQL execution error during operation execution
 - **`src/exports/control.ts`**: Control plane entry point (exports `SqlFamilyDescriptor` instance)
-- **`src/exports/runtime.ts`**: Runtime entry point (placeholder for future functionality)
+- **`src/exports/runtime.ts`**: Runtime plane entry point
 
 ## Entrypoints
 
 - **`./control`**: Control plane entry point for CLI/config usage (exports `SqlFamilyDescriptor`)
 - **`./control-adapter`**: SQL control adapter interface (`SqlControlAdapter`, `SqlControlAdapterDescriptor`) for target-specific adapters
-- **`./runtime`**: Runtime entry point (placeholder for future functionality)
+- **`./runtime`**: Runtime plane identity exports only (family ID, types, descriptor identity). Does **not** export runtime creation helpers—use `instantiateExecutionStack` from `@prisma-next/framework-components/execution` and `createExecutionContext`, `createRuntime`, `createSqlExecutionStack` from `@prisma-next/sql-runtime`. See [ADR 152](../../../docs/architecture%20docs/adrs/ADR%20152%20-%20Execution%20Plane%20Descriptors%20and%20Instances.md).
 - **`./verify`**: Verification utilities (`readMarker`, `readMarkerSql`, `parseContractMarkerRow`) for reading contract markers from databases
 
 ## Dependencies
 
-- **`@prisma-next/core-control-plane`**: Control plane types (`ControlFamilyDescriptor`, `ControlTargetDescriptor`, `ControlAdapterDescriptor`, `ControlDriverDescriptor`, `ControlExtensionDescriptor`, `ControlDriverInstance`, etc.)
-- **`@prisma-next/sql-contract-emitter`**: SQL target family hook (`sqlTargetFamilyHook`)
-- **`@prisma-next/sql-contract-ts`**: Contract validation (`validateContract`)
-- **`@prisma-next/sql-contract`**: SQL contract types (`SqlContract`, `SqlStorage`)
-- **`@prisma-next/sql-operations`**: SQL operation signature types (`SqlOperationSignature`)
+- **`@prisma-next/framework-components`**: Control plane types via `./control` (`ControlFamilyDescriptor`, `ControlTargetDescriptor`, `ControlAdapterDescriptor`, `ControlDriverDescriptor`, `ControlExtensionDescriptor`, `ControlDriverInstance`, etc.)
+- **`@prisma-next/sql-contract-emitter`**: SQL target family hook (`sqlEmission`)
+- **`@prisma-next/sql-contract`**: SQL contract types plus validation (`validateContract`)
+- **`@prisma-next/sql-operations`**: SQL operation registry types (`SqlOperationEntry`, `SqlOperationRegistry`)
 
 **Dependents:**
 - CLI configuration files import this package to register the SQL family
@@ -142,4 +179,3 @@ The runner returns structured errors with the following codes:
 - **Tests**:
   - CLI integration: `test/integration/test/cli.db-init.e2e.test.ts`
   - Target unit/integration: `packages/3-targets/3-targets/postgres/test/migrations/*`
-

package/dist/authoring-type-constructors-DgU-RFaP.mjs

@@ -0,0 +1,203 @@
+//#region src/core/authoring-field-presets.ts
+const CHARACTER_CODEC_ID = "sql/char@1";
+const CHARACTER_NATIVE_TYPE = "character";
+const nanoidOptionsArgument = {
+	kind: "object",
+	optional: true,
+	properties: { size: {
+		kind: "number",
+		optional: true,
+		integer: true,
+		minimum: 2,
+		maximum: 255
+	} }
+};
+const sqlFamilyAuthoringFieldPresets = {
+	text: {
+		kind: "fieldPreset",
+		output: {
+			codecId: "sql/text@1",
+			nativeType: "text"
+		}
+	},
+	timestamp: {
+		kind: "fieldPreset",
+		output: {
+			codecId: "sql/timestamp@1",
+			nativeType: "timestamp"
+		}
+	},
+	createdAt: {
+		kind: "fieldPreset",
+		output: {
+			codecId: "sql/timestamp@1",
+			nativeType: "timestamp",
+			default: {
+				kind: "function",
+				expression: "CURRENT_TIMESTAMP"
+			}
+		}
+	},
+	uuid: {
+		kind: "fieldPreset",
+		output: {
+			codecId: CHARACTER_CODEC_ID,
+			nativeType: CHARACTER_NATIVE_TYPE,
+			typeParams: { length: 36 }
+		}
+	},
+	ulid: {
+		kind: "fieldPreset",
+		output: {
+			codecId: CHARACTER_CODEC_ID,
+			nativeType: CHARACTER_NATIVE_TYPE,
+			typeParams: { length: 26 }
+		}
+	},
+	nanoid: {
+		kind: "fieldPreset",
+		args: [nanoidOptionsArgument],
+		output: {
+			codecId: CHARACTER_CODEC_ID,
+			nativeType: CHARACTER_NATIVE_TYPE,
+			typeParams: { length: {
+				kind: "arg",
+				index: 0,
+				path: ["size"],
+				default: 21
+			} }
+		}
+	},
+	cuid2: {
+		kind: "fieldPreset",
+		output: {
+			codecId: CHARACTER_CODEC_ID,
+			nativeType: CHARACTER_NATIVE_TYPE,
+			typeParams: { length: 24 }
+		}
+	},
+	ksuid: {
+		kind: "fieldPreset",
+		output: {
+			codecId: CHARACTER_CODEC_ID,
+			nativeType: CHARACTER_NATIVE_TYPE,
+			typeParams: { length: 27 }
+		}
+	},
+	id: {
+		uuidv4: {
+			kind: "fieldPreset",
+			output: {
+				codecId: CHARACTER_CODEC_ID,
+				nativeType: CHARACTER_NATIVE_TYPE,
+				typeParams: { length: 36 },
+				executionDefault: {
+					kind: "generator",
+					id: "uuidv4"
+				},
+				id: true
+			}
+		},
+		uuidv7: {
+			kind: "fieldPreset",
+			output: {
+				codecId: CHARACTER_CODEC_ID,
+				nativeType: CHARACTER_NATIVE_TYPE,
+				typeParams: { length: 36 },
+				executionDefault: {
+					kind: "generator",
+					id: "uuidv7"
+				},
+				id: true
+			}
+		},
+		ulid: {
+			kind: "fieldPreset",
+			output: {
+				codecId: CHARACTER_CODEC_ID,
+				nativeType: CHARACTER_NATIVE_TYPE,
+				typeParams: { length: 26 },
+				executionDefault: {
+					kind: "generator",
+					id: "ulid"
+				},
+				id: true
+			}
+		},
+		nanoid: {
+			kind: "fieldPreset",
+			args: [nanoidOptionsArgument],
+			output: {
+				codecId: CHARACTER_CODEC_ID,
+				nativeType: CHARACTER_NATIVE_TYPE,
+				typeParams: { length: {
+					kind: "arg",
+					index: 0,
+					path: ["size"],
+					default: 21
+				} },
+				executionDefault: {
+					kind: "generator",
+					id: "nanoid",
+					params: { size: {
+						kind: "arg",
+						index: 0,
+						path: ["size"]
+					} }
+				},
+				id: true
+			}
+		},
+		cuid2: {
+			kind: "fieldPreset",
+			output: {
+				codecId: CHARACTER_CODEC_ID,
+				nativeType: CHARACTER_NATIVE_TYPE,
+				typeParams: { length: 24 },
+				executionDefault: {
+					kind: "generator",
+					id: "cuid2"
+				},
+				id: true
+			}
+		},
+		ksuid: {
+			kind: "fieldPreset",
+			output: {
+				codecId: CHARACTER_CODEC_ID,
+				nativeType: CHARACTER_NATIVE_TYPE,
+				typeParams: { length: 27 },
+				executionDefault: {
+					kind: "generator",
+					id: "ksuid"
+				},
+				id: true
+			}
+		}
+	}
+};
+
+//#endregion
+//#region src/core/authoring-type-constructors.ts
+const sqlFamilyAuthoringTypes = { sql: { String: {
+	kind: "typeConstructor",
+	args: [{
+		kind: "number",
+		name: "length",
+		integer: true,
+		minimum: 1,
+		maximum: 10485760
+	}],
+	output: {
+		codecId: "sql/varchar@1",
+		nativeType: "character varying",
+		typeParams: { length: {
+			kind: "arg",
+			index: 0
+		} }
+	}
+} } };
+
+//#endregion
+export { sqlFamilyAuthoringFieldPresets as n, sqlFamilyAuthoringTypes as t };
+//# sourceMappingURL=authoring-type-constructors-DgU-RFaP.mjs.map

package/dist/authoring-type-constructors-DgU-RFaP.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"authoring-type-constructors-DgU-RFaP.mjs","names":[],"sources":["../src/core/authoring-field-presets.ts","../src/core/authoring-type-constructors.ts"],"sourcesContent":["import type { AuthoringFieldNamespace } from '@prisma-next/framework-components/authoring';\n\nconst CHARACTER_CODEC_ID = 'sql/char@1';\nconst CHARACTER_NATIVE_TYPE = 'character';\n\nconst nanoidOptionsArgument = {\n  kind: 'object',\n  optional: true,\n  properties: {\n    size: {\n      kind: 'number',\n      optional: true,\n      integer: true,\n      minimum: 2,\n      maximum: 255,\n    },\n  },\n} as const;\n\nexport const sqlFamilyAuthoringFieldPresets = {\n  text: {\n    kind: 'fieldPreset',\n    output: {\n      codecId: 'sql/text@1',\n      nativeType: 'text',\n    },\n  },\n  timestamp: {\n    kind: 'fieldPreset',\n    output: {\n      codecId: 'sql/timestamp@1',\n      nativeType: 'timestamp',\n    },\n  },\n  createdAt: {\n    kind: 'fieldPreset',\n    output: {\n      codecId: 'sql/timestamp@1',\n      nativeType: 'timestamp',\n      default: {\n        kind: 'function',\n        expression: 'CURRENT_TIMESTAMP',\n      },\n    },\n  },\n  uuid: {\n    kind: 'fieldPreset',\n    output: {\n      codecId: CHARACTER_CODEC_ID,\n      nativeType: CHARACTER_NATIVE_TYPE,\n      typeParams: {\n        length: 36,\n      },\n    },\n  },\n  ulid: {\n    kind: 'fieldPreset',\n    output: {\n      codecId: CHARACTER_CODEC_ID,\n      nativeType: CHARACTER_NATIVE_TYPE,\n      typeParams: {\n        length: 26,\n      },\n    },\n  },\n  nanoid: {\n    kind: 'fieldPreset',\n    args: [nanoidOptionsArgument],\n    output: {\n      codecId: CHARACTER_CODEC_ID,\n      nativeType: CHARACTER_NATIVE_TYPE,\n      typeParams: {\n        length: {\n          kind: 'arg',\n          index: 0,\n          path: ['size'],\n          default: 21,\n        },\n      },\n    },\n  },\n  cuid2: {\n    kind: 'fieldPreset',\n    output: {\n      codecId: CHARACTER_CODEC_ID,\n      nativeType: CHARACTER_NATIVE_TYPE,\n      typeParams: {\n        length: 24,\n      },\n    },\n  },\n  ksuid: {\n    kind: 'fieldPreset',\n    output: {\n      codecId: CHARACTER_CODEC_ID,\n      nativeType: CHARACTER_NATIVE_TYPE,\n      typeParams: {\n        length: 27,\n      },\n    },\n  },\n  id: {\n    uuidv4: {\n      kind: 'fieldPreset',\n      output: {\n        codecId: CHARACTER_CODEC_ID,\n        nativeType: CHARACTER_NATIVE_TYPE,\n        typeParams: {\n          length: 36,\n        },\n        executionDefault: {\n          kind: 'generator',\n          id: 'uuidv4',\n        },\n        id: true,\n      },\n    },\n    uuidv7: {\n      kind: 'fieldPreset',\n      output: {\n        codecId: CHARACTER_CODEC_ID,\n        nativeType: CHARACTER_NATIVE_TYPE,\n        typeParams: {\n          length: 36,\n        },\n        executionDefault: {\n          kind: 'generator',\n          id: 'uuidv7',\n        },\n        id: true,\n      },\n    },\n    ulid: {\n      kind: 'fieldPreset',\n      output: {\n        codecId: CHARACTER_CODEC_ID,\n        nativeType: CHARACTER_NATIVE_TYPE,\n        typeParams: {\n          length: 26,\n        },\n        executionDefault: {\n          kind: 'generator',\n          id: 'ulid',\n        },\n        id: true,\n      },\n    },\n    nanoid: {\n      kind: 'fieldPreset',\n      args: [nanoidOptionsArgument],\n      output: {\n        codecId: CHARACTER_CODEC_ID,\n        nativeType: CHARACTER_NATIVE_TYPE,\n        typeParams: {\n          length: {\n            kind: 'arg',\n            index: 0,\n            path: ['size'],\n            default: 21,\n          },\n        },\n        executionDefault: {\n          kind: 'generator',\n          id: 'nanoid',\n          params: {\n            size: {\n              kind: 'arg',\n              index: 0,\n              path: ['size'],\n            },\n          },\n        },\n        id: true,\n      },\n    },\n    cuid2: {\n      kind: 'fieldPreset',\n      output: {\n        codecId: CHARACTER_CODEC_ID,\n        nativeType: CHARACTER_NATIVE_TYPE,\n        typeParams: {\n          length: 24,\n        },\n        executionDefault: {\n          kind: 'generator',\n          id: 'cuid2',\n        },\n        id: true,\n      },\n    },\n    ksuid: {\n      kind: 'fieldPreset',\n      output: {\n        codecId: CHARACTER_CODEC_ID,\n        nativeType: CHARACTER_NATIVE_TYPE,\n        typeParams: {\n          length: 27,\n        },\n        executionDefault: {\n          kind: 'generator',\n          id: 'ksuid',\n        },\n        id: true,\n      },\n    },\n  },\n} as const satisfies AuthoringFieldNamespace;\n","import type { AuthoringTypeNamespace } from '@prisma-next/framework-components/authoring';\n\nexport const sqlFamilyAuthoringTypes = {\n  sql: {\n    String: {\n      kind: 'typeConstructor',\n      args: [{ kind: 'number', name: 'length', integer: true, minimum: 1, maximum: 10485760 }],\n      output: {\n        codecId: 'sql/varchar@1',\n        nativeType: 'character varying',\n        typeParams: {\n          length: { kind: 'arg', index: 0 },\n        },\n      },\n    },\n  },\n} as const satisfies AuthoringTypeNamespace;\n"],"mappings":"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"}

package/dist/control-adapter.d.mts

@@ -0,0 +1,54 @@
+import { n as NativeTypeNormalizer, t as DefaultNormalizer } from "./verify-sql-schema-BBhkqEDo.mjs";
+import { ControlAdapterInstance, ControlDriverInstance } from "@prisma-next/framework-components/control";
+import { SqlSchemaIR } from "@prisma-next/sql-schema-ir/types";
+
+//#region src/core/control-adapter.d.ts
+
+/**
+ * SQL control adapter interface for control-plane operations.
+ * Implemented by target-specific adapters (e.g., Postgres, MySQL).
+ *
+ * @template TTarget - The target ID (e.g., 'postgres', 'mysql')
+ */
+interface SqlControlAdapter<TTarget extends string = string> extends ControlAdapterInstance<'sql', TTarget> {
+  /**
+   * Introspects a database schema and returns a raw SqlSchemaIR.
+   *
+   * This is a pure schema discovery operation that queries the database catalog
+   * and returns the schema structure without type mapping or contract enrichment.
+   * Type mapping and enrichment are handled separately by enrichment helpers.
+   *
+   * @param driver - ControlDriverInstance instance for executing queries (target-specific)
+   * @param contract - Optional contract for contract-guided introspection (filtering, optimization)
+   * @param schema - Schema name to introspect (defaults to 'public')
+   * @returns Promise resolving to SqlSchemaIR representing the live database schema
+   */
+  introspect(driver: ControlDriverInstance<'sql', TTarget>, contract?: unknown, schema?: string): Promise<SqlSchemaIR>;
+  /**
+   * Optional target-specific normalizer for raw database default expressions.
+   * When provided, schema defaults (raw strings) are normalized before comparison
+   * 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;
+}
+/**
+ * SQL control adapter descriptor interface.
+ * Provides a factory method to create control adapter instances.
+ *
+ * @template TTarget - The target ID (e.g., 'postgres', 'mysql')
+ */
+interface SqlControlAdapterDescriptor<TTarget extends string = string> {
+  /**
+   * Creates a SQL control adapter instance for control-plane operations.
+   */
+  create(): SqlControlAdapter<TTarget>;
+}
+//#endregion
+export { type SqlControlAdapter, type SqlControlAdapterDescriptor };
+//# sourceMappingURL=control-adapter.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"control-adapter.d.mts","names":[],"sources":["../src/core/control-adapter.ts"],"sourcesContent":[],"mappings":";;;;;;;;AAaA;;;;AAkBa,UAlBI,iBAkBJ,CAAA,gBAAA,MAAA,GAAA,MAAA,CAAA,SAjBH,sBAiBG,CAAA,KAAA,EAjB2B,OAiB3B,CAAA,CAAA;EAAR;;;;;AAuBL;;;;;;;qBA1BY,6BAA6B,gDAGpC,QAAQ;;;;;;8BAOiB;;;;;;iCAOG;;;;;;;;UAShB;;;;YAIL,kBAAkB"}

package/dist/control-adapter.mjs

@@ -0,0 +1 @@
+export {  };