@prisma-next/family-sql 0.14.0-dev.5 → 0.14.0-dev.50

package/dist/diff.d.mts

@@ -0,0 +1,150 @@
+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 { 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 { 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
+ * demand, from the issue's node's `nodeKind` via the target-provided
+ * `granularityOf` map. The node carries only its `nodeKind` identity, never a
+ * classification, and nothing is stamped onto the issue — every consumer
+ * (the family verdict below, the framework aggregate's unclaimed-elements
+ * sweep via {@link import('@prisma-next/framework-components/control').SchemaSubjectClassifierCapable})
+ * calls this the same way, resolved by the family/target that owns the node
+ * vocabulary. `undefined` for an issue with no node.
+ */
+declare function classifyDiffSubjectGranularity(issue: SchemaDiffIssue, granularityOf: (nodeKind: string) => DiffSubjectGranularity): DiffSubjectGranularity | undefined;
+/**
+ * Re-keys the legacy `classifySqlVerifierIssueKind` category mapping on the
+ * issue's {@link DiffSubjectGranularity} (resolved via `granularityOf`) + the
+ * issue reason. The vocabulary maps one-to-one: an undeclared live entity or
+ * namespace is `extraTopLevelObject`, an undeclared live field
+ * `extraNestedElement`, undeclared auxiliaries (constraints, indexes,
+ * defaults) and structural leaves (policies) `extraAuxiliary`; a value-set
+ * drift on a check node is `valueDrift`; every other paired divergence is
+ * `declaredIncompatible`; anything the database lacks is `declaredMissing`.
+ * `granularityOf` is the target's classifier, so target and extension node
+ * kinds classify without the family importing them.
+ */
+declare function classifySqlDiffIssue(issue: SchemaDiffIssue, granularityOf: (nodeKind: string) => DiffSubjectGranularity): VerifierIssueCategory;
+interface SqlDiffVerdictInput {
+  /** The full, ownership-scoped diff issue list from the target's differ. */
+  readonly issues: readonly SchemaDiffIssue[];
+  /** Resolves a diff issue's subject table's declared control policy directly from the contract. */
+  readonly resolveControlPolicy: (issue: SchemaDiffIssue) => ControlPolicy | undefined;
+  readonly strict: boolean;
+  readonly defaultControlPolicy: ControlPolicy | undefined;
+  /** The target's classifier: a diff issue node's `nodeKind` → its subject granularity. */
+  readonly granularityOf: (nodeKind: string) => DiffSubjectGranularity;
+}
+interface SqlDiffVerdict {
+  readonly failures: readonly SchemaDiffIssue[];
+  readonly warnings: readonly SchemaDiffIssue[];
+}
+/**
+ * Applies the two consumer filters to a diff issue list: strict gating
+ * (relational `not-expected` findings drop in lenient mode) and
+ * control-policy disposition (each surviving issue grades against its
+ * subject table's effective policy; suppressed issues drop, `observed`
+ * subjects warn). The verify verdict is `failures.length === 0`.
+ */
+declare function computeSqlDiffVerdict(input: SqlDiffVerdictInput): SqlDiffVerdict;
+interface StorageTypeVerdictInput {
+  readonly contract: Contract<SqlStorage>;
+  /**
+   * Expected/actual namespace-node pairs the target's differ input produced:
+   * for a namespaced tree, one entry per expected namespace with a
+   * non-empty table set, paired by DDL schema name (absent actual side for
+   * a schema the database lacks); a flat tree is the sole pair.
+   */
+  readonly namespacePairs: ReadonlyArray<{
+    readonly actual: SqlSchemaIRNode | undefined;
+  }>;
+  readonly codecHooks: ReadonlyMap<string, CodecControlHooks>;
+}
+/**
+ * Runs the codec `verifyType` hooks the way the legacy walk did: once per
+ * contract namespace with tables, against that namespace's paired actual
+ * node (the hook reads namespace-scoped state such as
+ * `nativeEnumTypeNames` off it). Issue dispositions grade against the
+ * contract default policy, matching the legacy `pushTypeNode` semantics.
+ */
+interface StorageTypeVerdict {
+  readonly failures: readonly SchemaDiffIssue[];
+  readonly warnings: readonly SchemaDiffIssue[];
+}
+declare function computeStorageTypeVerdict(input: StorageTypeVerdictInput): StorageTypeVerdict;
+interface VerifySqlSchemaByDiffInput {
+  readonly contract: Contract<SqlStorage>;
+  readonly schema: SqlSchemaIRNode;
+  readonly strict: boolean;
+  readonly frameworkComponents: ReadonlyArray<TargetBoundComponentDescriptor<'sql', string>>;
+  /** The target's full-tree node diff (`diffSchema` descriptor hook). */
+  readonly diffSchema: SqlSchemaDiffFn;
+  /** The target's classifier: a diff issue node's `nodeKind` → its subject granularity. */
+  readonly granularityOf: (nodeKind: string) => DiffSubjectGranularity;
+}
+/**
+ * THE SQL schema verify: runs the target's full-tree node diff, grades it
+ * through the family's post-diff filters (strict gating + control-policy
+ * disposition) plus the codec `verifyType` hook findings, and wraps the
+ * verdict in the issue-based result envelope. `ok` holds exactly when both
+ * issue lists are empty — the lists carry the verdict's failures.
+ */
+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 };
+//# sourceMappingURL=diff.d.mts.map

package/dist/diff.d.mts.map

@@ -0,0 +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"}

package/dist/diff.mjs

@@ -0,0 +1,188 @@
+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).
+*/
+function arraysEqual(a, b) {
+	if (a.length !== b.length) return false;
+	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 };
+
+//# sourceMappingURL=diff.mjs.map

