@prisma-next/family-sql 0.3.0-dev.6 → 0.3.0-dev.64

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

@@ -16,6 +16,14 @@ Provides the SQL family descriptor (`ControlFamilyDescriptor`) that includes:
 - **Family Hook Integration**: Integrates the SQL target family hook (`sqlTargetFamilyHook`) 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
+- **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
 
@@ -82,7 +90,7 @@ The framework CLI uses this descriptor to:
 
 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)
+- **`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.
@@ -92,12 +100,13 @@ The descriptor is "pure data + factory" - it only provides the hook and factory
 
 ## 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 (`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, extracting type imports, and collecting codec-owned storage type control hooks. Test utilities import `convertOperationManifest` from the same package via relative path.
 - **`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(storage)` converts a contract's `SqlStorage` 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,13 +120,13 @@ 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 `createExecutionStack`, `instantiateExecutionStack` from `@prisma-next/core-execution-plane/stack` and `createExecutionContext`, `createRuntime` 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

package/dist/assembly-BVS641kd.mjs

@@ -0,0 +1,106 @@
+import { normalizeRenderer } from "@prisma-next/contract/framework-components";
+import { createOperationRegistry } from "@prisma-next/operations";
+
+//#region src/core/assembly.ts
+function addUniqueId(ids, seen, id) {
+	if (!seen.has(id)) {
+		ids.push(id);
+		seen.add(id);
+	}
+}
+function assertUniqueCodecOwner(options) {
+	const existingOwner = options.owners.get(options.codecId);
+	if (existingOwner !== void 0) throw new Error(`Duplicate ${options.entityLabel} for codecId "${options.codecId}". Descriptor "${options.descriptorId}" conflicts with "${existingOwner}". Each codecId can only have one ${options.entityOwnershipLabel}.`);
+}
+function assembleOperationRegistry(descriptors) {
+	const registry = createOperationRegistry();
+	for (const descriptor of descriptors) {
+		const signatures = descriptor.operationSignatures();
+		for (const signature of signatures) registry.register(signature);
+	}
+	return registry;
+}
+function extractCodecTypeImports(descriptors) {
+	const imports = [];
+	for (const descriptor of descriptors) {
+		const codecTypes = descriptor.types?.codecTypes;
+		if (codecTypes?.import) imports.push(codecTypes.import);
+		if (codecTypes?.typeImports) imports.push(...codecTypes.typeImports);
+	}
+	return imports;
+}
+function extractOperationTypeImports(descriptors) {
+	const imports = [];
+	for (const descriptor of descriptors) {
+		const operationTypes = descriptor.types?.operationTypes;
+		if (operationTypes?.import) imports.push(operationTypes.import);
+	}
+	return imports;
+}
+function extractExtensionIds(adapter, target, extensions) {
+	const ids = [];
+	const seen = /* @__PURE__ */ new Set();
+	addUniqueId(ids, seen, adapter.id);
+	addUniqueId(ids, seen, target.id);
+	for (const ext of extensions) addUniqueId(ids, seen, ext.id);
+	return ids;
+}
+function extractParameterizedRenderers(descriptors) {
+	const renderers = /* @__PURE__ */ new Map();
+	const owners = /* @__PURE__ */ new Map();
+	for (const descriptor of descriptors) {
+		const codecTypes = descriptor.types?.codecTypes;
+		if (!codecTypes?.parameterized) continue;
+		const parameterized = codecTypes.parameterized;
+		for (const [codecId, renderer] of Object.entries(parameterized)) {
+			assertUniqueCodecOwner({
+				codecId,
+				owners,
+				descriptorId: descriptor.id,
+				entityLabel: "parameterized renderer",
+				entityOwnershipLabel: "renderer"
+			});
+			renderers.set(codecId, normalizeRenderer(codecId, renderer));
+			owners.set(codecId, descriptor.id);
+		}
+	}
+	return renderers;
+}
+function hasCodecControlHooks(descriptor) {
+	if (typeof descriptor !== "object" || descriptor === null) return false;
+	const hooks = descriptor.types?.codecTypes?.controlPlaneHooks;
+	return hooks !== null && hooks !== void 0 && typeof hooks === "object";
+}
+function extractCodecControlHooks(descriptors) {
+	const hooks = /* @__PURE__ */ new Map();
+	const owners = /* @__PURE__ */ new Map();
+	for (const descriptor of descriptors) {
+		if (typeof descriptor !== "object" || descriptor === null) continue;
+		if (!hasCodecControlHooks(descriptor)) continue;
+		const controlPlaneHooks = descriptor.types.codecTypes.controlPlaneHooks;
+		for (const [codecId, hook] of Object.entries(controlPlaneHooks)) {
+			assertUniqueCodecOwner({
+				codecId,
+				owners,
+				descriptorId: descriptor.id,
+				entityLabel: "control hooks",
+				entityOwnershipLabel: "owner"
+			});
+			hooks.set(codecId, hook);
+			owners.set(codecId, descriptor.id);
+		}
+	}
+	return hooks;
+}
+function extractParameterizedTypeImports(descriptors) {
+	const imports = [];
+	for (const descriptor of descriptors) {
+		const typeImports = descriptor.types?.codecTypes?.typeImports;
+		if (typeImports) imports.push(...typeImports);
+	}
+	return imports;
+}
+
+//#endregion
+export { extractOperationTypeImports as a, extractExtensionIds as i, extractCodecControlHooks as n, extractParameterizedRenderers as o, extractCodecTypeImports as r, extractParameterizedTypeImports as s, assembleOperationRegistry as t };
+//# sourceMappingURL=assembly-BVS641kd.mjs.map

