@prisma/orm-family-sql 0.16.0-dev.36

package/dist/types-DmhUVq4u-BpqqjPJx.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"types-DmhUVq4u-BpqqjPJx.mjs","names":[],"sources":["../../../../2-sql/1-core/schema-ir/dist/types-DmhUVq4u.mjs"],"sourcesContent":["import { l as normalizeIndexOptionValue, o as nameOf } from \"./naming-BwqqVcZy.mjs\";\nimport { IRNodeBase, freezeNode } from \"@internal/framework-components/ir\";\nimport { blindCast } from \"@internal/utils/casts\";\nimport { InternalError } from \"@internal/utils/internal-error\";\nimport { canonicalStringify } from \"@internal/utils/canonical-stringify\";\nimport { ifDefined } from \"@internal/utils/defined\";\nimport { isArrayEqual } from \"@internal/utils/array-equal\";\n//#region src/ir/schema-node-kinds.ts\n/**\n* The `nodeKind` discriminant for each relational schema-diff leaf node.\n* Each node carries a unique value; the differ pairs siblings by `id`, and\n* these kinds distinguish the node types that appear as `PostgresTableSchemaNode`\n* children (columns, primary key, foreign keys, uniques, indexes, checks) from\n* each other and from the RLS policy/role kinds a target defines separately.\n*/\nconst RelationalSchemaNodeKind = {\n\tschema: \"sql-schema\",\n\ttable: \"sql-table\",\n\tcolumn: \"sql-column\",\n\tcolumnDefault: \"sql-column-default\",\n\tprimaryKey: \"sql-primary-key\",\n\tforeignKey: \"sql-foreign-key\",\n\tunique: \"sql-unique\",\n\tindex: \"sql-index\",\n\tcheck: \"sql-check-constraint\"\n};\n/**\n* The one real map from a relational `nodeKind` to the framework-neutral\n* {@link DiffSubjectGranularity} its diff issues carry — the SQL family's\n* post-diff filters (issue category, strict-mode gating) and the framework\n* aggregate's unclaimed-elements sweep key on the granularity, never on the\n* `nodeKind` spelling and never on anything stamped on the node. Resolution\n* is by `nodeKind` equality against this map, not a suffix string match.\n* Target-specific node kinds (Postgres namespace/table/policy/role) are\n* outside this family layer's vocabulary and map their own kinds directly.\n*/\nconst RELATIONAL_NODE_GRANULARITY = {\n\t[RelationalSchemaNodeKind.schema]: \"structural\",\n\t[RelationalSchemaNodeKind.table]: \"entity\",\n\t[RelationalSchemaNodeKind.column]: \"field\",\n\t[RelationalSchemaNodeKind.columnDefault]: \"auxiliary\",\n\t[RelationalSchemaNodeKind.primaryKey]: \"auxiliary\",\n\t[RelationalSchemaNodeKind.foreignKey]: \"auxiliary\",\n\t[RelationalSchemaNodeKind.unique]: \"auxiliary\",\n\t[RelationalSchemaNodeKind.index]: \"auxiliary\",\n\t[RelationalSchemaNodeKind.check]: \"auxiliary\"\n};\nfunction isRelationalSchemaNodeKind(nodeKind) {\n\treturn Object.hasOwn(RELATIONAL_NODE_GRANULARITY, nodeKind);\n}\n/**\n* Looks up the subject granularity for a relational `nodeKind`. Throws for a\n* `nodeKind` outside this map (a target-specific kind, e.g. Postgres's\n* namespace/table/policy/role) — those map their own kinds directly rather\n* than through this family-level map.\n*/\nfunction relationalNodeGranularity(nodeKind) {\n\tif (!isRelationalSchemaNodeKind(nodeKind)) throw new InternalError(`relationalNodeGranularity: unrecognized relational node kind \"${nodeKind}\"`);\n\treturn RELATIONAL_NODE_GRANULARITY[nodeKind];\n}\n/**\n* The one real map from a relational `nodeKind` to its storage `entityKind`\n* — the same vocabulary the contract storage's `entries` dictionary keys use\n* (`elementCoordinates` walks it). Only the whole-table kind has an entity of\n* its own; every other relational node (a column, an index, …) is nested\n* under one and maps to nothing here.\n*/\nconst RELATIONAL_NODE_ENTITY_KIND = { [RelationalSchemaNodeKind.table]: \"table\" };\n/**\n* Looks up the storage `entityKind` for a relational `nodeKind` — sibling of\n* {@link relationalNodeGranularity}, resolved by `nodeKind` equality against\n* {@link RELATIONAL_NODE_ENTITY_KIND}. `undefined` for a target-specific kind\n* (targets map their own kinds directly) or a relational kind with no entity\n* of its own.\n*/\nfunction relationalNodeEntityKind(nodeKind) {\n\treturn isRelationalSchemaNodeKind(nodeKind) ? RELATIONAL_NODE_ENTITY_KIND[nodeKind] : void 0;\n}\n//#endregion\n//#region src/ir/sql-schema-ir-node.ts\n/**\n* SQL Schema IR node base. Carries the family-level\n* `kind = 'sql-schema-ir'` discriminator and inherits the framework's\n* `freezeNode` affordance.\n*\n* SQL Schema IR represents the actual database state as discovered by\n* introspection (the parallel to SQL Contract IR, which represents the\n* desired state).\n*\n* The discriminator is installed as a non-enumerable own property,\n* matching the SqlNode pattern. This keeps `JSON.stringify(node)`\n* canonical (no `kind` field), keeps `toEqual({...})` test assertions\n* against pre-lift flat shapes passing, and keeps `node.kind` readable\n* for dispatch.\n*\n* Both `kind` and `nodeKind` are required: every concrete leaf is a node\n* the generic differ can pair and compare, so every leaf must declare which\n* node it is. `nodeKind` has no default here — every direct subclass sets its\n* own literal value (the relational leaves via `RelationalSchemaNodeKind`,\n* target concretions via their own vocabulary, e.g. `PostgresSchemaNodeKind`).\n*/\nvar SqlSchemaIRNode = class extends IRNodeBase {\n\tconstructor() {\n\t\tsuper();\n\t\tObject.defineProperty(this, \"kind\", {\n\t\t\tvalue: \"sql-schema-ir\",\n\t\t\twritable: false,\n\t\t\tenumerable: false,\n\t\t\tconfigurable: false\n\t\t});\n\t}\n};\n/**\n* Asserts `node` matches `predicate`, narrowing its type to `T`. The one\n* shared implementation every node class's `static assert` and `isEqualTo`\n* reach for, instead of each hand-writing its own throw: the message names\n* the class the caller expected.\n*/\nfunction assertNode(node, className, predicate) {\n\tif (node === void 0 || !predicate(node)) throw new InternalError(`Expected a ${className} but got nodeKind=${node?.nodeKind ?? \"undefined\"}`);\n}\n/**\n* Defines a non-enumerable own property, the same treatment `kind` gets\n* above: a derivation-time render-support field stays out of\n* `JSON.stringify`, `toEqual({...})` structural assertions, and spreads,\n* while remaining directly readable (`node.field`) for the one consumer\n* that resolves it at plan time. A no-op when `value` is `undefined` — the\n* property is simply absent, matching every other optional field on these\n* nodes.\n*/\nfunction defineNonEnumerable(target, key, value) {\n\tif (value === void 0) return;\n\tObject.defineProperty(target, key, {\n\t\tvalue,\n\t\tenumerable: false,\n\t\twritable: false,\n\t\tconfigurable: false\n\t});\n}\n//#endregion\n//#region src/ir/primary-key.ts\n/**\n* Primary-key Schema IR node. Mirrors the Contract IR `PrimaryKey`\n* shape (same `columns` + optional `name`) so verification can compare\n* intent and actual structurally. Defined here independently to avoid\n* a sql-schema-ir -> sql-contract dependency.\n*\n* Implements `DiffableNode` so a primary key is directly a table's diff-tree\n* child. `id` is a fixed sentinel — a table has at most one primary key, so\n* there is never a sibling to disambiguate against. `isEqualTo` compares the\n* column tuple; the PK's own `name` is a database-assigned label with no\n* semantic weight, so it is not compared (mirrors the policy node's\n* name-insensitivity to non-identifying detail).\n*/\nvar PrimaryKey = class PrimaryKey extends SqlSchemaIRNode {\n\tnodeKind = RelationalSchemaNodeKind.primaryKey;\n\tcolumns;\n\tconstructor(input) {\n\t\tsuper();\n\t\tthis.columns = input.columns;\n\t\tif (input.name !== void 0) this.name = input.name;\n\t\tdefineNonEnumerable(this, \"dependsOn\", input.dependsOn);\n\t\tfreezeNode(this);\n\t}\n\tget id() {\n\t\treturn \"primary-key\";\n\t}\n\tchildren() {\n\t\treturn [];\n\t}\n\tstatic is(node) {\n\t\treturn node.nodeKind === RelationalSchemaNodeKind.primaryKey;\n\t}\n\tisEqualTo(other) {\n\t\tconst node = blindCast(other);\n\t\tassertNode(node, \"PrimaryKey\", PrimaryKey.is);\n\t\treturn this.columns.length === node.columns.length && this.columns.every((c, i) => c === node.columns[i]);\n\t}\n};\n//#endregion\n//#region src/ir/sql-check-constraint-ir.ts\n/**\n* Schema IR node for a table-level check constraint that restricts a\n* column to a set of permitted values (an enum-style `IN (...)` check).\n*\n* Carries the **resolved values** rather than a raw SQL predicate so\n* callers can compare value-sets without parsing SQL.\n*\n* Implements `DiffableNode` so a check constraint is directly a table's\n* diff-tree child: `id` is the constraint name. `isEqualTo` compares\n* `column` and the permitted-value set (order-insensitive — the database\n* does not guarantee `IN (...)` ordering).\n*/\nvar SqlCheckConstraintIR = class SqlCheckConstraintIR extends SqlSchemaIRNode {\n\tnodeKind = RelationalSchemaNodeKind.check;\n\tname;\n\tcolumn;\n\tpermittedValues;\n\tconstructor(input) {\n\t\tsuper();\n\t\tthis.name = input.name;\n\t\tthis.column = input.column;\n\t\tthis.permittedValues = Object.freeze([...input.permittedValues]);\n\t\tfreezeNode(this);\n\t}\n\tget id() {\n\t\treturn `check:${this.name}`;\n\t}\n\tchildren() {\n\t\treturn [];\n\t}\n\tstatic is(node) {\n\t\treturn node.nodeKind === RelationalSchemaNodeKind.check;\n\t}\n\t/**\n\t* Compares the permitted-value sets only (unordered), matching the\n\t* relational walk's `verifyCheckConstraints`: two checks pairing by name\n\t* compare their value sets — the `column` field is descriptive, not part\n\t* of the comparison, so a name-paired check with equal values verifies\n\t* regardless of which column carries it.\n\t*/\n\tisEqualTo(other) {\n\t\tconst node = blindCast(other);\n\t\tassertNode(node, \"SqlCheckConstraintIR\", SqlCheckConstraintIR.is);\n\t\tconst thisValues = new Set(this.permittedValues);\n\t\tconst otherValues = new Set(node.permittedValues);\n\t\tif (thisValues.size !== otherValues.size) return false;\n\t\treturn [...thisValues].every((v) => otherValues.has(v));\n\t}\n};\n//#endregion\n//#region src/ir/resolved-default-equality.ts\n/**\n* Structural equality for two resolved column defaults, ported from the\n* relational walk's `columnDefaultsEqual` normalized branch: kinds must\n* match; literal values are normalized (Date and temporal-typed strings to\n* ISO instants) then compared canonically (JSON objects match their\n* canonical string form); function expressions compare case- and\n* whitespace-insensitively.\n*\n* `nativeType` provides the temporal-normalization context (the actual\n* side's resolved native type in a diff comparison).\n*/\nfunction resolvedDefaultsEqual(expected, actual, nativeType) {\n\tif (expected.kind !== actual.kind) return false;\n\tif (expected.kind === \"literal\" && actual.kind === \"literal\") return literalValuesEqual(normalizeLiteralValue(expected.value, nativeType), normalizeLiteralValue(actual.value, nativeType));\n\tif (expected.kind === \"function\" && actual.kind === \"function\") return normalizeFunctionExpression(expected.expression) === normalizeFunctionExpression(actual.expression);\n\treturn false;\n}\nfunction normalizeFunctionExpression(expression) {\n\treturn expression.toLowerCase().replace(/\\s+/g, \"\");\n}\nfunction isTemporalNativeType(nativeType) {\n\tif (!nativeType) return false;\n\tconst normalized = nativeType.toLowerCase();\n\treturn normalized.includes(\"timestamp\") || normalized === \"date\";\n}\nfunction normalizeLiteralValue(value, nativeType) {\n\tif (value instanceof Date) return value.toISOString();\n\tif (typeof value === \"string\" && isTemporalNativeType(nativeType)) {\n\t\tconst parsed = new Date(value);\n\t\tif (!Number.isNaN(parsed.getTime())) return parsed.toISOString();\n\t}\n\treturn value;\n}\nfunction literalValuesEqual(a, b) {\n\tif (a === b) return true;\n\tif (typeof a === \"object\" && a !== null && typeof b === \"object\" && b !== null) return canonicalStringify(a) === canonicalStringify(b);\n\tif (typeof a === \"object\" && a !== null && typeof b === \"string\") try {\n\t\treturn canonicalStringify(a) === canonicalStringify(JSON.parse(b));\n\t} catch {\n\t\treturn false;\n\t}\n\tif (typeof a === \"string\" && typeof b === \"object\" && b !== null) try {\n\t\treturn canonicalStringify(JSON.parse(a)) === canonicalStringify(b);\n\t} catch {\n\t\treturn false;\n\t}\n\treturn false;\n}\n//#endregion\n//#region src/ir/sql-column-default-ir.ts\n/**\n* Schema-diff node for a column's default value. The default is the one\n* column attribute with an extra/missing/drift lifecycle of its own, so it\n* is a child node of the column rather than a compared attribute: an\n* undeclared live default surfaces as `not-expected`, a declared default the\n* database lacks as `not-found`, and a divergent value as `not-equal` — the\n* three reasons cover the legacy `extra_default` / `default_missing` /\n* `default_mismatch` vocabulary with no attribute inspection.\n*\n* `id` is a fixed sentinel — a column has at most one default. Built\n* transiently by `SqlColumnIR.children()` from the column's own fields;\n* never constructed by derivation or introspection directly.\n*/\nvar SqlColumnDefaultIR = class SqlColumnDefaultIR extends SqlSchemaIRNode {\n\tnodeKind = RelationalSchemaNodeKind.columnDefault;\n\tconstructor(input) {\n\t\tsuper();\n\t\tif (input.resolved !== void 0) this.resolved = input.resolved;\n\t\tif (input.raw !== void 0) this.raw = input.raw;\n\t\tif (input.nativeTypeContext !== void 0) this.nativeTypeContext = input.nativeTypeContext;\n\t\tdefineNonEnumerable(this, \"many\", input.many);\n\t\tfreezeNode(this);\n\t}\n\tget id() {\n\t\treturn \"default\";\n\t}\n\tchildren() {\n\t\treturn [];\n\t}\n\tstatic is(node) {\n\t\treturn node.nodeKind === RelationalSchemaNodeKind.columnDefault;\n\t}\n\t/**\n\t* Structured comparison with `this` as the expected side: both sides\n\t* resolved compare per the relational walk's `columnDefaultsEqual`\n\t* semantics; a declared expected default against an unparseable actual\n\t* (raw present, no resolved parse) is a mismatch; two raw-only nodes fall\n\t* back to raw string equality.\n\t*/\n\tisEqualTo(other) {\n\t\tconst node = blindCast(other);\n\t\tassertNode(node, \"SqlColumnDefaultIR\", SqlColumnDefaultIR.is);\n\t\tif (this.resolved !== void 0 && node.resolved !== void 0) return resolvedDefaultsEqual(this.resolved, node.resolved, node.nativeTypeContext ?? this.nativeTypeContext);\n\t\tif (this.resolved !== void 0 || node.resolved !== void 0) return false;\n\t\treturn this.raw === node.raw;\n\t}\n};\n//#endregion\n//#region src/ir/sql-column-ir.ts\n/**\n* Schema IR node for a single column on a table, as observed by\n* introspection. Unlike the Contract IR `StorageColumn`, this carries\n* the column's `name` (Schema IR columns are returned as arrays from\n* introspection queries; the parent table re-keys them into a record\n* for downstream consumers).\n*\n* Implements `DiffableNode` so a column is directly a table's diff-tree\n* child: `id` is the column name (unique among a table's columns); `isEqualTo`\n* compares this column's own attributes only — never children, since a\n* column is a leaf. When both sides carry `resolvedNativeType` (stamped at\n* derivation/introspection), the comparison uses the resolved values —\n* resolved native type, nullability, and structured default equality per\n* the relational walk's `columnDefaultsEqual` semantics, with `this` as the\n* expected side. Otherwise it falls back to comparing raw fields.\n*/\nvar SqlColumnIR = class SqlColumnIR extends SqlSchemaIRNode {\n\tnodeKind = RelationalSchemaNodeKind.column;\n\tname;\n\tnativeType;\n\tnullable;\n\tconstructor(input) {\n\t\tsuper();\n\t\tthis.name = input.name;\n\t\tthis.nativeType = input.nativeType;\n\t\tthis.nullable = input.nullable;\n\t\tif (input.default !== void 0) this.default = input.default;\n\t\tif (input.annotations !== void 0) this.annotations = input.annotations;\n\t\tif (input.many !== void 0) this.many = input.many;\n\t\tif (input.resolvedNativeType !== void 0) this.resolvedNativeType = input.resolvedNativeType;\n\t\tif (input.resolvedDefault !== void 0) this.resolvedDefault = input.resolvedDefault;\n\t\tdefineNonEnumerable(this, \"codecRef\", input.codecRef);\n\t\tdefineNonEnumerable(this, \"codecBaseNativeType\", input.codecBaseNativeType);\n\t\tdefineNonEnumerable(this, \"codecNamedType\", input.codecNamedType);\n\t\tfreezeNode(this);\n\t}\n\tget id() {\n\t\treturn `column:${this.name}`;\n\t}\n\t/**\n\t* The column's default, when declared/present, is the column's one child\n\t* node — it has an extra/missing/drift lifecycle of its own, so the differ\n\t* recurses to it rather than `isEqualTo` comparing it. Built transiently\n\t* from this column's own fields.\n\t*/\n\tchildren() {\n\t\tif (this.resolvedDefault === void 0 && this.default === void 0) return [];\n\t\treturn [new SqlColumnDefaultIR({\n\t\t\t...ifDefined(\"resolved\", this.resolvedDefault),\n\t\t\t...ifDefined(\"raw\", this.default),\n\t\t\t...ifDefined(\"nativeTypeContext\", this.resolvedNativeType),\n\t\t\t...ifDefined(\"many\", this.many ?? this.codecRef?.many)\n\t\t})];\n\t}\n\tstatic is(node) {\n\t\treturn node.nodeKind === RelationalSchemaNodeKind.column;\n\t}\n\t/**\n\t* Compares the column's own attributes only — the default lives on the\n\t* child node. When both sides carry `resolvedNativeType`, the resolved\n\t* value governs (array-ness rides on its `[]` suffix); otherwise raw\n\t* fields compare.\n\t*/\n\tisEqualTo(other) {\n\t\tconst node = blindCast(other);\n\t\tassertNode(node, \"SqlColumnIR\", SqlColumnIR.is);\n\t\tif (this.resolvedNativeType !== void 0 && node.resolvedNativeType !== void 0) return this.resolvedNativeType === node.resolvedNativeType && this.nullable === node.nullable;\n\t\treturn this.nativeType === node.nativeType && this.nullable === node.nullable && Boolean(this.many) === Boolean(node.many);\n\t}\n};\n//#endregion\n//#region src/ir/sql-foreign-key-ir.ts\n/**\n* Schema IR node for a foreign-key constraint as observed by\n* introspection. The `referencedTable` / `referencedColumns` field\n* names match the introspection vocabulary (`pg_constraint.confkey`,\n* etc.) and intentionally differ from the Contract IR's nested\n* `references: { table, columns }` shape so that the verifier's\n* structural comparison stays explicit about which side it's reading.\n*\n* Implements `DiffableNode` so a foreign key is directly a table's diff-tree\n* child. Foreign keys are frequently unnamed (introspection may not carry a\n* constraint name, and the contract side never invents one), so `id` is\n* derived from the referencing/referenced coordinates rather than `name` —\n* the same tuple that makes two FK constraints the same constraint. This\n* also serves as the comparison key: two FKs with the same coordinates are\n* paired by the differ, and `isEqualTo` then compares the remaining\n* attribute — the referential actions.\n*/\nvar SqlForeignKeyIR = class SqlForeignKeyIR extends SqlSchemaIRNode {\n\tnodeKind = RelationalSchemaNodeKind.foreignKey;\n\tcolumns;\n\treferencedTable;\n\treferencedColumns;\n\tconstructor(input) {\n\t\tsuper();\n\t\tthis.columns = input.columns;\n\t\tthis.referencedTable = input.referencedTable;\n\t\tthis.referencedColumns = input.referencedColumns;\n\t\tif (input.referencedSchema !== void 0) this.referencedSchema = input.referencedSchema;\n\t\tif (input.name !== void 0) this.name = input.name;\n\t\tif (input.onDelete !== void 0) this.onDelete = input.onDelete;\n\t\tif (input.onUpdate !== void 0) this.onUpdate = input.onUpdate;\n\t\tif (input.annotations !== void 0) this.annotations = input.annotations;\n\t\tconst resolvedReferencedNamespace = input.resolvedReferencedNamespace ?? input.referencedSchema;\n\t\tif (resolvedReferencedNamespace !== void 0) this.resolvedReferencedNamespace = resolvedReferencedNamespace;\n\t\tdefineNonEnumerable(this, \"dependsOn\", input.dependsOn);\n\t\tfreezeNode(this);\n\t}\n\tget id() {\n\t\tconst referencedNamespace = this.resolvedReferencedNamespace ?? \"\";\n\t\treturn `foreign-key:${this.columns.join(\",\")}->${referencedNamespace}.${this.referencedTable}(${this.referencedColumns.join(\",\")})`;\n\t}\n\tchildren() {\n\t\treturn [];\n\t}\n\tstatic is(node) {\n\t\treturn node.nodeKind === RelationalSchemaNodeKind.foreignKey;\n\t}\n\t/**\n\t* Referential-action comparison with `this` as the expected side, matching\n\t* the relational walk's `getReferentialActionMismatches`: `noAction` is the\n\t* database default and equivalent to an undeclared action, and drift is\n\t* flagged only when the expected side declares a (normalized) action.\n\t*/\n\tisEqualTo(other) {\n\t\tconst node = blindCast(other);\n\t\tassertNode(node, \"SqlForeignKeyIR\", SqlForeignKeyIR.is);\n\t\treturn referentialActionMatches(this.onDelete, node.onDelete) && referentialActionMatches(this.onUpdate, node.onUpdate);\n\t}\n};\nfunction referentialActionMatches(expected, actual) {\n\tconst normalizedExpected = expected === \"noAction\" ? void 0 : expected;\n\tif (normalizedExpected === void 0) return true;\n\treturn normalizedExpected === (actual === \"noAction\" ? void 0 : actual);\n}\n//#endregion\n//#region src/ir/sql-index-ir.ts\n/**\n* Schema IR node for a secondary index as observed by introspection.\n* Unlike the Contract IR `Index`, the Schema IR carries an explicit\n* `unique` field — introspection sees the underlying index regardless\n* of whether the user expressed it as `@@index` or `@@unique`, and the\n* verifier needs to distinguish them when comparing to the Contract.\n*\n* Implements `DiffableNode` so an index is directly a table's diff-tree\n* child. Indexes are name-identified: every index — contract-derived or\n* introspected — carries its full physical name, and `id` is that name.\n* Names are catalog-unique per schema, so two indexes legitimately sharing\n* one column tuple (a unique index beside a redundant plain index) are two\n* distinct siblings, and expression indexes need no column tuple at all.\n*\n* `isEqualTo` is selected by the receiver (the differ always calls\n* `expected.isEqualTo(actual)`) and delegates to {@link contentEquals} —\n* the single node-owned content relation: both modes compare `unique`\n* strict, `type` and option values through the named normalization seams,\n* and `columns` ordered-strict when both sides carry them; an exact-named\n* receiver (`prefix === undefined`) additionally byte-compares\n* `expression`/`where` (both sides are reprints in the supported flow —\n* normalizing would only mask real drift); a wire-named receiver never\n* compares bodies (the wire-name hash already commits to them).\n*\n* `expression`, `where`, and `unique` are genuine SQL-family attributes —\n* functional and partial indexes are standard SQL that any SQL target may\n* introspect, so the family node must represent them; a target declining\n* to author them is a capability decision, not target-specificity.\n*/\nvar SqlIndexIR = class SqlIndexIR extends SqlSchemaIRNode {\n\tnodeKind = RelationalSchemaNodeKind.index;\n\tname;\n\tunique;\n\tconstructor(input) {\n\t\tsuper();\n\t\tconst name = nameOf(input.naming);\n\t\tif (input.columns === void 0 === (input.expression === void 0)) throw new InternalError(`SqlIndexIR \"${name}\": exactly one of columns or expression must be set.`);\n\t\tthis.name = name;\n\t\tthis.unique = input.unique;\n\t\tif (input.naming.kind === \"wire\") this.prefix = input.naming.prefix;\n\t\tif (input.columns !== void 0) this.columns = input.columns;\n\t\tif (input.expression !== void 0) this.expression = input.expression;\n\t\tif (input.where !== void 0) this.where = input.where;\n\t\tconst normalizedType = normalizeIndexType(input.type);\n\t\tif (normalizedType !== void 0) this.type = normalizedType;\n\t\tif (input.options !== void 0) this.options = input.options;\n\t\tif (input.annotations !== void 0) this.annotations = input.annotations;\n\t\tdefineNonEnumerable(this, \"dependsOn\", input.dependsOn);\n\t\tdefineNonEnumerable(this, \"partial\", input.partial);\n\t\tfreezeNode(this);\n\t}\n\tget id() {\n\t\treturn `index:${this.name}`;\n\t}\n\tchildren() {\n\t\treturn [];\n\t}\n\tstatic is(node) {\n\t\treturn node.nodeKind === RelationalSchemaNodeKind.index;\n\t}\n\t/**\n\t* Mode-selected structural equality — see the class doc. Delegates to the\n\t* single node-owned relation: `columns` compare ordered-strict when both\n\t* sides carry them; an exact receiver (`prefix === undefined`)\n\t* byte-compares `expression ?? ''` and `where ?? ''`; a wire-named receiver\n\t* never compares bodies (the wire-name hash already commits to them).\n\t*/\n\tisEqualTo(other) {\n\t\tconst node = blindCast(other);\n\t\tassertNode(node, \"SqlIndexIR\", SqlIndexIR.is);\n\t\treturn this.contentEquals(node, {\n\t\t\tcolumnPresence: \"when-both-defined\",\n\t\t\tbodies: this.prefix !== void 0 ? \"ignored\" : \"verbatim\"\n\t\t});\n\t}\n\t/**\n\t* The single index content-equality relation — every comparer (the differ\n\t* via {@link isEqualTo}, the planner's rename content-pairing) calls this\n\t* with its mode-appropriate strictness rather than growing a parallel\n\t* relation:\n\t*\n\t* - `columnPresence: 'when-both-defined'` (the differ's rule) compares\n\t*   the tuples ordered-strict only when both sides carry them — a paired\n\t*   node's identity already agreed, so a column node meeting an\n\t*   expression node skips the tuple.\n\t* - `columnPresence: 'matching'` (the rename-pairing rule) additionally\n\t*   requires presence to agree: a column index never pairs an expression\n\t*   index.\n\t* - `bodies: 'verbatim'` byte-compares `expression ?? ''` / `where ?? ''`\n\t*   (absent ≡ empty, no normalization — both sides are reprints in the\n\t*   supported flow); `bodies: 'ignored'` skips them (wire identity —\n\t*   the wire-name hash commits to the content).\n\t*\n\t* `unique` compares strictly; `type` and option VALUES compare through\n\t* the named normalization seams below.\n\t*/\n\tcontentEquals(other, strictness) {\n\t\tconst columnsEqual = strictness.columnPresence === \"matching\" ? this.columns === void 0 === (other.columns === void 0) && (this.columns === void 0 || isArrayEqual(this.columns, other.columns ?? [])) : this.columns === void 0 || other.columns === void 0 || isArrayEqual(this.columns, other.columns);\n\t\tif (!(this.unique === other.unique && normalizeIndexType(this.type) === normalizeIndexType(other.type) && indexOptionsEqual(this.options, other.options) && columnsEqual)) return false;\n\t\tif (strictness.bodies === \"ignored\") return true;\n\t\treturn (this.expression ?? \"\") === (other.expression ?? \"\") && (this.where ?? \"\") === (other.where ?? \"\");\n\t}\n};\n/**\n* The btree-default normalization seam: the default access method (`btree`\n* in every supported SQL target) normalizes to absent. Applied at\n* construction — every derivation path (contract tree, introspection, flat\n* family tree) builds through the class, so both compare sides are\n* symmetric by definition — and again inside\n* {@link SqlIndexIR.contentEquals} so the relation holds for any input.\n* The contract JSON and the wire-name content hash keep the authored\n* spelling: `@@index([a], type: \"btree\")` and `@@index([a])` are distinct\n* wire names — but content-equal after normalization, so a spelling change\n* between them converges as a rename via the planner's content\n* pairing (the hashes differ, so hash pairing never pairs them).\n*/\nfunction normalizeIndexType(type) {\n\treturn type === \"btree\" ? void 0 : type;\n}\n/**\n* Option-bag equality: same key set, values compared through\n* {@link normalizeIndexOptionValue} — Postgres introspection returns\n* reloptions values as catalog-reprint strings (`'70'`, `'on'`) while\n* contract option leaves are typed (number, boolean, string).\n*/\nfunction indexOptionsEqual(a, b) {\n\tconst aKeys = a ? Object.keys(a).sort() : [];\n\tconst bKeys = b ? Object.keys(b).sort() : [];\n\tif (aKeys.length !== bKeys.length) return false;\n\tfor (let i = 0; i < aKeys.length; i += 1) if (aKeys[i] !== bKeys[i]) return false;\n\tif (aKeys.length === 0) return true;\n\tfor (const key of aKeys) if (normalizeIndexOptionValue(a?.[key]) !== normalizeIndexOptionValue(b?.[key])) return false;\n\treturn true;\n}\n//#endregion\n//#region src/ir/sql-unique-ir.ts\n/**\n* Schema IR node for a table-level unique constraint as observed by\n* introspection.\n*\n* Implements `DiffableNode` so a unique constraint is directly a table's\n* diff-tree child. Unique constraints are frequently unnamed, so `id` is\n* derived from the column tuple rather than `name` — the column tuple is\n* also what makes two unique constraints the same constraint, so it doubles\n* as the pairing key. There are no further attributes to compare once\n* columns are equal (the differ pairs on `id`), so `isEqualTo` is identity.\n*/\nvar SqlUniqueIR = class SqlUniqueIR extends SqlSchemaIRNode {\n\tnodeKind = RelationalSchemaNodeKind.unique;\n\tcolumns;\n\tconstructor(input) {\n\t\tsuper();\n\t\tthis.columns = [...input.columns];\n\t\tif (input.name !== void 0) this.name = input.name;\n\t\tif (input.annotations !== void 0) this.annotations = input.annotations;\n\t\tdefineNonEnumerable(this, \"dependsOn\", input.dependsOn);\n\t\tfreezeNode(this);\n\t}\n\tget id() {\n\t\treturn `unique:${this.columns.join(\",\")}`;\n\t}\n\tchildren() {\n\t\treturn [];\n\t}\n\tstatic is(node) {\n\t\treturn node.nodeKind === RelationalSchemaNodeKind.unique;\n\t}\n\tisEqualTo(other) {\n\t\tconst node = blindCast(other);\n\t\tassertNode(node, \"SqlUniqueIR\", SqlUniqueIR.is);\n\t\treturn this.id === node.id;\n\t}\n};\n//#endregion\n//#region src/ir/sql-table-ir.ts\n/**\n* Schema IR node for a single table as observed by introspection.\n*\n* Unlike the Contract IR `StorageTable`, this carries the table's\n* `name` — introspection queries return tables as arrays and the\n* verifier keys them into `SqlSchemaIR.tables` afterwards, so the name\n* stays on the table object for downstream call sites that walk\n* `Object.values(schema.tables)`.\n*\n* The constructor normalises nested IR-class fields so downstream\n* walks see a uniform AST regardless of whether the input was a\n* plain-data literal (from introspection) or already-constructed\n* class instances.\n*\n* Implements `DiffableNode` so a flat (single-schema) tree is directly\n* diffable: `id` is the table name; `isEqualTo` is identity (the table's\n* structural drift is entirely expressed by its children); `children()`\n* yields every column, the primary key (when present), every foreign key,\n* unique, index, and check constraint — the same composition and order as\n* the Postgres table node, minus policies.\n*/\nvar SqlTableIR = class extends SqlSchemaIRNode {\n\tnodeKind = RelationalSchemaNodeKind.table;\n\tname;\n\tcolumns;\n\tforeignKeys;\n\tuniques;\n\tindexes;\n\tconstructor(input) {\n\t\tsuper();\n\t\tthis.name = input.name;\n\t\tthis.columns = Object.freeze(Object.fromEntries(Object.entries(input.columns).map(([key, col]) => [key, col instanceof SqlColumnIR ? col : new SqlColumnIR(col)])));\n\t\tthis.foreignKeys = Object.freeze(input.foreignKeys.map((fk) => fk instanceof SqlForeignKeyIR ? fk : new SqlForeignKeyIR(fk)));\n\t\tthis.uniques = Object.freeze(input.uniques.map((u) => u instanceof SqlUniqueIR ? u : new SqlUniqueIR(u)));\n\t\tthis.indexes = Object.freeze(input.indexes.map((i) => i instanceof SqlIndexIR ? i : new SqlIndexIR(i)));\n\t\tif (input.primaryKey !== void 0) this.primaryKey = input.primaryKey instanceof PrimaryKey ? input.primaryKey : new PrimaryKey(input.primaryKey);\n\t\tif (input.annotations !== void 0) this.annotations = input.annotations;\n\t\tif (input.checks !== void 0 && input.checks.length > 0) this.checks = Object.freeze(input.checks.map((c) => c instanceof SqlCheckConstraintIR ? c : new SqlCheckConstraintIR(c)));\n\t\tfreezeNode(this);\n\t}\n\tget id() {\n\t\treturn this.name;\n\t}\n\tisEqualTo(other) {\n\t\treturn this.id === other.id;\n\t}\n\tchildren() {\n\t\treturn [\n\t\t\t...Object.values(this.columns),\n\t\t\t...this.primaryKey ? [this.primaryKey] : [],\n\t\t\t...this.foreignKeys,\n\t\t\t...this.uniques,\n\t\t\t...this.indexes,\n\t\t\t...this.checks ?? []\n\t\t];\n\t}\n};\n//#endregion\n//#region src/ir/sql-schema-ir.ts\n/**\n* Root Schema IR node representing the complete database schema as\n* observed by introspection. Target-agnostic; used by both verifiers\n* (compare against intended Contract storage) and migration planners\n* (derive operations needed to reconcile).\n*\n* The constructor normalises nested `SqlTableIR` instances so\n* downstream walks see a uniform AST regardless of whether the input\n* was a plain-data literal or already-constructed class instances.\n*\n* Implements `DiffableNode` as the root of a flat (single-schema) diff\n* tree: `id` is the fixed sentinel `'database'` (roots have no siblings),\n* `isEqualTo` is identity (a container has no own attributes), and\n* `children()` yields the table nodes.\n*/\nvar SqlSchemaIR = class extends SqlSchemaIRNode {\n\tnodeKind = RelationalSchemaNodeKind.schema;\n\ttables;\n\tconstructor(input) {\n\t\tsuper();\n\t\tthis.tables = Object.freeze(Object.fromEntries(Object.entries(input.tables).map(([key, t]) => [key, t instanceof SqlTableIR ? t : new SqlTableIR(t)])));\n\t\tif (input.annotations !== void 0) this.annotations = input.annotations;\n\t\tfreezeNode(this);\n\t}\n\tget id() {\n\t\treturn \"database\";\n\t}\n\tisEqualTo(other) {\n\t\treturn this.id === other.id;\n\t}\n\tchildren() {\n\t\treturn Object.values(this.tables);\n\t}\n};\n//#endregion\nexport { SqlForeignKeyIR as a, SqlCheckConstraintIR as c, assertNode as d, defineNonEnumerable as f, relationalNodeGranularity as h, SqlIndexIR as i, PrimaryKey as l, relationalNodeEntityKind as m, SqlTableIR as n, SqlColumnIR as o, RelationalSchemaNodeKind as p, SqlUniqueIR as r, SqlColumnDefaultIR as s, SqlSchemaIR as t, SqlSchemaIRNode as u };\n\n//# sourceMappingURL=types-DmhUVq4u.mjs.map"],"mappings":";;;;;;;;;;;;;;;AAeA,MAAM,2BAA2B;CAChC,QAAQ;CACR,OAAO;CACP,QAAQ;CACR,eAAe;CACf,YAAY;CACZ,YAAY;CACZ,QAAQ;CACR,OAAO;CACP,OAAO;AACR;;;;;;;;;;;AAWA,MAAM,8BAA8B;EAClC,yBAAyB,SAAS;EAClC,yBAAyB,QAAQ;EACjC,yBAAyB,SAAS;EAClC,yBAAyB,gBAAgB;EACzC,yBAAyB,aAAa;EACtC,yBAAyB,aAAa;EACtC,yBAAyB,SAAS;EAClC,yBAAyB,QAAQ;EACjC,yBAAyB,QAAQ;AACnC;AACA,SAAS,2BAA2B,UAAU;CAC7C,OAAO,OAAO,OAAO,6BAA6B,QAAQ;AAC3D;;;;;;;AAOA,SAAS,0BAA0B,UAAU;CAC5C,IAAI,CAAC,2BAA2B,QAAQ,GAAG,MAAM,IAAI,cAAc,iEAAiE,SAAS,EAAE;CAC/I,OAAO,4BAA4B;AACpC;;;;;;;;AAQA,MAAM,8BAA8B,GAAG,yBAAyB,QAAQ,QAAQ;;;;;;;;AAQhF,SAAS,yBAAyB,UAAU;CAC3C,OAAO,2BAA2B,QAAQ,IAAI,4BAA4B,YAAY,KAAK;AAC5F;;;;;;;;;;;;;;;;;;;;;;AAwBA,IAAI,kBAAkB,cAAc,WAAW;CAC9C,cAAc;EACb,MAAM;EACN,OAAO,eAAe,MAAM,QAAQ;GACnC,OAAO;GACP,UAAU;GACV,YAAY;GACZ,cAAc;EACf,CAAC;CACF;AACD;;;;;;;AAOA,SAAS,WAAW,MAAM,WAAW,WAAW;CAC/C,IAAI,SAAS,KAAK,KAAK,CAAC,UAAU,IAAI,GAAG,MAAM,IAAI,cAAc,cAAc,UAAU,oBAAoB,MAAM,YAAY,aAAa;AAC7I;;;;;;;;;;AAUA,SAAS,oBAAoB,QAAQ,KAAK,OAAO;CAChD,IAAI,UAAU,KAAK,GAAG;CACtB,OAAO,eAAe,QAAQ,KAAK;EAClC;EACA,YAAY;EACZ,UAAU;EACV,cAAc;CACf,CAAC;AACF;;;;;;;;;;;;;;AAgBA,IAAI,aAAa,MAAM,mBAAmB,gBAAgB;CACzD,WAAW,yBAAyB;CACpC;CACA,YAAY,OAAO;EAClB,MAAM;EACN,KAAK,UAAU,MAAM;EACrB,IAAI,MAAM,SAAS,KAAK,GAAG,KAAK,OAAO,MAAM;EAC7C,oBAAoB,MAAM,aAAa,MAAM,SAAS;EACtD,WAAW,IAAI;CAChB;CACA,IAAI,KAAK;EACR,OAAO;CACR;CACA,WAAW;EACV,OAAO,CAAC;CACT;CACA,OAAO,GAAG,MAAM;EACf,OAAO,KAAK,aAAa,yBAAyB;CACnD;CACA,UAAU,OAAO;EAChB,MAAM,OAAO,UAAU,KAAK;EAC5B,WAAW,MAAM,cAAc,WAAW,EAAE;EAC5C,OAAO,KAAK,QAAQ,WAAW,KAAK,QAAQ,UAAU,KAAK,QAAQ,OAAO,GAAG,MAAM,MAAM,KAAK,QAAQ,EAAE;CACzG;AACD;;;;;;;;;;;;;AAeA,IAAI,uBAAuB,MAAM,6BAA6B,gBAAgB;CAC7E,WAAW,yBAAyB;CACpC;CACA;CACA;CACA,YAAY,OAAO;EAClB,MAAM;EACN,KAAK,OAAO,MAAM;EAClB,KAAK,SAAS,MAAM;EACpB,KAAK,kBAAkB,OAAO,OAAO,CAAC,GAAG,MAAM,eAAe,CAAC;EAC/D,WAAW,IAAI;CAChB;CACA,IAAI,KAAK;EACR,OAAO,SAAS,KAAK;CACtB;CACA,WAAW;EACV,OAAO,CAAC;CACT;CACA,OAAO,GAAG,MAAM;EACf,OAAO,KAAK,aAAa,yBAAyB;CACnD;;;;;;;;CAQA,UAAU,OAAO;EAChB,MAAM,OAAO,UAAU,KAAK;EAC5B,WAAW,MAAM,wBAAwB,qBAAqB,EAAE;EAChE,MAAM,aAAa,IAAI,IAAI,KAAK,eAAe;EAC/C,MAAM,cAAc,IAAI,IAAI,KAAK,eAAe;EAChD,IAAI,WAAW,SAAS,YAAY,MAAM,OAAO;EACjD,OAAO,CAAC,GAAG,UAAU,CAAC,CAAC,OAAO,MAAM,YAAY,IAAI,CAAC,CAAC;CACvD;AACD;;;;;;;;;;;;AAcA,SAAS,sBAAsB,UAAU,QAAQ,YAAY;CAC5D,IAAI,SAAS,SAAS,OAAO,MAAM,OAAO;CAC1C,IAAI,SAAS,SAAS,aAAa,OAAO,SAAS,WAAW,OAAO,mBAAmB,sBAAsB,SAAS,OAAO,UAAU,GAAG,sBAAsB,OAAO,OAAO,UAAU,CAAC;CAC1L,IAAI,SAAS,SAAS,cAAc,OAAO,SAAS,YAAY,OAAO,4BAA4B,SAAS,UAAU,MAAM,4BAA4B,OAAO,UAAU;CACzK,OAAO;AACR;AACA,SAAS,4BAA4B,YAAY;CAChD,OAAO,WAAW,YAAY,CAAC,CAAC,QAAQ,QAAQ,EAAE;AACnD;AACA,SAAS,qBAAqB,YAAY;CACzC,IAAI,CAAC,YAAY,OAAO;CACxB,MAAM,aAAa,WAAW,YAAY;CAC1C,OAAO,WAAW,SAAS,WAAW,KAAK,eAAe;AAC3D;AACA,SAAS,sBAAsB,OAAO,YAAY;CACjD,IAAI,iBAAiB,MAAM,OAAO,MAAM,YAAY;CACpD,IAAI,OAAO,UAAU,YAAY,qBAAqB,UAAU,GAAG;EAClE,MAAM,SAAS,IAAI,KAAK,KAAK;EAC7B,IAAI,CAAC,OAAO,MAAM,OAAO,QAAQ,CAAC,GAAG,OAAO,OAAO,YAAY;CAChE;CACA,OAAO;AACR;AACA,SAAS,mBAAmB,GAAG,GAAG;CACjC,IAAI,MAAM,GAAG,OAAO;CACpB,IAAI,OAAO,MAAM,YAAY,MAAM,QAAQ,OAAO,MAAM,YAAY,MAAM,MAAM,OAAO,mBAAmB,CAAC,MAAM,mBAAmB,CAAC;CACrI,IAAI,OAAO,MAAM,YAAY,MAAM,QAAQ,OAAO,MAAM,UAAU,IAAI;EACrE,OAAO,mBAAmB,CAAC,MAAM,mBAAmB,KAAK,MAAM,CAAC,CAAC;CAClE,QAAQ;EACP,OAAO;CACR;CACA,IAAI,OAAO,MAAM,YAAY,OAAO,MAAM,YAAY,MAAM,MAAM,IAAI;EACrE,OAAO,mBAAmB,KAAK,MAAM,CAAC,CAAC,MAAM,mBAAmB,CAAC;CAClE,QAAQ;EACP,OAAO;CACR;CACA,OAAO;AACR;;;;;;;;;;;;;;AAgBA,IAAI,qBAAqB,MAAM,2BAA2B,gBAAgB;CACzE,WAAW,yBAAyB;CACpC,YAAY,OAAO;EAClB,MAAM;EACN,IAAI,MAAM,aAAa,KAAK,GAAG,KAAK,WAAW,MAAM;EACrD,IAAI,MAAM,QAAQ,KAAK,GAAG,KAAK,MAAM,MAAM;EAC3C,IAAI,MAAM,sBAAsB,KAAK,GAAG,KAAK,oBAAoB,MAAM;EACvE,oBAAoB,MAAM,QAAQ,MAAM,IAAI;EAC5C,WAAW,IAAI;CAChB;CACA,IAAI,KAAK;EACR,OAAO;CACR;CACA,WAAW;EACV,OAAO,CAAC;CACT;CACA,OAAO,GAAG,MAAM;EACf,OAAO,KAAK,aAAa,yBAAyB;CACnD;;;;;;;;CAQA,UAAU,OAAO;EAChB,MAAM,OAAO,UAAU,KAAK;EAC5B,WAAW,MAAM,sBAAsB,mBAAmB,EAAE;EAC5D,IAAI,KAAK,aAAa,KAAK,KAAK,KAAK,aAAa,KAAK,GAAG,OAAO,sBAAsB,KAAK,UAAU,KAAK,UAAU,KAAK,qBAAqB,KAAK,iBAAiB;EACrK,IAAI,KAAK,aAAa,KAAK,KAAK,KAAK,aAAa,KAAK,GAAG,OAAO;EACjE,OAAO,KAAK,QAAQ,KAAK;CAC1B;AACD;;;;;;;;;;;;;;;;;AAmBA,IAAI,cAAc,MAAM,oBAAoB,gBAAgB;CAC3D,WAAW,yBAAyB;CACpC;CACA;CACA;CACA,YAAY,OAAO;EAClB,MAAM;EACN,KAAK,OAAO,MAAM;EAClB,KAAK,aAAa,MAAM;EACxB,KAAK,WAAW,MAAM;EACtB,IAAI,MAAM,YAAY,KAAK,GAAG,KAAK,UAAU,MAAM;EACnD,IAAI,MAAM,gBAAgB,KAAK,GAAG,KAAK,cAAc,MAAM;EAC3D,IAAI,MAAM,SAAS,KAAK,GAAG,KAAK,OAAO,MAAM;EAC7C,IAAI,MAAM,uBAAuB,KAAK,GAAG,KAAK,qBAAqB,MAAM;EACzE,IAAI,MAAM,oBAAoB,KAAK,GAAG,KAAK,kBAAkB,MAAM;EACnE,oBAAoB,MAAM,YAAY,MAAM,QAAQ;EACpD,oBAAoB,MAAM,uBAAuB,MAAM,mBAAmB;EAC1E,oBAAoB,MAAM,kBAAkB,MAAM,cAAc;EAChE,WAAW,IAAI;CAChB;CACA,IAAI,KAAK;EACR,OAAO,UAAU,KAAK;CACvB;;;;;;;CAOA,WAAW;EACV,IAAI,KAAK,oBAAoB,KAAK,KAAK,KAAK,YAAY,KAAK,GAAG,OAAO,CAAC;EACxE,OAAO,CAAC,IAAI,mBAAmB;GAC9B,GAAG,UAAU,YAAY,KAAK,eAAe;GAC7C,GAAG,UAAU,OAAO,KAAK,OAAO;GAChC,GAAG,UAAU,qBAAqB,KAAK,kBAAkB;GACzD,GAAG,UAAU,QAAQ,KAAK,QAAQ,KAAK,UAAU,IAAI;EACtD,CAAC,CAAC;CACH;CACA,OAAO,GAAG,MAAM;EACf,OAAO,KAAK,aAAa,yBAAyB;CACnD;;;;;;;CAOA,UAAU,OAAO;EAChB,MAAM,OAAO,UAAU,KAAK;EAC5B,WAAW,MAAM,eAAe,YAAY,EAAE;EAC9C,IAAI,KAAK,uBAAuB,KAAK,KAAK,KAAK,uBAAuB,KAAK,GAAG,OAAO,KAAK,uBAAuB,KAAK,sBAAsB,KAAK,aAAa,KAAK;EACnK,OAAO,KAAK,eAAe,KAAK,cAAc,KAAK,aAAa,KAAK,YAAY,QAAQ,KAAK,IAAI,MAAM,QAAQ,KAAK,IAAI;CAC1H;AACD;;;;;;;;;;;;;;;;;;AAoBA,IAAI,kBAAkB,MAAM,wBAAwB,gBAAgB;CACnE,WAAW,yBAAyB;CACpC;CACA;CACA;CACA,YAAY,OAAO;EAClB,MAAM;EACN,KAAK,UAAU,MAAM;EACrB,KAAK,kBAAkB,MAAM;EAC7B,KAAK,oBAAoB,MAAM;EAC/B,IAAI,MAAM,qBAAqB,KAAK,GAAG,KAAK,mBAAmB,MAAM;EACrE,IAAI,MAAM,SAAS,KAAK,GAAG,KAAK,OAAO,MAAM;EAC7C,IAAI,MAAM,aAAa,KAAK,GAAG,KAAK,WAAW,MAAM;EACrD,IAAI,MAAM,aAAa,KAAK,GAAG,KAAK,WAAW,MAAM;EACrD,IAAI,MAAM,gBAAgB,KAAK,GAAG,KAAK,cAAc,MAAM;EAC3D,MAAM,8BAA8B,MAAM,+BAA+B,MAAM;EAC/E,IAAI,gCAAgC,KAAK,GAAG,KAAK,8BAA8B;EAC/E,oBAAoB,MAAM,aAAa,MAAM,SAAS;EACtD,WAAW,IAAI;CAChB;CACA,IAAI,KAAK;EACR,MAAM,sBAAsB,KAAK,+BAA+B;EAChE,OAAO,eAAe,KAAK,QAAQ,KAAK,GAAG,EAAE,IAAI,oBAAoB,GAAG,KAAK,gBAAgB,GAAG,KAAK,kBAAkB,KAAK,GAAG,EAAE;CAClI;CACA,WAAW;EACV,OAAO,CAAC;CACT;CACA,OAAO,GAAG,MAAM;EACf,OAAO,KAAK,aAAa,yBAAyB;CACnD;;;;;;;CAOA,UAAU,OAAO;EAChB,MAAM,OAAO,UAAU,KAAK;EAC5B,WAAW,MAAM,mBAAmB,gBAAgB,EAAE;EACtD,OAAO,yBAAyB,KAAK,UAAU,KAAK,QAAQ,KAAK,yBAAyB,KAAK,UAAU,KAAK,QAAQ;CACvH;AACD;AACA,SAAS,yBAAyB,UAAU,QAAQ;CACnD,MAAM,qBAAqB,aAAa,aAAa,KAAK,IAAI;CAC9D,IAAI,uBAAuB,KAAK,GAAG,OAAO;CAC1C,OAAO,wBAAwB,WAAW,aAAa,KAAK,IAAI;AACjE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgCA,IAAI,aAAa,MAAM,mBAAmB,gBAAgB;CACzD,WAAW,yBAAyB;CACpC;CACA;CACA,YAAY,OAAO;EAClB,MAAM;EACN,MAAM,OAAO,OAAO,MAAM,MAAM;EAChC,IAAI,MAAM,YAAY,KAAK,OAAO,MAAM,eAAe,KAAK,IAAI,MAAM,IAAI,cAAc,eAAe,KAAK,qDAAqD;EACjK,KAAK,OAAO;EACZ,KAAK,SAAS,MAAM;EACpB,IAAI,MAAM,OAAO,SAAS,QAAQ,KAAK,SAAS,MAAM,OAAO;EAC7D,IAAI,MAAM,YAAY,KAAK,GAAG,KAAK,UAAU,MAAM;EACnD,IAAI,MAAM,eAAe,KAAK,GAAG,KAAK,aAAa,MAAM;EACzD,IAAI,MAAM,UAAU,KAAK,GAAG,KAAK,QAAQ,MAAM;EAC/C,MAAM,iBAAiB,mBAAmB,MAAM,IAAI;EACpD,IAAI,mBAAmB,KAAK,GAAG,KAAK,OAAO;EAC3C,IAAI,MAAM,YAAY,KAAK,GAAG,KAAK,UAAU,MAAM;EACnD,IAAI,MAAM,gBAAgB,KAAK,GAAG,KAAK,cAAc,MAAM;EAC3D,oBAAoB,MAAM,aAAa,MAAM,SAAS;EACtD,oBAAoB,MAAM,WAAW,MAAM,OAAO;EAClD,WAAW,IAAI;CAChB;CACA,IAAI,KAAK;EACR,OAAO,SAAS,KAAK;CACtB;CACA,WAAW;EACV,OAAO,CAAC;CACT;CACA,OAAO,GAAG,MAAM;EACf,OAAO,KAAK,aAAa,yBAAyB;CACnD;;;;;;;;CAQA,UAAU,OAAO;EAChB,MAAM,OAAO,UAAU,KAAK;EAC5B,WAAW,MAAM,cAAc,WAAW,EAAE;EAC5C,OAAO,KAAK,cAAc,MAAM;GAC/B,gBAAgB;GAChB,QAAQ,KAAK,WAAW,KAAK,IAAI,YAAY;EAC9C,CAAC;CACF;;;;;;;;;;;;;;;;;;;;;;CAsBA,cAAc,OAAO,YAAY;EAChC,MAAM,eAAe,WAAW,mBAAmB,aAAa,KAAK,YAAY,KAAK,OAAO,MAAM,YAAY,KAAK,OAAO,KAAK,YAAY,KAAK,KAAK,aAAa,KAAK,SAAS,MAAM,WAAW,CAAC,CAAC,KAAK,KAAK,YAAY,KAAK,KAAK,MAAM,YAAY,KAAK,KAAK,aAAa,KAAK,SAAS,MAAM,OAAO;EACxS,IAAI,EAAE,KAAK,WAAW,MAAM,UAAU,mBAAmB,KAAK,IAAI,MAAM,mBAAmB,MAAM,IAAI,KAAK,kBAAkB,KAAK,SAAS,MAAM,OAAO,KAAK,eAAe,OAAO;EAClL,IAAI,WAAW,WAAW,WAAW,OAAO;EAC5C,QAAQ,KAAK,cAAc,SAAS,MAAM,cAAc,QAAQ,KAAK,SAAS,SAAS,MAAM,SAAS;CACvG;AACD;;;;;;;;;;;;;;AAcA,SAAS,mBAAmB,MAAM;CACjC,OAAO,SAAS,UAAU,KAAK,IAAI;AACpC;;;;;;;AAOA,SAAS,kBAAkB,GAAG,GAAG;CAChC,MAAM,QAAQ,IAAI,OAAO,KAAK,CAAC,CAAC,CAAC,KAAK,IAAI,CAAC;CAC3C,MAAM,QAAQ,IAAI,OAAO,KAAK,CAAC,CAAC,CAAC,KAAK,IAAI,CAAC;CAC3C,IAAI,MAAM,WAAW,MAAM,QAAQ,OAAO;CAC1C,KAAK,IAAI,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK,GAAG,IAAI,MAAM,OAAO,MAAM,IAAI,OAAO;CAC5E,IAAI,MAAM,WAAW,GAAG,OAAO;CAC/B,KAAK,MAAM,OAAO,OAAO,IAAI,0BAA0B,IAAI,IAAI,MAAM,0BAA0B,IAAI,IAAI,GAAG,OAAO;CACjH,OAAO;AACR;;;;;;;;;;;;AAcA,IAAI,cAAc,MAAM,oBAAoB,gBAAgB;CAC3D,WAAW,yBAAyB;CACpC;CACA,YAAY,OAAO;EAClB,MAAM;EACN,KAAK,UAAU,CAAC,GAAG,MAAM,OAAO;EAChC,IAAI,MAAM,SAAS,KAAK,GAAG,KAAK,OAAO,MAAM;EAC7C,IAAI,MAAM,gBAAgB,KAAK,GAAG,KAAK,cAAc,MAAM;EAC3D,oBAAoB,MAAM,aAAa,MAAM,SAAS;EACtD,WAAW,IAAI;CAChB;CACA,IAAI,KAAK;EACR,OAAO,UAAU,KAAK,QAAQ,KAAK,GAAG;CACvC;CACA,WAAW;EACV,OAAO,CAAC;CACT;CACA,OAAO,GAAG,MAAM;EACf,OAAO,KAAK,aAAa,yBAAyB;CACnD;CACA,UAAU,OAAO;EAChB,MAAM,OAAO,UAAU,KAAK;EAC5B,WAAW,MAAM,eAAe,YAAY,EAAE;EAC9C,OAAO,KAAK,OAAO,KAAK;CACzB;AACD;;;;;;;;;;;;;;;;;;;;;;AAwBA,IAAI,aAAa,cAAc,gBAAgB;CAC9C,WAAW,yBAAyB;CACpC;CACA;CACA;CACA;CACA;CACA,YAAY,OAAO;EAClB,MAAM;EACN,KAAK,OAAO,MAAM;EAClB,KAAK,UAAU,OAAO,OAAO,OAAO,YAAY,OAAO,QAAQ,MAAM,OAAO,CAAC,CAAC,KAAK,CAAC,KAAK,SAAS,CAAC,KAAK,eAAe,cAAc,MAAM,IAAI,YAAY,GAAG,CAAC,CAAC,CAAC,CAAC;EAClK,KAAK,cAAc,OAAO,OAAO,MAAM,YAAY,KAAK,OAAO,cAAc,kBAAkB,KAAK,IAAI,gBAAgB,EAAE,CAAC,CAAC;EAC5H,KAAK,UAAU,OAAO,OAAO,MAAM,QAAQ,KAAK,MAAM,aAAa,cAAc,IAAI,IAAI,YAAY,CAAC,CAAC,CAAC;EACxG,KAAK,UAAU,OAAO,OAAO,MAAM,QAAQ,KAAK,MAAM,aAAa,aAAa,IAAI,IAAI,WAAW,CAAC,CAAC,CAAC;EACtG,IAAI,MAAM,eAAe,KAAK,GAAG,KAAK,aAAa,MAAM,sBAAsB,aAAa,MAAM,aAAa,IAAI,WAAW,MAAM,UAAU;EAC9I,IAAI,MAAM,gBAAgB,KAAK,GAAG,KAAK,cAAc,MAAM;EAC3D,IAAI,MAAM,WAAW,KAAK,KAAK,MAAM,OAAO,SAAS,GAAG,KAAK,SAAS,OAAO,OAAO,MAAM,OAAO,KAAK,MAAM,aAAa,uBAAuB,IAAI,IAAI,qBAAqB,CAAC,CAAC,CAAC;EAChL,WAAW,IAAI;CAChB;CACA,IAAI,KAAK;EACR,OAAO,KAAK;CACb;CACA,UAAU,OAAO;EAChB,OAAO,KAAK,OAAO,MAAM;CAC1B;CACA,WAAW;EACV,OAAO;GACN,GAAG,OAAO,OAAO,KAAK,OAAO;GAC7B,GAAG,KAAK,aAAa,CAAC,KAAK,UAAU,IAAI,CAAC;GAC1C,GAAG,KAAK;GACR,GAAG,KAAK;GACR,GAAG,KAAK;GACR,GAAG,KAAK,UAAU,CAAC;EACpB;CACD;AACD;;;;;;;;;;;;;;;;AAkBA,IAAI,cAAc,cAAc,gBAAgB;CAC/C,WAAW,yBAAyB;CACpC;CACA,YAAY,OAAO;EAClB,MAAM;EACN,KAAK,SAAS,OAAO,OAAO,OAAO,YAAY,OAAO,QAAQ,MAAM,MAAM,CAAC,CAAC,KAAK,CAAC,KAAK,OAAO,CAAC,KAAK,aAAa,aAAa,IAAI,IAAI,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC;EACtJ,IAAI,MAAM,gBAAgB,KAAK,GAAG,KAAK,cAAc,MAAM;EAC3D,WAAW,IAAI;CAChB;CACA,IAAI,KAAK;EACR,OAAO;CACR;CACA,UAAU,OAAO;EAChB,OAAO,KAAK,OAAO,MAAM;CAC1B;CACA,WAAW;EACV,OAAO,OAAO,OAAO,KAAK,MAAM;CACjC;AACD"}