package/dist/diff.mjs.map

@@ -0,0 +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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"}

package/dist/ir.d.mts

@@ -1,7 +1,7 @@
-import { ContractSerializer, SchemaIssue, SchemaVerifier, SchemaVerifyOptions, SchemaVerifyResult } from "@prisma-next/framework-components/control";
+import { ContractSerializer, SchemaDiffIssue, SchemaVerifier, SchemaVerifyOptions, SchemaVerifyResult } from "@prisma-next/framework-components/control";
 import { AnyEntityKindDescriptor, Namespace } from "@prisma-next/framework-components/ir";
-import { SqlNamespaceTablesInput, SqlStorage, SqlStorageTypeEntry } from "@prisma-next/sql-contract/types";
 import { Contract } from "@prisma-next/contract/types";
+import { SqlNamespaceInput, SqlStorage, SqlStorageTypeEntry } from "@prisma-next/sql-contract/types";
 import { JsonObject } from "@prisma-next/utils/json";
 
 //#region src/core/ir/sql-contract-serializer-base.d.ts
@@ -41,11 +41,24 @@ declare abstract class SqlContractSerializerBase<TContract extends Contract<SqlS
   sortStorage: import("@prisma-next/contract/hashing").StorageSort;
   protected parseSqlContractStructure(json: unknown): Contract<SqlStorage>;
   protected hydrateSqlStorage(validated: Contract<SqlStorage>): Contract<SqlStorage>;
-  protected abstract get defaultNamespaceId(): string;
-  protected hydrateSqlNamespaceMap(namespaces: Readonly<Record<string, Namespace | Record<string, unknown>>>): Readonly<Record<string, Namespace>>;
-  protected hydrateSqlNamespaceEntry(nsId: string, raw: Namespace | Record<string, unknown>): Namespace | SqlNamespaceTablesInput;
+  protected hydrateSqlNamespaceMap(namespaces: Readonly<Record<string, Record<string, unknown>>>): Readonly<Record<string, Namespace>>;
+  protected hydrateSqlNamespaceEntry(nsId: string, raw: Record<string, unknown>): Namespace | SqlNamespaceInput;
   protected hydrateStorageTypeEntry(entry: SqlStorageTypeEntry): SqlStorageTypeEntry;
   protected constructTargetContract(hydrated: Contract<SqlStorage>): TContract;
+  /**
+   * Serializes a namespace's `entries` dict by walking every enumerable
+   * kind — no kind is named here, mirroring the generic hydrate walk in
+   * `hydrateSqlNamespaceEntry` above. `table` is the SQL family's one
+   * universal base kind (every namespace carries it), so it is always
+   * emitted, even when empty; every other kind — target- or
+   * pack-contributed — is emitted only when it holds at least one entry.
+   * A kind carried non-enumerable on `entries` is excluded here for free,
+   * since `Object.entries` honors enumerability.
+   */
+  protected serializeNamespaceEntries(entries: Readonly<Record<string, Readonly<Record<string, unknown>>>>): Record<string, Record<string, JsonObject>>;
+  private serializeEntries;
+  protected serializeJsonObject(value: unknown): JsonObject;
+  private serializeJsonValue;
 }
 //#endregion
 //#region src/core/ir/sql-contract-serializer.d.ts