package/dist/assembly-BVS641kd.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"assembly-BVS641kd.mjs","names":["imports: TypesImportSpec[]","ids: string[]","parameterized: Record<string, TypeRenderer>"],"sources":["../src/core/assembly.ts"],"sourcesContent":["import type {\n  NormalizedTypeRenderer,\n  TargetBoundComponentDescriptor,\n  TypeRenderer,\n} from '@prisma-next/contract/framework-components';\nimport { normalizeRenderer } from '@prisma-next/contract/framework-components';\nimport type { TypesImportSpec } from '@prisma-next/contract/types';\nimport type { OperationRegistry } from '@prisma-next/operations';\nimport { createOperationRegistry } from '@prisma-next/operations';\nimport type { CodecControlHooks, SqlControlStaticContributions } from './migrations/types';\n\nfunction addUniqueId(ids: string[], seen: Set<string>, id: string): void {\n  if (!seen.has(id)) {\n    ids.push(id);\n    seen.add(id);\n  }\n}\n\nfunction assertUniqueCodecOwner(options: {\n  readonly codecId: string;\n  readonly owners: Map<string, string>;\n  readonly descriptorId: string;\n  readonly entityLabel: string;\n  readonly entityOwnershipLabel: string;\n}): void {\n  const existingOwner = options.owners.get(options.codecId);\n  if (existingOwner !== undefined) {\n    throw new Error(\n      `Duplicate ${options.entityLabel} for codecId \"${options.codecId}\". ` +\n        `Descriptor \"${options.descriptorId}\" conflicts with \"${existingOwner}\". ` +\n        `Each codecId can only have one ${options.entityOwnershipLabel}.`,\n    );\n  }\n}\n\nexport interface SqlControlDescriptorWithContributions extends SqlControlStaticContributions {\n  readonly id: string;\n  readonly types?: {\n    readonly codecTypes?: {\n      readonly import?: TypesImportSpec;\n      readonly parameterized?: Record<string, TypeRenderer>;\n      readonly typeImports?: ReadonlyArray<TypesImportSpec>;\n    };\n    readonly operationTypes?: { readonly import: TypesImportSpec };\n  };\n}\n\nexport function assembleOperationRegistry(\n  descriptors: ReadonlyArray<SqlControlDescriptorWithContributions>,\n): OperationRegistry {\n  const registry = createOperationRegistry();\n\n  for (const descriptor of descriptors) {\n    const signatures = descriptor.operationSignatures();\n    for (const signature of signatures) {\n      registry.register(signature);\n    }\n  }\n\n  return registry;\n}\n\ninterface DescriptorWithTypes {\n  readonly id: string;\n  readonly types?: {\n    readonly codecTypes?: {\n      readonly import?: TypesImportSpec;\n      readonly parameterized?: Record<string, TypeRenderer>;\n      readonly typeImports?: ReadonlyArray<TypesImportSpec>;\n    };\n    readonly operationTypes?: { readonly import: TypesImportSpec };\n  };\n}\n\nexport function extractCodecTypeImports(\n  descriptors: ReadonlyArray<DescriptorWithTypes>,\n): ReadonlyArray<TypesImportSpec> {\n  const imports: TypesImportSpec[] = [];\n\n  for (const descriptor of descriptors) {\n    const types = descriptor.types;\n    const codecTypes = types?.codecTypes;\n    if (codecTypes?.import) {\n      imports.push(codecTypes.import);\n    }\n    if (codecTypes?.typeImports) {\n      imports.push(...codecTypes.typeImports);\n    }\n  }\n\n  return imports;\n}\n\nexport function extractOperationTypeImports(\n  descriptors: ReadonlyArray<DescriptorWithTypes>,\n): ReadonlyArray<TypesImportSpec> {\n  const imports: TypesImportSpec[] = [];\n\n  for (const descriptor of descriptors) {\n    const types = descriptor.types;\n    const operationTypes = types?.operationTypes;\n    if (operationTypes?.import) {\n      imports.push(operationTypes.import);\n    }\n  }\n\n  return imports;\n}\n\nexport function extractExtensionIds(\n  adapter: { readonly id: string },\n  target: { readonly id: string },\n  extensions: ReadonlyArray<{ readonly id: string }>,\n): ReadonlyArray<string> {\n  const ids: string[] = [];\n  const seen = new Set<string>();\n\n  addUniqueId(ids, seen, adapter.id);\n  addUniqueId(ids, seen, target.id);\n\n  for (const ext of extensions) {\n    addUniqueId(ids, seen, ext.id);\n  }\n\n  return ids;\n}\n\nexport function extractParameterizedRenderers(\n  descriptors: ReadonlyArray<DescriptorWithTypes>,\n): Map<string, NormalizedTypeRenderer> {\n  const renderers = new Map<string, NormalizedTypeRenderer>();\n  const owners = new Map<string, string>();\n\n  for (const descriptor of descriptors) {\n    const codecTypes = descriptor.types?.codecTypes;\n    if (!codecTypes?.parameterized) continue;\n\n    const parameterized: Record<string, TypeRenderer> = codecTypes.parameterized;\n    for (const [codecId, renderer] of Object.entries(parameterized)) {\n      assertUniqueCodecOwner({\n        codecId,\n        owners,\n        descriptorId: descriptor.id,\n        entityLabel: 'parameterized renderer',\n        entityOwnershipLabel: 'renderer',\n      });\n      renderers.set(codecId, normalizeRenderer(codecId, renderer));\n      owners.set(codecId, descriptor.id);\n    }\n  }\n\n  return renderers;\n}\n\ntype CodecControlHooksMap = Record<string, CodecControlHooks>;\n\nfunction hasCodecControlHooks(descriptor: unknown): descriptor is {\n  readonly id: string;\n  readonly types: {\n    readonly codecTypes: {\n      readonly controlPlaneHooks: CodecControlHooksMap;\n    };\n  };\n} {\n  if (typeof descriptor !== 'object' || descriptor === null) {\n    return false;\n  }\n  const d = descriptor as { types?: { codecTypes?: { controlPlaneHooks?: unknown } } };\n  const hooks = d.types?.codecTypes?.controlPlaneHooks;\n  return hooks !== null && hooks !== undefined && typeof hooks === 'object';\n}\n\nexport function extractCodecControlHooks(\n  descriptors: ReadonlyArray<TargetBoundComponentDescriptor<'sql', string>>,\n): Map<string, CodecControlHooks> {\n  const hooks = new Map<string, CodecControlHooks>();\n  const owners = new Map<string, string>();\n\n  for (const descriptor of descriptors) {\n    if (typeof descriptor !== 'object' || descriptor === null) {\n      continue;\n    }\n    if (!hasCodecControlHooks(descriptor)) {\n      continue;\n    }\n    const controlPlaneHooks = descriptor.types.codecTypes.controlPlaneHooks;\n    for (const [codecId, hook] of Object.entries(controlPlaneHooks)) {\n      assertUniqueCodecOwner({\n        codecId,\n        owners,\n        descriptorId: descriptor.id,\n        entityLabel: 'control hooks',\n        entityOwnershipLabel: 'owner',\n      });\n      hooks.set(codecId, hook);\n      owners.set(codecId, descriptor.id);\n    }\n  }\n\n  return hooks;\n}\n\nexport function extractParameterizedTypeImports(\n  descriptors: ReadonlyArray<DescriptorWithTypes>,\n): ReadonlyArray<TypesImportSpec> {\n  const imports: TypesImportSpec[] = [];\n\n  for (const descriptor of descriptors) {\n    const typeImports = descriptor.types?.codecTypes?.typeImports;\n    if (typeImports) {\n      imports.push(...typeImports);\n    }\n  }\n\n  return imports;\n}\n"],"mappings":"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"}

package/dist/control-adapter.d.mts

@@ -0,0 +1,60 @@
+import { n as NativeTypeNormalizer, t as DefaultNormalizer } from "./verify-sql-schema-DhHnkpPa.mjs";
+import { ControlAdapterInstance, ControlDriverInstance } from "@prisma-next/core-control-plane/types";
+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> {
+  /**
+   * The target ID this adapter implements.
+   * Used for type tracking and runtime validation.
+   * @deprecated Use targetId from ControlAdapterInstance instead
+   */
+  readonly target: 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 contractIR - Optional contract IR 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>, contractIR?: 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;;;;AAsBY,UAtBK,iBAsBL,CAAA,gBAAA,MAAA,GAAA,MAAA,CAAA,SArBF,sBAqBE,CAAA,KAAA,EArB4B,OAqB5B,CAAA,CAAA;EAGC;;;;;EAxBmB,SAAA,MAAA,EAMb,OANa;EA+Cf;;;;;;;;;;;;qBA1BL,6BAA6B,kDAGpC,QAAQ;;;;;;8BAOiB;;;;;;iCAOG;;;;;;;;UAShB;;;;YAIL,kBAAkB"}

package/dist/control-adapter.mjs

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