package/dist/types-IqZMLrFC-DtdJNICr.d.mts

@@ -0,0 +1,426 @@
+import { a as StorageTable, r as StorageColumn } from "./storage-table-BBaAmanc-BwR37LMA.mjs";
+import { c as SqlStorage, d as StorageTypeInstance } from "./sql-storage-B0QwiTg6-B8DVctJm.mjs";
+import { C as SqlControlDriverInstance } from "./types-CuDrWc5v-ISVXBmBs.mjs";
+import "./types-BchwQpmO.mjs";
+import { r as SqlOperationDescriptors } from "./index-BgaTJRxj.mjs";
+import { v as SqlSchemaIRNode } from "./types-CvbBw1Jo-3KQdErJY.mjs";
+import "./types-TvBZ2Ne9.mjs";
+import { i as SqlControlAdapter } from "./control-adapter-C99J7aEF-C-17lFY8.mjs";
+import { Contract } from "@prisma/orm-framework/contract/types";
+import { Result } from "@prisma/orm-framework/utils/result";
+import { TargetBoundComponentDescriptor } from "@prisma/orm-framework/components/components";
+import { ContractSpace, ControlAdapterDescriptor, ControlExtensionDescriptor, MigrationOperationPolicy, MigrationPlan, MigrationPlanOperation, MigrationPlannerConflict, MigrationPlannerFailureResult, MigrationPlannerSuccessResult, MigrationRunnerExecutionChecks, MigrationRunnerFailure, MigrationRunnerPerSpaceSuccessValue, MigrationRunnerResult, OpFactoryCall, OperationContext, SchemaDiffIssue, SchemaOwnership } from "@prisma/orm-framework/components/control";
+import { AggregateMigrationEdgeRef } from "@prisma/orm-toolchain/migration-tools/aggregate";
+//#region ../../../2-sql/9-family/dist/types-IqZMLrFC.d.mts
+//#region src/core/migrations/types.d.ts
+type AnyRecord = Readonly<Record<string, unknown>>;
+interface StorageTypePlanResult<TTargetDetails> {
+  readonly operations: readonly SqlMigrationPlanOperation<TTargetDetails>[];
+}
+/**
+ * Input for expanding parameterized native types.
+ */
+interface ExpandNativeTypeInput {
+  readonly nativeType: string;
+  readonly codecId?: string;
+  readonly typeParams?: Record<string, unknown>;
+}
+/**
+ * Input for resolving an identity-value SQL literal used to backfill existing rows when
+ * adding a NOT NULL column without an explicit default.
+ *
+ * "Identity value" in the algebraic (monoid) sense: the neutral element for the type
+ * (0 for numbers, '' for strings, false for booleans, etc.).
+ */
+interface ResolveIdentityValueInput {
+  readonly nativeType: string;
+  readonly codecId?: string;
+  readonly typeParams?: Record<string, unknown>;
+}
+/**
+ * Per-field lifecycle event a codec hook can react to.
+ *
+ * Fired during app-space migration emission as the SQL family diffs the
+ * prior contract against the new contract. See
+ * `docs/architecture docs/adrs/ADR 213 - Codec lifecycle hooks.md`
+ * for the wiring contract.
+ *
+ * - `'added'`     — the field is present in the new contract but not the prior.
+ * - `'dropped'`   — the field is present in the prior contract but not the new.
+ * - `'altered'`   — the field is present in both and any property other than
+ *                   `codecId` differs. Codec-id changes are a v1 non-goal:
+ *                   when only `codecId` differs, no `'altered'` event fires.
+ */
+type FieldEvent = 'added' | 'dropped' | 'altered';
+/**
+ * Context passed to {@link CodecControlHooks.onFieldEvent}.
+ *
+ * `namespaceId`, `tableName`, and `fieldName` are always populated; `priorTable` /
+ * `priorField` carry the prior contract's view of the table and column
+ * (present for `'dropped'` and `'altered'`); `newTable` / `newField`
+ * carry the new contract's view (present for `'added'` and `'altered'`).
+ *
+ * The hook only ever receives app-space contract IR — extension-space
+ * fields are scoped out by the API: the hook is wired at the
+ * application emitter only.
+ */
+interface FieldEventContext {
+  readonly namespaceId: string;
+  readonly tableName: string;
+  readonly fieldName: string;
+  readonly priorTable?: StorageTable;
+  readonly newTable?: StorageTable;
+  readonly priorField?: StorageColumn;
+  readonly newField?: StorageColumn;
+}
+interface CodecControlHooks<TTargetDetails = unknown> {
+  /**
+   * `schema` is typed as the family-level `SqlSchemaIRNode` (not the concrete
+   * `SqlSchemaIR` class) because the actual value handed in is whatever
+   * per-namespace node the calling target's tree shape produces — a flat
+   * `SqlSchemaIR` for SQLite, a `PostgresNamespaceSchemaNode` for Postgres —
+   * read structurally for its `tables`/`nativeEnums` fields. Hooks that need
+   * the concrete Postgres shape narrow via `PostgresNamespaceSchemaNode.is(schema)`.
+   */
+  planTypeOperations?: (options: {
+    readonly typeName: string;
+    readonly typeInstance: StorageTypeInstance;
+    readonly contract: Contract<SqlStorage>;
+    readonly schema: SqlSchemaIRNode;
+    readonly schemaName?: string;
+    readonly policy: MigrationOperationPolicy;
+  }) => StorageTypePlanResult<TTargetDetails>;
+  verifyType?: (options: {
+    readonly typeName: string;
+    readonly typeInstance: StorageTypeInstance;
+    readonly schema: SqlSchemaIRNode;
+    readonly schemaName?: string;
+  }) => readonly SchemaDiffIssue[];
+  introspectTypes?: (options: {
+    readonly driver: SqlControlDriverInstance<string>;
+    readonly schemaName?: string;
+  }) => Promise<Record<string, StorageTypeInstance>>;
+  /**
+   * Expands a parameterized native type to its full SQL representation.
+   * Used by schema verification to compare contract types against database types.
+   *
+   * For example, expands:
+   * - { nativeType: 'character varying', typeParams: { length: 255 } } -> 'character varying(255)'
+   * - { nativeType: 'numeric', typeParams: { precision: 10, scale: 2 } } -> 'numeric(10,2)'
+   *
+   * Returns the expanded type string, or the original nativeType if no expansion is needed.
+   */
+  expandNativeType?: (input: ExpandNativeTypeInput) => string;
+  /**
+   * Resolves the identity value (monoid neutral element) as a SQL literal for safely adding
+   * a NOT NULL column without an explicit default to a non-empty table.
+   *
+   * Return semantics:
+   * - string: use this literal
+   * - null: explicitly no safe identity value is known; fall back to another strategy
+   * - undefined: no opinion; planner may use built-in fallbacks
+   */
+  resolveIdentityValue?: (input: ResolveIdentityValueInput) => string | null | undefined;
+  /**
+   * Reacts to per-field added / dropped / altered events as the app-space
+   * emitter diffs the prior contract against the new contract. Returned
+   * ops are inlined into the app-space migration's `ops.json` alongside
+   * the user's structural ops.
+   *
+   * Synchronous. Each returned op must carry its own `invariantId`. Hooks
+   * are dispatched per `(table, field)` based on the field's `codecId`
+   * (the new field's codec for `'added'` / `'altered'`; the prior field's
+   * codec for `'dropped'`).
+   *
+   * See `docs/architecture docs/adrs/ADR 213 - Codec lifecycle hooks.md`
+   * for the wiring contract and the deterministic ordering rule.
+   */
+  onFieldEvent?: (event: FieldEvent, ctx: FieldEventContext) => readonly OpFactoryCall[];
+}
+interface SqlControlExtensionDescriptor<TTargetId extends string> extends ControlExtensionDescriptor<'sql', TTargetId> {
+  readonly queryOperations?: () => SqlOperationDescriptors;
+  /**
+   * Schema-contributing extensions opt into the per-space planner / runner /
+   * verifier by setting this field. Extensions without it are codec-only or
+   * query-ops-only — today's behaviour preserved.
+   *
+   * The shape comes from `@internal/framework-components/control`
+   * (`ContractSpace`) — contract-space identity is a framework concept,
+   * not a SQL-specific one. The SQL family specialises the generic to
+   * `Contract<SqlStorage>` so descriptor authors continue to see a
+   * typed contract value.
+   */
+  readonly contractSpace?: ContractSpace<Contract<SqlStorage>>;
+}
+interface SqlControlAdapterDescriptor<TTargetId extends string> extends ControlAdapterDescriptor<'sql', TTargetId, SqlControlAdapter<TTargetId>> {
+  readonly queryOperations?: () => SqlOperationDescriptors;
+}
+interface SqlMigrationPlanOperationStep {
+  readonly description: string;
+  readonly sql: string;
+  /**
+   * Optional parameter values bound at execution time. The runner forwards
+   * these to `driver.query(sql, params ?? [])`, so step authors can use
+   * placeholder syntax (`$1`, `$2`, …) instead of inlining literals into
+   * the SQL string. Reuses the driver's parameter binder rather than
+   * rolling per-target literal serialization for every type the planner
+   * may emit.
+   */
+  readonly params?: readonly unknown[];
+  readonly meta?: AnyRecord;
+}
+/**
+ * Minimal shape every SQL-family target must conform to for its per-operation
+ * `target.details` payload. Each SQL operation addresses a named database
+ * object in some schema; targets (Postgres, MySQL, SQLite, …) extend this
+ * shape with their own fields (e.g. Postgres adds `objectType` and optional
+ * `table`).
+ */
+interface SqlPlanTargetDetails {
+  readonly schema: string;
+  readonly name: string;
+}
+interface SqlMigrationPlanOperationTarget<TTargetDetails> {
+  readonly id: string;
+  readonly details?: TTargetDetails;
+}
+interface SqlMigrationPlanOperation<TTargetDetails> extends MigrationPlanOperation {
+  readonly summary?: string;
+  readonly target: SqlMigrationPlanOperationTarget<TTargetDetails>;
+  readonly precheck: readonly SqlMigrationPlanOperationStep[];
+  readonly execute: readonly SqlMigrationPlanOperationStep[];
+  readonly postcheck: readonly SqlMigrationPlanOperationStep[];
+  readonly meta?: AnyRecord;
+}
+interface SqlMigrationPlanContractInfo {
+  readonly storageHash: string;
+  readonly profileHash?: string;
+}
+interface SqlMigrationPlan<TTargetDetails> extends MigrationPlan {
+  /**
+   * Contract space this plan applies to. The runner uses this to key the
+   * `prisma_contract.marker` row it writes/reads (`space = <spaceId>`),
+   * so per-extension plans hit per-extension marker rows instead of all
+   * collapsing onto the app's row.
+   *
+   * App-plan callers pass `APP_SPACE_ID` (`'app'`); per-extension plans
+   * pass the extension's space id. Required at every call site so the
+   * type system surfaces every place that needs to thread the value
+   * (rather than letting an `?? APP_SPACE_ID` fall-through silently
+   * collapse per-space markers onto the `'app'` row).
+   *
+   * @see specs/framework-mechanism.spec.md § 2.
+   */
+  readonly spaceId: string;
+  /**
+   * Origin contract identity that the plan expects the database to currently be at.
+   * If omitted or null, the runner skips origin validation entirely.
+   */
+  readonly origin?: SqlMigrationPlanContractInfo | null;
+  /**
+   * Destination contract identity that the plan intends to reach.
+   */
+  readonly destination: SqlMigrationPlanContractInfo;
+  readonly operations: readonly (SqlMigrationPlanOperation<TTargetDetails> | Promise<SqlMigrationPlanOperation<TTargetDetails>>)[];
+  /**
+   * Sorted, deduplicated invariant ids declared by this plan's data-transform
+   * ops. Required at the SQL-family layer (the SQL runners consume this as
+   * the source of truth for marker writes and self-edge no-op checks); the
+   * framework-level {@link MigrationPlan.providedInvariants} stays optional
+   * because `db init` / `db update` plans don't have a corresponding
+   * migration manifest.
+   */
+  readonly providedInvariants: readonly string[];
+  readonly meta?: AnyRecord;
+}
+type SqlPlannerConflictKind = 'typeMismatch' | 'nullabilityConflict' | 'indexIncompatible' | 'rlsPolicyIncompatible' | 'foreignKeyConflict' | 'missingButNonAdditive' | 'unsupportedOperation' | 'controlPolicySuppressedCall';
+interface SqlPlannerConflictLocation {
+  readonly namespaceId?: string;
+  readonly entityKind?: string;
+  readonly entityName?: string;
+  readonly column?: string;
+  readonly index?: string;
+  readonly constraint?: string;
+  readonly rlsPolicy?: string;
+}
+interface SqlPlannerConflict extends MigrationPlannerConflict {
+  readonly kind: SqlPlannerConflictKind;
+  readonly location?: SqlPlannerConflictLocation;
+  readonly meta?: AnyRecord;
+}
+interface SqlPlannerSuccessResult<TTargetDetails> extends Omit<MigrationPlannerSuccessResult, 'plan'> {
+  readonly kind: 'success';
+  readonly plan: SqlMigrationPlan<TTargetDetails>;
+}
+interface SqlPlannerFailureResult extends Omit<MigrationPlannerFailureResult, 'conflicts'> {
+  readonly kind: 'failure';
+  readonly conflicts: readonly SqlPlannerConflict[];
+}
+type SqlPlannerResult<TTargetDetails> = SqlPlannerSuccessResult<TTargetDetails> | SqlPlannerFailureResult;
+interface SqlMigrationPlannerPlanOptions {
+  readonly contract: Contract<SqlStorage>;
+  /**
+   * The "from"/live schema as the target's introspected node (SQLite a flat
+   * `SqlSchemaIR`, Postgres a `PostgresDatabaseSchemaNode` root). Structure-aware
+   * consumers narrow the concrete shape before walking it.
+   */
+  readonly schema: SqlSchemaIRNode;
+  readonly policy: MigrationOperationPolicy;
+  readonly schemaName?: string;
+  /**
+   * Contract space the plan applies to. The planner stamps this onto
+   * the produced {@link SqlMigrationPlan.spaceId} so the runner keys
+   * the marker row by the right space. App-plan callers pass
+   * `APP_SPACE_ID`; per-extension callers pass the extension's space
+   * id.
+   */
+  readonly spaceId: string;
+  /**
+   * The "from" contract (state the planner assumes the database starts at),
+   * or `null` for reconciliation flows that have no prior contract.
+   *
+   * Required at every call site so the structural fact "I have a prior
+   * contract / I don't" is visible in the type. `migration plan` reads the
+   * predecessor's contract from the snapshot store by its storage hash and
+   * passes the parsed value; `db update` / `db init` reconcile against the
+   * live schema and pass `null`. Strategies that
+   * need from/to column-shape comparisons (unsafe type change, nullability
+   * tightening) use this to decide whether to emit `dataTransform`
+   * placeholders; they short-circuit when it is `null`.
+   *
+   * Planners also derive the "from" identity they stamp onto the produced
+   * plan's `describe()` as `fromContract?.storage.storageHash ?? null`.
+   */
+  readonly fromContract: Contract<SqlStorage> | null;
+  /**
+   * POSIX-relative path from the migration package dir to
+   * `migrations/snapshots`, e.g. `'../../snapshots'`. Threaded straight
+   * into the produced plan's `renderTypeScript()` metadata so the
+   * scaffold's contract-snapshot imports point at the deduplicated store.
+   */
+  readonly snapshotsImportPath: string;
+  /**
+   * Active framework components participating in this composition.
+   * Each component is target-bound so SQL targets can dispatch
+   * component-owned planning behaviour from the same descriptor list.
+   * All components must have matching familyId ('sql') and targetId.
+   */
+  readonly frameworkComponents: ReadonlyArray<TargetBoundComponentDescriptor<'sql', string>>;
+  /**
+   * Ownership oracle over the whole contract-space composition (the passive
+   * aggregate). The planner asks it, per live extra node, whether any space
+   * declares that entity: a sibling-owned node is left untouched, an unowned
+   * node is a genuine extra it may drop under a destructive policy. The
+   * planner holds no list of other spaces' names — ownership lives in the
+   * aggregate; it only asks. Absent for a single-space plan handed no
+   * aggregate. See {@link SchemaOwnership}.
+   */
+  readonly ownership?: SchemaOwnership;
+}
+interface SqlMigrationPlanner<TTargetDetails> {
+  plan(options: SqlMigrationPlannerPlanOptions): SqlPlannerResult<TTargetDetails>;
+}
+interface SqlMigrationRunnerExecuteCallbacks<TTargetDetails> {
+  onOperationStart?(operation: SqlMigrationPlanOperation<TTargetDetails>): void;
+  onOperationComplete?(operation: SqlMigrationPlanOperation<TTargetDetails>): void;
+}
+interface SqlMigrationRunnerExecuteOptions<TTargetDetails> {
+  readonly plan: SqlMigrationPlan<TTargetDetails>;
+  readonly driver: SqlControlDriverInstance<string>;
+  /**
+   * Logical contract space this plan applies to. When omitted the
+   * runner derives the space from {@link SqlMigrationPlan.spaceId};
+   * when supplied, the runner asserts it matches `plan.spaceId` so a
+   * caller cannot accidentally write the marker row for a different
+   * space than the plan was produced for.
+   */
+  readonly space?: string;
+  /**
+   * Destination contract IR.
+   * Must correspond to `plan.destination` and is used for schema verification and marker/ledger writes.
+   */
+  readonly destinationContract: Contract<SqlStorage>;
+  /**
+   * Execution-time policy that defines which operation classes are allowed.
+   * The runner validates each operation against this policy before execution.
+   */
+  readonly policy: MigrationOperationPolicy;
+  readonly schemaName?: string;
+  readonly strictVerification?: boolean;
+  readonly callbacks?: SqlMigrationRunnerExecuteCallbacks<TTargetDetails>;
+  readonly context?: OperationContext;
+  /**
+   * Execution-time checks configuration.
+   * All checks default to `true` (enabled) when omitted.
+   */
+  readonly executionChecks?: MigrationRunnerExecutionChecks;
+  /**
+   * Active framework components participating in this composition.
+   * Each component is target-bound so SQL targets can dispatch
+   * component-owned execution behaviour from the same descriptor list.
+   * All components must have matching familyId ('sql') and targetId.
+   */
+  readonly frameworkComponents: ReadonlyArray<TargetBoundComponentDescriptor<'sql', string>>;
+  /**
+   * Per-edge breakdown from graph-walk planning. When present, the runner
+   * writes one ledger row per edge instead of one collapsed row per apply.
+   */
+  readonly migrationEdges: readonly AggregateMigrationEdgeRef[];
+}
+type SqlMigrationRunnerErrorCode = 'MIGRATION.DESTINATION_CONTRACT_MISMATCH' | 'MIGRATION.LEGACY_MARKER_SHAPE' | 'MIGRATION.MARKER_ORIGIN_MISMATCH' | 'MIGRATION.MARKER_CAS_FAILURE' | 'MIGRATION.POLICY_VIOLATION' | 'MIGRATION.PRECHECK_FAILED' | 'MIGRATION.POSTCHECK_FAILED' | 'MIGRATION.SCHEMA_VERIFY_FAILED' | 'MIGRATION.FOREIGN_KEY_VIOLATION' | 'MIGRATION.EXECUTION_FAILED';
+interface SqlMigrationRunnerFailure extends MigrationRunnerFailure {
+  readonly code: SqlMigrationRunnerErrorCode;
+  readonly meta?: AnyRecord;
+}
+interface SqlMigrationRunnerSuccessValue extends MigrationRunnerPerSpaceSuccessValue {}
+type SqlMigrationRunnerResult = Result<SqlMigrationRunnerSuccessValue, SqlMigrationRunnerFailure>;
+interface SqlMigrationRunner<TTargetDetails> {
+  /**
+   * Apply one or more per-space migration plans, opening and managing the
+   * outer transaction (and any target-specific connection-level setup, e.g.
+   * SQLite's `PRAGMA foreign_keys` toggle). An apply that targets one space
+   * passes a one-element `perSpaceOptions` list.
+   *
+   * The caller orders the input list (typically via the aggregate planner's
+   * `applyOrder`: extensions alphabetical, then app). A failure on any space
+   * rolls back every space's writes.
+   *
+   * Each entry must reference the same `driver` as the top-level `driver`
+   * (the connection the outer transaction is open on).
+   */
+  execute(options: {
+    readonly driver: SqlControlDriverInstance<string>;
+    readonly perSpaceOptions: ReadonlyArray<SqlMigrationRunnerExecuteOptions<TTargetDetails>>;
+  }): Promise<MigrationRunnerResult>;
+  /**
+   * Apply a single migration plan against an already-open connection
+   * **without** opening a transaction. The caller is responsible for
+   * wrapping the call (and any siblings) in `BEGIN` / `COMMIT` /
+   * `ROLLBACK`. Used by {@link SqlMigrationRunner.execute} to fan out
+   * across contract spaces inside one outer transaction.
+   *
+   * Idempotent control-table setup (`prisma_contract.*`) and marker
+   * writes use `options.space` to address the per-space marker row.
+   */
+  executeOnConnection(options: SqlMigrationRunnerExecuteOptions<TTargetDetails>): Promise<SqlMigrationRunnerResult>;
+}
+interface CreateSqlMigrationPlanOptions<TTargetDetails> {
+  readonly targetId: string;
+  /**
+   * Contract space this plan applies to. Mirrors {@link SqlMigrationPlan.spaceId}.
+   */
+  readonly spaceId: string;
+  readonly origin?: SqlMigrationPlanContractInfo | null;
+  readonly destination: SqlMigrationPlanContractInfo;
+  readonly operations: readonly SqlMigrationPlanOperation<TTargetDetails>[];
+  /**
+   * Sorted, deduplicated invariant ids for this plan; mirrors the required
+   * field on {@link SqlMigrationPlan}. Callers without a migration manifest
+   * (`db init`, `db update`, planner-built plans) pass `[]`.
+   */
+  readonly providedInvariants: readonly string[];
+  readonly meta?: AnyRecord;
+}
+//#endregion
+export { 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-IqZMLrFC-DtdJNICr.d.mts.map

package/dist/types-IqZMLrFC-DtdJNICr.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types-IqZMLrFC-DtdJNICr.d.mts","names":[],"sources":["../../../../2-sql/9-family/dist/types-IqZMLrFC.d.mts"],"mappings":";;;;;;;;;;;;;;;KAUK,YAAY,SAAS;UAChB,sBAAsB;WACrB,qBAAqB,0BAA0B;;;;;UAKhD;WACC;WACA;WACA,aAAa;;;;;;;;;UASd;WACC;WACA;WACA,aAAa;;;;;;;;;;;;;;;;KAgBnB;;;;;;;;;;;;;UAaK;WACC;WACA;WACA;WACA,aAAa;WACb,WAAW;WACX,aAAa;WACb,WAAW;;UAEZ,kBAAkB;;;;;;;;;EAS1B,sBAAsB;aACX;aACA,cAAc;aACd,UAAU,SAAS;aACnB,QAAQ;aACR;aACA,QAAQ;QACb,sBAAsB;EAC5B,cAAc;aACH;aACA,cAAc;aACd,QAAQ;aACR;iBACI;EACf,mBAAmB;aACR,QAAQ;aACR;QACL,QAAQ,eAAe;;;;;;;;;;;EAW7B,oBAAoB,OAAO;;;;;;;;;;EAU3B,wBAAwB,OAAO;;;;;;;;;;;;;;;EAe/B,gBAAgB,OAAO,YAAY,KAAK,+BAA+B;;UAE/D,8BAA8B,kCAAkC,kCAAkC;WACjG,wBAAwB;;;;;;;;;;;;WAYxB,gBAAgB,cAAc,SAAS;;UAExC,4BAA4B,kCAAkC,gCAAgC,WAAW,kBAAkB;WAC1H,wBAAwB;;UAEzB;WACC;WACA;;;;;;;;;WASA;WACA,OAAO;;;;;;;;;UASR;WACC;WACA;;UAED,gCAAgC;WAC/B;WACA,UAAU;;UAEX,0BAA0B,wBAAwB;WACjD;WACA,QAAQ,gCAAgC;WACxC,mBAAmB;WACnB,kBAAkB;WAClB,oBAAoB;WACpB,OAAO;;UAER;WACC;WACA;;UAED,iBAAiB,wBAAwB;;;;;;;;;;;;;;;WAexC;;;;;WAKA,SAAS;;;;WAIT,aAAa;WACb,sBAAsB,0BAA0B,kBAAkB,QAAQ,0BAA0B;;;;;;;;;WASpG;WACA,OAAO;;KAEb;UACK;WACC;WACA;WACA;WACA;WACA;WACA;WACA;;UAED,2BAA2B;WAC1B,MAAM;WACN,WAAW;WACX,OAAO;;UAER,wBAAwB,wBAAwB,KAAK;WACpD;WACA,MAAM,iBAAiB;;UAExB,gCAAgC,KAAK;WACpC;WACA,oBAAoB;;KAE1B,iBAAiB,kBAAkB,wBAAwB,kBAAkB;UACxE;WACC,UAAU,SAAS;;;;;;WAMnB,QAAQ;WACR,QAAQ;WACR;;;;;;;;WAQA;;;;;;;;;;;;;;;;;WAiBA,cAAc,SAAS;;;;;;;WAOvB;;;;;;;WAOA,qBAAqB,cAAc;;;;;;;;;;WAUnC,YAAY;;UAEb,oBAAoB;EAC5B,KAAK,SAAS,iCAAiC,iBAAiB;;UAExD,mCAAmC;EAC3C,kBAAkB,WAAW,0BAA0B;EACvD,qBAAqB,WAAW,0BAA0B;;UAElD,iCAAiC;WAChC,MAAM,iBAAiB;WACvB,QAAQ;;;;;;;;WAQR;;;;;WAKA,qBAAqB,SAAS;;;;;WAK9B,QAAQ;WACR;WACA;WACA,YAAY,mCAAmC;WAC/C,UAAU;;;;;WAKV,kBAAkB;;;;;;;WAOlB,qBAAqB,cAAc;;;;;WAKnC,yBAAyB;;KAE/B;UACK,kCAAkC;WACjC,MAAM;WACN,OAAO;;UAER,uCAAuC;KAC5C,2BAA2B,OAAO,gCAAgC;UAC7D,mBAAmB;;;;;;;;;;;;;;EAc3B,QAAQ;aACG,QAAQ;aACR,iBAAiB,cAAc,iCAAiC;MACvE,QAAQ;;;;;;;;;;;EAWZ,oBAAoB,SAAS,iCAAiC,kBAAkB,QAAQ;;UAEhF,8BAA8B;WAC7B;;;;WAIA;WACA,SAAS;WACT,aAAa;WACb,qBAAqB,0BAA0B;;;;;;WAM/C;WACA,OAAO"}

package/dist/types-TvBZ2Ne9.d.mts

@@ -0,0 +1 @@
+import "./types-CvbBw1Jo-3KQdErJY.mjs";

package/dist/unique-constraint-jQWfH7dg-zLWtFp99.d.mts

@@ -0,0 +1,32 @@
+import { t as SqlNode } from "./sql-node-kEz6YFZo-v2F7delx.mjs";
+//#region ../../../2-sql/1-core/contract/dist/unique-constraint-jQWfH7dg.d.mts
+//#region src/ir/primary-key.d.ts
+interface PrimaryKeyInput {
+  readonly columns: readonly string[];
+  readonly name?: string;
+}
+/**
+ * SQL Contract IR node for a table's primary-key constraint.
+ */
+declare class PrimaryKey extends SqlNode {
+  readonly columns: readonly string[];
+  readonly name?: string;
+  constructor(input: PrimaryKeyInput);
+}
+//#endregion
+//#region src/ir/unique-constraint.d.ts
+interface UniqueConstraintInput {
+  readonly columns: readonly string[];
+  readonly name?: string;
+}
+/**
+ * SQL Contract IR node for a table-level unique constraint.
+ */
+declare class UniqueConstraint extends SqlNode {
+  readonly columns: readonly string[];
+  readonly name?: string;
+  constructor(input: UniqueConstraintInput);
+}
+//#endregion
+export { UniqueConstraintInput as i, PrimaryKeyInput as n, UniqueConstraint as r, PrimaryKey as t };
+//# sourceMappingURL=unique-constraint-jQWfH7dg-zLWtFp99.d.mts.map

package/dist/unique-constraint-jQWfH7dg-zLWtFp99.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"unique-constraint-jQWfH7dg-zLWtFp99.d.mts","names":[],"sources":["../../../../2-sql/1-core/contract/dist/unique-constraint-jQWfH7dg.d.mts"],"mappings":";;;UAEU;WACC;WACA;;;;;cAKG,mBAAmB;WACtB;WACA;EACT,YAAY,OAAO;;;;UAIX;WACC;WACA;;;;;cAKG,yBAAyB;WAC5B;WACA;EACT,YAAY,OAAO"}

