@prisma/orm-family-sql 8.0.0-rc.2-dev.3 → 8.0.0-rc.20-dev.1

package/dist/{naming-CV9j2pXl-KARaDReS.d.mts → naming-BcD36g9T-Mfe_xGGL.d.mts}

@@ -1,4 +1,4 @@
-//#region ../../../2-sql/1-core/schema-ir/dist/naming-CV9j2pXl.d.mts
+//#region ../../../2-sql-family/1-core/schema-ir/dist/naming-BcD36g9T.d.mts
 //#region src/naming.d.ts
 declare function defaultIndexName(tableName: string, columns: readonly string[]): string;
 interface WireName {
@@ -68,9 +68,7 @@ declare function formatWireName(prefix: string, hash: string): string;
  */
 declare function parseWireName(name: string): WireName | undefined;
 /**
- * Stabilizes an authored SQL body (index expression, partial-index predicate,
- * RLS policy predicate) for hashing: trim, and collapse runs of internal
- * whitespace to a single space.
+ * Stabilizes an authored SQL body (index expression, partial-index predicate, RLS policy predicate) for hashing: trim, and collapse runs of internal whitespace to a single space. A body that contains `--` is collapsed line by line and keeps its line breaks.
  *
  * This is deliberately minimal. The content hash is the equivalence relation
  * for a wire-named object, and the wire name (prefix + hash) is the only
@@ -80,7 +78,11 @@ declare function parseWireName(name: string): WireName | undefined;
  * (lowercasing, paren-stripping, cast-alias folding) risks collapsing two
  * distinct bodies onto one hash.
  *
- * The normalizer is a stability commitment: any change re-suffixes all wire names.
+ * A body that contains `--` keeps its line breaks, because a line break ends a line comment: `a --c` followed by a line break and `b` compares `b`, while `a --c b` does not. Such a body is split into lines, each line is collapsed and trimmed, blank lines are dropped, and the lines are joined with `\n`. Every body without `--` normalizes as it always has.
+ *
+ * The normalizer gives the same output on its own output, which policy hashing relies on: it normalizes twice.
+ *
+ * The normalizer is a stability commitment: a change to it re-suffixes the wire name of every body whose normalized form changes, so a change must say which bodies it affects. See ADR 234, "Normalizer stability".
  */
 declare function normalizeSqlBody(sql: string): string;
 /**
@@ -149,14 +151,7 @@ interface IndexContentHashParts {
  * status as the RLS tuple: any change re-suffixes every wire name.
  */
 /**
- * Canonicalizes one index option VALUE to the `on`/`off` boolean spelling:
- * JS booleans and the common catalog spellings (`pg_class.reloptions`
- * stores whatever spelling the DDL used, so a live index may carry
- * `'true'`/`'false'` or `'on'`/`'off'`) all map to one form; everything
- * else via `String()` (fully specified for numbers, so no platform
- * variance). Shared by the wire-name hash tuple, the node's option
- * equality, and the DDL renderer, so an authored `{ fastupdate: true }`
- * agrees with a live index created under any boolean spelling.
+ * Canonicalizes one index option VALUE to the `on`/`off` boolean spelling: JS booleans and the common catalog spellings (`pg_class.reloptions` stores whatever spelling the DDL used, so a live index may carry `'true'`/`'false'` or `'on'`/`'off'`) all map to one form; every other scalar via `String()` (fully specified for numbers, so no platform variance); an array or object as JSON, since `String()` would flatten `[['a', 'b']]` and `[['a'], ['b']]` to the same text, with object keys sorted at every depth so key order never changes the value. Shared by the wire-name hash tuple, the node's option equality, and the DDL renderer, so an authored `{ fastupdate: true }` agrees with a live index created under any boolean spelling.
  */
 declare function normalizeIndexOptionValue(value: unknown): string;
 declare function computeIndexContentHash(parts: IndexContentHashParts): string;
@@ -183,4 +178,4 @@ declare function assertWireNamePrefixLength(prefix: string, subject: string): vo
 declare function truncateToWireNamePrefixBytes(prefix: string): string;
 //#endregion
 export { normalizeSqlBody as _, WireName as a, truncateToWireNamePrefixBytes as b, computeCheckContentHash as c, derivedCheckPrefixes as d, formatWireName as f, normalizeIndexOptionValue as g, namingOfLiveName as h, WIRE_NAME_PREFIX_MAX_BYTES as i, computeIndexContentHash as l, namingOf as m, IndexContentHashParts as n, assertWireNamePrefixLength as o, nameOf as p, SqlObjectNaming as r, composeCheckWirePrefix as s, CheckKind as t, defaultIndexName as u, parseNaming as v, parseWireName as y };
-//# sourceMappingURL=naming-CV9j2pXl-KARaDReS.d.mts.map
+//# sourceMappingURL=naming-BcD36g9T-Mfe_xGGL.d.mts.map

package/dist/naming-BcD36g9T-Mfe_xGGL.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"naming-BcD36g9T-Mfe_xGGL.d.mts","names":[],"sources":["../../../../2-sql-family/1-core/schema-ir/dist/naming-BcD36g9T.d.mts"],"mappings":";;iBACiB,iBAAiB,mBAAmB;UAC3C;;WAEC;;WAEA;;;;;;;;;;;KAWN;WACM;WACA;;WAEA;IACP;;iBAEa,OAAO,QAAQ;;;;;;;;iBAQf,SAAS,cAAc,6BAA6B;;;;;;iBAMpD,YAAY,cAAc,6BAA6B;;;;;;;;;;;;;;iBAcvD,iBAAiB,eAAe;;;;;;;iBAOhC,eAAe,gBAAgB;;;;;;;;iBAQ/B,cAAc,eAAe;;;;;;;;;;;;;;;;;;iBAkB7B,iBAAiB;;;;;;;;;;;;;;;iBAejB,wBAAwB;;;;;;KAMpC;;;;;;;;iBAQY,uBAAuB,mBAAmB,oBAAoB,MAAM;;;;;;;;;;;;;iBAapE,qBAAqB,mBAAmB,aAAa,mBAAmB;UAC/E;WACC;WACA;WACA;WACA;WACA;WACA,UAAU;;;;;;;;;;;;;;;;;;;;iBAoBJ,0BAA0B;iBAC1B,wBAAwB,OAAO;;;;;;;;;cASlC;;;;;iBAKG,2BAA2B,gBAAgB;;;;;;;iBAO3C,8BAA8B"}

