@prisma-next/family-sql 0.14.0-dev.57 → 0.14.0-dev.59

package/dist/diff.d.mts

@@ -1,60 +1,12 @@
-import { a as NativeTypeNormalizer, c as isUniqueConstraintSatisfied, o as arraysEqual, s as isIndexSatisfied } from "./control-adapter-BVOj4gXI.mjs";
-import { n as CodecControlHooks } from "./types-BW7pzb2j.mjs";
+import { a as NativeTypeNormalizer, o as arraysEqual } from "./control-adapter-BeN8TDZ5.mjs";
+import { n as CodecControlHooks } from "./types-COTsneBU.mjs";
 import { t as SqlSchemaDiffFn } from "./schema-differ-DnoopSXm.mjs";
 import { DiffSubjectGranularity, SchemaDiffIssue, VerifierIssueCategory, VerifyDatabaseSchemaResult } from "@prisma-next/framework-components/control";
 import { Contract, ControlPolicy } from "@prisma-next/contract/types";
 import { SqlStorage } from "@prisma-next/sql-contract/types";
-import { SqlIndexIR, SqlSchemaIR, SqlSchemaIRNode, SqlUniqueIR } from "@prisma-next/sql-schema-ir/types";
+import { SqlSchemaIRNode } from "@prisma-next/sql-schema-ir/types";
 import { TargetBoundComponentDescriptor } from "@prisma-next/framework-components/components";
 
-//#region src/core/diff/diff-tree-normalization.d.ts
-interface SemanticSatisfactionInput {
-  readonly expectedUniques: readonly SqlUniqueIR[];
-  readonly expectedIndexes: readonly SqlIndexIR[];
-  readonly actualUniques: readonly SqlUniqueIR[];
-  readonly actualIndexes: readonly SqlIndexIR[];
-}
-interface SemanticSatisfactionResult {
-  readonly actualUniques: readonly SqlUniqueIR[];
-  readonly actualIndexes: readonly SqlIndexIR[];
-}
-/**
- * Adjusts a table pair's ACTUAL unique/index child lists so the legacy
- * walk's cross-kind semantic satisfaction materializes as same-kind node
- * pairs for the differ (the differ pairs strictly by id, so a `unique:`
- * node can never pair with an `index:` node). Three legacy rules, ported
- * from `isUniqueConstraintSatisfied` / `isIndexSatisfied` and the
- * strict-extras loops of the retired relational walk:
- *
- * 1. A contract unique satisfied by a live unique INDEX: the actual index
- *    node is reclassified as a unique node (it pairs with the expected
- *    unique and stops being a candidate extra).
- * 2. A contract index (with no type/options demands) satisfied by a live
- *    unique CONSTRAINT: a same-kind actual index node is synthesized so
- *    the expected index pairs — the unique constraint itself stays (the
- *    legacy strict-extras loop still reports it as an undeclared unique).
- * 3. Live unique indexes are never extras in the legacy walk (its
- *    strict-extras loop skips `unique: true` rows), so any remaining
- *    actual unique-index node with no expected index counterpart is
- *    dropped rather than surfacing as `not-expected`.
- */
-declare function resolveSemanticSatisfaction(input: SemanticSatisfactionInput): SemanticSatisfactionResult;
-/**
- * Applies {@link resolveSemanticSatisfaction} across a flat table pair set:
- * every actual table with an expected counterpart gets its unique/index
- * child lists adjusted; unpaired tables pass through untouched.
- */
-declare function normalizeFlatActualForDiff(expected: SqlSchemaIR, actual: SqlSchemaIR): SqlSchemaIR;
-/**
- * Neutralizes the FK schema segment on a flat expected tree so its FK diff
- * nodes pair with introspected FKs on single-schema targets: the family
- * converter stamps `referencedSchema` with the contract namespace id
- * verbatim (the unbound sentinel on non-namespaced targets), while a
- * single-schema introspection stamps none — resolving both sides to the
- * empty segment makes the ids meet.
- */
-declare function neutralizeFlatExpectedFkSchemas(expected: SqlSchemaIR): SqlSchemaIR;
-//#endregion
 //#region src/core/diff/schema-verify.d.ts
 /**
  * Resolves an issue's framework-neutral {@link DiffSubjectGranularity} on
@@ -146,5 +98,5 @@ interface VerifySqlSchemaByDiffInput {
  */
 declare function verifySqlSchemaByDiff(input: VerifySqlSchemaByDiffInput): VerifyDatabaseSchemaResult;
 //#endregion
-export { type NativeTypeNormalizer, type SemanticSatisfactionInput, type SemanticSatisfactionResult, type SqlDiffVerdict, type SqlDiffVerdictInput, type StorageTypeVerdict, type StorageTypeVerdictInput, type VerifySqlSchemaByDiffInput, arraysEqual, classifyDiffSubjectGranularity, classifySqlDiffIssue, computeSqlDiffVerdict, computeStorageTypeVerdict, isIndexSatisfied, isUniqueConstraintSatisfied, neutralizeFlatExpectedFkSchemas, normalizeFlatActualForDiff, resolveSemanticSatisfaction, verifySqlSchemaByDiff };
+export { type NativeTypeNormalizer, type SqlDiffVerdict, type SqlDiffVerdictInput, type StorageTypeVerdict, type StorageTypeVerdictInput, type VerifySqlSchemaByDiffInput, arraysEqual, classifyDiffSubjectGranularity, classifySqlDiffIssue, computeSqlDiffVerdict, computeStorageTypeVerdict, verifySqlSchemaByDiff };
 //# sourceMappingURL=diff.d.mts.map

package/dist/diff.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"diff.d.mts","names":[],"sources":["../src/core/diff/diff-tree-normalization.ts","../src/core/diff/schema-verify.ts"],"mappings":";;;;;;;;;;UAqCiB,yBAAA;EAAA,SACN,eAAA,WAA0B,WAAA;EAAA,SAC1B,eAAA,WAA0B,UAAA;EAAA,SAC1B,aAAA,WAAwB,WAAA;EAAA,SACxB,aAAA,WAAwB,UAAA;AAAA;AAAA,UAGlB,0BAAA;EAAA,SACN,aAAA,WAAwB,WAAA;EAAA,SACxB,aAAA,WAAwB,UAAU;AAAA;;;;;AAAA;AA2B7C;;;;;;;;AAE6B;AAyD7B;;;;;;iBA3DgB,2BAAA,CACd,KAAA,EAAO,yBAAA,GACN,0BAA0B;;;;;;iBAyDb,0BAAA,CACd,QAAA,EAAU,WAAA,EACV,MAAA,EAAQ,WAAA,GACP,WAAA;;AAAW;AAuCd;;;;;;iBAAgB,+BAAA,CAAgC,QAAA,EAAU,WAAA,GAAc,WAAW;;;;;;;;;;AArItC;AAG7C;;iBCcgB,8BAAA,CACd,KAAA,EAAO,eAAA,EACP,aAAA,GAAgB,QAAA,aAAqB,sBAAA,GACpC,sBAAA;;;;;;ADc0B;AAyD7B;;;;;;iBCjCgB,oBAAA,CACd,KAAA,EAAO,eAAA,EACP,aAAA,GAAgB,QAAA,aAAqB,sBAAA,GACpC,qBAAA;AAAA,UA4Cc,mBAAA;EDbL;EAAA,SCeD,MAAA,WAAiB,eAAA;EDdlB;EAAA,SCgBC,oBAAA,GAAuB,KAAA,EAAO,eAAA,KAAoB,aAAA;EAAA,SAClD,MAAA;EAAA,SACA,oBAAA,EAAsB,aAAA;EDjBnB;EAAA,SCmBH,aAAA,GAAgB,QAAA,aAAqB,sBAAA;AAAA;AAAA,UAG/B,cAAA;EAAA,SACN,QAAA,WAAmB,eAAA;EAAA,SACnB,QAAA,WAAmB,eAAe;AAAA;;;ADesC;;;;ACpHnF;iBA+GgB,qBAAA,CAAsB,KAAA,EAAO,mBAAA,GAAsB,cAAc;AAAA,UA+BhE,uBAAA;EAAA,SACN,QAAA,EAAU,QAAA,CAAS,UAAA;EA7IS;;;;;;EAAA,SAoJ5B,cAAA,EAAgB,aAAA;IAAA,SACd,MAAA,EAAQ,eAAA;EAAA;EAAA,SAEV,UAAA,EAAY,WAAA,SAAoB,iBAAA;AAAA;AAtJlB;AAsCzB;;;;;;AAtCyB,UAgKR,kBAAA;EAAA,SACN,QAAA,WAAmB,eAAA;EAAA,SACnB,QAAA,WAAmB,eAAe;AAAA;AAAA,iBAG7B,yBAAA,CAA0B,KAAA,EAAO,uBAAA,GAA0B,kBAAkB;AAAA,UA6B5E,0BAAA;EAAA,SACN,QAAA,EAAU,QAAA,CAAS,UAAA;EAAA,SACnB,MAAA,EAAQ,eAAA;EAAA,SACR,MAAA;EAAA,SACA,mBAAA,EAAqB,aAAA,CAAc,8BAAA;EAjH7B;EAAA,SAmHN,UAAA,EAAY,eAAA;;WAEZ,aAAA,GAAgB,QAAA,aAAqB,sBAAA;AAAA;;;;;;;;iBAUhC,qBAAA,CACd,KAAA,EAAO,0BAAA,GACN,0BAA0B"}
+{"version":3,"file":"diff.d.mts","names":[],"sources":["../src/core/diff/schema-verify.ts"],"mappings":";;;;;;;;;;;;;;AA6DyB;AAsCzB;;;;;iBAzCgB,8BAAA,CACd,KAAA,EAAO,eAAA,EACP,aAAA,GAAgB,QAAA,aAAqB,sBAAA,GACpC,sBAAA;AAqFH;;;;;;;;;;;;AAAA,iBA/CgB,oBAAA,CACd,KAAA,EAAO,eAAA,EACP,aAAA,GAAgB,QAAA,aAAqB,sBAAA,GACpC,qBAAA;AAAA,UA4Cc,mBAAA;EAIiB;EAAA,SAFvB,MAAA,WAAiB,eAAA;EAGjB;EAAA,SADA,oBAAA,GAAuB,KAAA,EAAO,eAAA,KAAoB,aAAA;EAAA,SAClD,MAAA;EAAA,SACA,oBAAA,EAAsB,aAAA;EAEN;EAAA,SAAhB,aAAA,GAAgB,QAAA,aAAqB,sBAAA;AAAA;AAAA,UAG/B,cAAA;EAAA,SACN,QAAA,WAAmB,eAAA;EAAA,SACnB,QAAA,WAAmB,eAAe;AAAA;;;;;;;AAAA;iBAU7B,qBAAA,CAAsB,KAAA,EAAO,mBAAA,GAAsB,cAAc;AAAA,UA+BhE,uBAAA;EAAA,SACN,QAAA,EAAU,QAAA,CAAS,UAAA;EAhCmD;;;;;AAAA;EAAA,SAuCtE,cAAA,EAAgB,aAAA;IAAA,SACd,MAAA,EAAQ,eAAA;EAAA;EAAA,SAEV,UAAA,EAAY,WAAA,SAAoB,iBAAA;AAAA;;;;;;;;UAU1B,kBAAA;EAAA,SACN,QAAA,WAAmB,eAAA;EAAA,SACnB,QAAA,WAAmB,eAAe;AAAA;AAAA,iBAG7B,yBAAA,CAA0B,KAAA,EAAO,uBAAA,GAA0B,kBAAkB;AAAA,UA6B5E,0BAAA;EAAA,SACN,QAAA,EAAU,QAAA,CAAS,UAAA;EAAA,SACnB,MAAA,EAAQ,eAAA;EAAA,SACR,MAAA;EAAA,SACA,mBAAA,EAAqB,aAAA,CAAc,8BAAA;EAhDc;EAAA,SAkDjD,UAAA,EAAY,eAAA;EAxCY;EAAA,SA0CxB,aAAA,GAAgB,QAAA,aAAqB,sBAAA;AAAA;;;;;;AAxCH;AAG7C;iBA+CgB,qBAAA,CACd,KAAA,EAAO,0BAAA,GACN,0BAA0B"}