@@ -57,10 +70,14 @@ declare abstract class SqlContractSerializerBase<TContract extends Contract<SqlS
  * codec-typed envelope wire a target-specific subclass with a populated
  * registry (see Postgres). Family-level call sites instantiate this
  * default directly when no target serializer is supplied.
+ *
+ * Because this serializer has no target concretion, deserialization of
+ * contracts that include namespace entries from JSON will throw unless
+ * the caller provides pre-hydrated `NamespaceBase` instances. Production
+ * paths always supply a target-specific serializer.
  */
 declare class SqlContractSerializer extends SqlContractSerializerBase<Contract<SqlStorage>> {
   constructor();
-  protected get defaultNamespaceId(): string;
 }
 //#endregion
 //#region src/core/ir/sql-schema-verifier-base.d.ts
@@ -68,7 +85,7 @@ declare class SqlContractSerializer extends SqlContractSerializerBase<Contract<S
  * SQL family `SchemaVerifier` abstract base. Centralises the SQL-shared
  * walk (table-by-table + column-by-column matching keyed by
  * `(namespace.id, name)`, FK / unique / index comparisons via the
- * existing helpers in `verify-helpers.ts`) and exposes a protected hook
+ * shared satisfaction helpers in `sql-schema-diff.ts`) and exposes a protected hook
  * for target extensions (Postgres functions, RLS policies, future
  * target-only kinds).
  *
@@ -92,13 +109,13 @@ declare abstract class SqlSchemaVerifierBase<TContract, TSchema> implements Sche
    * family-shared implementation today; a future iteration will lift
    * the shared walk into this base.
    */
-  protected abstract verifyCommonSqlSchema(options: SchemaVerifyOptions<TContract, TSchema>): readonly SchemaIssue[];
+  protected abstract verifyCommonSqlSchema(options: SchemaVerifyOptions<TContract, TSchema>): readonly SchemaDiffIssue[];
   /**
    * Target-specific extensions — e.g. Postgres functions, future RLS
    * policies, namespace-mismatch issues. Returns the empty list when the
    * target ships no extensions over the SQL family alphabet.
    */
-  protected abstract verifyTargetExtensions(options: SchemaVerifyOptions<TContract, TSchema>): readonly SchemaIssue[];
+  protected abstract verifyTargetExtensions(options: SchemaVerifyOptions<TContract, TSchema>): readonly SchemaDiffIssue[];
 }
 //#endregion
 export { SqlContractSerializer, SqlContractSerializerBase, type SqlEntityHydrationFactory, SqlSchemaVerifierBase };

