@prisma-next/family-sql 0.5.0-dev.9 → 0.5.0

package/dist/{types-C6K4mxDM.d.mts → types-BQBbcXg3.d.mts}

@@ -1,11 +1,12 @@
-import { ControlAdapterDescriptor, ControlDriverInstance, ControlExtensionDescriptor, ControlFamilyInstance, ControlStack, DataTransformOperation, MigratableTargetDescriptor, MigrationOperationPolicy, MigrationPlan, MigrationPlanOperation, MigrationPlannerConflict, MigrationPlannerFailureResult, MigrationPlannerSuccessResult, MigrationRunnerExecutionChecks, MigrationRunnerFailure, MigrationRunnerSuccessValue, OperationContext, SchemaIssue, SchemaViewCapable, SignDatabaseResult, VerifyDatabaseResult, VerifyDatabaseSchemaResult } from "@prisma-next/framework-components/control";
+import { ContractSpace, ControlAdapterDescriptor, ControlDriverInstance, ControlExtensionDescriptor, ControlFamilyInstance, ControlStack, MigratableTargetDescriptor, MigrationOperationPolicy, MigrationPlan, MigrationPlanOperation, MigrationPlannerConflict, MigrationPlannerFailureResult, MigrationPlannerSuccessResult, MigrationRunnerExecutionChecks, MigrationRunnerFailure, MigrationRunnerSuccessValue, OpFactoryCall, OperationContext, OperationPreview, OperationPreviewCapable, PslContractInferCapable, SchemaIssue, SchemaViewCapable, SignDatabaseResult, VerifyDatabaseResult, VerifyDatabaseSchemaResult } from "@prisma-next/framework-components/control";
 import { Result } from "@prisma-next/utils/result";
-import { SqlSchemaIR } from "@prisma-next/sql-schema-ir/types";
 import { Contract } from "@prisma-next/contract/types";
+import { SqlSchemaIR } from "@prisma-next/sql-schema-ir/types";
 import { TargetBoundComponentDescriptor } from "@prisma-next/framework-components/components";
-import { SqlStorage, StorageTypeInstance } from "@prisma-next/sql-contract/types";
+import { SqlStorage, StorageColumn, StorageTable, StorageTypeInstance } from "@prisma-next/sql-contract/types";
 import { TypesImportSpec } from "@prisma-next/framework-components/emission";