package/dist/diff.mjs

@@ -1,159 +1,4 @@
 import { a as computeStorageTypeVerdict, i as computeSqlDiffVerdict, n as classifyDiffSubjectGranularity, o as verifySqlSchemaByDiff, r as classifySqlDiffIssue } from "./schema-verify-W3r631Jh.mjs";
-import { SqlForeignKeyIR, SqlIndexIR, SqlSchemaIR, SqlTableIR, SqlUniqueIR } from "@prisma-next/sql-schema-ir/types";
-//#region src/core/diff/diff-tree-normalization.ts
-/**
-* ⚠️ ACCEPTED-UNDER-PROTEST DEBT — DELETE IN SLICE 2.6 (`unify-unique-and-index-nodes`).
-*
-* A unique constraint IS a unique index. This slice modeled uniques and indexes
-* as two separate node kinds (`SqlUniqueIR` vs `SqlIndexIR` — even though
-* `SqlIndexIR` already carries `unique: boolean`), so the strict-by-kind differ
-* cannot pair a contract unique with a live unique index. This whole file
-* exists only to reconcile those two representations after the fact — it
-* should not exist.
-*
-* The fix — delete `SqlUniqueIR`, model unique enforcement as
-* `SqlIndexIR { unique: true }` on both derivation and introspection, and
-* delete `diff-tree-normalization.ts` — is specified in
-* `projects/postgres-rls/slices/unify-unique-and-index-nodes/spec.md` and
-* scheduled as the very next slice. Do NOT extend this.
-*/
-/**
-* Pre-diff tree normalization: adjustments to the actual/expected trees the
-* generic differ (`diffSchemas`) runs over, so legacy semantic-equivalence
-* rules (a unique constraint satisfied by a unique index, an FK schema
-* segment that differs only in spelling) surface as same-kind node pairs
-* instead of spurious drift.
-*/
-function sameColumns(a, b) {
-	return a.length === b.length && a.every((c, i) => c === b[i]);
-}
-/**
-* Adjusts a table pair's ACTUAL unique/index child lists so the legacy
-* walk's cross-kind semantic satisfaction materializes as same-kind node
-* pairs for the differ (the differ pairs strictly by id, so a `unique:`
-* node can never pair with an `index:` node). Three legacy rules, ported
-* from `isUniqueConstraintSatisfied` / `isIndexSatisfied` and the
-* strict-extras loops of the retired relational walk:
-*
-* 1. A contract unique satisfied by a live unique INDEX: the actual index
-*    node is reclassified as a unique node (it pairs with the expected
-*    unique and stops being a candidate extra).
-* 2. A contract index (with no type/options demands) satisfied by a live
-*    unique CONSTRAINT: a same-kind actual index node is synthesized so
-*    the expected index pairs — the unique constraint itself stays (the
-*    legacy strict-extras loop still reports it as an undeclared unique).
-* 3. Live unique indexes are never extras in the legacy walk (its
-*    strict-extras loop skips `unique: true` rows), so any remaining
-*    actual unique-index node with no expected index counterpart is
-*    dropped rather than surfacing as `not-expected`.
-*/
-function resolveSemanticSatisfaction(input) {
-	let actualIndexes = [...input.actualIndexes];
-	const actualUniques = [...input.actualUniques];
-	for (const expectedUnique of input.expectedUniques) {
-		if (actualUniques.some((u) => sameColumns(u.columns, expectedUnique.columns))) continue;
-		const satisfyingIndex = actualIndexes.find((idx) => idx.unique && sameColumns(idx.columns, expectedUnique.columns));
-		if (satisfyingIndex) {
-			actualIndexes = actualIndexes.filter((idx) => idx !== satisfyingIndex);
-			actualUniques.push(new SqlUniqueIR({
-				columns: satisfyingIndex.columns,
-				...satisfyingIndex.name !== void 0 ? { name: satisfyingIndex.name } : {}
-			}));
-		}
-	}
-	for (const expectedIndex of input.expectedIndexes) {
-		if (expectedIndex.type !== void 0 || expectedIndex.options !== void 0) continue;
-		if (actualIndexes.some((idx) => sameColumns(idx.columns, expectedIndex.columns))) continue;
-		const satisfyingUnique = actualUniques.find((u) => sameColumns(u.columns, expectedIndex.columns));
-		if (satisfyingUnique) actualIndexes.push(new SqlIndexIR({
-			columns: satisfyingUnique.columns,
-			unique: false
-		}));
-	}
-	actualIndexes = actualIndexes.filter((idx) => !idx.unique || input.expectedIndexes.some((exp) => sameColumns(exp.columns, idx.columns)));
-	return {
-		actualUniques,
-		actualIndexes
-	};
-}
-/**
-* Applies {@link resolveSemanticSatisfaction} across a flat table pair set:
-* every actual table with an expected counterpart gets its unique/index
-* child lists adjusted; unpaired tables pass through untouched.
-*/
-function normalizeFlatActualForDiff(expected, actual) {
-	const tables = {};
-	for (const [name, actualTable] of Object.entries(actual.tables)) {
-		const expectedTable = expected.tables[name];
-		if (expectedTable === void 0) {
-			tables[name] = actualTable;
-			continue;
-		}
-		const adjusted = resolveSemanticSatisfaction({
-			expectedUniques: expectedTable.uniques,
-			expectedIndexes: expectedTable.indexes,
-			actualUniques: actualTable.uniques,
-			actualIndexes: actualTable.indexes
-		});
-		tables[name] = new SqlTableIR({
-			name: actualTable.name,
-			columns: actualTable.columns,
-			foreignKeys: actualTable.foreignKeys,
-			uniques: adjusted.actualUniques,
-			indexes: adjusted.actualIndexes,
-			...actualTable.primaryKey !== void 0 ? { primaryKey: actualTable.primaryKey } : {},
-			...actualTable.annotations !== void 0 ? { annotations: actualTable.annotations } : {},
-			...actualTable.checks !== void 0 ? { checks: actualTable.checks } : {}
-		});
-	}
-	return new SqlSchemaIR({
-		tables,
-		...actual.annotations !== void 0 ? { annotations: actual.annotations } : {}
-	});
-}
-/**
-* Neutralizes the FK schema segment on a flat expected tree so its FK diff
-* nodes pair with introspected FKs on single-schema targets: the family
-* converter stamps `referencedSchema` with the contract namespace id
-* verbatim (the unbound sentinel on non-namespaced targets), while a
-* single-schema introspection stamps none — resolving both sides to the
-* empty segment makes the ids meet.
-*/
-function neutralizeFlatExpectedFkSchemas(expected) {
-	const tables = {};
-	for (const [name, table] of Object.entries(expected.tables)) {
-		if (table.foreignKeys.length === 0) {
-			tables[name] = table;
-			continue;
-		}
-		const foreignKeys = table.foreignKeys.map((fk) => new SqlForeignKeyIR({
-			columns: fk.columns,
-			referencedTable: fk.referencedTable,
-			referencedColumns: fk.referencedColumns,
-			...fk.referencedSchema !== void 0 ? { referencedSchema: fk.referencedSchema } : {},
-			...fk.name !== void 0 ? { name: fk.name } : {},
-			...fk.onDelete !== void 0 ? { onDelete: fk.onDelete } : {},
-			...fk.onUpdate !== void 0 ? { onUpdate: fk.onUpdate } : {},
-			...fk.annotations !== void 0 ? { annotations: fk.annotations } : {},
-			resolvedReferencedNamespace: ""
-		}));
-		tables[name] = new SqlTableIR({
-			name: table.name,
-			columns: table.columns,
-			foreignKeys,
-			uniques: table.uniques,
-			indexes: table.indexes,
-			...table.primaryKey !== void 0 ? { primaryKey: table.primaryKey } : {},
-			...table.annotations !== void 0 ? { annotations: table.annotations } : {},
-			...table.checks !== void 0 ? { checks: table.checks } : {}
-		});
-	}
-	return new SqlSchemaIR({
-		tables,
-		...expected.annotations !== void 0 ? { annotations: expected.annotations } : {}
-	});
-}
-//#endregion
 //#region src/core/diff/sql-schema-diff.ts
 /**
 * Compares two arrays of strings for equality (order-sensitive).
@@ -163,26 +8,7 @@ function arraysEqual(a, b) {
 	for (let i = 0; i < a.length; i++) if (a[i] !== b[i]) return false;
 	return true;
 }
-/**
-* Checks if a unique constraint requirement is satisfied by the given columns:
-* a unique constraint with the same columns, or a unique index with the same
-* columns (semantic satisfaction). Used by the planners to keep the
-* "stronger satisfies weaker" behavior consistent across the control plane.
-*/
-function isUniqueConstraintSatisfied(uniques, indexes, columns) {
-	if (uniques.some((unique) => arraysEqual(unique.columns, columns))) return true;
-	return indexes.some((index) => index.unique && arraysEqual(index.columns, columns));
-}
-/**
-* Checks if an index requirement is satisfied by the given columns: any index
-* (unique or non-unique) with the same columns, or a unique constraint with
-* the same columns (stronger satisfies weaker).
-*/
-function isIndexSatisfied(indexes, uniques, columns) {
-	if (indexes.some((index) => arraysEqual(index.columns, columns))) return true;
-	return uniques.some((unique) => arraysEqual(unique.columns, columns));
-}
 //#endregion