package/dist/ir.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"ir.d.mts","names":[],"sources":["../src/core/ir/sql-contract-serializer-base.ts","../src/core/ir/sql-contract-serializer.ts","../src/core/ir/sql-schema-verifier-base.ts"],"mappings":";;;;;;;KAsCY,yBAAA,IAA6B,KAAc;;AAAvD;;;;AAAuD;AA0BvD;;;;;;;;;;;;;;;;;;uBAAsB,yBAAA,mBAA4C,QAAA,CAAS,UAAA,cAC9D,kBAAA,CAAmB,SAAA;EAAA,mBAMT,uBAAA,EAAyB,WAAA,SAE1C,yBAAA;EAAA,iBANa,cAAA;EAAA,iBACA,UAAA;cAGI,uBAAA,GAAyB,WAAA,SAE1C,yBAAA,GAEF,eAAA,YAA0B,uBAAA;EAO5B,mBAAA,WAA8B,SAAA,GAAY,SAAA,EAAW,IAAA,YAAgB,CAAA;EAMrE,iBAAA,CAAkB,QAAA,EAAU,SAAA,GAAY,UAAA;EAIxC,mBAAA,0CAAmB,sBAAA;EAEnB,WAAA,0CAAW,WAAA;EAAA,UAED,yBAAA,CAA0B,IAAA,YAAgB,QAAA,CAAS,UAAA;EAAA,UAOnD,iBAAA,CAAkB,SAAA,EAAW,QAAA,CAAS,UAAA,IAAc,QAAA,CAAS,UAAA;EAAA,uBAyDhD,kBAAA;EAAA,UAEb,sBAAA,CACR,UAAA,EAAY,QAAA,CAAS,MAAA,SAAe,SAAA,GAAY,MAAA,sBAC/C,QAAA,CAAS,MAAA,SAAe,SAAA;EAAA,UAmBjB,wBAAA,CACR,IAAA,UACA,GAAA,EAAK,SAAA,GAAY,MAAA,oBAChB,SAAA,GAAY,uBAAA;EAAA,UAmCL,uBAAA,CAAwB,KAAA,EAAO,mBAAA,GAAsB,mBAAA;EAAA,UAkBrD,uBAAA,CAAwB,QAAA,EAAU,QAAA,CAAS,UAAA,IAAc,SAAA;AAAA;;;;;;;AAzMrE;;;;AAAuD;cCxB1C,qBAAA,SAA8B,yBAAA,CAA0B,QAAA,CAAS,UAAA;;gBAOrD,kBAAA;AAAA;;;;;;;;;ADiBzB;;;;AAAuD;AA0BvD;;;;;;;;;uBErCsB,qBAAA,gCACT,cAAA,CAAe,SAAA,EAAW,OAAA;EAErC,YAAA,CAAa,OAAA,EAAS,mBAAA,CAAoB,SAAA,EAAW,OAAA,IAAW,kBAAA;EFoDlC;;;;;;EAAA,mBEvCX,qBAAA,CACjB,OAAA,EAAS,mBAAA,CAAoB,SAAA,EAAW,OAAA,aAC9B,WAAA;EF0DoC;;;;;EAAA,mBEnD7B,sBAAA,CACjB,OAAA,EAAS,mBAAA,CAAoB,SAAA,EAAW,OAAA,aAC9B,WAAA;AAAA"}
+{"version":3,"file":"ir.d.mts","names":[],"sources":["../src/core/ir/sql-contract-serializer-base.ts","../src/core/ir/sql-contract-serializer.ts","../src/core/ir/sql-schema-verifier-base.ts"],"mappings":";;;;;;;KAmCY,yBAAA,IAA6B,KAAc;;AAAvD;;;;AAAuD;AA0BvD;;;;;;;;;;;;;;;;;;uBAAsB,yBAAA,mBAA4C,QAAA,CAAS,UAAA,cAC9D,kBAAA,CAAmB,SAAA;EAAA,mBAMT,uBAAA,EAAyB,WAAA,SAE1C,yBAAA;EAAA,iBANa,cAAA;EAAA,iBACA,UAAA;cAGI,uBAAA,GAAyB,WAAA,SAE1C,yBAAA,GAEF,eAAA,YAA0B,uBAAA;EAO5B,mBAAA,WAA8B,SAAA,GAAY,SAAA,EAAW,IAAA,YAAgB,CAAA;EAMrE,iBAAA,CAAkB,QAAA,EAAU,SAAA,GAAY,UAAA;EAIxC,mBAAA,0CAAmB,sBAAA;EAEnB,WAAA,0CAAW,WAAA;EAAA,UAED,yBAAA,CAA0B,IAAA,YAAgB,QAAA,CAAS,UAAA;EAAA,UAOnD,iBAAA,CAAkB,SAAA,EAAW,QAAA,CAAS,UAAA,IAAc,QAAA,CAAS,UAAA;EAAA,UAuC7D,sBAAA,CACR,UAAA,EAAY,QAAA,CAAS,MAAA,SAAe,MAAA,sBACnC,QAAA,CAAS,MAAA,SAAe,SAAA;EAAA,UAcjB,wBAAA,CACR,IAAA,UACA,GAAA,EAAK,MAAA,oBACJ,SAAA,GAAY,iBAAA;EAAA,UA+BL,uBAAA,CAAwB,KAAA,EAAO,mBAAA,GAAsB,mBAAA;EAAA,UAkBrD,uBAAA,CAAwB,QAAA,EAAU,QAAA,CAAS,UAAA,IAAc,SAAA;EAAd;;;;;;;;;;EAAA,UAc3C,yBAAA,CACR,OAAA,EAAS,QAAA,CAAS,MAAA,SAAe,QAAA,CAAS,MAAA,uBACzC,MAAA,SAAe,MAAA,SAAe,UAAA;EAAA,QAazB,gBAAA;EAAA,UAQE,mBAAA,CAAoB,KAAA,YAAiB,UAAA;EAAA,QAOvC,kBAAA;AAAA;;;;;;;AAxNV;;;;AAAuD;AA0BvD;;;;;cC3Ca,qBAAA,SAA8B,yBAAA,CAA0B,QAAA,CAAS,UAAA;;;;;;;;;;;ADiB9E;;;;AAAuD;AA0BvD;;;;;;;;;uBElCsB,qBAAA,gCACT,cAAA,CAAe,SAAA,EAAW,OAAA;EAErC,YAAA,CAAa,OAAA,EAAS,mBAAA,CAAoB,SAAA,EAAW,OAAA,IAAW,kBAAA;EFiDlC;;;;;;EAAA,mBEpCX,qBAAA,CACjB,OAAA,EAAS,mBAAA,CAAoB,SAAA,EAAW,OAAA,aAC9B,eAAA;EFuDoC;;;;;EAAA,mBEhD7B,sBAAA,CACjB,OAAA,EAAS,mBAAA,CAAoB,SAAA,EAAW,OAAA,aAC9B,eAAA;AAAA"}