-import { SqlOperationDescriptor } from "@prisma-next/sql-operations";
+import { PslDocumentAst } from "@prisma-next/framework-components/psl-ast";
+import { SqlOperationDescriptors } from "@prisma-next/sql-operations";
 
 //#region src/core/control-instance.d.ts
 interface SqlTypeMetadata {
@@ -17,7 +18,6 @@ interface SqlTypeMetadata {
 type SqlTypeMetadataRegistry = Map<string, SqlTypeMetadata>;
 interface SqlFamilyInstanceState {
   readonly codecTypeImports: ReadonlyArray<TypesImportSpec>;
-  readonly operationTypeImports: ReadonlyArray<TypesImportSpec>;
   readonly extensionIds: ReadonlyArray<string>;
   readonly typeMetadataRegistry: SqlTypeMetadataRegistry;
 }
@@ -32,7 +32,7 @@ interface SchemaVerifyOptions {
    */
   readonly frameworkComponents: ReadonlyArray<TargetBoundComponentDescriptor<'sql', string>>;
 }
-interface SqlControlFamilyInstance extends ControlFamilyInstance<'sql', SqlSchemaIR>, SchemaViewCapable<SqlSchemaIR>, SqlFamilyInstanceState {
+interface SqlControlFamilyInstance extends ControlFamilyInstance<'sql', SqlSchemaIR>, SchemaViewCapable<SqlSchemaIR>, PslContractInferCapable<SqlSchemaIR>, OperationPreviewCapable, SqlFamilyInstanceState {
   validateContract(contractJson: unknown): Contract;
   verify(options: {
     readonly driver: ControlDriverInstance<'sql', string>;
@@ -42,6 +42,21 @@ interface SqlControlFamilyInstance extends ControlFamilyInstance<'sql', SqlSchem
     readonly configPath?: string;
   }): Promise<VerifyDatabaseResult>;
   schemaVerify(options: SchemaVerifyOptions): Promise<VerifyDatabaseSchemaResult>;
+  /**
+   * Verify a contract against an already-introspected schema slice.
+   *
+   * Used by the aggregate verifier to invoke per-member verification
+   * with the live schema pre-projected to the member's claimed slice
+   * via `projectSchemaToSpace`. Closes F23 — without per-member
+   * pre-projection, single-contract verifiers see other-space tables
+   * as `extras`.
+   */
+  schemaVerifyAgainstSchema(options: {
+    readonly contract: unknown;
+    readonly schema: SqlSchemaIR;
+    readonly strict: boolean;
+    readonly frameworkComponents: ReadonlyArray<TargetBoundComponentDescriptor<'sql', string>>;
+  }): VerifyDatabaseSchemaResult;
   sign(options: {
     readonly driver: ControlDriverInstance<'sql', string>;
     readonly contract: unknown;
@@ -52,6 +67,8 @@ interface SqlControlFamilyInstance extends ControlFamilyInstance<'sql', SqlSchem
     readonly driver: ControlDriverInstance<'sql', string>;
     readonly contract?: unknown;
   }): Promise<SqlSchemaIR>;
+  inferPslContract(schemaIR: SqlSchemaIR): PslDocumentAst;
+  toOperationPreview(operations: readonly MigrationPlanOperation[]): OperationPreview;
 }
 //#endregion
 //#region src/core/migrations/types.d.ts
@@ -92,6 +109,39 @@ interface ResolveIdentityValueInput {
   readonly codecId?: string;
   readonly typeParams?: Record<string, unknown>;
 }
+/**
+ * Per-field lifecycle event a codec hook can react to.
+ *
+ * Fired during app-space migration emission as the SQL family diffs the
+ * prior contract against the new contract.
+ *
+ * - `'added'`     — the field is present in the new contract but not the prior.
+ * - `'dropped'`   — the field is present in the prior contract but not the new.
+ * - `'altered'`   — the field is present in both and any property other than
+ *                   `codecId` differs. Codec-id changes are a v1 non-goal:
+ *                   when only `codecId` differs, no `'altered'` event fires.
+ */
+type FieldEvent = 'added' | 'dropped' | 'altered';
+/**
+ * Context passed to {@link CodecControlHooks.onFieldEvent}.
+ *
+ * `tableName` and `fieldName` are always populated; `priorTable` /
+ * `priorField` carry the prior contract's view of the table and column
+ * (present for `'dropped'` and `'altered'`); `newTable` / `newField`
+ * carry the new contract's view (present for `'added'` and `'altered'`).
+ *
+ * The hook only ever receives app-space contract IR — extension-space
+ * fields are scoped out by the API: the hook is wired at the
+ * application emitter only.
+ */
+interface FieldEventContext {
+  readonly tableName: string;
+  readonly fieldName: string;
+  readonly priorTable?: StorageTable;
+  readonly newTable?: StorageTable;
+  readonly priorField?: StorageColumn;
+  readonly newField?: StorageColumn;
+}
 interface CodecControlHooks<TTargetDetails = unknown> {
   planTypeOperations?: (options: {
     readonly typeName: string;
@@ -132,17 +182,52 @@ interface CodecControlHooks<TTargetDetails = unknown> {
    * - undefined: no opinion; planner may use built-in fallbacks
    */
   resolveIdentityValue?: (input: ResolveIdentityValueInput) => string | null | undefined;
+  /**
+   * Reacts to per-field added / dropped / altered events as the app-space
+   * emitter diffs the prior contract against the new contract. Returned
+   * ops are inlined into the app-space migration's `ops.json` alongside
+   * the user's structural ops.
+   *
+   * Synchronous. Each returned op must carry its own `invariantId`. Hooks
+   * are dispatched per `(table, field)` based on the field's `codecId`
+   * (the new field's codec for `'added'` / `'altered'`; the prior field's
+   * codec for `'dropped'`).
+   */
+  onFieldEvent?: (event: FieldEvent, ctx: FieldEventContext) => readonly OpFactoryCall[];
 }
 interface SqlControlExtensionDescriptor<TTargetId extends string> extends ControlExtensionDescriptor<'sql', TTargetId> {
   readonly databaseDependencies?: ComponentDatabaseDependencies<unknown>;
-  readonly queryOperations?: () => ReadonlyArray<SqlOperationDescriptor>;
+  readonly queryOperations?: () => SqlOperationDescriptors;
+  /**
+   * Schema-contributing extensions opt into the per-space planner / runner /
+   * verifier by setting this field. Extensions without it are codec-only or
+   * query-ops-only — today's behaviour preserved.
+   *
+   * The shape comes from `@prisma-next/framework-components/control`
+   * (`ContractSpace`) — contract-space identity is a framework concept,
+   * not a SQL-specific one. The SQL family specialises the generic to
+   * `Contract<SqlStorage>` so descriptor authors continue to see a
+   * typed contract value.
+   *
+   * @see specs/framework-mechanism.spec.md § 1.
+   */
+  readonly contractSpace?: ContractSpace<Contract<SqlStorage>>;
 }
 interface SqlControlAdapterDescriptor<TTargetId extends string> extends ControlAdapterDescriptor<'sql', TTargetId> {
-  readonly queryOperations?: () => ReadonlyArray<SqlOperationDescriptor>;
+  readonly queryOperations?: () => SqlOperationDescriptors;
 }
 interface SqlMigrationPlanOperationStep {
   readonly description: string;
   readonly sql: string;
+  /**
+   * Optional parameter values bound at execution time. The runner forwards
+   * these to `driver.query(sql, params ?? [])`, so step authors can use
+   * placeholder syntax (`$1`, `$2`, …) instead of inlining literals into
+   * the SQL string. Reuses the driver's parameter binder rather than
+   * rolling per-target literal serialization for every type the planner
+   * may emit.
+   */
+  readonly params?: readonly unknown[];
   readonly meta?: AnyRecord;
 }
 /**
@@ -168,21 +253,26 @@ interface SqlMigrationPlanOperation<TTargetDetails> extends MigrationPlanOperati
   readonly postcheck: readonly SqlMigrationPlanOperationStep[];
   readonly meta?: AnyRecord;
 }
-/**
- * Union of all operation shapes a SQL-family migration may emit: schema-facing
- * `SqlMigrationPlanOperation`s and family-agnostic `DataTransformOperation`s.
- *
- * Mirrors `AnyMongoMigrationOperation` in shape — the runner already handles
- * both branches via `isDataTransformOperation`, and authored `migration.ts`
- * files must be able to intermix `dataTransform(endContract, …)` calls with
- * DDL factory calls (e.g. `setNotNull(…)`) in a single `operations` array.
- */
-type AnySqlMigrationOperation<TTargetDetails> = SqlMigrationPlanOperation<TTargetDetails> | DataTransformOperation;
 interface SqlMigrationPlanContractInfo {
   readonly storageHash: string;
   readonly profileHash?: string;
 }
 interface SqlMigrationPlan<TTargetDetails> extends MigrationPlan {
+  /**
+   * Contract space this plan applies to. The runner uses this to key the
+   * `prisma_contract.marker` row it writes/reads (`space = <spaceId>`),
+   * so per-extension plans hit per-extension marker rows instead of all
+   * collapsing onto the app's row.
+   *
+   * App-plan callers pass `APP_SPACE_ID` (`'app'`); per-extension plans
+   * pass the extension's space id. Required at every call site so the
+   * type system surfaces every place that needs to thread the value
+   * (rather than letting an `?? APP_SPACE_ID` fall-through silently
+   * collapse multi-space markers onto the `'app'` row).
+   *
+   * @see specs/framework-mechanism.spec.md § 2.
+   */
+  readonly spaceId: string;
   /**
    * Origin contract identity that the plan expects the database to currently be at.
    * If omitted or null, the runner skips origin validation entirely.
@@ -193,6 +283,15 @@ interface SqlMigrationPlan<TTargetDetails> extends MigrationPlan {
    */
   readonly destination: SqlMigrationPlanContractInfo;
   readonly operations: readonly SqlMigrationPlanOperation<TTargetDetails>[];
+  /**
+   * Sorted, deduplicated invariant ids declared by this plan's data-transform
+   * ops. Required at the SQL-family layer (the SQL runners consume this as
+   * the source of truth for marker writes and self-edge no-op checks); the
+   * framework-level {@link MigrationPlan.providedInvariants} stays optional
+   * because `db init` / `db update` plans don't have a corresponding
+   * migration manifest.
+   */
+  readonly providedInvariants: readonly string[];
   readonly meta?: AnyRecord;
 }
 type SqlPlannerConflictKind = 'typeMismatch' | 'nullabilityConflict' | 'indexIncompatible' | 'foreignKeyConflict' | 'missingButNonAdditive' | 'unsupportedOperation';
@@ -223,14 +322,29 @@ interface SqlMigrationPlannerPlanOptions {
   readonly policy: MigrationOperationPolicy;
   readonly schemaName?: string;
   /**
-   * The "from" contract (state the planner assumes the database starts at).
-   * Only `migration plan` supplies this; `db update` / `db init` reconcile
-   * against the live schema with no old contract. Strategies that need
-   * from/to column-shape comparisons (unsafe type change, nullability
+   * Contract space the plan applies to. The planner stamps this onto
+   * the produced {@link SqlMigrationPlan.spaceId} so the runner keys
+   * the marker row by the right space. App-plan callers pass
+   * `APP_SPACE_ID`; per-extension callers pass the extension's space
+   * id.
+   */
+  readonly spaceId: string;
+  /**
+   * The "from" contract (state the planner assumes the database starts at),
+   * or `null` for reconciliation flows that have no prior contract.
+   *
+   * Required at every call site so the structural fact "I have a prior
+   * contract / I don't" is visible in the type. `migration plan` supplies
+   * the previous bundle's `metadata.toContract`; `db update` / `db init`
+   * reconcile against the live schema and pass `null`. Strategies that
+   * need from/to column-shape comparisons (unsafe type change, nullability
    * tightening) use this to decide whether to emit `dataTransform`
-   * placeholders.
+   * placeholders; they short-circuit when it is `null`.
+   *
+   * Planners also derive the "from" identity they stamp onto the produced
+   * plan's `describe()` as `fromContract?.storage.storageHash ?? null`.
    */
-  readonly fromContract?: Contract<SqlStorage> | null;
+  readonly fromContract: Contract<SqlStorage> | null;
   /**
    * Active framework components participating in this composition.
    * SQL targets can interpret this list to derive database dependencies.
@@ -248,6 +362,14 @@ interface SqlMigrationRunnerExecuteCallbacks<TTargetDetails> {
 interface SqlMigrationRunnerExecuteOptions<TTargetDetails> {
   readonly plan: SqlMigrationPlan<TTargetDetails>;
   readonly driver: ControlDriverInstance<'sql', string>;
+  /**
+   * Logical contract space this plan applies to. When omitted the
+   * runner derives the space from {@link SqlMigrationPlan.spaceId};
+   * when supplied, the runner asserts it matches `plan.spaceId` so a
+   * caller cannot accidentally write the marker row for a different
+   * space than the plan was produced for.
+   */
+  readonly space?: string;
   /**
    * Destination contract IR.
    * Must correspond to `plan.destination` and is used for schema verification and marker/ledger writes.
@@ -274,7 +396,7 @@ interface SqlMigrationRunnerExecuteOptions<TTargetDetails> {
    */
   readonly frameworkComponents: ReadonlyArray<TargetBoundComponentDescriptor<'sql', string>>;
 }
-type SqlMigrationRunnerErrorCode = 'DESTINATION_CONTRACT_MISMATCH' | 'MARKER_ORIGIN_MISMATCH' | 'POLICY_VIOLATION' | 'PRECHECK_FAILED' | 'POSTCHECK_FAILED' | 'SCHEMA_VERIFY_FAILED' | 'EXECUTION_FAILED';
+type SqlMigrationRunnerErrorCode = 'DESTINATION_CONTRACT_MISMATCH' | 'LEGACY_MARKER_SHAPE' | 'MARKER_ORIGIN_MISMATCH' | 'POLICY_VIOLATION' | 'PRECHECK_FAILED' | 'POSTCHECK_FAILED' | 'SCHEMA_VERIFY_FAILED' | 'FOREIGN_KEY_VIOLATION' | 'EXECUTION_FAILED';
 interface SqlMigrationRunnerFailure extends MigrationRunnerFailure {
   readonly code: SqlMigrationRunnerErrorCode;
   readonly meta?: AnyRecord;
@@ -282,20 +404,76 @@ interface SqlMigrationRunnerFailure extends MigrationRunnerFailure {
 interface SqlMigrationRunnerSuccessValue extends MigrationRunnerSuccessValue {}
 type SqlMigrationRunnerResult = Result<SqlMigrationRunnerSuccessValue, SqlMigrationRunnerFailure>;
 interface SqlMigrationRunner<TTargetDetails> {
+  /**
+   * Apply a single migration plan, opening and managing its own
+   * transaction (and any target-specific connection-level setup, e.g.
+   * SQLite's `PRAGMA foreign_keys` toggle). Existing single-space
+   * callers route through here.
+   */
   execute(options: SqlMigrationRunnerExecuteOptions<TTargetDetails>): Promise<SqlMigrationRunnerResult>;
+  /**
+   * Apply a single migration plan against an already-open connection
+   * **without** opening a transaction. The caller is responsible for
+   * wrapping the call (and any siblings) in `BEGIN` / `COMMIT` /
+   * `ROLLBACK`. Used by the per-space runner wiring to fan out across
+   * contract spaces inside one outer transaction so a mid-apply
+   * failure rolls back every space's writes.
+   *
+   * Idempotent control-table setup (`prisma_contract.*`) and marker
+   * writes use `options.space` to address the per-space marker row.
+   */
+  executeOnConnection(options: SqlMigrationRunnerExecuteOptions<TTargetDetails>): Promise<SqlMigrationRunnerResult>;
+  /**
+   * Apply per-space plans across multiple contract spaces inside a
+   * single outer transaction. The caller orders the input list
+   * (typically via the aggregate planner's `applyOrder`: extensions
+   * alphabetical, then app); the runner is responsible for opening
+   * / committing the outer
+   * transaction (and any target-specific connection-level setup such
+   * as the SQLite FK pragma toggle). A failure on any space rolls
+   * back every space's writes.
+   *
+   * Each space's `SqlMigrationRunnerExecuteOptions` must reference the
+   * same `driver` (the connection the outer transaction is open on).
+   * Per-space marker writes use `options.space` to address the row.
+   */
+  executeAcrossSpaces(options: {
+    readonly driver: ControlDriverInstance<'sql', string>;
+    readonly perSpaceOptions: ReadonlyArray<SqlMigrationRunnerExecuteOptions<TTargetDetails>>;
+  }): Promise<MultiSpaceRunnerResult>;
 }
+interface MultiSpaceRunnerSuccessValue {
+  readonly perSpaceResults: ReadonlyArray<{
+    readonly space: string;
+    readonly value: SqlMigrationRunnerSuccessValue;
+  }>;
+}
+interface MultiSpaceRunnerFailure extends SqlMigrationRunnerFailure {
+  readonly failingSpace: string;
+}
+type MultiSpaceRunnerResult = Result<MultiSpaceRunnerSuccessValue, MultiSpaceRunnerFailure>;
 interface SqlControlTargetDescriptor<TTargetId extends string, TTargetDetails> extends MigratableTargetDescriptor<'sql', TTargetId, SqlControlFamilyInstance> {
-  readonly queryOperations?: () => ReadonlyArray<SqlOperationDescriptor>;
+  readonly queryOperations?: () => SqlOperationDescriptors;
   createPlanner(family: SqlControlFamilyInstance): SqlMigrationPlanner<TTargetDetails>;
   createRunner(family: SqlControlFamilyInstance): SqlMigrationRunner<TTargetDetails>;
 }
 interface CreateSqlMigrationPlanOptions<TTargetDetails> {
   readonly targetId: string;
+  /**
+   * Contract space this plan applies to. Mirrors {@link SqlMigrationPlan.spaceId}.
+   */
+  readonly spaceId: string;
   readonly origin?: SqlMigrationPlanContractInfo | null;
   readonly destination: SqlMigrationPlanContractInfo;
   readonly operations: readonly SqlMigrationPlanOperation<TTargetDetails>[];
+  /**
+   * Sorted, deduplicated invariant ids for this plan; mirrors the required
+   * field on {@link SqlMigrationPlan}. Callers without a migration manifest
+   * (`db init`, `db update`, planner-built plans) pass `[]`.
+   */
+  readonly providedInvariants: readonly string[];
   readonly meta?: AnyRecord;
 }
 //#endregion
-export { SqlPlannerFailureResult as A, SqlMigrationRunnerFailure as C, SqlPlannerConflict as D, SqlPlanTargetDetails as E, isDatabaseDependencyProvider as F, SchemaVerifyOptions as I, SqlControlFamilyInstance as L, SqlPlannerSuccessResult as M, StorageTypePlanResult as N, SqlPlannerConflictKind as O, collectInitDependencies as P, SqlMigrationRunnerExecuteOptions as S, SqlMigrationRunnerSuccessValue as T, SqlMigrationPlanner as _, ComponentDatabaseDependency as a, SqlMigrationRunnerErrorCode as b, ResolveIdentityValueInput as c, SqlControlTargetDescriptor as d, SqlMigrationPlan as f, SqlMigrationPlanOperationTarget as g, SqlMigrationPlanOperationStep as h, ComponentDatabaseDependencies as i, SqlPlannerResult as j, SqlPlannerConflictLocation as k, SqlControlAdapterDescriptor as l, SqlMigrationPlanOperation as m, AnySqlMigrationOperation as n, CreateSqlMigrationPlanOptions as o, SqlMigrationPlanContractInfo as p, CodecControlHooks as r, ExpandNativeTypeInput as s, AnyRecord as t, SqlControlExtensionDescriptor as u, SqlMigrationPlannerPlanOptions as v, SqlMigrationRunnerResult as w, SqlMigrationRunnerExecuteCallbacks as x, SqlMigrationRunner as y };
-//# sourceMappingURL=types-C6K4mxDM.d.mts.map
+export { SqlPlanTargetDetails as A, SchemaVerifyOptions as B, SqlMigrationRunner as C, SqlMigrationRunnerFailure as D, SqlMigrationRunnerExecuteOptions as E, SqlPlannerResult as F, SqlPlannerSuccessResult as I, StorageTypePlanResult as L, SqlPlannerConflictKind as M, SqlPlannerConflictLocation as N, SqlMigrationRunnerResult as O, SqlPlannerFailureResult as P, collectInitDependencies as R, SqlMigrationPlannerPlanOptions as S, SqlMigrationRunnerExecuteCallbacks as T, SqlControlFamilyInstance as V, SqlMigrationPlanContractInfo as _, CreateSqlMigrationPlanOptions as a, SqlMigrationPlanOperationTarget as b, FieldEventContext as c, MultiSpaceRunnerSuccessValue as d, ResolveIdentityValueInput as f, SqlMigrationPlan as g, SqlControlTargetDescriptor as h, ComponentDatabaseDependency as i, SqlPlannerConflict as j, SqlMigrationRunnerSuccessValue as k, MultiSpaceRunnerFailure as l, SqlControlExtensionDescriptor as m, CodecControlHooks as n, ExpandNativeTypeInput as o, SqlControlAdapterDescriptor as p, ComponentDatabaseDependencies as r, FieldEvent as s, AnyRecord as t, MultiSpaceRunnerResult as u, SqlMigrationPlanOperation as v, SqlMigrationRunnerErrorCode as w, SqlMigrationPlanner as x, SqlMigrationPlanOperationStep as y, isDatabaseDependencyProvider as z };
+//# sourceMappingURL=types-BQBbcXg3.d.mts.map

package/dist/types-BQBbcXg3.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types-BQBbcXg3.d.mts","names":[],"sources":["../src/core/control-instance.ts","../src/core/migrations/types.ts"],"mappings":"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"}

package/dist/verify-pRYxnpiG.mjs

@@ -0,0 +1,81 @@
+import { type } from "arktype";
+//#region src/core/verify.ts
+const MetaSchema = type({ "[string]": "unknown" });
+function parseMeta(meta) {
+	if (meta === null || meta === void 0) return {};
+	let parsed;
+	if (typeof meta === "string") try {
+		parsed = JSON.parse(meta);
+	} catch {
+		return {};
+	}
+	else parsed = meta;
+	const result = MetaSchema(parsed);
+	if (result instanceof type.errors) return {};
+	return result;
+}
+/**
+* SQLite stores `contract_json` as TEXT, so the wire shape is a JSON string;
+* Postgres uses `jsonb` and returns an already-parsed value. Normalize both
+* here so `ContractMarkerRecord.contractJson` is always the structured form.
+*/
+function parseContractJson(value) {
+	if (value === null || value === void 0) return null;
+	if (typeof value !== "string") return value;
+	try {
+		return JSON.parse(value);
+	} catch {
+		return null;
+	}
+}
+const ContractMarkerRowSchema = type({
+	core_hash: "string",
+	profile_hash: "string",
+	"contract_json?": "unknown | null",
+	"canonical_version?": "number | null",
+	"updated_at?": "Date | string",
+	"app_tag?": "string | null",
+	"meta?": "unknown | null",
+	invariants: type("string").array()
+});
+/**
+* Parses a contract marker row from database query result.
+* This is SQL-specific parsing logic (handles SQL row structure with snake_case columns).
+*/
+function parseContractMarkerRow(row) {
+	const result = ContractMarkerRowSchema(row);
+	if (result instanceof type.errors) {
+		const messages = result.map((p) => p.message).join("; ");
+		throw new Error(`Invalid contract marker row: ${messages}`);
+	}
+	const updatedAt = result.updated_at ? result.updated_at instanceof Date ? result.updated_at : new Date(result.updated_at) : /* @__PURE__ */ new Date();
+	return {
+		storageHash: result.core_hash,
+		profileHash: result.profile_hash,
+		contractJson: parseContractJson(result.contract_json),
+		canonicalVersion: result.canonical_version ?? null,
+		updatedAt,
+		appTag: result.app_tag ?? null,
+		meta: parseMeta(result.meta),
+		invariants: result.invariants
+	};
+}
+/**
+* Collects supported codec type IDs from adapter and extension manifests.
+* Returns a sorted, unique array of type IDs that are declared in the manifests.
+* This enables coverage checks by comparing contract column types against supported types.
+*
+* Note: This extracts type IDs from manifest type imports, not from runtime codec registries.
+* The manifests declare which codec types are available, but the actual type IDs
+* are defined in the codec-types TypeScript modules that are imported.
+*
+* For MVP, we return an empty array since extracting type IDs from TypeScript modules
+* would require runtime evaluation or static analysis. This can be enhanced later.
+*/
+function collectSupportedCodecTypeIds(descriptors) {
+	return [];
+}
+//#endregion
+export { parseContractMarkerRow as n, collectSupportedCodecTypeIds as t };
+
+//# sourceMappingURL=verify-pRYxnpiG.mjs.map

package/dist/verify-pRYxnpiG.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"verify-pRYxnpiG.mjs","names":[],"sources":["../src/core/verify.ts"],"sourcesContent":["import type { ContractMarkerRecord } from '@prisma-next/contract/types';\nimport { type } from 'arktype';\n\nconst MetaSchema = type({ '[string]': 'unknown' });\n\nfunction parseMeta(meta: unknown): Record<string, unknown> {\n  if (meta === null || meta === undefined) {\n    return {};\n  }\n\n  let parsed: unknown;\n  if (typeof meta === 'string') {\n    try {\n      parsed = JSON.parse(meta);\n    } catch {\n      return {};\n    }\n  } else {\n    parsed = meta;\n  }\n\n  const result = MetaSchema(parsed);\n  if (result instanceof type.errors) {\n    return {};\n  }\n\n  return result as Record<string, unknown>;\n}\n\n/**\n * SQLite stores `contract_json` as TEXT, so the wire shape is a JSON string;\n * Postgres uses `jsonb` and returns an already-parsed value. Normalize both\n * here so `ContractMarkerRecord.contractJson` is always the structured form.\n */\nfunction parseContractJson(value: unknown): unknown {\n  if (value === null || value === undefined) return null;\n  if (typeof value !== 'string') return value;\n  try {\n    return JSON.parse(value);\n  } catch {\n    return null;\n  }\n}\n\n/**\n * Wire shape of a `prisma_contract.marker` row as it comes out of a SQL\n * driver. Snake-cased to match the on-disk column names. Shared by every\n * SQL target's `readMarker` so each runner doesn't redeclare it inline.\n */\nexport type ContractMarkerRow = {\n  core_hash: string;\n  profile_hash: string;\n  contract_json: unknown | null;\n  canonical_version: number | null;\n  updated_at: Date | string;\n  app_tag: string | null;\n  meta: unknown | null;\n  // SQLite stores arrays as JSON-TEXT, so this is `string` on the wire from\n  // a SQLite driver and `string[]` from a Postgres driver. Targets normalize\n  // before passing to `parseContractMarkerRow`.\n  invariants: unknown;\n};\n\nconst ContractMarkerRowSchema = type({\n  core_hash: 'string',\n  profile_hash: 'string',\n  'contract_json?': 'unknown | null',\n  'canonical_version?': 'number | null',\n  'updated_at?': 'Date | string',\n  'app_tag?': 'string | null',\n  'meta?': 'unknown | null',\n  invariants: type('string').array(),\n});\n\n/**\n * Parses a contract marker row from database query result.\n * This is SQL-specific parsing logic (handles SQL row structure with snake_case columns).\n */\nexport function parseContractMarkerRow(row: unknown): ContractMarkerRecord {\n  const result = ContractMarkerRowSchema(row);\n  if (result instanceof type.errors) {\n    const messages = result.map((p: { message: string }) => p.message).join('; ');\n    throw new Error(`Invalid contract marker row: ${messages}`);\n  }\n\n  const updatedAt = result.updated_at\n    ? result.updated_at instanceof Date\n      ? result.updated_at\n      : new Date(result.updated_at)\n    : new Date();\n\n  return {\n    storageHash: result.core_hash,\n    profileHash: result.profile_hash,\n    contractJson: parseContractJson(result.contract_json),\n    canonicalVersion: result.canonical_version ?? null,\n    updatedAt,\n    appTag: result.app_tag ?? null,\n    meta: parseMeta(result.meta),\n    invariants: result.invariants,\n  };\n}\n\n/**\n * Collects supported codec type IDs from adapter and extension manifests.\n * Returns a sorted, unique array of type IDs that are declared in the manifests.\n * This enables coverage checks by comparing contract column types against supported types.\n *\n * Note: This extracts type IDs from manifest type imports, not from runtime codec registries.\n * The manifests declare which codec types are available, but the actual type IDs\n * are defined in the codec-types TypeScript modules that are imported.\n *\n * For MVP, we return an empty array since extracting type IDs from TypeScript modules\n * would require runtime evaluation or static analysis. This can be enhanced later.\n */\nexport function collectSupportedCodecTypeIds(\n  descriptors: ReadonlyArray<{ readonly id: string }>,\n): readonly string[] {\n  // For MVP, return empty array\n  // Future enhancement: Extract type IDs from codec-types modules via static analysis\n  // or require manifests to explicitly list supported type IDs\n  void descriptors;\n  return [];\n}\n"],"mappings":";;AAGA,MAAM,aAAa,KAAK,EAAE,YAAY,WAAW,CAAC;AAElD,SAAS,UAAU,MAAwC;CACzD,IAAI,SAAS,QAAQ,SAAS,KAAA,GAC5B,OAAO,EAAE;CAGX,IAAI;CACJ,IAAI,OAAO,SAAS,UAClB,IAAI;EACF,SAAS,KAAK,MAAM,KAAK;SACnB;EACN,OAAO,EAAE;;MAGX,SAAS;CAGX,MAAM,SAAS,WAAW,OAAO;CACjC,IAAI,kBAAkB,KAAK,QACzB,OAAO,EAAE;CAGX,OAAO;;;;;;;AAQT,SAAS,kBAAkB,OAAyB;CAClD,IAAI,UAAU,QAAQ,UAAU,KAAA,GAAW,OAAO;CAClD,IAAI,OAAO,UAAU,UAAU,OAAO;CACtC,IAAI;EACF,OAAO,KAAK,MAAM,MAAM;SAClB;EACN,OAAO;;;AAuBX,MAAM,0BAA0B,KAAK;CACnC,WAAW;CACX,cAAc;CACd,kBAAkB;CAClB,sBAAsB;CACtB,eAAe;CACf,YAAY;CACZ,SAAS;CACT,YAAY,KAAK,SAAS,CAAC,OAAO;CACnC,CAAC;;;;;AAMF,SAAgB,uBAAuB,KAAoC;CACzE,MAAM,SAAS,wBAAwB,IAAI;CAC3C,IAAI,kBAAkB,KAAK,QAAQ;EACjC,MAAM,WAAW,OAAO,KAAK,MAA2B,EAAE,QAAQ,CAAC,KAAK,KAAK;EAC7E,MAAM,IAAI,MAAM,gCAAgC,WAAW;;CAG7D,MAAM,YAAY,OAAO,aACrB,OAAO,sBAAsB,OAC3B,OAAO,aACP,IAAI,KAAK,OAAO,WAAW,mBAC7B,IAAI,MAAM;CAEd,OAAO;EACL,aAAa,OAAO;EACpB,aAAa,OAAO;EACpB,cAAc,kBAAkB,OAAO,cAAc;EACrD,kBAAkB,OAAO,qBAAqB;EAC9C;EACA,QAAQ,OAAO,WAAW;EAC1B,MAAM,UAAU,OAAO,KAAK;EAC5B,YAAY,OAAO;EACpB;;;;;;;;;;;;;;AAeH,SAAgB,6BACd,aACmB;CAKnB,OAAO,EAAE"}

package/dist/{verify-sql-schema-BBhkqEDo.d.mts → verify-sql-schema-CPHiuYHR.d.mts}

@@ -1,11 +1,10 @@
 import { OperationContext, VerifyDatabaseSchemaResult } from "@prisma-next/framework-components/control";
-import { SqlSchemaIR } from "@prisma-next/sql-schema-ir/types";
 import { ColumnDefault, Contract } from "@prisma-next/contract/types";
+import { SqlSchemaIR } from "@prisma-next/sql-schema-ir/types";
 import { TargetBoundComponentDescriptor } from "@prisma-next/framework-components/components";
 import { SqlStorage } from "@prisma-next/sql-contract/types";
 
 //#region src/core/schema-verify/verify-sql-schema.d.ts
-
 /**
  * Function type for normalizing raw database default expressions into ColumnDefault.
  * Target-specific implementations handle database dialect differences.
@@ -64,4 +63,4 @@ interface VerifySqlSchemaOptions {
 declare function verifySqlSchema(options: VerifySqlSchemaOptions): VerifyDatabaseSchemaResult;
 //#endregion
 export { verifySqlSchema as i, NativeTypeNormalizer as n, VerifySqlSchemaOptions as r, DefaultNormalizer as t };
-//# sourceMappingURL=verify-sql-schema-BBhkqEDo.d.mts.map
+//# sourceMappingURL=verify-sql-schema-CPHiuYHR.d.mts.map

package/dist/verify-sql-schema-CPHiuYHR.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"verify-sql-schema-CPHiuYHR.d.mts","names":[],"sources":["../src/core/schema-verify/verify-sql-schema.ts"],"mappings":";;;;;;;;;;;KAuCY,iBAAA,IACV,UAAA,UACA,UAAA,aACG,aAAA;;;;;AAYL;KALY,oBAAA,IAAwB,UAAA;;;;UAKnB,sBAAA;EAQI;EAAA,SANV,QAAA,EAAU,QAAA,CAAS,UAAA;EAagB;EAAA,SAXnC,MAAA,EAAQ,WAAA;EAiBW;EAAA,SAfnB,MAAA;EAqB0C;EAAA,SAnB1C,OAAA,GAAU,gBAAA;EANV;EAAA,SAQA,oBAAA,EAAsB,WAAA;IAAsB,UAAA;EAAA;EANpC;;;;EAAA,SAWR,mBAAA,EAAqB,aAAA,CAAc,8BAAA;EALb;;;;;EAAA,SAWtB,gBAAA,GAAmB,iBAAA;EAAA;;;;;EAAA,SAMnB,mBAAA,GAAsB,oBAAA;AAAA;;;;;;;;;;;iBAajB,eAAA,CAAgB,OAAA,EAAS,sBAAA,GAAyB,0BAAA"}

package/dist/{verify-sql-schema-Ovz7RXR5.mjs → verify-sql-schema-r1-2apHI.mjs}

@@ -1,6 +1,5 @@
 import { assertUniqueCodecOwner } from "@prisma-next/framework-components/control";
 import { ifDefined } from "@prisma-next/utils/defined";
-
 //#region src/core/assembly.ts
 function hasCodecControlHooks(descriptor) {
 	if (typeof descriptor !== "object" || descriptor === null) return false;
@@ -28,7 +27,6 @@ function extractCodecControlHooks(descriptors) {
 	}
 	return hooks;
 }
-
 //#endregion
 //#region src/core/migrations/types.ts
 function isDatabaseDependencyProvider(value) {
@@ -44,9 +42,21 @@ function collectInitDependencies(components) {
 	}
 	return result;
 }
-
 //#endregion
 //#region src/core/schema-verify/verify-helpers.ts
+function indexOptionsLooselyEqual(a, b) {
+	const aKeys = a ? Object.keys(a).sort() : [];
+	const bKeys = b ? Object.keys(b).sort() : [];
+	if (aKeys.length !== bKeys.length) return false;
+	for (let i = 0; i < aKeys.length; i += 1) if (aKeys[i] !== bKeys[i]) return false;
+	if (aKeys.length === 0) return true;
+	for (const key of aKeys) if (String(a[key]) !== String(b[key])) return false;
+	return true;
+}
+function indexExtrasMatch(contractIndex, schemaIndex) {
+	if ((contractIndex.type ?? null) !== (schemaIndex.type ?? null)) return false;
+	return indexOptionsLooselyEqual(contractIndex.options, schemaIndex.options);
+}
 /**
 * Compares two arrays of strings for equality (order-sensitive).
 */
@@ -296,8 +306,8 @@ function verifyIndexes(contractIndexes, schemaIndexes, schemaUniques, tableName,
 	const nodes = [];
 	for (const contractIndex of contractIndexes) {
 		const indexPath = `${tablePath}.indexes[${contractIndex.columns.join(",")}]`;
-		const matchingIndex = schemaIndexes.find((idx) => arraysEqual(idx.columns, contractIndex.columns));
-		const matchingUniqueConstraint = !matchingIndex && schemaUniques.find((u) => arraysEqual(u.columns, contractIndex.columns));
+		const matchingIndex = schemaIndexes.find((idx) => arraysEqual(idx.columns, contractIndex.columns) && indexExtrasMatch(contractIndex, idx));
+		const matchingUniqueConstraint = !matchingIndex && contractIndex.type === void 0 && contractIndex.options === void 0 && schemaUniques.find((u) => arraysEqual(u.columns, contractIndex.columns));
 		if (!matchingIndex && !matchingUniqueConstraint) {
 			issues.push({
 				kind: "index_mismatch",
@@ -330,7 +340,7 @@ function verifyIndexes(contractIndexes, schemaIndexes, schemaUniques, tableName,
 	}
 	if (strict) for (const schemaIndex of schemaIndexes) {
 		if (schemaIndex.unique) continue;
-		if (!contractIndexes.find((idx) => arraysEqual(idx.columns, schemaIndex.columns))) {
+		if (!contractIndexes.find((idx) => arraysEqual(idx.columns, schemaIndex.columns) && indexExtrasMatch(idx, schemaIndex))) {
 			issues.push({
 				kind: "extra_index",
 				table: tableName,
@@ -453,7 +463,6 @@ function getReferentialActionMismatches(contractFK, schemaFK) {
 function normalizeReferentialAction(action) {
 	return action === "noAction" ? void 0 : action;
 }
-
 //#endregion
 //#region src/core/schema-verify/verify-sql-schema.ts
 /**
@@ -1123,7 +1132,7 @@ function formatLiteralValue(value) {
 	if (typeof value === "string") return value;
 	return JSON.stringify(value);
 }
-
 //#endregion
 export { verifyDatabaseDependencies as a, extractCodecControlHooks as c, isUniqueConstraintSatisfied as i, arraysEqual as n, collectInitDependencies as o, isIndexSatisfied as r, isDatabaseDependencyProvider as s, verifySqlSchema as t };
-//# sourceMappingURL=verify-sql-schema-Ovz7RXR5.mjs.map
+
+//# sourceMappingURL=verify-sql-schema-r1-2apHI.mjs.map