-export { arraysEqual, classifyDiffSubjectGranularity, classifySqlDiffIssue, computeSqlDiffVerdict, computeStorageTypeVerdict, isIndexSatisfied, isUniqueConstraintSatisfied, neutralizeFlatExpectedFkSchemas, normalizeFlatActualForDiff, resolveSemanticSatisfaction, verifySqlSchemaByDiff };
+export { arraysEqual, classifyDiffSubjectGranularity, classifySqlDiffIssue, computeSqlDiffVerdict, computeStorageTypeVerdict, verifySqlSchemaByDiff };
 
 //# sourceMappingURL=diff.mjs.map

package/dist/diff.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"diff.mjs","names":[],"sources":["../src/core/diff/diff-tree-normalization.ts","../src/core/diff/sql-schema-diff.ts"],"sourcesContent":["/**\n * ⚠️ ACCEPTED-UNDER-PROTEST DEBT — DELETE IN SLICE 2.6 (`unify-unique-and-index-nodes`).\n *\n * A unique constraint IS a unique index. This slice modeled uniques and indexes\n * as two separate node kinds (`SqlUniqueIR` vs `SqlIndexIR` — even though\n * `SqlIndexIR` already carries `unique: boolean`), so the strict-by-kind differ\n * cannot pair a contract unique with a live unique index. This whole file\n * exists only to reconcile those two representations after the fact — it\n * should not exist.\n *\n * The fix — delete `SqlUniqueIR`, model unique enforcement as\n * `SqlIndexIR { unique: true }` on both derivation and introspection, and\n * delete `diff-tree-normalization.ts` — is specified in\n * `projects/postgres-rls/slices/unify-unique-and-index-nodes/spec.md` and\n * scheduled as the very next slice. Do NOT extend this.\n */\n\n/**\n * Pre-diff tree normalization: adjustments to the actual/expected trees the\n * generic differ (`diffSchemas`) runs over, so legacy semantic-equivalence\n * rules (a unique constraint satisfied by a unique index, an FK schema\n * segment that differs only in spelling) surface as same-kind node pairs\n * instead of spurious drift.\n */\n\nimport {\n  SqlForeignKeyIR,\n  SqlIndexIR,\n  SqlSchemaIR,\n  SqlTableIR,\n  SqlUniqueIR,\n} from '@prisma-next/sql-schema-ir/types';\n\n// ============================================================================\n// Semantic satisfaction — derivation-side normalization of the actual tree\n// ============================================================================\n\nexport interface SemanticSatisfactionInput {\n  readonly expectedUniques: readonly SqlUniqueIR[];\n  readonly expectedIndexes: readonly SqlIndexIR[];\n  readonly actualUniques: readonly SqlUniqueIR[];\n  readonly actualIndexes: readonly SqlIndexIR[];\n}\n\nexport interface SemanticSatisfactionResult {\n  readonly actualUniques: readonly SqlUniqueIR[];\n  readonly actualIndexes: readonly SqlIndexIR[];\n}\n\nfunction sameColumns(a: readonly string[], b: readonly string[]): boolean {\n  return a.length === b.length && a.every((c, i) => c === b[i]);\n}\n\n/**\n * Adjusts a table pair's ACTUAL unique/index child lists so the legacy\n * walk's cross-kind semantic satisfaction materializes as same-kind node\n * pairs for the differ (the differ pairs strictly by id, so a `unique:`\n * node can never pair with an `index:` node). Three legacy rules, ported\n * from `isUniqueConstraintSatisfied` / `isIndexSatisfied` and the\n * strict-extras loops of the retired relational walk:\n *\n * 1. A contract unique satisfied by a live unique INDEX: the actual index\n *    node is reclassified as a unique node (it pairs with the expected\n *    unique and stops being a candidate extra).\n * 2. A contract index (with no type/options demands) satisfied by a live\n *    unique CONSTRAINT: a same-kind actual index node is synthesized so\n *    the expected index pairs — the unique constraint itself stays (the\n *    legacy strict-extras loop still reports it as an undeclared unique).\n * 3. Live unique indexes are never extras in the legacy walk (its\n *    strict-extras loop skips `unique: true` rows), so any remaining\n *    actual unique-index node with no expected index counterpart is\n *    dropped rather than surfacing as `not-expected`.\n */\nexport function resolveSemanticSatisfaction(\n  input: SemanticSatisfactionInput,\n): SemanticSatisfactionResult {\n  let actualIndexes = [...input.actualIndexes];\n  const actualUniques = [...input.actualUniques];\n\n  // Rule 1: reclassify a satisfying unique index as the unique constraint\n  // the contract declared.\n  for (const expectedUnique of input.expectedUniques) {\n    const alreadyPaired = actualUniques.some((u) => sameColumns(u.columns, expectedUnique.columns));\n    if (alreadyPaired) continue;\n    const satisfyingIndex = actualIndexes.find(\n      (idx) => idx.unique && sameColumns(idx.columns, expectedUnique.columns),\n    );\n    if (satisfyingIndex) {\n      actualIndexes = actualIndexes.filter((idx) => idx !== satisfyingIndex);\n      actualUniques.push(\n        new SqlUniqueIR({\n          columns: satisfyingIndex.columns,\n          ...(satisfyingIndex.name !== undefined ? { name: satisfyingIndex.name } : {}),\n        }),\n      );\n    }\n  }\n\n  // Rule 2: synthesize an index node from a satisfying unique constraint.\n  for (const expectedIndex of input.expectedIndexes) {\n    if (expectedIndex.type !== undefined || expectedIndex.options !== undefined) continue;\n    const alreadyPaired = actualIndexes.some((idx) =>\n      sameColumns(idx.columns, expectedIndex.columns),\n    );\n    if (alreadyPaired) continue;\n    const satisfyingUnique = actualUniques.find((u) =>\n      sameColumns(u.columns, expectedIndex.columns),\n    );\n    if (satisfyingUnique) {\n      actualIndexes.push(new SqlIndexIR({ columns: satisfyingUnique.columns, unique: false }));\n    }\n  }\n\n  // Rule 3: remaining unique indexes with no expected counterpart are\n  // invisible to the legacy extras loop — drop them.\n  actualIndexes = actualIndexes.filter(\n    (idx) =>\n      !idx.unique || input.expectedIndexes.some((exp) => sameColumns(exp.columns, idx.columns)),\n  );\n\n  return { actualUniques, actualIndexes };\n}\n\n// ============================================================================\n// Flat-tree helpers (single-schema targets)\n// ============================================================================\n\n/**\n * Applies {@link resolveSemanticSatisfaction} across a flat table pair set:\n * every actual table with an expected counterpart gets its unique/index\n * child lists adjusted; unpaired tables pass through untouched.\n */\nexport function normalizeFlatActualForDiff(\n  expected: SqlSchemaIR,\n  actual: SqlSchemaIR,\n): SqlSchemaIR {\n  const tables: Record<string, SqlTableIR> = {};\n  for (const [name, actualTable] of Object.entries(actual.tables)) {\n    const expectedTable = expected.tables[name];\n    if (expectedTable === undefined) {\n      tables[name] = actualTable;\n      continue;\n    }\n    const adjusted = resolveSemanticSatisfaction({\n      expectedUniques: expectedTable.uniques,\n      expectedIndexes: expectedTable.indexes,\n      actualUniques: actualTable.uniques,\n      actualIndexes: actualTable.indexes,\n    });\n    tables[name] = new SqlTableIR({\n      name: actualTable.name,\n      columns: actualTable.columns,\n      foreignKeys: actualTable.foreignKeys,\n      uniques: adjusted.actualUniques,\n      indexes: adjusted.actualIndexes,\n      ...(actualTable.primaryKey !== undefined ? { primaryKey: actualTable.primaryKey } : {}),\n      ...(actualTable.annotations !== undefined ? { annotations: actualTable.annotations } : {}),\n      ...(actualTable.checks !== undefined ? { checks: actualTable.checks } : {}),\n    });\n  }\n  return new SqlSchemaIR({\n    tables,\n    ...(actual.annotations !== undefined ? { annotations: actual.annotations } : {}),\n  });\n}\n\n/**\n * Neutralizes the FK schema segment on a flat expected tree so its FK diff\n * nodes pair with introspected FKs on single-schema targets: the family\n * converter stamps `referencedSchema` with the contract namespace id\n * verbatim (the unbound sentinel on non-namespaced targets), while a\n * single-schema introspection stamps none — resolving both sides to the\n * empty segment makes the ids meet.\n */\nexport function neutralizeFlatExpectedFkSchemas(expected: SqlSchemaIR): SqlSchemaIR {\n  const tables: Record<string, SqlTableIR> = {};\n  for (const [name, table] of Object.entries(expected.tables)) {\n    if (table.foreignKeys.length === 0) {\n      tables[name] = table;\n      continue;\n    }\n    const foreignKeys = table.foreignKeys.map(\n      (fk) =>\n        new SqlForeignKeyIR({\n          columns: fk.columns,\n          referencedTable: fk.referencedTable,\n          referencedColumns: fk.referencedColumns,\n          ...(fk.referencedSchema !== undefined ? { referencedSchema: fk.referencedSchema } : {}),\n          ...(fk.name !== undefined ? { name: fk.name } : {}),\n          ...(fk.onDelete !== undefined ? { onDelete: fk.onDelete } : {}),\n          ...(fk.onUpdate !== undefined ? { onUpdate: fk.onUpdate } : {}),\n          ...(fk.annotations !== undefined ? { annotations: fk.annotations } : {}),\n          resolvedReferencedNamespace: '',\n        }),\n    );\n    tables[name] = new SqlTableIR({\n      name: table.name,\n      columns: table.columns,\n      foreignKeys,\n      uniques: table.uniques,\n      indexes: table.indexes,\n      ...(table.primaryKey !== undefined ? { primaryKey: table.primaryKey } : {}),\n      ...(table.annotations !== undefined ? { annotations: table.annotations } : {}),\n      ...(table.checks !== undefined ? { checks: table.checks } : {}),\n    });\n  }\n  return new SqlSchemaIR({\n    tables,\n    ...(expected.annotations !== undefined ? { annotations: expected.annotations } : {}),\n  });\n}\n","/**\n * Shared relational-diff types and semantic-satisfaction predicates. The\n * coordinate-based issue diff this module used to house (`collectSqlSchemaIssues`\n * / `collectSqlSchemaIssuesPerNamespace`) retired once the migration planner\n * took `plan(start, end)` over the one differ (`buildPostgresPlanDiff` /\n * `buildSqlitePlanDiff`); what remains here is consumed by the surviving\n * verify verdict (`schema-verify.ts`) and the control adapters.\n */\n\nimport type { ColumnDefault } from '@prisma-next/contract/types';\nimport type { SqlIndexIR, SqlUniqueIR } from '@prisma-next/sql-schema-ir/types';\n\n/**\n * Function type for normalizing raw database default expressions into ColumnDefault.\n * Target-specific implementations handle database dialect differences.\n */\nexport type DefaultNormalizer = (\n  rawDefault: string,\n  nativeType: string,\n) => ColumnDefault | undefined;\n\n/**\n * Function type for normalizing schema native types to canonical form for comparison.\n * Target-specific implementations handle dialect-specific type name variations\n * (e.g., Postgres 'varchar' → 'character varying', 'timestamptz' normalization).\n */\nexport type NativeTypeNormalizer = (nativeType: string) => string;\n\n/**\n * Compares two arrays of strings for equality (order-sensitive).\n */\nexport function arraysEqual(a: readonly string[], b: readonly string[]): boolean {\n  if (a.length !== b.length) {\n    return false;\n  }\n  for (let i = 0; i < a.length; i++) {\n    if (a[i] !== b[i]) {\n      return false;\n    }\n  }\n  return true;\n}\n\n/**\n * Checks if a unique constraint requirement is satisfied by the given columns:\n * a unique constraint with the same columns, or a unique index with the same\n * columns (semantic satisfaction). Used by the planners to keep the\n * \"stronger satisfies weaker\" behavior consistent across the control plane.\n */\nexport function isUniqueConstraintSatisfied(\n  uniques: readonly SqlUniqueIR[],\n  indexes: readonly SqlIndexIR[],\n  columns: readonly string[],\n): boolean {\n  const hasConstraint = uniques.some((unique) => arraysEqual(unique.columns, columns));\n  if (hasConstraint) {\n    return true;\n  }\n  return indexes.some((index) => index.unique && arraysEqual(index.columns, columns));\n}\n\n/**\n * Checks if an index requirement is satisfied by the given columns: any index\n * (unique or non-unique) with the same columns, or a unique constraint with\n * the same columns (stronger satisfies weaker).\n */\nexport function isIndexSatisfied(\n  indexes: readonly SqlIndexIR[],\n  uniques: readonly SqlUniqueIR[],\n  columns: readonly string[],\n): boolean {\n  const hasMatchingIndex = indexes.some((index) => arraysEqual(index.columns, columns));\n  if (hasMatchingIndex) {\n    return true;\n  }\n  return uniques.some((unique) => arraysEqual(unique.columns, columns));\n}\n"],"mappings":"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"}
+{"version":3,"file":"diff.mjs","names":[],"sources":["../src/core/diff/sql-schema-diff.ts"],"sourcesContent":["/**\n * Shared relational-diff types and helpers. The coordinate-based issue diff\n * this module used to house (`collectSqlSchemaIssues` /\n * `collectSqlSchemaIssuesPerNamespace`) retired once the migration planner\n * took `plan(start, end)` over the one differ (`buildPostgresPlanDiff` /\n * `buildSqlitePlanDiff`); what remains here is consumed by the surviving\n * verify verdict (`schema-verify.ts`) and the control adapters.\n */\n\nimport type { ColumnDefault } from '@prisma-next/contract/types';\n\n/**\n * Function type for normalizing raw database default expressions into ColumnDefault.\n * Target-specific implementations handle database dialect differences.\n */\nexport type DefaultNormalizer = (\n  rawDefault: string,\n  nativeType: string,\n) => ColumnDefault | undefined;\n\n/**\n * Function type for normalizing schema native types to canonical form for comparison.\n * Target-specific implementations handle dialect-specific type name variations\n * (e.g., Postgres 'varchar' → 'character varying', 'timestamptz' normalization).\n */\nexport type NativeTypeNormalizer = (nativeType: string) => string;\n\n/**\n * Compares two arrays of strings for equality (order-sensitive).\n */\nexport function arraysEqual(a: readonly string[], b: readonly string[]): boolean {\n  if (a.length !== b.length) {\n    return false;\n  }\n  for (let i = 0; i < a.length; i++) {\n    if (a[i] !== b[i]) {\n      return false;\n    }\n  }\n  return true;\n}\n"],"mappings":";;;;;AA8BA,SAAgB,YAAY,GAAsB,GAA+B;CAC/E,IAAI,EAAE,WAAW,EAAE,QACjB,OAAO;CAET,KAAK,IAAI,IAAI,GAAG,IAAI,EAAE,QAAQ,KAC5B,IAAI,EAAE,OAAO,EAAE,IACb,OAAO;CAGX,OAAO;AACT"}