package/dist/util-DQQgv2j1-D6INZaRG.mjs

@@ -0,0 +1,34 @@
+//#region ../../../2-sql/4-lanes/relational-core/dist/util-DQQgv2j1.mjs
+function compact(o) {
+	const out = {};
+	for (const [k, v] of Object.entries(o)) {
+		if (v === void 0 || v === null) continue;
+		if (Array.isArray(v) && v.length === 0) continue;
+		out[k] = v;
+	}
+	return out;
+}
+/**
+* Walks an AST's parameter references in first-encounter order and dedupes
+* by ParamRef identity. The single canonical helper used by every consumer
+* that aligns `plan.params` with metadata-by-index — the SQL builder lane,
+* the SQL ORM client, the SQL runtime encoder, and the Postgres renderer's
+* `$N` index map — so the four walks cannot drift in dedupe semantics.
+*
+* SQLite's `?`-placeholder renderer intentionally does NOT use this helper
+* because it needs one params entry per occurrence in the SQL.
+*/
+function collectOrderedParamRefs(ast) {
+	const seen = /* @__PURE__ */ new Set();
+	const ordered = [];
+	for (const ref of ast.collectParamRefs()) {
+		if (seen.has(ref)) continue;
+		seen.add(ref);
+		ordered.push(ref);
+	}
+	return Object.freeze(ordered);
+}
+//#endregion
+export { compact as n, collectOrderedParamRefs as t };
+
+//# sourceMappingURL=util-DQQgv2j1-D6INZaRG.mjs.map