package/dist/{naming-DKr4TJd7-Cszhq9RV.mjs → naming-bM5qm5PY-jOg3JFMb.mjs}

@@ -1,7 +1,8 @@
 import { structuredError } from "@prisma/orm-framework/utils/structured-error";
 import { createHash } from "node:crypto";
 import { ContractValidationError } from "@prisma/orm-framework/contract/contract-validation-error";
-//#region ../../../2-sql/1-core/schema-ir/dist/naming-DKr4TJd7.mjs
+import { clipToUtf8Bytes, utf8ByteLength } from "@prisma/orm-framework/utils/text";
+//#region ../../../2-sql-family/1-core/schema-ir/dist/naming-bM5qm5PY.mjs
 function defaultIndexName(tableName, columns) {
 	return `${tableName}_${columns.join("_")}_idx`;
 }
@@ -97,9 +98,7 @@ function parseWireName(name) {
 	};
 }
 /**
-* Stabilizes an authored SQL body (index expression, partial-index predicate,
-* RLS policy predicate) for hashing: trim, and collapse runs of internal
-* whitespace to a single space.
+* Stabilizes an authored SQL body (index expression, partial-index predicate, RLS policy predicate) for hashing: trim, and collapse runs of internal whitespace to a single space. A body that contains `--` is collapsed line by line and keeps its line breaks.
 *
 * This is deliberately minimal. The content hash is the equivalence relation
 * for a wire-named object, and the wire name (prefix + hash) is the only
@@ -109,10 +108,15 @@ function parseWireName(name) {
 * (lowercasing, paren-stripping, cast-alias folding) risks collapsing two
 * distinct bodies onto one hash.
 *
-* The normalizer is a stability commitment: any change re-suffixes all wire names.
+* A body that contains `--` keeps its line breaks, because a line break ends a line comment: `a --c` followed by a line break and `b` compares `b`, while `a --c b` does not. Such a body is split into lines, each line is collapsed and trimmed, blank lines are dropped, and the lines are joined with `\n`. Every body without `--` normalizes as it always has.
+*
+* The normalizer gives the same output on its own output, which policy hashing relies on: it normalizes twice.
+*
+* The normalizer is a stability commitment: a change to it re-suffixes the wire name of every body whose normalized form changes, so a change must say which bodies it affects. See ADR 234, "Normalizer stability".
 */
 function normalizeSqlBody(sql) {
-	return sql.replace(/\s+/g, " ").trim();
+	if (!sql.includes("--")) return sql.replace(/\s+/g, " ").trim();
+	return sql.split(/\r\n|\r|\n/).map((line) => line.replace(/\s+/g, " ").trim()).filter((line) => line !== "").join("\n");
 }
 /**
 * Returns the first 8 lowercase hex characters of the SHA-256 digest over the
@@ -185,20 +189,19 @@ function derivedCheckPrefixes(tableName, columnNames) {
 * status as the RLS tuple: any change re-suffixes every wire name.
 */
 /**
-* Canonicalizes one index option VALUE to the `on`/`off` boolean spelling:
-* JS booleans and the common catalog spellings (`pg_class.reloptions`
-* stores whatever spelling the DDL used, so a live index may carry
-* `'true'`/`'false'` or `'on'`/`'off'`) all map to one form; everything
-* else via `String()` (fully specified for numbers, so no platform
-* variance). Shared by the wire-name hash tuple, the node's option
-* equality, and the DDL renderer, so an authored `{ fastupdate: true }`
-* agrees with a live index created under any boolean spelling.
+* Canonicalizes one index option VALUE to the `on`/`off` boolean spelling: JS booleans and the common catalog spellings (`pg_class.reloptions` stores whatever spelling the DDL used, so a live index may carry `'true'`/`'false'` or `'on'`/`'off'`) all map to one form; every other scalar via `String()` (fully specified for numbers, so no platform variance); an array or object as JSON, since `String()` would flatten `[['a', 'b']]` and `[['a'], ['b']]` to the same text, with object keys sorted at every depth so key order never changes the value. Shared by the wire-name hash tuple, the node's option equality, and the DDL renderer, so an authored `{ fastupdate: true }` agrees with a live index created under any boolean spelling.
 */
 function normalizeIndexOptionValue(value) {
 	if (value === true || value === "true" || value === "on") return "on";
 	if (value === false || value === "false" || value === "off") return "off";
+	if (typeof value === "object" && value !== null) return JSON.stringify(withSortedKeys(value));
 	return String(value);
 }