package/dist/migration.d.mts

@@ -1,4 +1,4 @@
-import { f as SqlMigrationPlanOperation, w as SqlPlanTargetDetails } from "./types-BW7pzb2j.mjs";
+import { f as SqlMigrationPlanOperation, w as SqlPlanTargetDetails } from "./types-COTsneBU.mjs";
 import { Contract } from "@prisma-next/contract/types";
 import { SqlStorage } from "@prisma-next/sql-contract/types";
 import { Migration } from "@prisma-next/migration-tools/migration";

package/dist/{types-BW7pzb2j.d.mts → types-COTsneBU.d.mts}

@@ -1,4 +1,4 @@
-import { r as SqlControlAdapter } from "./control-adapter-BVOj4gXI.mjs";
+import { r as SqlControlAdapter } from "./control-adapter-BeN8TDZ5.mjs";
 import { ContractSpace, ControlAdapterDescriptor, ControlExtensionDescriptor, MigrationOperationPolicy, MigrationPlan, MigrationPlanOperation, MigrationPlannerConflict, MigrationPlannerFailureResult, MigrationPlannerSuccessResult, MigrationRunnerExecutionChecks, MigrationRunnerFailure, MigrationRunnerPerSpaceSuccessValue, MigrationRunnerResult, OpFactoryCall, OperationContext, SchemaDiffIssue, SchemaOwnership } from "@prisma-next/framework-components/control";
 import { Contract } from "@prisma-next/contract/types";
 import { SqlControlDriverInstance, SqlStorage, StorageColumn, StorageTable, StorageTypeInstance } from "@prisma-next/sql-contract/types";