package/dist/util-DQQgv2j1-D6INZaRG.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"util-DQQgv2j1-D6INZaRG.mjs","names":[],"sources":["../../../../2-sql/4-lanes/relational-core/dist/util-DQQgv2j1.mjs"],"sourcesContent":["//#region src/ast/util.ts\nfunction compact(o) {\n\tconst out = {};\n\tfor (const [k, v] of Object.entries(o)) {\n\t\tif (v === void 0 || v === null) continue;\n\t\tif (Array.isArray(v) && v.length === 0) continue;\n\t\tout[k] = v;\n\t}\n\treturn out;\n}\n/**\n* Walks an AST's parameter references in first-encounter order and dedupes\n* by ParamRef identity. The single canonical helper used by every consumer\n* that aligns `plan.params` with metadata-by-index — the SQL builder lane,\n* the SQL ORM client, the SQL runtime encoder, and the Postgres renderer's\n* `$N` index map — so the four walks cannot drift in dedupe semantics.\n*\n* SQLite's `?`-placeholder renderer intentionally does NOT use this helper\n* because it needs one params entry per occurrence in the SQL.\n*/\nfunction collectOrderedParamRefs(ast) {\n\tconst seen = /* @__PURE__ */ new Set();\n\tconst ordered = [];\n\tfor (const ref of ast.collectParamRefs()) {\n\t\tif (seen.has(ref)) continue;\n\t\tseen.add(ref);\n\t\tordered.push(ref);\n\t}\n\treturn Object.freeze(ordered);\n}\n//#endregion\nexport { compact as n, collectOrderedParamRefs as t };\n\n//# sourceMappingURL=util-DQQgv2j1.mjs.map"],"mappings":";AACA,SAAS,QAAQ,GAAG;CACnB,MAAM,MAAM,CAAC;CACb,KAAK,MAAM,CAAC,GAAG,MAAM,OAAO,QAAQ,CAAC,GAAG;EACvC,IAAI,MAAM,KAAK,KAAK,MAAM,MAAM;EAChC,IAAI,MAAM,QAAQ,CAAC,KAAK,EAAE,WAAW,GAAG;EACxC,IAAI,KAAK;CACV;CACA,OAAO;AACR;;;;;;;;;;;AAWA,SAAS,wBAAwB,KAAK;CACrC,MAAM,uBAAuB,IAAI,IAAI;CACrC,MAAM,UAAU,CAAC;CACjB,KAAK,MAAM,OAAO,IAAI,iBAAiB,GAAG;EACzC,IAAI,KAAK,IAAI,GAAG,GAAG;EACnB,KAAK,IAAI,GAAG;EACZ,QAAQ,KAAK,GAAG;CACjB;CACA,OAAO,OAAO,OAAO,OAAO;AAC7B"}