+function withSortedKeys(value) {
+	if (Array.isArray(value)) return value.map(withSortedKeys);
+	if (typeof value !== "object" || value === null) return value;
+	return Object.fromEntries(Object.entries(value).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([key, entry]) => [key, withSortedKeys(entry)]));
+}
 function computeIndexContentHash(parts) {
 	const sortedOptions = Object.entries(parts.options ?? {}).map(([key, value]) => [key, normalizeIndexOptionValue(value)]).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0);
 	const tuple = JSON.stringify([
@@ -220,17 +223,12 @@ function computeIndexContentHash(parts) {
 * live one.
 */
 const WIRE_NAME_PREFIX_MAX_BYTES = 54;
-const utf8 = new TextEncoder();
-/** UTF-8 byte length — the unit Postgres measures identifiers in. */
-function byteLength(value) {
-	return utf8.encode(value).length;
-}
 /**
 * Rejects a wire-name prefix over {@link WIRE_NAME_PREFIX_MAX_BYTES}.
 * `subject` opens the error message (e.g. `defineContract: policy prefix`).
 */
 function assertWireNamePrefixLength(prefix, subject) {
-	if (byteLength(prefix) > 54) throw structuredError("CONTRACT.WIRE_NAME_PREFIX_TOO_LONG", `${subject} "${prefix}" exceeds the 54-byte maximum (Postgres identifiers cap at 63 bytes and the wire name appends a 9-byte hash suffix).`, { meta: {
+	if (utf8ByteLength(prefix) > 54) throw structuredError("CONTRACT.WIRE_NAME_PREFIX_TOO_LONG", `${subject} "${prefix}" exceeds the 54-byte maximum (Postgres identifiers cap at 63 bytes and the wire name appends a 9-byte hash suffix).`, { meta: {
 		prefix,
 		maxBytes: 54
 	} });
@@ -242,18 +240,9 @@ function assertWireNamePrefixLength(prefix, subject) {
 * ({@link assertWireNamePrefixLength}), because its author can shorten it.
 */
 function truncateToWireNamePrefixBytes(prefix) {
-	if (byteLength(prefix) <= 54) return prefix;
-	let out = "";
-	let bytes = 0;
-	for (const character of prefix) {
-		const size = byteLength(character);
-		if (bytes + size > 54) break;
-		out += character;
-		bytes += size;
-	}
-	return out;
+	return clipToUtf8Bytes(prefix, 54);
 }
 //#endregion
 export { computeIndexContentHash as a, formatWireName as c, namingOfLiveName as d, normalizeIndexOptionValue as f, truncateToWireNamePrefixBytes as g, parseWireName as h, computeCheckContentHash as i, nameOf as l, parseNaming as m, assertWireNamePrefixLength as n, defaultIndexName as o, normalizeSqlBody as p, composeCheckWirePrefix as r, derivedCheckPrefixes as s, WIRE_NAME_PREFIX_MAX_BYTES as t, namingOf as u };
 
-//# sourceMappingURL=naming-DKr4TJd7-Cszhq9RV.mjs.map
+//# sourceMappingURL=naming-bM5qm5PY-jOg3JFMb.mjs.map

package/dist/naming-bM5qm5PY-jOg3JFMb.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"naming-bM5qm5PY-jOg3JFMb.mjs","names":[],"sources":["../../../../2-sql-family/1-core/schema-ir/dist/naming-bM5qm5PY.mjs"],"sourcesContent":["import { createHash } from \"node:crypto\";\nimport { ContractValidationError } from \"@internal/contract/contract-validation-error\";\nimport { structuredError } from \"@internal/utils/structured-error\";\nimport { clipToUtf8Bytes, utf8ByteLength } from \"@internal/utils/text\";\n//#region src/naming.ts\nfunction defaultIndexName(tableName, columns) {\n\treturn `${tableName}_${columns.join(\"_\")}_idx`;\n}\n/** The flat name the union describes. Inverse of {@link namingOf}. */\nfunction nameOf(naming) {\n\treturn naming.kind === \"wire\" ? formatWireName(naming.prefix, naming.hash) : naming.name;\n}\n/**\n* The naming a name-identified node was built with, read back off the flat\n* pair it stores. Inverse of {@link nameOf}, and total for that\n* reason: the constructor derived `name` from the union, so the two agree.\n* Flat data arriving from outside the process goes through\n* {@link parseNaming} instead.\n*/\nfunction namingOf(name, prefix) {\n\tif (prefix === void 0) return {\n\t\tkind: \"exact\",\n\t\tname\n\t};\n\treturn {\n\t\tkind: \"wire\",\n\t\tprefix,\n\t\thash: name.slice(prefix.length + 1)\n\t};\n}\n/**\n* Reads naming out of flat stored data — deserialized contract JSON and the\n* literals a user may hand-edit, the one place a name and a prefix can still\n* disagree. Throws when a declared prefix does not parse back out of the name.\n*/\nfunction parseNaming(name, prefix) {\n\tif (prefix === void 0) return {\n\t\tkind: \"exact\",\n\t\tname\n\t};\n\tconst parsed = parseWireName(name);\n\tif (parsed === void 0 || parsed.prefix !== prefix) throw new ContractValidationError(`\"${name}\": prefix \"${prefix}\" does not match the wire name (expected \"${formatWireName(prefix, \"<8hex>\")}\").`, \"storage\");\n\treturn {\n\t\tkind: \"wire\",\n\t\tprefix: parsed.prefix,\n\t\thash: parsed.hash\n\t};\n}\n/**\n* The naming an object read out of a live catalog has: a wire-shaped name\n* gets the wire arm so the rename pass can pair it by prefix, and every\n* other name is exact.\n*\n* The wire answer is a claim about the name's SHAPE only — the hash is\n* deliberately not recomputed from the object's content here. Nothing\n* downstream reads it as more than that: the differ always asks the\n* contract-derived side to choose the comparison, so a shape-only wire\n* claim on the introspected side never suppresses a body comparison, and\n* `contract infer` recomputes the hash independently before it will emit an\n* index as wire-named.\n*/\nfunction namingOfLiveName(name) {\n\tconst wire = parseWireName(name);\n\treturn wire === void 0 ? {\n\t\tkind: \"exact\",\n\t\tname\n\t} : {\n\t\tkind: \"wire\",\n\t\tprefix: wire.prefix,\n\t\thash: wire.hash\n\t};\n}\nconst WIRE_NAME_PATTERN = /^(.+)_([0-9a-f]{8})$/;\n/**\n* Assembles a wire name from its user-supplied prefix and its 8-hex\n* content-hash suffix. This module owns the `<prefix>_<hash>` format on both\n* sides — construction here and parsing in {@link parseWireName} — so the two\n* never drift.\n*/\nfunction formatWireName(prefix, hash) {\n\treturn `${prefix}_${hash}`;\n}\n/**\n* Splits a wire name (`<prefix>_<8hex>`) into its prefix and content-hash\n* suffix. Returns `undefined` when the name does not follow the wire-name\n* shape (e.g. an object created outside the toolchain) — callers treat such\n* names as all-prefix. Consumed by introspection (prefix extraction) and by\n* rename pairing (same hash, different prefix).\n*/\nfunction parseWireName(name) {\n\tconst match = WIRE_NAME_PATTERN.exec(name);\n\tconst prefix = match?.[1];\n\tconst hash = match?.[2];\n\tif (prefix === void 0 || hash === void 0) return void 0;\n\treturn {\n\t\tprefix,\n\t\thash\n\t};\n}\n/**\n* Stabilizes an authored SQL body (index expression, partial-index predicate, RLS policy predicate) for hashing: trim, and collapse runs of internal whitespace to a single space. A body that contains `--` is collapsed line by line and keeps its line breaks.\n*\n* This is deliberately minimal. The content hash is the equivalence relation\n* for a wire-named object, and the wire name (prefix + hash) is the only\n* thing ever compared — the hash is never recomputed from an introspected\n* body, so there is no need to match the database's reprinted form. Minimal\n* normalization also protects the no-collision property: aggressive rewriting\n* (lowercasing, paren-stripping, cast-alias folding) risks collapsing two\n* distinct bodies onto one hash.\n*\n* A body that contains `--` keeps its line breaks, because a line break ends a line comment: `a --c` followed by a line break and `b` compares `b`, while `a --c b` does not. Such a body is split into lines, each line is collapsed and trimmed, blank lines are dropped, and the lines are joined with `\\n`. Every body without `--` normalizes as it always has.\n*\n* The normalizer gives the same output on its own output, which policy hashing relies on: it normalizes twice.\n*\n* The normalizer is a stability commitment: a change to it re-suffixes the wire name of every body whose normalized form changes, so a change must say which bodies it affects. See ADR 234, \"Normalizer stability\".\n*/\nfunction normalizeSqlBody(sql) {\n\tif (!sql.includes(\"--\")) return sql.replace(/\\s+/g, \" \").trim();\n\treturn sql.split(/\\r\\n|\\r|\\n/).map((line) => line.replace(/\\s+/g, \" \").trim()).filter((line) => line !== \"\").join(\"\\n\");\n}\n/**\n* Returns the first 8 lowercase hex characters of the SHA-256 digest over the\n* canonical content tuple for a check constraint:\n*\n*   [normalizeSqlBody(expression)]\n*\n* The predicate is the whole of a check's content — the constraint name,\n* schema, and table are orthogonal to its equivalence. The one-element tuple\n* keeps the encoding in the same shape as the index and RLS tuples so a member\n* can be added later without re-reading which encoding a kind uses.\n*\n* The tuple order and encoding are a stability commitment: any change\n* re-suffixes every wire name.\n*/\nfunction computeCheckContentHash(expression) {\n\tconst tuple = JSON.stringify([normalizeSqlBody(expression)]);\n\treturn createHash(\"sha256\").update(tuple).digest(\"hex\").slice(0, 8);\n}\n/** The trailing segment a check's wire-name prefix carries, per kind. */\nconst CHECK_KIND_SUFFIX = {\n\tmembership: \"check\",\n\telementNotNull: \"elem_not_null\"\n};\n/**\n* Composes the wire-name prefix of a derived CHECK constraint:\n* `${table}_${column}_${kindSuffix}`, capped at the wire-name byte budget.\n* Shared by contract authoring (naming emitted checks) and `contract infer`\n* (recomputing the name a derived check would carry), so truncated and\n* multibyte prefixes match by construction.\n*/\nfunction composeCheckWirePrefix(tableName, columnName, kind) {\n\treturn truncateToWireNamePrefixBytes(`${tableName}_${columnName}_${CHECK_KIND_SUFFIX[kind]}`);\n}\n/**\n* Every {@link CheckKind} value, read off {@link CHECK_KIND_SUFFIX}'s own keys\n* so the enumeration can never drift out of step with it.\n*/\nconst CHECK_KINDS = Object.keys(CHECK_KIND_SUFFIX).filter((kind) => kind in CHECK_KIND_SUFFIX);\n/**\n* The wire-name prefixes derivation could produce for `tableName`: every\n* {@link composeCheckWirePrefix} result crossing each of `columnNames` with\n* each {@link CheckKind}. A check is derived iff its prefix is a member of\n* this set.\n*\n* This is the prefix SHAPE only, not the full name-with-hash: it does not\n* know which kind a specific column's type would actually derive (that needs\n* the target's `renderCheckExpressions` hook, which callers of this function\n* do not have in hand), so every column is conservatively treated as capable\n* of producing every kind.\n*/\nfunction derivedCheckPrefixes(tableName, columnNames) {\n\tconst prefixes = /* @__PURE__ */ new Set();\n\tfor (const columnName of columnNames) for (const kind of CHECK_KINDS) prefixes.add(composeCheckWirePrefix(tableName, columnName, kind));\n\treturn prefixes;\n}\n/**\n* Returns the first 8 lowercase hex characters of the SHA-256 digest over the\n* canonical content tuple for an index:\n*\n*   [normalizeSqlBody(expression), normalizeSqlBody(where), columns, unique, type, sortedOptions]\n*\n* Columns hash in authored order — column order is semantic in an index.\n* Option values are `String()`-coerced (matching the loose option equality\n* used for diffing) so a hash computed from typed contract values agrees with\n* one recomputed from introspected reloptions strings. The prefix, schema,\n* and table are excluded (they are orthogonal to index equivalence).\n*\n* The tuple order and encoding are a stability commitment with the same\n* status as the RLS tuple: any change re-suffixes every wire name.\n*/\n/**\n* Canonicalizes one index option VALUE to the `on`/`off` boolean spelling: JS booleans and the common catalog spellings (`pg_class.reloptions` stores whatever spelling the DDL used, so a live index may carry `'true'`/`'false'` or `'on'`/`'off'`) all map to one form; every other scalar via `String()` (fully specified for numbers, so no platform variance); an array or object as JSON, since `String()` would flatten `[['a', 'b']]` and `[['a'], ['b']]` to the same text, with object keys sorted at every depth so key order never changes the value. Shared by the wire-name hash tuple, the node's option equality, and the DDL renderer, so an authored `{ fastupdate: true }` agrees with a live index created under any boolean spelling.\n*/\nfunction normalizeIndexOptionValue(value) {\n\tif (value === true || value === \"true\" || value === \"on\") return \"on\";\n\tif (value === false || value === \"false\" || value === \"off\") return \"off\";\n\tif (typeof value === \"object\" && value !== null) return JSON.stringify(withSortedKeys(value));\n\treturn String(value);\n}\nfunction withSortedKeys(value) {\n\tif (Array.isArray(value)) return value.map(withSortedKeys);\n\tif (typeof value !== \"object\" || value === null) return value;\n\treturn Object.fromEntries(Object.entries(value).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([key, entry]) => [key, withSortedKeys(entry)]));\n}\nfunction computeIndexContentHash(parts) {\n\tconst sortedOptions = Object.entries(parts.options ?? {}).map(([key, value]) => [key, normalizeIndexOptionValue(value)]).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0);\n\tconst tuple = JSON.stringify([\n\t\tnormalizeSqlBody(parts.expression ?? \"\"),\n\t\tnormalizeSqlBody(parts.where ?? \"\"),\n\t\tparts.columns ?? [],\n\t\tparts.unique,\n\t\tparts.type ?? \"\",\n\t\tsortedOptions\n\t]);\n\treturn createHash(\"sha256\").update(tuple).digest(\"hex\").slice(0, 8);\n}\n/**\n* Postgres truncates identifiers at `NAMEDATALEN - 1` = 63 **bytes**, not\n* characters, and the wire name appends a 9-byte `_<8hex>` suffix — so a\n* prefix is bounded at 54 bytes. A prefix of non-ASCII characters can sit well\n* under 54 characters and still overrun: the database would silently truncate\n* the name, leaving the declared object permanently unmatchable against the\n* live one.\n*/\nconst WIRE_NAME_PREFIX_MAX_BYTES = 54;\n/**\n* Rejects a wire-name prefix over {@link WIRE_NAME_PREFIX_MAX_BYTES}.\n* `subject` opens the error message (e.g. `defineContract: policy prefix`).\n*/\nfunction assertWireNamePrefixLength(prefix, subject) {\n\tif (utf8ByteLength(prefix) > 54) throw structuredError(\"CONTRACT.WIRE_NAME_PREFIX_TOO_LONG\", `${subject} \"${prefix}\" exceeds the 54-byte maximum (Postgres identifiers cap at 63 bytes and the wire name appends a 9-byte hash suffix).`, { meta: {\n\t\tprefix,\n\t\tmaxBytes: 54\n\t} });\n}\n/**\n* Shortens a DERIVED wire-name prefix to {@link WIRE_NAME_PREFIX_MAX_BYTES},\n* cutting on a code-point boundary so a multibyte character is never split.\n* Only derived prefixes truncate — an authored one throws\n* ({@link assertWireNamePrefixLength}), because its author can shorten it.\n*/\nfunction truncateToWireNamePrefixBytes(prefix) {\n\treturn clipToUtf8Bytes(prefix, 54);\n}\n//#endregion\nexport { computeIndexContentHash as a, formatWireName as c, namingOfLiveName as d, normalizeIndexOptionValue as f, truncateToWireNamePrefixBytes as g, parseWireName as h, computeCheckContentHash as i, nameOf as l, parseNaming as m, assertWireNamePrefixLength as n, defaultIndexName as o, normalizeSqlBody as p, composeCheckWirePrefix as r, derivedCheckPrefixes as s, WIRE_NAME_PREFIX_MAX_BYTES as t, namingOf as u };\n\n//# sourceMappingURL=naming-bM5qm5PY.mjs.map"],"mappings":"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"}

package/dist/{ddl-types-BGdnAbXo-DKPHPUGx.mjs → opaque-sql-Dset3kln-CtsPDTXn.mjs}

@@ -1,6 +1,6 @@
 import { structuredError } from "@prisma/orm-framework/utils/structured-error";
 import { isColumnDefaultLiteralInputValue } from "@prisma/orm-framework/contract/types";
-//#region ../../../2-sql/4-lanes/relational-core/dist/ddl-types-BGdnAbXo.mjs
+//#region ../../../2-sql-family/4-lanes/relational-core/dist/opaque-sql-Dset3kln.mjs
 var DdlColumnDefault = class {
 	freeze() {
 		Object.freeze(this);
@@ -15,9 +15,6 @@ var LiteralColumnDefault = class extends DdlColumnDefault {
 		this.value = value;
 		this.freeze();
 	}
-	accept(visitor, ctx) {
-		return visitor.literal(this, ctx);
-	}
 };
 var FunctionColumnDefault = class extends DdlColumnDefault {
 	kind = "function";
@@ -27,9 +24,6 @@ var FunctionColumnDefault = class extends DdlColumnDefault {
 		this.expression = expression;
 		this.freeze();
 	}
-	accept(visitor, ctx) {
-		return visitor.function(this, ctx);
-	}
 };
 var DdlColumn = class {
 	name;
@@ -37,7 +31,7 @@ var DdlColumn = class {
 	notNull;
 	primaryKey;
 	default;
-	/** Codec identity for this column. When present, the DDL walker resolves the codec via `codecLookup.get(codecRef.codecId)` and runs the literal default through both declared conversions in order — `codec.encode(codec.decodeJson(default.value), {})` — to obtain the wire value it inlines into the DDL string. The read-back is what makes the pair sound: a contract stores a literal default in the codec's canonical JSON, which is not always the application value `encode` takes (`pg/int8@1` stores decimal text for a `bigint`). A `Date` is the one authored value JSON has no notation for, so it arrives as itself and skips `decodeJson`. When absent, literal defaults follow RawSqlLiteral wire-scalar semantics (string / number / boolean / bigint / null / Uint8Array / Date inlined directly). */
+	/** Codec identity for this column. When present, the DDL walker builds the codec with the column's type parameters and runs the literal default through both declared conversions in order — `codec.toWire(codec.fromDataTypeValue(dataType.fromContract(default.value, params)), {})` — to obtain the wire value it inlines into the DDL string (`encodeLiteralDefault`), and reads each element of a list default the same way (`encodeListLiteralDefault`). The read-back is what makes the pair sound: a contract stores a literal default as its data type's stored JSON, which is not always the application value `toWire` takes (`pg/int8@1` stores decimal text for a `bigint`). A `Date` is the one authored value JSON has no notation for, so it arrives as itself, and the codec reads it with `toDataTypeValue` before `fromDataTypeValue` and `toWire`, so the column's type checks it. A `null` default the type refuses is SQL NULL, `DEFAULT NULL`; a JSON type reads it as the JSON value null. When absent, literal defaults follow RawSqlLiteral wire-scalar semantics (string / number / boolean / bigint / null / Uint8Array / Date inlined directly). */
 	codecRef;
 	constructor(options) {
 		this.name = options.name;
@@ -132,7 +126,7 @@ var UniqueConstraint = class {
 * A table-level CHECK constraint carrying a raw SQL predicate expression. Used
 * for checks that are not enum value-set restrictions — e.g. the element-non-null
 * constraint on a scalar-array column (`array_position(col, NULL) IS NULL`).
-* The `expression` is emitted verbatim, so callers must supply safe,
+* The `expression` is emitted through `renderOpaqueSql`, so callers must supply safe,
 * pre-validated SQL.
 *
 * Frozen on construction — immutable after creation.
@@ -147,7 +141,26 @@ var CheckExpressionConstraint = class {
 		Object.freeze(this);
 	}
 };
+/**
+* SQL text that Prisma does not parse, placed inside a larger statement: a CHECK or policy predicate, an index element list or predicate, a column default, or an ALTER COLUMN TYPE conversion. ADR 244 calls such text opaque.
+*/
+var OpaqueSql = class {
+	text;
+	constructor(text) {
+		this.text = text;
+		Object.freeze(this);
+	}
+};
+function opaqueSql(text) {
+	return new OpaqueSql(text);
+}
+/**
+* The text as a statement includes it. Text containing `--` ends with a line break, so a line comment on its last line cannot hide what the statement writes after it.
+*/
+function renderOpaqueSql(sql) {
+	return sql.text.includes("--") ? `${sql.text}\n` : sql.text;
+}
 //#endregion
-export { ForeignKeyConstraint as a, PrimaryKeyConstraint as c, DdlNode as i, UniqueConstraint as l, DdlColumn as n, FunctionColumnDefault as o, DdlColumnDefault as r, LiteralColumnDefault as s, CheckExpressionConstraint as t, isDdlNode as u };
+export { ForeignKeyConstraint as a, OpaqueSql as c, isDdlNode as d, opaqueSql as f, DdlNode as i, PrimaryKeyConstraint as l, DdlColumn as n, FunctionColumnDefault as o, renderOpaqueSql as p, DdlColumnDefault as r, LiteralColumnDefault as s, CheckExpressionConstraint as t, UniqueConstraint as u };
 
-//# sourceMappingURL=ddl-types-BGdnAbXo-DKPHPUGx.mjs.map
+//# sourceMappingURL=opaque-sql-Dset3kln-CtsPDTXn.mjs.map

package/dist/opaque-sql-Dset3kln-CtsPDTXn.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"opaque-sql-Dset3kln-CtsPDTXn.mjs","names":[],"sources":["../../../../2-sql-family/4-lanes/relational-core/dist/opaque-sql-Dset3kln.mjs"],"sourcesContent":["import { structuredError } from \"@internal/utils/structured-error\";\nimport { isColumnDefaultLiteralInputValue } from \"@internal/contract/types\";\n//#region src/ast/ddl-types.ts\nvar DdlColumnDefault = class {\n\tfreeze() {\n\t\tObject.freeze(this);\n\t}\n};\nvar LiteralColumnDefault = class extends DdlColumnDefault {\n\tkind = \"literal\";\n\tvalue;\n\tconstructor(value) {\n\t\tsuper();\n\t\tif (!isColumnDefaultLiteralInputValue(value)) throw structuredError(\"CONTRACT.DEFAULT_INVALID\", \"Invalid column default literal value\");\n\t\tthis.value = value;\n\t\tthis.freeze();\n\t}\n};\nvar FunctionColumnDefault = class extends DdlColumnDefault {\n\tkind = \"function\";\n\texpression;\n\tconstructor(expression) {\n\t\tsuper();\n\t\tthis.expression = expression;\n\t\tthis.freeze();\n\t}\n};\nvar DdlColumn = class {\n\tname;\n\ttype;\n\tnotNull;\n\tprimaryKey;\n\tdefault;\n\t/** Codec identity for this column. When present, the DDL walker builds the codec with the column's type parameters and runs the literal default through both declared conversions in order — `codec.toWire(codec.fromDataTypeValue(dataType.fromContract(default.value, params)), {})` — to obtain the wire value it inlines into the DDL string (`encodeLiteralDefault`), and reads each element of a list default the same way (`encodeListLiteralDefault`). The read-back is what makes the pair sound: a contract stores a literal default as its data type's stored JSON, which is not always the application value `toWire` takes (`pg/int8@1` stores decimal text for a `bigint`). A `Date` is the one authored value JSON has no notation for, so it arrives as itself, and the codec reads it with `toDataTypeValue` before `fromDataTypeValue` and `toWire`, so the column's type checks it. A `null` default the type refuses is SQL NULL, `DEFAULT NULL`; a JSON type reads it as the JSON value null. When absent, literal defaults follow RawSqlLiteral wire-scalar semantics (string / number / boolean / bigint / null / Uint8Array / Date inlined directly). */\n\tcodecRef;\n\tconstructor(options) {\n\t\tthis.name = options.name;\n\t\tthis.type = options.type;\n\t\tthis.notNull = options.notNull;\n\t\tthis.primaryKey = options.primaryKey;\n\t\tthis.default = options.default;\n\t\tthis.codecRef = options.codecRef;\n\t\tObject.freeze(this);\n\t}\n};\nvar DdlNode = class {\n\t/**\n\t* Structural brand: every DDL node answers `true`. Lets {@link isDdlNode}\n\t* recognise any `DdlNode` subclass — including target-contributed kinds —\n\t* without a central kind registry that subclasses would have to register\n\t* into.\n\t*/\n\tisDdlNode() {\n\t\treturn true;\n\t}\n\tfreeze() {\n\t\tObject.freeze(this);\n\t}\n\tcollectParamRefs() {\n\t\treturn [];\n\t}\n};\nfunction isDdlNode(value) {\n\treturn typeof value === \"object\" && value !== null && \"isDdlNode\" in value && typeof value.isDdlNode === \"function\";\n}\n/**\n* A composite (or single-column) PRIMARY KEY constraint on a `CreateTable`\n* node. When `name` is set, the adapter renders `CONSTRAINT <name> PRIMARY KEY\n* (…)`; otherwise it renders an anonymous `PRIMARY KEY (…)`.\n*\n* Frozen on construction — immutable after creation.\n*/\nvar PrimaryKeyConstraint = class {\n\tkind = \"primary-key\";\n\tcolumns;\n\tname;\n\tconstructor(options) {\n\t\tthis.columns = Object.freeze([...options.columns]);\n\t\tthis.name = options.name;\n\t\tObject.freeze(this);\n\t}\n};\n/**\n* A FOREIGN KEY constraint on a `CreateTable` node. `onDelete` and `onUpdate`\n* use the same `ReferentialAction` vocabulary already used by the migration\n* planner and the contract IR — no parallel string enum.\n*\n* Frozen on construction — immutable after creation.\n*/\nvar ForeignKeyConstraint = class {\n\tkind = \"foreign-key\";\n\tcolumns;\n\trefTable;\n\trefColumns;\n\tonDelete;\n\tonUpdate;\n\tname;\n\tconstructor(options) {\n\t\tthis.columns = Object.freeze([...options.columns]);\n\t\tthis.refTable = options.refTable;\n\t\tthis.refColumns = Object.freeze([...options.refColumns]);\n\t\tthis.onDelete = options.onDelete;\n\t\tthis.onUpdate = options.onUpdate;\n\t\tthis.name = options.name;\n\t\tObject.freeze(this);\n\t}\n};\n/**\n* A table-level UNIQUE constraint on a `CreateTable` node. When `name` is\n* set, the adapter renders `CONSTRAINT <name> UNIQUE (…)`; otherwise it\n* renders an anonymous `UNIQUE (…)`.\n*\n* Frozen on construction — immutable after creation.\n*/\nvar UniqueConstraint = class {\n\tkind = \"unique\";\n\tcolumns;\n\tname;\n\tconstructor(options) {\n\t\tthis.columns = Object.freeze([...options.columns]);\n\t\tthis.name = options.name;\n\t\tObject.freeze(this);\n\t}\n};\n/**\n* A table-level CHECK constraint carrying a raw SQL predicate expression. Used\n* for checks that are not enum value-set restrictions — e.g. the element-non-null\n* constraint on a scalar-array column (`array_position(col, NULL) IS NULL`).\n* The `expression` is emitted through `renderOpaqueSql`, so callers must supply safe,\n* pre-validated SQL.\n*\n* Frozen on construction — immutable after creation.\n*/\nvar CheckExpressionConstraint = class {\n\tkind = \"check-expression\";\n\tname;\n\texpression;\n\tconstructor(options) {\n\t\tthis.name = options.name;\n\t\tthis.expression = options.expression;\n\t\tObject.freeze(this);\n\t}\n};\n//#endregion\n//#region src/ast/opaque-sql.ts\n/**\n* SQL text that Prisma does not parse, placed inside a larger statement: a CHECK or policy predicate, an index element list or predicate, a column default, or an ALTER COLUMN TYPE conversion. ADR 244 calls such text opaque.\n*/\nvar OpaqueSql = class {\n\ttext;\n\tconstructor(text) {\n\t\tthis.text = text;\n\t\tObject.freeze(this);\n\t}\n};\nfunction opaqueSql(text) {\n\treturn new OpaqueSql(text);\n}\n/**\n* The text as a statement includes it. Text containing `--` ends with a line break, so a line comment on its last line cannot hide what the statement writes after it.\n*/\nfunction renderOpaqueSql(sql) {\n\treturn sql.text.includes(\"--\") ? `${sql.text}\\n` : sql.text;\n}\n//#endregion\nexport { DdlColumn as a, ForeignKeyConstraint as c, PrimaryKeyConstraint as d, UniqueConstraint as f, CheckExpressionConstraint as i, FunctionColumnDefault as l, opaqueSql as n, DdlColumnDefault as o, isDdlNode as p, renderOpaqueSql as r, DdlNode as s, OpaqueSql as t, LiteralColumnDefault as u };\n\n//# sourceMappingURL=opaque-sql-Dset3kln.mjs.map"],"mappings":";;;AAGA,IAAI,mBAAmB,MAAM;CAC5B,SAAS;EACR,OAAO,OAAO,IAAI;CACnB;AACD;AACA,IAAI,uBAAuB,cAAc,iBAAiB;CACzD,OAAO;CACP;CACA,YAAY,OAAO;EAClB,MAAM;EACN,IAAI,CAAC,iCAAiC,KAAK,GAAG,MAAM,gBAAgB,4BAA4B,sCAAsC;EACtI,KAAK,QAAQ;EACb,KAAK,OAAO;CACb;AACD;AACA,IAAI,wBAAwB,cAAc,iBAAiB;CAC1D,OAAO;CACP;CACA,YAAY,YAAY;EACvB,MAAM;EACN,KAAK,aAAa;EAClB,KAAK,OAAO;CACb;AACD;AACA,IAAI,YAAY,MAAM;CACrB;CACA;CACA;CACA;CACA;;CAEA;CACA,YAAY,SAAS;EACpB,KAAK,OAAO,QAAQ;EACpB,KAAK,OAAO,QAAQ;EACpB,KAAK,UAAU,QAAQ;EACvB,KAAK,aAAa,QAAQ;EAC1B,KAAK,UAAU,QAAQ;EACvB,KAAK,WAAW,QAAQ;EACxB,OAAO,OAAO,IAAI;CACnB;AACD;AACA,IAAI,UAAU,MAAM;;;;;;;CAOnB,YAAY;EACX,OAAO;CACR;CACA,SAAS;EACR,OAAO,OAAO,IAAI;CACnB;CACA,mBAAmB;EAClB,OAAO,CAAC;CACT;AACD;AACA,SAAS,UAAU,OAAO;CACzB,OAAO,OAAO,UAAU,YAAY,UAAU,QAAQ,eAAe,SAAS,OAAO,MAAM,cAAc;AAC1G;;;;;;;;AAQA,IAAI,uBAAuB,MAAM;CAChC,OAAO;CACP;CACA;CACA,YAAY,SAAS;EACpB,KAAK,UAAU,OAAO,OAAO,CAAC,GAAG,QAAQ,OAAO,CAAC;EACjD,KAAK,OAAO,QAAQ;EACpB,OAAO,OAAO,IAAI;CACnB;AACD;;;;;;;;AAQA,IAAI,uBAAuB,MAAM;CAChC,OAAO;CACP;CACA;CACA;CACA;CACA;CACA;CACA,YAAY,SAAS;EACpB,KAAK,UAAU,OAAO,OAAO,CAAC,GAAG,QAAQ,OAAO,CAAC;EACjD,KAAK,WAAW,QAAQ;EACxB,KAAK,aAAa,OAAO,OAAO,CAAC,GAAG,QAAQ,UAAU,CAAC;EACvD,KAAK,WAAW,QAAQ;EACxB,KAAK,WAAW,QAAQ;EACxB,KAAK,OAAO,QAAQ;EACpB,OAAO,OAAO,IAAI;CACnB;AACD;;;;;;;;AAQA,IAAI,mBAAmB,MAAM;CAC5B,OAAO;CACP;CACA;CACA,YAAY,SAAS;EACpB,KAAK,UAAU,OAAO,OAAO,CAAC,GAAG,QAAQ,OAAO,CAAC;EACjD,KAAK,OAAO,QAAQ;EACpB,OAAO,OAAO,IAAI;CACnB;AACD;;;;;;;;;;AAUA,IAAI,4BAA4B,MAAM;CACrC,OAAO;CACP;CACA;CACA,YAAY,SAAS;EACpB,KAAK,OAAO,QAAQ;EACpB,KAAK,aAAa,QAAQ;EAC1B,OAAO,OAAO,IAAI;CACnB;AACD;;;;AAMA,IAAI,YAAY,MAAM;CACrB;CACA,YAAY,MAAM;EACjB,KAAK,OAAO;EACZ,OAAO,OAAO,IAAI;CACnB;AACD;AACA,SAAS,UAAU,MAAM;CACxB,OAAO,IAAI,UAAU,IAAI;AAC1B;;;;AAIA,SAAS,gBAAgB,KAAK;CAC7B,OAAO,IAAI,KAAK,SAAS,IAAI,IAAI,GAAG,IAAI,KAAK,MAAM,IAAI;AACxD"}

package/dist/operations.d.mts

@@ -1,2 +1,2 @@
-import { a as SqlOperationRegistry, i as SqlOperationEntry, n as SqlOperationDescriptor, o as createSqlOperationRegistry, r as SqlOperationDescriptors, t as SqlLoweringSpec } from "./index-C5I8D-MB.mjs";
+import { a as SqlOperationRegistry, i as SqlOperationEntry, n as SqlOperationDescriptor, o as createSqlOperationRegistry, r as SqlOperationDescriptors, t as SqlLoweringSpec } from "./index-Nqc3OHR_.mjs";
 export { SqlLoweringSpec, SqlOperationDescriptor, SqlOperationDescriptors, SqlOperationEntry, SqlOperationRegistry, createSqlOperationRegistry };

package/dist/operations.mjs

@@ -1,2 +1,2 @@
-import { t as createSqlOperationRegistry } from "./dist-C_q1_QR9.mjs";
+import { t as createSqlOperationRegistry } from "./dist-CHz1hF8M.mjs";
 export { createSqlOperationRegistry };