@@ -412,4 +412,4 @@ interface CreateSqlMigrationPlanOptions<TTargetDetails> {
 }
 //#endregion
 export { SqlPlannerSuccessResult as A, SqlMigrationRunnerSuccessValue as C, SqlPlannerConflictLocation as D, SqlPlannerConflictKind as E, SqlPlannerFailureResult as O, SqlMigrationRunnerResult as S, SqlPlannerConflict as T, SqlMigrationRunner as _, FieldEvent as a, SqlMigrationRunnerExecuteOptions as b, SqlControlAdapterDescriptor as c, SqlMigrationPlanContractInfo as d, SqlMigrationPlanOperation as f, SqlMigrationPlannerPlanOptions as g, SqlMigrationPlanner as h, ExpandNativeTypeInput as i, StorageTypePlanResult as j, SqlPlannerResult as k, SqlControlExtensionDescriptor as l, SqlMigrationPlanOperationTarget as m, CodecControlHooks as n, FieldEventContext as o, SqlMigrationPlanOperationStep as p, CreateSqlMigrationPlanOptions as r, ResolveIdentityValueInput as s, AnyRecord as t, SqlMigrationPlan as u, SqlMigrationRunnerErrorCode as v, SqlPlanTargetDetails as w, SqlMigrationRunnerFailure as x, SqlMigrationRunnerExecuteCallbacks as y };
-//# sourceMappingURL=types-BW7pzb2j.d.mts.map
+//# sourceMappingURL=types-COTsneBU.d.mts.map

package/dist/{types-BW7pzb2j.d.mts.map → types-COTsneBU.d.mts.map}