package/dist/ir.mjs

@@ -1,10 +1,10 @@
-import { n as SqlContractSerializerBase, t as SqlContractSerializer } from "./sql-contract-serializer-BR2vC7Z-.mjs";
+import { n as SqlContractSerializerBase, t as SqlContractSerializer } from "./sql-contract-serializer-C75cfMSS.mjs";
 //#region src/core/ir/sql-schema-verifier-base.ts
 /**
 * SQL family `SchemaVerifier` abstract base. Centralises the SQL-shared
 * walk (table-by-table + column-by-column matching keyed by
 * `(namespace.id, name)`, FK / unique / index comparisons via the
-* existing helpers in `verify-helpers.ts`) and exposes a protected hook
+* shared satisfaction helpers in `sql-schema-diff.ts`) and exposes a protected hook
 * for target extensions (Postgres functions, RLS policies, future
 * target-only kinds).
 *

package/dist/ir.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"ir.mjs","names":[],"sources":["../src/core/ir/sql-schema-verifier-base.ts"],"sourcesContent":["import type {\n  SchemaIssue,\n  SchemaVerifier,\n  SchemaVerifyOptions,\n  SchemaVerifyResult,\n} from '@prisma-next/framework-components/control';\n\n/**\n * SQL family `SchemaVerifier` abstract base. Centralises the SQL-shared\n * walk (table-by-table + column-by-column matching keyed by\n * `(namespace.id, name)`, FK / unique / index comparisons via the\n * existing helpers in `verify-helpers.ts`) and exposes a protected hook\n * for target extensions (Postgres functions, RLS policies, future\n * target-only kinds).\n *\n * The base accumulates issues in a single buffer and returns the\n * combined result; the per-SPI family abstract handles the result\n * envelope shape so concrete subclasses focus on target-specific\n * verification logic.\n *\n * The protected hooks (`verifyCommonSqlSchema`,\n * `verifyTargetExtensions`) carry the stable base API that target\n * subclasses (`PostgresSchemaVerifier`, `SqliteSchemaVerifier`)\n * compile against; the SQL-shared walk implementation will be lifted\n * into this base when the verifier behaviour migrates off the\n * legacy adapter shells.\n */\nexport abstract class SqlSchemaVerifierBase<TContract, TSchema>\n  implements SchemaVerifier<TContract, TSchema>\n{\n  verifySchema(options: SchemaVerifyOptions<TContract, TSchema>): SchemaVerifyResult {\n    const issues: SchemaIssue[] = [];\n    issues.push(...this.verifyCommonSqlSchema(options));\n    issues.push(...this.verifyTargetExtensions(options));\n    return { ok: issues.length === 0, issues };\n  }\n\n  /**\n   * SQL-shared verification — table/column/FK/unique/index walks keyed\n   * by `(namespace.id, name)`. Concrete subclasses provide the\n   * family-shared implementation today; a future iteration will lift\n   * the shared walk into this base.\n   */\n  protected abstract verifyCommonSqlSchema(\n    options: SchemaVerifyOptions<TContract, TSchema>,\n  ): readonly SchemaIssue[];\n\n  /**\n   * Target-specific extensions — e.g. Postgres functions, future RLS\n   * policies, namespace-mismatch issues. Returns the empty list when the\n   * target ships no extensions over the SQL family alphabet.\n   */\n  protected abstract verifyTargetExtensions(\n    options: SchemaVerifyOptions<TContract, TSchema>,\n  ): readonly SchemaIssue[];\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;AA2BA,IAAsB,wBAAtB,MAEA;CACE,aAAa,SAAsE;EACjF,MAAM,SAAwB,CAAC;EAC/B,OAAO,KAAK,GAAG,KAAK,sBAAsB,OAAO,CAAC;EAClD,OAAO,KAAK,GAAG,KAAK,uBAAuB,OAAO,CAAC;EACnD,OAAO;GAAE,IAAI,OAAO,WAAW;GAAG;EAAO;CAC3C;AAoBF"}
+{"version":3,"file":"ir.mjs","names":[],"sources":["../src/core/ir/sql-schema-verifier-base.ts"],"sourcesContent":["import type {\n  SchemaDiffIssue,\n  SchemaVerifier,\n  SchemaVerifyOptions,\n  SchemaVerifyResult,\n} from '@prisma-next/framework-components/control';\n\n/**\n * SQL family `SchemaVerifier` abstract base. Centralises the SQL-shared\n * walk (table-by-table + column-by-column matching keyed by\n * `(namespace.id, name)`, FK / unique / index comparisons via the\n * shared satisfaction helpers in `sql-schema-diff.ts`) and exposes a protected hook\n * for target extensions (Postgres functions, RLS policies, future\n * target-only kinds).\n *\n * The base accumulates issues in a single buffer and returns the\n * combined result; the per-SPI family abstract handles the result\n * envelope shape so concrete subclasses focus on target-specific\n * verification logic.\n *\n * The protected hooks (`verifyCommonSqlSchema`,\n * `verifyTargetExtensions`) carry the stable base API that target\n * subclasses (`PostgresSchemaVerifier`, `SqliteSchemaVerifier`)\n * compile against; the SQL-shared walk implementation will be lifted\n * into this base when the verifier behaviour migrates off the\n * legacy adapter shells.\n */\nexport abstract class SqlSchemaVerifierBase<TContract, TSchema>\n  implements SchemaVerifier<TContract, TSchema>\n{\n  verifySchema(options: SchemaVerifyOptions<TContract, TSchema>): SchemaVerifyResult {\n    const issues: SchemaDiffIssue[] = [];\n    issues.push(...this.verifyCommonSqlSchema(options));\n    issues.push(...this.verifyTargetExtensions(options));\n    return { ok: issues.length === 0, issues };\n  }\n\n  /**\n   * SQL-shared verification — table/column/FK/unique/index walks keyed\n   * by `(namespace.id, name)`. Concrete subclasses provide the\n   * family-shared implementation today; a future iteration will lift\n   * the shared walk into this base.\n   */\n  protected abstract verifyCommonSqlSchema(\n    options: SchemaVerifyOptions<TContract, TSchema>,\n  ): readonly SchemaDiffIssue[];\n\n  /**\n   * Target-specific extensions — e.g. Postgres functions, future RLS\n   * policies, namespace-mismatch issues. Returns the empty list when the\n   * target ships no extensions over the SQL family alphabet.\n   */\n  protected abstract verifyTargetExtensions(\n    options: SchemaVerifyOptions<TContract, TSchema>,\n  ): readonly SchemaDiffIssue[];\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;AA2BA,IAAsB,wBAAtB,MAEA;CACE,aAAa,SAAsE;EACjF,MAAM,SAA4B,CAAC;EACnC,OAAO,KAAK,GAAG,KAAK,sBAAsB,OAAO,CAAC;EAClD,OAAO,KAAK,GAAG,KAAK,uBAAuB,OAAO,CAAC;EACnD,OAAO;GAAE,IAAI,OAAO,WAAW;GAAG;EAAO;CAC3C;AAoBF"}

package/dist/migration.d.mts

@@ -1,4 +1,6 @@
-import { T as SqlPlanTargetDetails, p as SqlMigrationPlanOperation } from "./types-kgstZ_Zd.mjs";
+import { f as SqlMigrationPlanOperation, w as SqlPlanTargetDetails } from "./types-BW7pzb2j.mjs";
+import { Contract } from "@prisma-next/contract/types";
+import { SqlStorage } from "@prisma-next/sql-contract/types";
 import { Migration } from "@prisma-next/migration-tools/migration";
 
 //#region src/core/sql-migration.d.ts
@@ -13,10 +15,17 @@ import { Migration } from "@prisma-next/migration-tools/migration";
  * fully concrete operation shape. Target-free code in SQL family / tooling
  * parameterises over `TDetails` (and usually `TTargetId = string`).
  *
+ * The `Start` / `End` contract generics are forwarded to the framework
+ * `Migration` base so the derived `describe()` and the per-target view getters
+ * (`PostgresMigration` / `SqliteMigration`) carry each migration's precise
+ * contract types. The view getters themselves live on the per-target bases
+ * because the SQL ContractView shapes differ per target (SQLite unwraps its
+ * sole namespace to the root; Postgres is schema-qualified).
+ *
  * Keeps target-free contract/runtime features in the family layer while
  * letting adapters own target shape.
  */
-declare abstract class SqlMigration<TDetails extends SqlPlanTargetDetails, TTargetId extends string = string> extends Migration<SqlMigrationPlanOperation<TDetails>, 'sql', TTargetId> {
+declare abstract class SqlMigration<TDetails extends SqlPlanTargetDetails, TTargetId extends string = string, Start extends Contract<SqlStorage> = Contract<SqlStorage>, End extends Contract<SqlStorage> = Contract<SqlStorage>> extends Migration<SqlMigrationPlanOperation<TDetails>, 'sql', TTargetId, Start, End> {
   /**
    * Sorted, deduplicated invariant ids declared by this migration's
    * data-transform ops. Derived from `this.operations` so the field remains

package/dist/migration.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"migration.d.mts","names":[],"sources":["../src/core/sql-migration.ts"],"mappings":";;;;;;AAmBA;;;;;;;;;;;;uBAAsB,YAAA,kBACH,oBAAA,6CAET,SAAA,CAAU,yBAAA,CAA0B,QAAA,UAAkB,SAAA;EAAtD;;;;;;AAWc;;;;EAXd,IAWJ,kBAAA;AAAA"}
+{"version":3,"file":"migration.d.mts","names":[],"sources":["../src/core/sql-migration.ts"],"mappings":";;;;;;;;AA4BA;;;;;;;;;;;;;;;;;;;uBAAsB,YAAA,kBACH,oBAAA,mDAEH,QAAA,CAAS,UAAA,IAAc,QAAA,CAAS,UAAA,eAClC,QAAA,CAAS,UAAA,IAAc,QAAA,CAAS,UAAA,WACpC,SAAA,CAAU,yBAAA,CAA0B,QAAA,UAAkB,SAAA,EAAW,KAAA,EAAO,GAAA;EAJhF;;;;;;;;;;EAAA,IAeI,kBAAA;AAAA"}

package/dist/migration.mjs

@@ -13,6 +13,13 @@ import { isThenable } from "@prisma-next/utils/promise";
 * fully concrete operation shape. Target-free code in SQL family / tooling
 * parameterises over `TDetails` (and usually `TTargetId = string`).
 *
+* The `Start` / `End` contract generics are forwarded to the framework
+* `Migration` base so the derived `describe()` and the per-target view getters
+* (`PostgresMigration` / `SqliteMigration`) carry each migration's precise
+* contract types. The view getters themselves live on the per-target bases
+* because the SQL ContractView shapes differ per target (SQLite unwraps its
+* sole namespace to the root; Postgres is schema-qualified).
+*
 * Keeps target-free contract/runtime features in the family layer while
 * letting adapters own target shape.
 */

package/dist/migration.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"migration.mjs","names":[],"sources":["../src/core/sql-migration.ts"],"sourcesContent":["import { deriveProvidedInvariants } from '@prisma-next/migration-tools/invariants';\nimport { Migration } from '@prisma-next/migration-tools/migration';\nimport { isThenable } from '@prisma-next/utils/promise';\nimport type { SqlMigrationPlanOperation, SqlPlanTargetDetails } from './migrations/types';\n\n/**\n * Family-owned base class for SQL migrations.\n *\n * Generic in `TDetails` (family plan target details, e.g. Postgres vs SQLite)\n * and in `TTargetId` (the literal target identifier, e.g. `'postgres'`).\n *\n * Adapters (Postgres, SQLite, …) extend this with a concrete `TDetails` and\n * a fixed `TTargetId` literal, so the public `Migration<TOp>` base sees the\n * fully concrete operation shape. Target-free code in SQL family / tooling\n * parameterises over `TDetails` (and usually `TTargetId = string`).\n *\n * Keeps target-free contract/runtime features in the family layer while\n * letting adapters own target shape.\n */\nexport abstract class SqlMigration<\n  TDetails extends SqlPlanTargetDetails,\n  TTargetId extends string = string,\n> extends Migration<SqlMigrationPlanOperation<TDetails>, 'sql', TTargetId> {\n  /**\n   * Sorted, deduplicated invariant ids declared by this migration's\n   * data-transform ops. Derived from `this.operations` so the field remains\n   * consistent with the operation list — planner-built plans (`db init`,\n   * `db update`) yield `[]` because they emit no data-transform ops.\n   *\n   * Required by `SqlMigrationPlan.providedInvariants` (tightened from\n   * optional at the SQL-family layer); the framework-level\n   * `MigrationPlan.providedInvariants?` stays optional.\n   */\n  get providedInvariants(): readonly string[] {\n    const ops = this.operations.filter(\n      (op): op is SqlMigrationPlanOperation<TDetails> => !isThenable(op),\n    );\n    return deriveProvidedInvariants(ops);\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAmBA,IAAsB,eAAtB,cAGU,UAAiE;;;;;;;;;;;CAWzE,IAAI,qBAAwC;EAI1C,OAAO,yBAHK,KAAK,WAAW,QACzB,OAAkD,CAAC,WAAW,EAAE,CAEjC,CAAC;CACrC;AACF"}
+{"version":3,"file":"migration.mjs","names":[],"sources":["../src/core/sql-migration.ts"],"sourcesContent":["import type { Contract } from '@prisma-next/contract/types';\nimport { deriveProvidedInvariants } from '@prisma-next/migration-tools/invariants';\nimport { Migration } from '@prisma-next/migration-tools/migration';\nimport type { SqlStorage } from '@prisma-next/sql-contract/types';\nimport { isThenable } from '@prisma-next/utils/promise';\nimport type { SqlMigrationPlanOperation, SqlPlanTargetDetails } from './migrations/types';\n\n/**\n * Family-owned base class for SQL migrations.\n *\n * Generic in `TDetails` (family plan target details, e.g. Postgres vs SQLite)\n * and in `TTargetId` (the literal target identifier, e.g. `'postgres'`).\n *\n * Adapters (Postgres, SQLite, …) extend this with a concrete `TDetails` and\n * a fixed `TTargetId` literal, so the public `Migration<TOp>` base sees the\n * fully concrete operation shape. Target-free code in SQL family / tooling\n * parameterises over `TDetails` (and usually `TTargetId = string`).\n *\n * The `Start` / `End` contract generics are forwarded to the framework\n * `Migration` base so the derived `describe()` and the per-target view getters\n * (`PostgresMigration` / `SqliteMigration`) carry each migration's precise\n * contract types. The view getters themselves live on the per-target bases\n * because the SQL ContractView shapes differ per target (SQLite unwraps its\n * sole namespace to the root; Postgres is schema-qualified).\n *\n * Keeps target-free contract/runtime features in the family layer while\n * letting adapters own target shape.\n */\nexport abstract class SqlMigration<\n  TDetails extends SqlPlanTargetDetails,\n  TTargetId extends string = string,\n  Start extends Contract<SqlStorage> = Contract<SqlStorage>,\n  End extends Contract<SqlStorage> = Contract<SqlStorage>,\n> extends Migration<SqlMigrationPlanOperation<TDetails>, 'sql', TTargetId, Start, End> {\n  /**\n   * Sorted, deduplicated invariant ids declared by this migration's\n   * data-transform ops. Derived from `this.operations` so the field remains\n   * consistent with the operation list — planner-built plans (`db init`,\n   * `db update`) yield `[]` because they emit no data-transform ops.\n   *\n   * Required by `SqlMigrationPlan.providedInvariants` (tightened from\n   * optional at the SQL-family layer); the framework-level\n   * `MigrationPlan.providedInvariants?` stays optional.\n   */\n  get providedInvariants(): readonly string[] {\n    const ops = this.operations.filter(\n      (op): op is SqlMigrationPlanOperation<TDetails> => !isThenable(op),\n    );\n    return deriveProvidedInvariants(ops);\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AA4BA,IAAsB,eAAtB,cAKU,UAA6E;;;;;;;;;;;CAWrF,IAAI,qBAAwC;EAI1C,OAAO,yBAHK,KAAK,WAAW,QACzB,OAAkD,CAAC,WAAW,EAAE,CAEjC,CAAC;CACrC;AACF"}

package/dist/pack.mjs

@@ -1,4 +1,4 @@
-import { i as sqlFamilyPslBlockDescriptors, n as sqlFamilyAuthoringFieldPresets, r as sqlFamilyEntityTypes, t as sqlFamilyAuthoringTypes } from "./authoring-type-constructors-CjFfO6LM.mjs";
+import { i as sqlFamilyPslBlockDescriptors, n as sqlFamilyAuthoringFieldPresets, r as sqlFamilyEntityTypes, t as sqlFamilyAuthoringTypes } from "./authoring-type-constructors-CXd-8ydc.mjs";
 //#region src/exports/pack.ts
 const sqlFamilyPack = {
 	kind: "family",