@@ -1 +1 @@
-{"version":3,"file":"types-BW7pzb2j.d.mts","names":[],"sources":["../src/core/migrations/types.ts"],"mappings":";;;;;;;;;;;KAkCY,SAAA,GAAY,QAAQ,CAAC,MAAA;AAAA,UAEhB,qBAAA;EAAA,SACN,UAAA,WAAqB,yBAAyB,CAAC,cAAA;AAAA;;;AAHnB;UAStB,qBAAA;EAAA,SACN,UAAA;EAAA,SACA,OAAA;EAAA,SACA,UAAA,GAAa,MAAM;AAAA;;;;;AAT0C;AAMxE;;UAaiB,yBAAA;EAAA,SACN,UAAA;EAAA,SACA,OAAA;EAAA,SACA,UAAA,GAAa,MAAM;AAAA;;;AAbA;AAU9B;;;;;;;;;AAG8B;AAiB9B;KAAY,UAAA;;;AAAU;AActB;;;;;;;;;UAAiB,iBAAA;EAAA,SACN,WAAA;EAAA,SACA,SAAA;EAAA,SACA,SAAA;EAAA,SACA,UAAA,GAAa,YAAA;EAAA,SACb,QAAA,GAAW,YAAA;EAAA,SACX,UAAA,GAAa,aAAA;EAAA,SACb,QAAA,GAAW,aAAA;AAAA;AAAA,UAGL,iBAAA;EAHK;;AAAa;AAGnC;;;;;;EAUE,kBAAA,IAAsB,OAAA;IAAA,SACX,QAAA;IAAA,SACA,YAAA,EAAc,mBAAA;IAAA,SACd,QAAA,EAAU,QAAA,CAAS,UAAA;IAAA,SACnB,MAAA,EAAQ,eAAA;IAAA,SACR,UAAA;IAAA,SACA,MAAA,EAAQ,wBAAA;EAAA,MACb,qBAAA,CAAsB,cAAA;EAC5B,UAAA,IAAc,OAAA;IAAA,SACH,QAAA;IAAA,SACA,YAAA,EAAc,mBAAA;IAAA,SACd,MAAA,EAAQ,eAAA;IAAA,SACR,UAAA;EAAA,eACI,eAAA;EACf,eAAA,IAAmB,OAAA;IAAA,SACR,MAAA,EAAQ,wBAAA;IAAA,SACR,UAAA;EAAA,MACL,OAAA,CAAQ,MAAA,SAAe,mBAAA;EA3BI;;;;;;;;;;EAsCjC,gBAAA,IAAoB,KAAA,EAAO,qBAAA;EAtBhB;;;;;;;;;EAgCX,oBAAA,IAAwB,KAAA,EAAO,yBAAA;EA3BZ;;;;;;;;;;;;;;EA0CnB,YAAA,IAAgB,KAAA,EAAO,UAAA,EAAY,GAAA,EAAK,iBAAA,cAA+B,aAAA;AAAA;AAAA,UAGxD,6BAAA,mCACP,0BAAA,QAAkC,SAAA;EAAA,SACjC,eAAA,SAAwB,uBAAA;EALjC;;;;;;;AAAoF;AAGtF;;;EAHE,SAiBS,aAAA,GAAgB,aAAA,CAAc,QAAA,CAAS,UAAA;AAAA;AAAA,UAGjC,2BAAA,mCACP,wBAAA,QAAgC,SAAA,EAAW,iBAAA,CAAkB,SAAA;EAAA,SAC5D,eAAA,SAAwB,uBAAA;AAAA;AAAA,UAGlB,6BAAA;EAAA,SACN,WAAA;EAAA,SACA,GAAA;EAxBoC;;;;;;;;EAAA,SAiCpC,MAAA;EAAA,SACA,IAAA,GAAO,SAAS;AAAA;AAjB3B;;;;;;;AAAA,UA2BiB,oBAAA;EAAA,SACN,MAAA;EAAA,SACA,IAAI;AAAA;AAAA,UAGE,+BAAA;EAAA,SACN,EAAA;EAAA,SACA,OAAA,GAAU,cAAc;AAAA;AAAA,UAGlB,yBAAA,yBAAkD,sBAAA;EAAA,SACxD,OAAA;EAAA,SACA,MAAA,EAAQ,+BAAA,CAAgC,cAAA;EAAA,SACxC,QAAA,WAAmB,6BAAA;EAAA,SACnB,OAAA,WAAkB,6BAAA;EAAA,SAClB,SAAA,WAAoB,6BAAA;EAAA,SACpB,IAAA,GAAO,SAAA;AAAA;AAAA,UAGD,4BAAA;EAAA,SACN,WAAA;EAAA,SACA,WAAW;AAAA;AAAA,UAGL,gBAAA,yBAAyC,aAAA;EAlC/B;AAAA;AAU3B;;;;AAEe;AAGf;;;;;;;EAf2B,SAiDhB,OAAA;EAhCwB;AAAA;AAGnC;;EAHmC,SAqCxB,MAAA,GAAS,4BAAA;EAhC+B;;;EAAA,SAoCxC,WAAA,EAAa,4BAAA;EAAA,SACb,UAAA,YACL,yBAAA,CAA0B,cAAA,IAC1B,OAAA,CAAQ,yBAAA,CAA0B,cAAA;EAnCtB;;;;;;;;EAAA,SA6CP,kBAAA;EAAA,SACA,IAAA,GAAO,SAAA;AAAA;AAAA,KAGN,sBAAA;AAAA,UASK,0BAAA;EAAA,SACN,SAAA;EAAA,SACA,KAAA;EAAA,SACA,MAAA;EAAA,SACA,KAAA;EAAA,SACA,UAAA;EAAA,SACA,IAAA;AAAA;AAAA,UAGM,kBAAA,SAA2B,wBAAA;EAAA,SACjC,IAAA,EAAM,sBAAA;EAAA,SACN,QAAA,GAAW,0BAAA;EAAA,SACX,IAAA,GAAO,SAAA;AAAA;AAAA,UAGD,uBAAA,yBACP,IAAA,CAAK,6BAAA;EAAA,SACJ,IAAA;EAAA,SACA,IAAA,EAAM,gBAAA,CAAiB,cAAA;AAAA;AAAA,UAGjB,uBAAA,SAAgC,IAAA,CAAK,6BAAA;EAAA,SAC3C,IAAA;EAAA,SACA,SAAA,WAAoB,kBAAA;AAAA;AAAA,KAGnB,gBAAA,mBACR,uBAAA,CAAwB,cAAA,IACxB,uBAAA;AAAA,UAEa,8BAAA;EAAA,SACN,QAAA,EAAU,QAAA,CAAS,UAAA;EAjF4B;;;;;EAAA,SAuF/C,MAAA,EAAQ,eAAA;EAAA,SACR,MAAA,EAAQ,wBAAA;EAAA,SACR,UAAA;EAjEA;;;;;;;EAAA,SAyEA,OAAA;EA5DA;;;;AACgB;AAG3B;;;;AAAkC;AASlC;;;;;;EAbW,SA6EA,YAAA,EAAc,QAAA,CAAS,UAAA;EA5DvB;;;;AAEI;AAGf;EALW,SAmEA,mBAAA,EAAqB,aAAA,CAAc,8BAAA;;;;;;;;;;WAUnC,SAAA,GAAY,eAAA;AAAA;AAAA,UAGN,mBAAA;EACf,IAAA,CAAK,OAAA,EAAS,8BAAA,GAAiC,gBAAA,CAAiB,cAAA;AAAA;AAAA,UAGjD,kCAAA;EACf,gBAAA,EAAkB,SAAA,EAAW,yBAAA,CAA0B,cAAA;EACvD,mBAAA,EAAqB,SAAA,EAAW,yBAAA,CAA0B,cAAA;AAAA;AAAA,UAG3C,gCAAA;EAAA,SACN,IAAA,EAAM,gBAAA,CAAiB,cAAA;EAAA,SACvB,MAAA,EAAQ,wBAAA;EA7EF;;;;;;;EAAA,SAqFN,KAAA;EArFA;;;;EAAA,SA0FA,mBAAA,EAAqB,QAAA,CAAS,UAAA;EAvFxB;;;;EAAA,SA4FN,MAAA,EAAQ,wBAAA;EAAA,SACR,UAAA;EAAA,SACA,kBAAA;EAAA,SACA,SAAA,GAAY,kCAAA,CAAmC,cAAA;EAAA,SAC/C,OAAA,GAAU,gBAAA;EAhGiC;;;;EAAA,SAqG3C,eAAA,GAAkB,8BAAA;EAnGoB;AAGjD;;;;;EAHiD,SA0GtC,mBAAA,EAAqB,aAAA,CAAc,8BAAA;EArGnB;;;;EAAA,SA0GhB,cAAA,WAAyB,yBAAA;AAAA;AAAA,KAGxB,2BAAA;AAAA,UAYK,yBAAA,SAAkC,sBAAA;EAAA,SACxC,IAAA,EAAM,2BAAA;EAAA,SACN,IAAA,GAAO,SAAA;AAAA;AAAA,UAGD,8BAAA,SAAuC,mCAAmC;AAAA,KAE/E,wBAAA,GAA2B,MAAA,CACrC,8BAAA,EACA,yBAAA;AAAA,UAGe,kBAAA;EAjGiB;;;;;;;;;;;;;EA+GhC,OAAA,CAAQ,OAAA;IAAA,SACG,MAAA,EAAQ,wBAAA;IAAA,SACR,eAAA,EAAiB,aAAA,CAAc,gCAAA,CAAiC,cAAA;EAAA,IACvE,OAAA,CAAQ,qBAAA;EAlHW;;;;;;;;AAiBa;AAGtC;EA0GE,mBAAA,CACE,OAAA,EAAS,gCAAA,CAAiC,cAAA,IACzC,OAAA,CAAQ,wBAAA;AAAA;AAAA,UAGI,6BAAA;EAAA,SACN,QAAA;EA/GsC;;;EAAA,SAmHtC,OAAA;EAAA,SACA,MAAA,GAAS,4BAAA;EAAA,SACT,WAAA,EAAa,4BAAA;EAAA,SACb,UAAA,WAAqB,yBAAA,CAA0B,cAAA;EAtHT;;;AAA+B;AAGhF;EAHiD,SA4HtC,kBAAA;EAAA,SACA,IAAA,GAAO,SAAA;AAAA"}
+{"version":3,"file":"types-COTsneBU.d.mts","names":[],"sources":["../src/core/migrations/types.ts"],"mappings":";;;;;;;;;;;KAkCY,SAAA,GAAY,QAAQ,CAAC,MAAA;AAAA,UAEhB,qBAAA;EAAA,SACN,UAAA,WAAqB,yBAAyB,CAAC,cAAA;AAAA;;;AAHnB;UAStB,qBAAA;EAAA,SACN,UAAA;EAAA,SACA,OAAA;EAAA,SACA,UAAA,GAAa,MAAM;AAAA;;;;;AAT0C;AAMxE;;UAaiB,yBAAA;EAAA,SACN,UAAA;EAAA,SACA,OAAA;EAAA,SACA,UAAA,GAAa,MAAM;AAAA;;;AAbA;AAU9B;;;;;;;;;AAG8B;AAiB9B;KAAY,UAAA;;;AAAU;AActB;;;;;;;;;UAAiB,iBAAA;EAAA,SACN,WAAA;EAAA,SACA,SAAA;EAAA,SACA,SAAA;EAAA,SACA,UAAA,GAAa,YAAA;EAAA,SACb,QAAA,GAAW,YAAA;EAAA,SACX,UAAA,GAAa,aAAA;EAAA,SACb,QAAA,GAAW,aAAA;AAAA;AAAA,UAGL,iBAAA;EAHK;;AAAa;AAGnC;;;;;;EAUE,kBAAA,IAAsB,OAAA;IAAA,SACX,QAAA;IAAA,SACA,YAAA,EAAc,mBAAA;IAAA,SACd,QAAA,EAAU,QAAA,CAAS,UAAA;IAAA,SACnB,MAAA,EAAQ,eAAA;IAAA,SACR,UAAA;IAAA,SACA,MAAA,EAAQ,wBAAA;EAAA,MACb,qBAAA,CAAsB,cAAA;EAC5B,UAAA,IAAc,OAAA;IAAA,SACH,QAAA;IAAA,SACA,YAAA,EAAc,mBAAA;IAAA,SACd,MAAA,EAAQ,eAAA;IAAA,SACR,UAAA;EAAA,eACI,eAAA;EACf,eAAA,IAAmB,OAAA;IAAA,SACR,MAAA,EAAQ,wBAAA;IAAA,SACR,UAAA;EAAA,MACL,OAAA,CAAQ,MAAA,SAAe,mBAAA;EA3BI;;;;;;;;;;EAsCjC,gBAAA,IAAoB,KAAA,EAAO,qBAAA;EAtBhB;;;;;;;;;EAgCX,oBAAA,IAAwB,KAAA,EAAO,yBAAA;EA3BZ;;;;;;;;;;;;;;EA0CnB,YAAA,IAAgB,KAAA,EAAO,UAAA,EAAY,GAAA,EAAK,iBAAA,cAA+B,aAAA;AAAA;AAAA,UAGxD,6BAAA,mCACP,0BAAA,QAAkC,SAAA;EAAA,SACjC,eAAA,SAAwB,uBAAA;EALjC;;;;;;;AAAoF;AAGtF;;;EAHE,SAiBS,aAAA,GAAgB,aAAA,CAAc,QAAA,CAAS,UAAA;AAAA;AAAA,UAGjC,2BAAA,mCACP,wBAAA,QAAgC,SAAA,EAAW,iBAAA,CAAkB,SAAA;EAAA,SAC5D,eAAA,SAAwB,uBAAA;AAAA;AAAA,UAGlB,6BAAA;EAAA,SACN,WAAA;EAAA,SACA,GAAA;EAxBoC;;;;;;;;EAAA,SAiCpC,MAAA;EAAA,SACA,IAAA,GAAO,SAAS;AAAA;AAjB3B;;;;;;;AAAA,UA2BiB,oBAAA;EAAA,SACN,MAAA;EAAA,SACA,IAAI;AAAA;AAAA,UAGE,+BAAA;EAAA,SACN,EAAA;EAAA,SACA,OAAA,GAAU,cAAc;AAAA;AAAA,UAGlB,yBAAA,yBAAkD,sBAAA;EAAA,SACxD,OAAA;EAAA,SACA,MAAA,EAAQ,+BAAA,CAAgC,cAAA;EAAA,SACxC,QAAA,WAAmB,6BAAA;EAAA,SACnB,OAAA,WAAkB,6BAAA;EAAA,SAClB,SAAA,WAAoB,6BAAA;EAAA,SACpB,IAAA,GAAO,SAAA;AAAA;AAAA,UAGD,4BAAA;EAAA,SACN,WAAA;EAAA,SACA,WAAW;AAAA;AAAA,UAGL,gBAAA,yBAAyC,aAAA;EAlC/B;AAAA;AAU3B;;;;AAEe;AAGf;;;;;;;EAf2B,SAiDhB,OAAA;EAhCwB;AAAA;AAGnC;;EAHmC,SAqCxB,MAAA,GAAS,4BAAA;EAhC+B;;;EAAA,SAoCxC,WAAA,EAAa,4BAAA;EAAA,SACb,UAAA,YACL,yBAAA,CAA0B,cAAA,IAC1B,OAAA,CAAQ,yBAAA,CAA0B,cAAA;EAnCtB;;;;;;;;EAAA,SA6CP,kBAAA;EAAA,SACA,IAAA,GAAO,SAAA;AAAA;AAAA,KAGN,sBAAA;AAAA,UASK,0BAAA;EAAA,SACN,SAAA;EAAA,SACA,KAAA;EAAA,SACA,MAAA;EAAA,SACA,KAAA;EAAA,SACA,UAAA;EAAA,SACA,IAAA;AAAA;AAAA,UAGM,kBAAA,SAA2B,wBAAA;EAAA,SACjC,IAAA,EAAM,sBAAA;EAAA,SACN,QAAA,GAAW,0BAAA;EAAA,SACX,IAAA,GAAO,SAAA;AAAA;AAAA,UAGD,uBAAA,yBACP,IAAA,CAAK,6BAAA;EAAA,SACJ,IAAA;EAAA,SACA,IAAA,EAAM,gBAAA,CAAiB,cAAA;AAAA;AAAA,UAGjB,uBAAA,SAAgC,IAAA,CAAK,6BAAA;EAAA,SAC3C,IAAA;EAAA,SACA,SAAA,WAAoB,kBAAA;AAAA;AAAA,KAGnB,gBAAA,mBACR,uBAAA,CAAwB,cAAA,IACxB,uBAAA;AAAA,UAEa,8BAAA;EAAA,SACN,QAAA,EAAU,QAAA,CAAS,UAAA;EAjF4B;;;;;EAAA,SAuF/C,MAAA,EAAQ,eAAA;EAAA,SACR,MAAA,EAAQ,wBAAA;EAAA,SACR,UAAA;EAjEA;;;;;;;EAAA,SAyEA,OAAA;EA5DA;;;;AACgB;AAG3B;;;;AAAkC;AASlC;;;;;;EAbW,SA6EA,YAAA,EAAc,QAAA,CAAS,UAAA;EA5DvB;;;;AAEI;AAGf;EALW,SAmEA,mBAAA,EAAqB,aAAA,CAAc,8BAAA;;;;;;;;;;WAUnC,SAAA,GAAY,eAAA;AAAA;AAAA,UAGN,mBAAA;EACf,IAAA,CAAK,OAAA,EAAS,8BAAA,GAAiC,gBAAA,CAAiB,cAAA;AAAA;AAAA,UAGjD,kCAAA;EACf,gBAAA,EAAkB,SAAA,EAAW,yBAAA,CAA0B,cAAA;EACvD,mBAAA,EAAqB,SAAA,EAAW,yBAAA,CAA0B,cAAA;AAAA;AAAA,UAG3C,gCAAA;EAAA,SACN,IAAA,EAAM,gBAAA,CAAiB,cAAA;EAAA,SACvB,MAAA,EAAQ,wBAAA;EA7EF;;;;;;;EAAA,SAqFN,KAAA;EArFA;;;;EAAA,SA0FA,mBAAA,EAAqB,QAAA,CAAS,UAAA;EAvFxB;;;;EAAA,SA4FN,MAAA,EAAQ,wBAAA;EAAA,SACR,UAAA;EAAA,SACA,kBAAA;EAAA,SACA,SAAA,GAAY,kCAAA,CAAmC,cAAA;EAAA,SAC/C,OAAA,GAAU,gBAAA;EAhGiC;;;;EAAA,SAqG3C,eAAA,GAAkB,8BAAA;EAnGoB;AAGjD;;;;;EAHiD,SA0GtC,mBAAA,EAAqB,aAAA,CAAc,8BAAA;EArGnB;;;;EAAA,SA0GhB,cAAA,WAAyB,yBAAA;AAAA;AAAA,KAGxB,2BAAA;AAAA,UAYK,yBAAA,SAAkC,sBAAA;EAAA,SACxC,IAAA,EAAM,2BAAA;EAAA,SACN,IAAA,GAAO,SAAA;AAAA;AAAA,UAGD,8BAAA,SAAuC,mCAAmC;AAAA,KAE/E,wBAAA,GAA2B,MAAA,CACrC,8BAAA,EACA,yBAAA;AAAA,UAGe,kBAAA;EAjGiB;;;;;;;;;;;;;EA+GhC,OAAA,CAAQ,OAAA;IAAA,SACG,MAAA,EAAQ,wBAAA;IAAA,SACR,eAAA,EAAiB,aAAA,CAAc,gCAAA,CAAiC,cAAA;EAAA,IACvE,OAAA,CAAQ,qBAAA;EAlHW;;;;;;;;AAiBa;AAGtC;EA0GE,mBAAA,CACE,OAAA,EAAS,gCAAA,CAAiC,cAAA,IACzC,OAAA,CAAQ,wBAAA;AAAA;AAAA,UAGI,6BAAA;EAAA,SACN,QAAA;EA/GsC;;;EAAA,SAmHtC,OAAA;EAAA,SACA,MAAA,GAAS,4BAAA;EAAA,SACT,WAAA,EAAa,4BAAA;EAAA,SACb,UAAA,WAAqB,yBAAA,CAA0B,cAAA;EAtHT;;;AAA+B;AAGhF;EAHiD,SA4HtC,kBAAA;EAAA,SACA,IAAA,GAAO,SAAA;AAAA"}

package/package.json

@@ -1,34 +1,34 @@
 {
   "name": "@prisma-next/family-sql",
-  "version": "0.14.0-dev.57",
+  "version": "0.14.0-dev.59",
   "license": "Apache-2.0",
   "type": "module",
   "sideEffects": false,
   "description": "SQL family descriptor for Prisma Next",
   "dependencies": {
-    "@prisma-next/contract": "0.14.0-dev.57",
-    "@prisma-next/emitter": "0.14.0-dev.57",
-    "@prisma-next/framework-components": "0.14.0-dev.57",
-    "@prisma-next/migration-tools": "0.14.0-dev.57",
-    "@prisma-next/operations": "0.14.0-dev.57",
-    "@prisma-next/sql-contract": "0.14.0-dev.57",
-    "@prisma-next/sql-contract-emitter": "0.14.0-dev.57",
-    "@prisma-next/sql-contract-ts": "0.14.0-dev.57",
-    "@prisma-next/sql-operations": "0.14.0-dev.57",
-    "@prisma-next/sql-relational-core": "0.14.0-dev.57",
-    "@prisma-next/sql-runtime": "0.14.0-dev.57",
-    "@prisma-next/sql-schema-ir": "0.14.0-dev.57",
-    "@prisma-next/utils": "0.14.0-dev.57",
+    "@prisma-next/contract": "0.14.0-dev.59",
+    "@prisma-next/emitter": "0.14.0-dev.59",
+    "@prisma-next/framework-components": "0.14.0-dev.59",
+    "@prisma-next/migration-tools": "0.14.0-dev.59",
+    "@prisma-next/operations": "0.14.0-dev.59",
+    "@prisma-next/sql-contract": "0.14.0-dev.59",
+    "@prisma-next/sql-contract-emitter": "0.14.0-dev.59",
+    "@prisma-next/sql-contract-ts": "0.14.0-dev.59",
+    "@prisma-next/sql-operations": "0.14.0-dev.59",
+    "@prisma-next/sql-relational-core": "0.14.0-dev.59",
+    "@prisma-next/sql-runtime": "0.14.0-dev.59",
+    "@prisma-next/sql-schema-ir": "0.14.0-dev.59",
+    "@prisma-next/utils": "0.14.0-dev.59",
     "arktype": "^2.2.0"
   },
   "devDependencies": {
-    "@prisma-next/driver-postgres": "0.14.0-dev.57",
-    "@prisma-next/psl-parser": "0.14.0-dev.57",
-    "@prisma-next/psl-printer": "0.14.0-dev.57",
-    "@prisma-next/sql-contract-psl": "0.14.0-dev.57",
-    "@prisma-next/test-utils": "0.14.0-dev.57",
-    "@prisma-next/tsconfig": "0.14.0-dev.57",
-    "@prisma-next/tsdown": "0.14.0-dev.57",
+    "@prisma-next/driver-postgres": "0.14.0-dev.59",
+    "@prisma-next/psl-parser": "0.14.0-dev.59",
+    "@prisma-next/psl-printer": "0.14.0-dev.59",
+    "@prisma-next/sql-contract-psl": "0.14.0-dev.59",
+    "@prisma-next/test-utils": "0.14.0-dev.59",
+    "@prisma-next/tsconfig": "0.14.0-dev.59",
+    "@prisma-next/tsdown": "0.14.0-dev.59",
     "tsdown": "0.22.1",
     "typescript": "5.9.3",
     "vitest": "4.1.8"

package/src/core/diff/sql-schema-diff.ts

@@ -1,14 +1,13 @@
 /**
- * Shared relational-diff types and semantic-satisfaction predicates. The
- * coordinate-based issue diff this module used to house (`collectSqlSchemaIssues`
- * / `collectSqlSchemaIssuesPerNamespace`) retired once the migration planner
+ * Shared relational-diff types and helpers. The coordinate-based issue diff
+ * this module used to house (`collectSqlSchemaIssues` /
+ * `collectSqlSchemaIssuesPerNamespace`) retired once the migration planner
  * took `plan(start, end)` over the one differ (`buildPostgresPlanDiff` /
  * `buildSqlitePlanDiff`); what remains here is consumed by the surviving
  * verify verdict (`schema-verify.ts`) and the control adapters.
  */
 
 import type { ColumnDefault } from '@prisma-next/contract/types';
-import type { SqlIndexIR, SqlUniqueIR } from '@prisma-next/sql-schema-ir/types';
 
 /**
  * Function type for normalizing raw database default expressions into ColumnDefault.
@@ -40,38 +39,3 @@ export function arraysEqual(a: readonly string[], b: readonly string[]): boolean
   }
   return true;
 }
-
-/**
- * Checks if a unique constraint requirement is satisfied by the given columns:
- * a unique constraint with the same columns, or a unique index with the same
- * columns (semantic satisfaction). Used by the planners to keep the
- * "stronger satisfies weaker" behavior consistent across the control plane.
- */
-export function isUniqueConstraintSatisfied(
-  uniques: readonly SqlUniqueIR[],
-  indexes: readonly SqlIndexIR[],
-  columns: readonly string[],
-): boolean {
-  const hasConstraint = uniques.some((unique) => arraysEqual(unique.columns, columns));
-  if (hasConstraint) {
-    return true;
-  }
-  return indexes.some((index) => index.unique && arraysEqual(index.columns, columns));
-}
-
-/**
- * Checks if an index requirement is satisfied by the given columns: any index
- * (unique or non-unique) with the same columns, or a unique constraint with
- * the same columns (stronger satisfies weaker).
- */
-export function isIndexSatisfied(
-  indexes: readonly SqlIndexIR[],
-  uniques: readonly SqlUniqueIR[],
-  columns: readonly string[],
-): boolean {
-  const hasMatchingIndex = indexes.some((index) => arraysEqual(index.columns, columns));
-  if (hasMatchingIndex) {
-    return true;
-  }
-  return uniques.some((unique) => arraysEqual(unique.columns, columns));
-}

package/src/core/migrations/contract-to-schema-ir.ts

@@ -251,11 +251,23 @@ function convertIndex(index: Index): SqlIndexIRInput {
   };
 }
 
-function convertForeignKey(fk: ForeignKey): SqlForeignKeyIRInput {
+/**
+ * The FK's referenced-namespace identity comes from the target's namespace
+ * node, not the raw namespace-id string. An unbound target namespace stamps
+ * no `referencedSchema` at all — the FK node's id renders the absence as the
+ * empty segment, which is what flat (single-schema) introspection produces,
+ * so both diff sides' FK ids meet by construction. A bound namespace (or a
+ * cross-space target whose namespace lives in another contract's storage)
+ * stamps its coordinate verbatim; namespaced targets (Postgres) resolve the
+ * real DDL schema downstream.
+ */
+function convertForeignKey(fk: ForeignKey, storage: SqlStorage): SqlForeignKeyIRInput {
+  const targetNamespace = storage.namespaces[fk.target.namespaceId];
+  const targetIsUnbound = targetNamespace?.isUnbound === true;
   return {
     columns: fk.source.columns,
     referencedTable: fk.target.tableName,
-    referencedSchema: fk.target.namespaceId,
+    ...(targetIsUnbound ? {} : { referencedSchema: fk.target.namespaceId }),
     referencedColumns: fk.target.columns,
     ...ifDefined('name', fk.name),
     ...ifDefined('onDelete', fk.onDelete),
@@ -309,7 +321,9 @@ function convertTable(
     name,
     columns,
     ...ifDefined('primaryKey', table.primaryKey),
-    foreignKeys: table.foreignKeys.filter((fk) => fk.constraint !== false).map(convertForeignKey),
+    foreignKeys: table.foreignKeys
+      .filter((fk) => fk.constraint !== false)
+      .map((fk) => convertForeignKey(fk, storage)),
     uniques: table.uniques.map(convertUnique),
     indexes: [...table.indexes.map(convertIndex), ...fkBackingIndexes],
     ...ifDefined('checks', checks),

package/src/exports/diff.ts

@@ -2,20 +2,11 @@
  * SQL relational schema-diff exports.
  *
  * The generic node differ (`buildPostgresPlanDiff` / `buildSqlitePlanDiff`)
- * drives both plan and verify; this module surfaces the shared
- * semantic-satisfaction predicates and verify-verdict machinery that survive
- * it. Pure — no database connection required.
+ * drives both plan and verify over the trees as derived — no pre-diff
+ * transformation. This module surfaces the verify-verdict machinery. Pure —
+ * no database connection required.
  */
 
-export type {
-  SemanticSatisfactionInput,
-  SemanticSatisfactionResult,
-} from '../core/diff/diff-tree-normalization';
-export {
-  neutralizeFlatExpectedFkSchemas,
-  normalizeFlatActualForDiff,
-  resolveSemanticSatisfaction,
-} from '../core/diff/diff-tree-normalization';
 export type {
   SqlDiffVerdict,
   SqlDiffVerdictInput,
@@ -31,8 +22,4 @@ export {
   verifySqlSchemaByDiff,
 } from '../core/diff/schema-verify';
 export type { NativeTypeNormalizer } from '../core/diff/sql-schema-diff';
-export {
-  arraysEqual,
-  isIndexSatisfied,
-  isUniqueConstraintSatisfied,
-} from '../core/diff/sql-schema-diff';
+export { arraysEqual } from '../core/diff/sql-schema-diff';

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

@@ -1 +0,0 @@
-{"version":3,"file":"control-adapter-BVOj4gXI.d.mts","names":[],"sources":["../src/core/diff/sql-schema-diff.ts","../src/core/control-adapter.ts"],"mappings":";;;;;;;;;;;KAgBY,iBAAA,IACV,UAAA,UACA,UAAA,aACG,aAAa;AAAA;AAOlB;;;;AAPkB,KAON,oBAAA,IAAwB,UAAkB;AAKtD;;;AAAA,iBAAgB,WAAA,CAAY,CAAA,qBAAsB,CAAoB;AAAA;AAkBtE;;;;;AAlBsE,iBAkBtD,2BAAA,CACd,OAAA,WAAkB,WAAA,IAClB,OAAA,WAAkB,UAAU,IAC5B,OAAA;;;;;AAA0B;iBAcZ,gBAAA,CACd,OAAA,WAAkB,UAAA,IAClB,OAAA,WAAkB,WAAW,IAC7B,OAAA;;;;AArDF;;;;;;UCOiB,OAAA;EACf,KAAA,CAAM,GAAA,EAAK,WAAA,GAAc,OAAA,EAAS,OAAA,EAAS,cAAA,YAA0B,gBAAA;AAAA;ADEvE;;;;AAAsD;AAKtD;AALA,UCOiB,qBAAA,SAA8B,OAAA;EAC7C,qBAAA,CACE,GAAA,EAAK,WAAA,GAAc,OAAA,EACnB,OAAA,GAAU,cAAA,YACT,OAAA,CAAQ,iBAAA;AAAA;ADNyD;AAkBtE;;;;;AAlBsE,UCerD,iBAAA,0CACP,sBAAA,QAA8B,OAAA,GACpC,qBAAA;EDGgB;;;;AACQ;AAc5B;;;;;;;;;;ECFE,UAAA,CACE,MAAA,EAAQ,wBAAA,CAAyB,OAAA,GACjC,KAAA,WACC,OAAA,CAAQ,oBAAA;;;;AA5Cb;;;;EAqDE,cAAA,CACE,MAAA,EAAQ,wBAAA,CAAyB,OAAA,IAChC,OAAA,CAAQ,WAAA,SAAoB,oBAAA;EAtDY;;;;EA4D3C,UAAA,CACE,MAAA,EAAQ,wBAAA,CAAyB,OAAA,GACjC,KAAA,YACC,OAAA,UAAiB,iBAAA;EA/DT;;;;;;EAuEX,YAAA,CACE,MAAA,EAAQ,wBAAA,CAAyB,OAAA,GACjC,KAAA,UACA,WAAA;IAAA,SACW,WAAA;IAAA,SACA,WAAA;IAAA,SACA,UAAA;EAAA,IAEV,OAAA;EApEI;;;;;;EA4EP,UAAA,CACE,MAAA,EAAQ,wBAAA,CAAyB,OAAA,GACjC,KAAA,UACA,WAAA;IAAA,SACW,WAAA;IAAA,SACA,WAAA;IAAA,SACA,UAAA;EAAA,IAEV,OAAA;EApFkB;;;;;;;EA6FrB,YAAA,CACE,MAAA,EAAQ,wBAAA,CAAyB,OAAA,GACjC,KAAA,UACA,YAAA,UACA,WAAA;IAAA,SACW,WAAA;IAAA,SACA,WAAA;IAAA,SACA,UAAA;EAAA,IAEV,OAAA;EAxEgC;;;;;;EAgFnC,gBAAA,CACE,MAAA,EAAQ,wBAAA,CAAyB,OAAA,GACjC,KAAA,UACA,KAAA;IAAA,SACW,MAAA;IAAA,SACA,IAAA;IAAA,SACA,EAAA;IAAA,SACA,aAAA;IAAA,SACA,aAAA;IAAA,SACA,UAAA;EAAA,IAEV,OAAA;EA5DO;;;;;;;;;;;;;;;;;EA+EV,UAAA,CACE,MAAA,EAAQ,wBAAA,CAAyB,OAAA,GACjC,QAAA,YACA,MAAA,YACC,OAAA,CAAQ,eAAA;EA0B4B;;;;;EAAA,SAnB9B,gBAAA,GAAmB,iBAAA;EA3IpB;;;;;EAAA,SAkJC,mBAAA,GAAsB,oBAAA;EAhI7B;;;;EAsIF,4BAAA,aAAyC,OAAA;EA1H/B;;;;EAgIV,0BAAA,aAAuC,OAAA;AAAA;;;;;;;UASxB,2BAAA;EAvHf;;;;;;EA8HA,MAAA,CAAO,KAAA,EAAO,YAAA,QAAoB,OAAA,IAAW,iBAAA,CAAkB,OAAA;AAAA"}