@prisma/orm-family-sql 8.0.0-rc.12-dev.14 → 8.0.0-rc.12-dev.16

package/dist/{prepared-statement-B6zvhJej-Dl488oBR.d.mts → prepared-statement-BHSj2pDk-CRzjNpcv.d.mts}

@@ -8,17 +8,17 @@ import { n as SqlQueryPlan } from "./plan-B7g2kDfQ-Bw0784x6.mjs";
 import { a as CodecValue, i as CodecTypesBase, l as RawCodecInferer, o as Expression, t as AffectedCount } from "./expression-BPoA5eEl.mjs";
 import { t as SqlExecutionPlan } from "./sql-execution-plan-Db0j752I-CI5WbdLi.mjs";
 import "./plan-DiT00Rg8.mjs";
-import { r as ExecutionContext } from "./query-lane-context-Bi1GUXHp-Bo4OTjhW.mjs";
-import "./query-lane-context-CJNBt8cm.mjs";
+import { n as ExecutionContext } from "./query-lane-context-D6o9YrEV-bouFPM6u.mjs";
+import "./query-lane-context-BcXiJasG.mjs";
+import { h as RuntimeScope } from "./types-DFJNPLXY-vp6AGe5e.mjs";
+import "./types-BvTYXSiS.mjs";
 import { i as SqlParamRefMutator } from "./middleware-CuGBptK0-C88HCnh5.mjs";
 import "./middleware-aoqicpDI.mjs";
-import { h as RuntimeScope } from "./types-Bcujdkdw-2SDajXRo.mjs";
-import "./types-nNy0nND_.mjs";
 import { Contract, JsonValue, PlanMeta } from "@prisma/orm-framework/contract/types";
-import { AfterExecuteResult, AfterQueryResult, AsyncIterableResult, ExecuteInterceptResult, ExecutionPlan, QueryInterceptResult, RuntimeCore, RuntimeExecuteOptions, RuntimeLog, RuntimeMiddleware, RuntimeMiddlewareContext } from "@prisma/orm-framework/components/runtime";
+import { AfterExecuteResult, AfterQueryResult, AsyncIterableResult, ExecuteInterceptResult, ExecutionPlan, MutationDefaultGeneratorContributor, QueryInterceptResult, RuntimeCore, RuntimeExecuteOptions, RuntimeLog, RuntimeMiddleware, RuntimeMiddlewareContext } from "@prisma/orm-framework/components/runtime";
 import { AnyCodecDescriptor, CodecDescriptor } from "@prisma/orm-framework/components/codec";
 import { ExecutionStack, RuntimeAdapterDescriptor, RuntimeAdapterInstance, RuntimeDriverDescriptor, RuntimeDriverInstance, RuntimeExtensionDescriptor, RuntimeExtensionInstance, RuntimeTargetDescriptor, RuntimeTargetInstance } from "@prisma/orm-framework/components/execution";
-//#region ../../../2-sql/5-runtime/dist/prepared-statement-B6zvhJej.d.mts
+//#region ../../../2-sql/5-runtime/dist/prepared-statement-BHSj2pDk.d.mts
 //#region src/codecs/encoding.d.ts
 interface ParamMetadata {
   readonly codec: CodecRef$1 | undefined;
@@ -273,26 +273,9 @@ type RuntimeParameterizedCodecDescriptor<P = Record<string, unknown>> = CodecDes
 /**
  * Contributor protocol for SQL components (target, adapter, extension pack). The unified `codecs:` slot returns the full {@link CodecDescriptor} list — non-parameterized and parameterized descriptors live side-by-side in the same array. The framework dispatches every codec id through the unified descriptor map without branching on parameterization.
  */
-interface SqlStaticContributions {
+interface SqlStaticContributions extends Pick<MutationDefaultGeneratorContributor, 'mutationDefaultGenerators'> {
   readonly codecs: () => ReadonlyArray<AnyCodecDescriptor>;
   readonly queryOperations?: () => SqlOperationDescriptors;
-  readonly mutationDefaultGenerators?: () => ReadonlyArray<RuntimeMutationDefaultGenerator>;
-}
-/**
- * Scope across which a generator's value is constant.
- *
- * - `'field'` — one value per defaulting site (one column, one row). Cache strategy: no cache; call per defaulting site. Right for per-row identifiers (UUIDs, CUIDs, ULIDs, nanoid, ksuid).
- * - `'row'` — one value across all defaulting sites of one row of one operation. Cache strategy: per-call cache keyed by `generatorId`. Right for correlation ids stamped into multiple columns of one row.
- * - `'query'` — one value across all rows and columns of one ORM operation. Cache strategy: caller-provided cache keyed by `generatorId`. Right for `timestampNow` (a single timestamp per bulk insert/update).
- */
-type GeneratorStability = 'field' | 'row' | 'query';
-interface RuntimeMutationDefaultGenerator {
-  readonly id: string;
-  readonly generate: (params?: Record<string, unknown>) => unknown;
-  /**
-   * Scope across which the generator's value is constant. The framework derives the cache strategy from this declaration; generator authors never need to know about cache keys. See `GeneratorStability` for the per-value semantics.
-   */
-  readonly stability: GeneratorStability;
 }
 interface SqlRuntimeTargetDescriptor<TTargetId extends string = string, TTargetInstance extends RuntimeTargetInstance<'sql', TTargetId> = RuntimeTargetInstance<'sql', TTargetId>> extends RuntimeTargetDescriptor<'sql', TTargetId, TTargetInstance>, SqlStaticContributions {}
 interface SqlRuntimeAdapterDescriptor<TTargetId extends string = string, TAdapterInstance extends RuntimeAdapterInstance<'sql', TTargetId> = SqlRuntimeAdapterInstance<TTargetId>> extends RuntimeAdapterDescriptor<'sql', TTargetId, TAdapterInstance>, SqlStaticContributions {
@@ -529,5 +512,5 @@ declare class PreparedExecutionImpl<Params> implements PreparedExecution<Params>
   execute(target: RuntimeQueryable, params: Params, options?: RuntimeExecuteOptions): Promise<SqlStatementStats>;
 }
 //#endregion
-export { SqlMiddleware as A, TelemetryOutcome as B, RuntimeOptions as C, RuntimeTransaction as D, RuntimeTelemetryEvent as E, SqlRuntimeDriverInstance as F, deriveParamMetadata as G, VerifyMarkerOption as H, SqlRuntimeExtensionDescriptor as I, preparedStatementQuery as J, encodeParamsWithMetadata as K, SqlRuntimeExtensionInstance as L, SqlRuntimeAdapterDescriptor as M, SqlRuntimeAdapterInstance as N, SqlExecutionStack as O, SqlRuntimeBase as P, SqlRuntimeTargetDescriptor as R, RuntimeMutationDefaultGenerator as S, RuntimeQueryable as T, createExecutionContext as U, TransactionContext as V, createSqlExecutionStack as W, withTransaction as Y, PreparedStatementInternals as _, DeclaredNullable as a, RuntimeConnection as b, ParamSpec as c, PreparedExecution as d, PreparedExecutionImpl as f, PreparedStatementImpl as g, PreparedStatementExecuteTarget as h, DeclaredCodecId as i, SqlMiddlewareContext as j, SqlExecutionStackWithDriver as k, ParamsFromDeclaration as l, PreparedStatement as m, ConnectionProvider as n, GeneratorStability as o, PreparedFor as p, preparedStatementExecute as q, Declaration as r, MarkerReader as s, BindSiteParams as t, PrepareCallback as u, PreparedStatementQueryTarget as v, RuntimeParameterizedCodecDescriptor as w, RuntimeFamilyAdapter as x, Runtime as y, SqlStaticContributions as z };
-//# sourceMappingURL=prepared-statement-B6zvhJej-Dl488oBR.d.mts.map
+export { SqlRuntimeAdapterDescriptor as A, VerifyMarkerOption as B, RuntimeQueryable as C, SqlExecutionStackWithDriver as D, SqlExecutionStack as E, SqlRuntimeExtensionInstance as F, preparedStatementExecute as G, createSqlExecutionStack as H, SqlRuntimeTargetDescriptor as I, preparedStatementQuery as K, SqlStaticContributions as L, SqlRuntimeBase as M, SqlRuntimeDriverInstance as N, SqlMiddleware as O, SqlRuntimeExtensionDescriptor as P, TelemetryOutcome as R, RuntimeParameterizedCodecDescriptor as S, RuntimeTransaction as T, deriveParamMetadata as U, createExecutionContext as V, encodeParamsWithMetadata as W, PreparedStatementQueryTarget as _, DeclaredNullable as a, RuntimeFamilyAdapter as b, ParamsFromDeclaration as c, PreparedExecutionImpl as d, PreparedFor as f, PreparedStatementInternals as g, PreparedStatementImpl as h, DeclaredCodecId as i, SqlRuntimeAdapterInstance as j, SqlMiddlewareContext as k, PrepareCallback as l, PreparedStatementExecuteTarget as m, ConnectionProvider as n, MarkerReader as o, PreparedStatement as p, withTransaction as q, Declaration as r, ParamSpec as s, BindSiteParams as t, PreparedExecution as u, Runtime as v, RuntimeTelemetryEvent as w, RuntimeOptions as x, RuntimeConnection as y, TransactionContext as z };
+//# sourceMappingURL=prepared-statement-BHSj2pDk-CRzjNpcv.d.mts.map

package/dist/prepared-statement-BHSj2pDk-CRzjNpcv.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prepared-statement-BHSj2pDk-CRzjNpcv.d.mts","names":[],"sources":["../../../../2-sql/5-runtime/dist/prepared-statement-BHSj2pDk.d.mts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;UAaU;WACC,OAAO;WACP;;iBAEM,oBAAoB,KAAK,uBAAuB;iBAChD,yBAAyB,4BAA4B,mBAAmB,iBAAiB,KAAK,qBAAqB,iBAAiB,wBAAwB;;;UAGnK,6BAA6B;WAC5B,UAAU,SAAS;;;;;;UAMpB;WACC,KAAK;WACL,MAAM;;UAEP,cAAc,kBAAkB,0BAA0B,iCAAiC,kBAAkB,kBAAkB,mBAAmB;WACjJ;;;;;;;;;;;;;;;;;;;EAmBT,eAAe,OAAO,WAAW,KAAK,uBAAuB,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;EA0BrE,aAAa,MAAM,kBAAkB,KAAK,sBAAsB,SAAS,mBAAmB,oBAAoB;EAChH,gBAAgB,MAAM,kBAAkB,KAAK,uBAAuB,QAAQ;EAC5E,OAAO,KAAK,yBAAyB,MAAM,kBAAkB,KAAK,uBAAuB;EACzF,YAAY,MAAM,kBAAkB,QAAQ,kBAAkB,KAAK,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;EA0B1F,eAAe,MAAM,kBAAkB,KAAK,sBAAsB,SAAS,mBAAmB,oBAAoB;EAClH,kBAAkB,MAAM,kBAAkB,KAAK,uBAAuB,QAAQ;EAC9E,cAAc,MAAM,kBAAkB,QAAQ,oBAAoB,KAAK,uBAAuB;;;;KAI3F;EACH;EACA;;KAEG,eAAe,oBAAoB,gBAAgB,mBAAmB,qBAAqB;UAEtF;WACC,SAAS;WACT,QAAQ,oBAAoB;WAC5B,YAAY,oBAAoB;WAChC,gBAAgB;WAChB,aAAa;;;;;;;WAOb;;;;KAeN,UAAU,WAAW,iBAAiB,yBAAyB;WACzD,eAAe;WACf,aAAa;WACb;;KAEN,YAAY,WAAW,iBAAiB,kBAAkB,SAAS,eAAe,UAAU;KAC5F,gBAAgB,KAAK,mBAAmB,IAAI;WACtC,eAAe;IACtB;KACC,iBAAiB,KAAK;WAChB;;KAEN,eAAe,iBAAiB,WAAW,IAAI;EAClD,SAAS,gBAAgB,EAAE;EAC3B,UAAU,iBAAiB,EAAE;;KAE1B,sBAAsB,GAAG,WAAW,8BAA8B,WAAW,IAAI,WAAW,gBAAgB,EAAE,KAAK,iBAAiB,EAAE,KAAK;KAC3I,gBAAgB,GAAG,QAAQ,QAAQ,eAAe,OAAO,aAAa;UACjE,kBAAkB,QAAQ;WACzB;WACA,KAAK;WACL,MAAM;WACN,gBAAgB;WAChB,UAAU;WACV,OAAO;EAChB,MAAM,QAAQ,kBAAkB,QAAQ,QAAQ,UAAU,wBAAwB,oBAAoB;;;;;;;;UAQ9F,kBAAkB;WACjB;WACA,KAAK;WACL,MAAM;WACN,gBAAgB;WAChB,UAAU;EACnB,QAAQ,QAAQ,kBAAkB,QAAQ,QAAQ,UAAU,wBAAwB,QAAQ;;;;;;;;;;;;;;;;;;KAkBzF,YAAY,QAAQ,QAAQ,uBAAuB,kBAAkB,QAAQ,QAAQ,cAAc,iBAAiB,kBAAkB,UAAU,kBAAkB,QAAQ;;;cAGjK;UACJ,uCAAuC;GAC9C,0BAA0B,QAAQ,WAAW,kBAAkB,SAAS,QAAQ,QAAQ,UAAU,wBAAwB,QAAQ;;;;cAIvH;UACJ,qCAAqC;GAC5C,wBAAwB,QAAQ,KAAK,WAAW,kBAAkB,QAAQ,MAAM,QAAQ,QAAQ,UAAU,wBAAwB,oBAAoB;;;;;;;UAO/I;EACR,WAAW,WAAW,eAAe,QAAQ;;;;;;;;;;UAUrC,qBAAqB;WACpB,UAAU;WACV,cAAc;EACvB,aAAa,MAAM,eAAe,UAAU;;;;;;;;;;;;;;;;;;;KAmBzC;KACA;UACK;WACC;WACA;WACA;WACA,SAAS;WACT;;;;;;;;;;;KAWN,oCAAoC,IAAI,2BAA2B,gBAAgB;WAC7E,cAAc,YAAY,gBAAgB;;;;;UAK3C,+BAA+B,KAAK;WACnC,cAAc,cAAc;WAC5B,wBAAwB;;UAEzB,2BAA2B,mCAAmC,wBAAwB,6BAA6B,aAAa,6BAA6B,oBAAoB,+BAA+B,WAAW,kBAAkB;UAC7O,4BAA4B,mCAAmC,yBAAyB,8BAA8B,aAAa,0BAA0B,oBAAoB,gCAAgC,WAAW,mBAAmB;;;;WAI9O,iBAAiB;;UAElB,8BAA8B,2CAA2C,kCAAkC,WAAW,4BAA4B,aAAa;EACvK,UAAU,4BAA4B;;UAE9B,kBAAkB;WACjB,QAAQ,2BAA2B;WACnC,SAAS,4BAA4B;WACrC,qBAAqB,8BAA8B;;KAEzD,4BAA4B,qCAAqC,KAAK,sBAAsB,WAAW,0BAA0B,YAAY,yBAAyB,YAAY,4BAA4B;WACxM,QAAQ,2BAA2B;WACnC,SAAS,4BAA4B,WAAW,0BAA0B;WAC1E,QAAQ,+BAA+B,oBAAoB,yBAAyB;WACpF,qBAAqB,8BAA8B;;UAEpD,4BAA4B,kCAAkC,gCAAgC;KACnG,0BAA0B,qCAAqC,8BAA8B,aAAa,QAAQ,aAAa,SAAS,aAAa;;;;KAIrJ,yBAAyB,qCAAqC,6BAA6B,aAAa;iBAC5F,wBAAwB,0BAA0B;WACxD,QAAQ,2BAA2B;WACnC,SAAS,4BAA4B;WACrC,SAAS,+BAA+B,oBAAoB,yBAAyB;WACrF,sBAAsB,8BAA8B;IAC3D,4BAA4B;iBACf,uBAAuB,kBAAkB,SAAS,cAAc,SAAS,aAAa,mCAAmC;WAC/H,UAAU;WACV,OAAO,kBAAkB;;;;WAIzB,SAAS,+BAA+B,oBAAoB,yBAAyB;IAC5F,iBAAiB;;;KAGhB,MAAM;UACD,eAAe,kBAAkB,SAAS,cAAc,SAAS;WAChE,SAAS,iBAAiB;WAC1B,SAAS,QAAQ,aAAa,SAAS,aAAa;WACpD,QAAQ;WACR,eAAe;WACf,sBAAsB;WACtB;WACA,MAAM;;;;;;UAMP,gBAAgB;EACxB,cAAc,QAAQ;EACtB,aAAa;EACb,SAAS;;;;;;EAMT,QAAQ,UAAU,YAAY,KAAK,KAAK,WAAW,iBAAiB,gBAAgB,aAAa,GAAG,UAAU,gBAAgB,GAAG,OAAO,QAAQ,YAAY,sBAAsB,GAAG,KAAK;;UAElL,0BAA0B;EAClC,eAAe,QAAQ;;;;EAIvB,WAAW;;;;;;;;EAQX,QAAQ,mBAAmB;;UAEnB,2BAA2B;EACnC,UAAU;EACV,YAAY;;UAEJ,yBAAyB;UACzB,2BAA2B;WAC1B;;;;;;;uBAOY,eAAe,kBAAkB,SAAS,cAAc,SAAS,qBAAqB,YAAY,cAAc,kBAAkB,0BAA0B;;mBAEhK;mBACA;mBACA;mBACA;mBACA;mBACA;mBACA;mBACA;UACT;UACA;UACA;EACR,YAAY,SAAS,eAAe;;;;;;;;;;;;;;;;;;;;YAoB1B,MAAM,MAAM,cAAc,KAAK,sBAAsB,QAAQ;;;;;;;;UAQ/D;;;;;;;UAOA;;YAEE,UAAU,MAAM,mBAAmB,cAAc;YACjD,WAAW,MAAM,mBAAmB,QAAQ;;;;;YAK5C,iBAAiB,MAAM,eAAe,QAAQ;UAChD;EACR,MAAM,KAAK,OAAO,4BAA4B;aACnC,OAAO;KACf,UAAU,wBAAwB,oBAAoB;EACzD,QAAQ,MAAM,4BAA4B,uBAAuB,UAAU,wBAAwB,QAAQ;GAC1G,wBAAwB,QAAQ,KAAK,IAAI,kBAAkB,QAAQ,MAAM,QAAQ,QAAQ,UAAU,wBAAwB,oBAAoB;GAC/I,0BAA0B,QAAQ,IAAI,kBAAkB,SAAS,QAAQ,QAAQ,UAAU,wBAAwB,QAAQ;;;;;;;YAOlH,wBAAwB,QAAQ;UAClC;YACE,kBAAkB;UACpB;UACA;UACA;UACA;UACA;;YAEE,sBAAsB,KAAK,MAAM,4BAA4B,uBAAuB,WAAW,cAAc,UAAU,wBAAwB,oBAAoB;;YAEnK,kCAAkC,MAAM,4BAA4B,uBAAuB,WAAW,cAAc,UAAU,wBAAwB,QAAQ;EACxK,QAAQ,UAAU,YAAY,KAAK,KAAK,WAAW,iBAAiB,gBAAgB,aAAa,GAAG,UAAU,gBAAgB,GAAG,OAAO,QAAQ,YAAY,sBAAsB,GAAG,KAAK;;YAEhL,iCAAiC,GAAG,KAAK,IAAI,sBAAsB,GAAG,MAAM,qBAAqB,WAAW,cAAc,UAAU,wBAAwB,oBAAoB;;YAEhL,mCAAmC,GAAG,IAAI,sBAAsB,IAAI,qBAAqB,WAAW,cAAc,UAAU,wBAAwB,QAAQ;EACtK,cAAc,QAAQ;UACd;EACR,aAAa;EACb,SAAS;UACD;UACA;UACA;;;UAGA;EACR,cAAc,QAAQ;;iBAEP,gBAAgB,GAAG,SAAS,oBAAoB,KAAK,IAAI,uBAAuB,YAAY,KAAK,QAAQ;;;UAGhH;WACC;WACA,KAAK;WACL,MAAM;WACN,gBAAgB;WAChB,eAAe;WACf,wBAAwB;;cAErB,sBAAsB,QAAQ,gBAAgB,kBAAkB,QAAQ,MAAM;WACjF;WACA,KAAK;WACL,MAAM;WACN,gBAAgB;WAChB,eAAe;WACf,wBAAwB;EACjC,YAAY,WAAW;EACvB,MAAM,QAAQ,kBAAkB,QAAQ,QAAQ,UAAU,wBAAwB,oBAAoB;;;;;;;;;;cAU1F,sBAAsB,mBAAmB,kBAAkB,SAAS;WACvE;WACA,KAAK;WACL,MAAM;WACN,gBAAgB;WAChB,eAAe;WACf,wBAAwB;EACjC,YAAY,WAAW;EACvB,QAAQ,QAAQ,kBAAkB,QAAQ,QAAQ,UAAU,wBAAwB,QAAQ"}

package/dist/psl-build-Cp32ahjI.mjs

@@ -0,0 +1,224 @@
+import { w as numeralText, x as escapePslString } from "./ast-Bhj549wG.mjs";
+import { isDataTypeLoweringEntry } from "@prisma/orm-framework/components/authoring";
+import { dataTypeId } from "@prisma/orm-framework/components/codec";
+//#region ../../../2-sql/9-family/dist/psl-build.mjs
+const DEFAULT_FUNCTION_ATTRIBUTES = {
+	"autoincrement()": "@default(autoincrement())",
+	"now()": "@default(now())"
+};
+/**
+* The attribute a stored default prints as: a named function, a literal the column takes, or any
+* other expression as a raw SQL tagged literal. `undefined` when a literal has no written form.
+*/
+function mapDefault(columnDefault, options) {
+	switch (columnDefault.kind) {
+		case "literal": {
+			const text = writeDefaultLiteral(columnDefault.value, options);
+			return text === void 0 ? void 0 : { attribute: `@default(${text})` };
+		}
+		case "function": return { attribute: options?.functionAttributes?.[columnDefault.expression] ?? DEFAULT_FUNCTION_ATTRIBUTES[columnDefault.expression] ?? `@default(${sqlLiteralText(columnDefault.expression)})` };
+	}
+}
+/**
+* A raw SQL default as a `sql` tagged literal. The backtick fence resolves only `` \` `` and `\\`,
+* so a body holding a backtick is written inside the double-quote fence with PSL string escaping.
+*/
+function sqlLiteralText(expression) {
+	if (expression.includes("`")) return `sql"${escapePslString(expression)}"`;
+	return `sql\`${expression.replace(/\\/g, "\\\\")}\``;
+}
+function writingSurface(entries) {
+	const entryOf = /* @__PURE__ */ new Map();
+	let classify;
+	let plainStringType;
+	let plainBooleanType;
+	const tagTypes = [];
+	for (const [key, entry] of Object.entries(entries)) {
+		if (isDataTypeLoweringEntry(entry)) continue;
+		const written = entry.written;
+		if (written.kind === "tag") {
+			entryOf.set(key, entry);
+			tagTypes.push(dataTypeId(key));
+			continue;
+		}
+		if (written.syntax === "number") {
+			classify = written.classify;
+			for (const type of written.types) entryOf.set(type, entry);
+			continue;
+		}
+		entryOf.set(key, entry);
+		if (written.syntax === "string") plainStringType = dataTypeId(key);
+		else plainBooleanType = dataTypeId(key);
+	}
+	return {
+		entryOf,
+		classify,
+		plainStringType,
+		plainBooleanType,
+		tagTypes
+	};
+}
+/**
+* Every type the stored form could be a value of, in the order a written value would be read: a
+* number or numeral text through the classifier first, then the plain syntax that matches the
+* shape, then each tag, whose canonical form is a whole document.
+*/
+function classifications(value, surface) {
+	const found = [];
+	if (typeof value === "number") {
+		const classified = surface.classify?.(numeralText(value));
+		return classified === void 0 ? [] : [classified];
+	}
+	if (typeof value === "boolean") return surface.plainBooleanType === void 0 ? [] : [{
+		type: surface.plainBooleanType,
+		value
+	}];
+	if (typeof value === "string") {
+		const classified = surface.classify?.(value);
+		if (classified !== void 0) found.push(classified);
+		if (surface.plainStringType !== void 0) found.push({
+			type: surface.plainStringType,
+			value
+		});
+	}
+	for (const type of surface.tagTypes) found.push({
+		type,
+		value
+	});
+	return found;
+}
+/** The stored form the column takes this value as, or `undefined` when its type takes no such value. */
+function admitted(candidate, columnDataType, dataTypes) {
+	if (candidate.type === columnDataType) return candidate.value;
+	const cast = dataTypes.get(columnDataType)?.casts[candidate.type];
+	if (cast === void 0) return void 0;
+	try {
+		return cast(candidate.value);
+	} catch {
+		return;
+	}
+}
+/** The body of the literal: what the entry prints, before the syntax that fences it. */
+function printedBody(entry, value) {
+	try {
+		return entry.print(value);
+	} catch {
+		return;
+	}
+}
+/** What the entry reads the printed body back as, which for a number is the classifier's answer. */
+function readBack(entry, type, body) {
+	const written = entry.written;
+	try {
+		return written.kind === "plain" && written.syntax === "number" ? written.classify(body) : {
+			type,
+			value: written.parse(body)
+		};
+	} catch {
+		return;
+	}
+}
+/**
+* The literal as PSL source. A tag body sits inside a backtick fence, which resolves `` \` `` and
+* `\\` and nothing else, so a `\n` in the body survives as the two characters the entry wrote.
+*/
+function literalText(entry, body) {
+	const written = entry.written;
+	if (written.kind === "tag") {
+		const fenced = body.replace(/\\/g, "\\\\").replace(/`/g, "\\`");
+		return `${written.tag}\`${fenced}\``;
+	}
+	return written.syntax === "string" ? `"${escapePslString(body)}"` : body;
+}
+/**
+* The value written as the literal of one of its types, proven by reading the text straight back:
+* the same entry, the same cast, and the stored form again.
+*/
+function writeScalar(value, columnDataType, dataTypes, surface) {
+	for (const candidate of classifications(value, surface)) {
+		const entry = surface.entryOf.get(candidate.type);
+		if (entry === void 0) continue;
+		const stored = admitted(candidate, columnDataType, dataTypes);
+		if (stored === void 0 || !sameForm(stored, value)) continue;
+		const body = printedBody(entry, candidate.value);
+		if (body === void 0) continue;
+		const reread = readBack(entry, candidate.type, body);
+		if (reread === void 0) continue;
+		const restored = admitted(reread, columnDataType, dataTypes);
+		if (restored === void 0 || !sameForm(restored, value)) continue;
+		return literalText(entry, body);
+	}
+}
+/** One written element of a list, printed as a value of any type, with no column type to admit it. */
+function writeElement(value, of, surface) {
+	for (const candidate of classifications(value, surface)) {
+		if (!of.includes(candidate.type)) continue;
+		const entry = surface.entryOf.get(candidate.type);
+		if (entry === void 0) continue;
+		const body = printedBody(entry, candidate.value);
+		if (body === void 0) continue;
+		const reread = readBack(entry, candidate.type, body);
+		if (reread === void 0 || !of.includes(reread.type)) continue;
+		return {
+			text: literalText(entry, body),
+			value: reread.value
+		};
+	}
+}
+/**
+* A written list on a scalar column, which the column type's list cast turns into its one value.
+* Each element is classified on its own and must be of a type the cast takes.
+*/
+function writeListCast(value, columnDataType, dataTypes, surface) {
+	const listCast = dataTypes.get(columnDataType)?.listCast;
+	if (listCast === void 0) return void 0;
+	const parts = [];
+	const elements = [];
+	for (const element of value) {
+		const written = writeElement(element, listCast.of, surface);
+		if (written === void 0) return void 0;
+		parts.push(written.text);
+		elements.push(written.value);
+	}
+	try {
+		if (!sameForm(listCast.cast(elements), value)) return void 0;
+	} catch {
+		return;
+	}
+	return `[${parts.join(", ")}]`;
+}
+function writeDefaultLiteral(value, options) {
+	if (value instanceof Date) return void 0;
+	const { dataTypeEntries, dataTypes, columnDataType } = options ?? {};
+	if (dataTypeEntries === void 0 || dataTypes === void 0 || columnDataType === void 0) return;
+	const surface = writingSurface(dataTypeEntries);
+	if (options?.list === true) {
+		if (!Array.isArray(value)) return void 0;
+		const parts = [];
+		for (const element of value) {
+			const written = writeScalar(element, columnDataType, dataTypes, surface);
+			if (written === void 0) return void 0;
+			parts.push(written);
+		}
+		return `[${parts.join(", ")}]`;
+	}
+	const written = writeScalar(value, columnDataType, dataTypes, surface);
+	if (written !== void 0) return written;
+	return Array.isArray(value) ? writeListCast(value, columnDataType, dataTypes, surface) : void 0;
+}
+/** Whether two canonical forms are the same JSON value, member by member and element by element. */
+function sameForm(left, right) {
+	if (left === right) return true;
+	if (Array.isArray(left) !== Array.isArray(right)) return false;
+	if (typeof left !== "object" || typeof right !== "object" || left === null || right === null) return false;
+	const members = Object.entries(left);
+	const others = new Map(Object.entries(right));
+	return members.length === others.size && members.every(([key, member]) => {
+		const other = others.get(key);
+		return other !== void 0 && sameForm(member, other);
+	});
+}
+//#endregion
+export { mapDefault as t };
+
+//# sourceMappingURL=psl-build-Cp32ahjI.mjs.map

package/dist/psl-build-Cp32ahjI.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"psl-build-Cp32ahjI.mjs","names":[],"sources":["../../../../2-sql/9-family/dist/psl-build.mjs"],"sourcesContent":["import { s as toEnumMemberName } from \"./psl-names-C3cwe0rg.mjs\";\nimport { isDataTypeLoweringEntry } from \"@internal/framework-components/authoring\";\nimport { dataTypeId } from \"@internal/framework-components/codec\";\nimport { escapePslString, numeralText } from \"@internal/sql-relational-core/ast\";\n//#region src/core/psl-build/default-mapping.ts\nconst DEFAULT_FUNCTION_ATTRIBUTES = {\n\t\"autoincrement()\": \"@default(autoincrement())\",\n\t\"now()\": \"@default(now())\"\n};\n/**\n* The attribute a stored default prints as: a named function, a literal the column takes, or any\n* other expression as a raw SQL tagged literal. `undefined` when a literal has no written form.\n*/\nfunction mapDefault(columnDefault, options) {\n\tswitch (columnDefault.kind) {\n\t\tcase \"literal\": {\n\t\t\tconst text = writeDefaultLiteral(columnDefault.value, options);\n\t\t\treturn text === void 0 ? void 0 : { attribute: `@default(${text})` };\n\t\t}\n\t\tcase \"function\": return { attribute: options?.functionAttributes?.[columnDefault.expression] ?? DEFAULT_FUNCTION_ATTRIBUTES[columnDefault.expression] ?? `@default(${sqlLiteralText(columnDefault.expression)})` };\n\t}\n}\n/**\n* A raw SQL default as a `sql` tagged literal. The backtick fence resolves only `` \\` `` and `\\\\`,\n* so a body holding a backtick is written inside the double-quote fence with PSL string escaping.\n*/\nfunction sqlLiteralText(expression) {\n\tif (expression.includes(\"`\")) return `sql\"${escapePslString(expression)}\"`;\n\treturn `sql\\`${expression.replace(/\\\\/g, \"\\\\\\\\\")}\\``;\n}\nfunction writingSurface(entries) {\n\tconst entryOf = /* @__PURE__ */ new Map();\n\tlet classify;\n\tlet plainStringType;\n\tlet plainBooleanType;\n\tconst tagTypes = [];\n\tfor (const [key, entry] of Object.entries(entries)) {\n\t\tif (isDataTypeLoweringEntry(entry)) continue;\n\t\tconst written = entry.written;\n\t\tif (written.kind === \"tag\") {\n\t\t\tentryOf.set(key, entry);\n\t\t\ttagTypes.push(dataTypeId(key));\n\t\t\tcontinue;\n\t\t}\n\t\tif (written.syntax === \"number\") {\n\t\t\tclassify = written.classify;\n\t\t\tfor (const type of written.types) entryOf.set(type, entry);\n\t\t\tcontinue;\n\t\t}\n\t\tentryOf.set(key, entry);\n\t\tif (written.syntax === \"string\") plainStringType = dataTypeId(key);\n\t\telse plainBooleanType = dataTypeId(key);\n\t}\n\treturn {\n\t\tentryOf,\n\t\tclassify,\n\t\tplainStringType,\n\t\tplainBooleanType,\n\t\ttagTypes\n\t};\n}\n/**\n* Every type the stored form could be a value of, in the order a written value would be read: a\n* number or numeral text through the classifier first, then the plain syntax that matches the\n* shape, then each tag, whose canonical form is a whole document.\n*/\nfunction classifications(value, surface) {\n\tconst found = [];\n\tif (typeof value === \"number\") {\n\t\tconst classified = surface.classify?.(numeralText(value));\n\t\treturn classified === void 0 ? [] : [classified];\n\t}\n\tif (typeof value === \"boolean\") return surface.plainBooleanType === void 0 ? [] : [{\n\t\ttype: surface.plainBooleanType,\n\t\tvalue\n\t}];\n\tif (typeof value === \"string\") {\n\t\tconst classified = surface.classify?.(value);\n\t\tif (classified !== void 0) found.push(classified);\n\t\tif (surface.plainStringType !== void 0) found.push({\n\t\t\ttype: surface.plainStringType,\n\t\t\tvalue\n\t\t});\n\t}\n\tfor (const type of surface.tagTypes) found.push({\n\t\ttype,\n\t\tvalue\n\t});\n\treturn found;\n}\n/** The stored form the column takes this value as, or `undefined` when its type takes no such value. */\nfunction admitted(candidate, columnDataType, dataTypes) {\n\tif (candidate.type === columnDataType) return candidate.value;\n\tconst cast = dataTypes.get(columnDataType)?.casts[candidate.type];\n\tif (cast === void 0) return void 0;\n\ttry {\n\t\treturn cast(candidate.value);\n\t} catch {\n\t\treturn;\n\t}\n}\n/** The body of the literal: what the entry prints, before the syntax that fences it. */\nfunction printedBody(entry, value) {\n\ttry {\n\t\treturn entry.print(value);\n\t} catch {\n\t\treturn;\n\t}\n}\n/** What the entry reads the printed body back as, which for a number is the classifier's answer. */\nfunction readBack(entry, type, body) {\n\tconst written = entry.written;\n\ttry {\n\t\treturn written.kind === \"plain\" && written.syntax === \"number\" ? written.classify(body) : {\n\t\t\ttype,\n\t\t\tvalue: written.parse(body)\n\t\t};\n\t} catch {\n\t\treturn;\n\t}\n}\n/**\n* The literal as PSL source. A tag body sits inside a backtick fence, which resolves `` \\` `` and\n* `\\\\` and nothing else, so a `\\n` in the body survives as the two characters the entry wrote.\n*/\nfunction literalText(entry, body) {\n\tconst written = entry.written;\n\tif (written.kind === \"tag\") {\n\t\tconst fenced = body.replace(/\\\\/g, \"\\\\\\\\\").replace(/`/g, \"\\\\`\");\n\t\treturn `${written.tag}\\`${fenced}\\``;\n\t}\n\treturn written.syntax === \"string\" ? `\"${escapePslString(body)}\"` : body;\n}\n/**\n* The value written as the literal of one of its types, proven by reading the text straight back:\n* the same entry, the same cast, and the stored form again.\n*/\nfunction writeScalar(value, columnDataType, dataTypes, surface) {\n\tfor (const candidate of classifications(value, surface)) {\n\t\tconst entry = surface.entryOf.get(candidate.type);\n\t\tif (entry === void 0) continue;\n\t\tconst stored = admitted(candidate, columnDataType, dataTypes);\n\t\tif (stored === void 0 || !sameForm(stored, value)) continue;\n\t\tconst body = printedBody(entry, candidate.value);\n\t\tif (body === void 0) continue;\n\t\tconst reread = readBack(entry, candidate.type, body);\n\t\tif (reread === void 0) continue;\n\t\tconst restored = admitted(reread, columnDataType, dataTypes);\n\t\tif (restored === void 0 || !sameForm(restored, value)) continue;\n\t\treturn literalText(entry, body);\n\t}\n}\n/** One written element of a list, printed as a value of any type, with no column type to admit it. */\nfunction writeElement(value, of, surface) {\n\tfor (const candidate of classifications(value, surface)) {\n\t\tif (!of.includes(candidate.type)) continue;\n\t\tconst entry = surface.entryOf.get(candidate.type);\n\t\tif (entry === void 0) continue;\n\t\tconst body = printedBody(entry, candidate.value);\n\t\tif (body === void 0) continue;\n\t\tconst reread = readBack(entry, candidate.type, body);\n\t\tif (reread === void 0 || !of.includes(reread.type)) continue;\n\t\treturn {\n\t\t\ttext: literalText(entry, body),\n\t\t\tvalue: reread.value\n\t\t};\n\t}\n}\n/**\n* A written list on a scalar column, which the column type's list cast turns into its one value.\n* Each element is classified on its own and must be of a type the cast takes.\n*/\nfunction writeListCast(value, columnDataType, dataTypes, surface) {\n\tconst listCast = dataTypes.get(columnDataType)?.listCast;\n\tif (listCast === void 0) return void 0;\n\tconst parts = [];\n\tconst elements = [];\n\tfor (const element of value) {\n\t\tconst written = writeElement(element, listCast.of, surface);\n\t\tif (written === void 0) return void 0;\n\t\tparts.push(written.text);\n\t\telements.push(written.value);\n\t}\n\ttry {\n\t\tif (!sameForm(listCast.cast(elements), value)) return void 0;\n\t} catch {\n\t\treturn;\n\t}\n\treturn `[${parts.join(\", \")}]`;\n}\nfunction writeDefaultLiteral(value, options) {\n\tif (value instanceof Date) return void 0;\n\tconst { dataTypeEntries, dataTypes, columnDataType } = options ?? {};\n\tif (dataTypeEntries === void 0 || dataTypes === void 0 || columnDataType === void 0) return;\n\tconst surface = writingSurface(dataTypeEntries);\n\tif (options?.list === true) {\n\t\tif (!Array.isArray(value)) return void 0;\n\t\tconst parts = [];\n\t\tfor (const element of value) {\n\t\t\tconst written = writeScalar(element, columnDataType, dataTypes, surface);\n\t\t\tif (written === void 0) return void 0;\n\t\t\tparts.push(written);\n\t\t}\n\t\treturn `[${parts.join(\", \")}]`;\n\t}\n\tconst written = writeScalar(value, columnDataType, dataTypes, surface);\n\tif (written !== void 0) return written;\n\treturn Array.isArray(value) ? writeListCast(value, columnDataType, dataTypes, surface) : void 0;\n}\n/** Whether two canonical forms are the same JSON value, member by member and element by element. */\nfunction sameForm(left, right) {\n\tif (left === right) return true;\n\tif (Array.isArray(left) !== Array.isArray(right)) return false;\n\tif (typeof left !== \"object\" || typeof right !== \"object\" || left === null || right === null) return false;\n\tconst members = Object.entries(left);\n\tconst others = new Map(Object.entries(right));\n\treturn members.length === others.size && members.every(([key, member]) => {\n\t\tconst other = others.get(key);\n\t\treturn other !== void 0 && sameForm(member, other);\n\t});\n}\n//#endregion\nexport { mapDefault, toEnumMemberName };\n\n//# sourceMappingURL=psl-build.mjs.map"],"mappings":"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"}

package/dist/psl-build-yBrQQN3r.d.mts

@@ -0,0 +1,13 @@
+import "./type-map-BwBI56i3-DDERtzxf.mjs";
+//#region ../../../2-sql/9-family/dist/psl-build.d.mts
+//#region src/core/psl-build/psl-names.d.ts
+/**
+ * PSL member name for a native-enum value. The value itself always prints
+ * explicitly (`member = "value"`), so the returned name never needs a map:
+ * a value that already is a valid, non-reserved identifier is kept verbatim
+ * (case included); anything else is camelCased/escaped like a field name.
+ */
+declare function toEnumMemberName(value: string): string;
+//#endregion
+export { toEnumMemberName as t };
+//# sourceMappingURL=psl-build-yBrQQN3r.d.mts.map

package/dist/psl-build-yBrQQN3r.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"psl-build-yBrQQN3r.d.mts","names":[],"sources":["../../../../2-sql/9-family/dist/psl-build.d.mts"],"mappings":";;;;;;;;;iBAQiB,iBAAiB"}

package/dist/{psl-infer-CuTqC9UV.d.mts → psl-infer-BzjA7U3b.d.mts}

@@ -1,33 +1,8 @@
 import { d as SqlForeignKeyIR, y as SqlTableIR } from "./types-CHOgKgHg-BxgkL3GS.mjs";
 import "./types-BijNazlM.mjs";
-import { AuthoringDataTypeEntry } from "@prisma/orm-framework/components/authoring";
+import { r as PslTypeMap, t as DefaultMappingOptions } from "./type-map-BwBI56i3-DDERtzxf.mjs";
 import { ColumnDefault } from "@prisma/orm-framework/contract/types";
-import { DataTypeId, DataTypeLookup } from "@prisma/orm-framework/components/codec";
 //#region ../../../2-sql/9-family/dist/psl-infer.d.mts
-//#region src/core/psl-contract-infer/default-mapping.d.ts
-interface DefaultMappingOptions {
-  readonly functionAttributes?: Readonly<Record<string, string>>;
-  /** PSL support for the stack's data types, keyed by data type id. */
-  readonly dataTypeEntries?: Readonly<Record<string, AuthoringDataTypeEntry>> | undefined;
-  /** The stack's data types, whose casts say which other types' values each one takes. */
-  readonly dataTypes?: DataTypeLookup | undefined;
-  /** The data type of the column's codec. */
-  readonly columnDataType?: DataTypeId | undefined;
-  /**
-   * Whether the column is a list, whose elements each carry the column's own data type. A written
-   * list on a scalar column goes through that type's list cast instead.
-   */
-  readonly list?: boolean;
-}
-type DefaultMappingResult = {
-  readonly attribute: string;
-};
-/**
- * The attribute a stored default prints as: a named function, a literal the column takes, or any
- * other expression as a raw SQL tagged literal. `undefined` when a literal has no written form.
- */
-declare function mapDefault(columnDefault: ColumnDefault, options?: DefaultMappingOptions): DefaultMappingResult | undefined;
-//#endregion
 //#region src/core/psl-contract-infer/name-transforms.d.ts
 type NameResult = {
   readonly name: string;
@@ -36,33 +11,11 @@ type NameResult = {
 declare function toModelName(tableName: string): NameResult;
 declare function toFieldName(columnName: string): NameResult;
 declare function toEnumName(pgTypeName: string): NameResult;
-/**
- * PSL member name for a native-enum value. The value itself always prints
- * explicitly (`member = "value"`), so the returned name never needs a map:
- * a value that already is a valid, non-reserved identifier is kept verbatim
- * (case included); anything else is camelCased/escaped like a field name.
- */
-declare function toEnumMemberName(value: string): string;
 declare function pluralize(word: string): string;
 declare function deriveRelationFieldName(fkColumns: readonly string[], referencedTableName: string): string;
 declare function deriveBackRelationFieldName(childModelName: string, isOneToOne: boolean): string;
 //#endregion
 //#region src/core/psl-contract-infer/printer-config.d.ts
-type PslTypeReference = {
-  readonly name: string;
-  readonly args?: readonly string[];
-};
-type PslTypeResolution = {
-  readonly pslType: PslTypeReference;
-  readonly nativeType: string;
-  readonly typeParams?: Record<string, unknown>;
-} | {
-  readonly unsupported: true;
-  readonly nativeType: string;
-};
-interface PslTypeMap {
-  resolve(nativeType: string, annotations?: Record<string, unknown>): PslTypeResolution;
-}
 interface EnumInfo {
   readonly typeNames: ReadonlySet<string>;
   readonly definitions: ReadonlyMap<string, readonly string[]>;
@@ -126,5 +79,5 @@ declare function inferRelations(tables: Record<string, SqlTableIR>, modelNameMap
  */
 declare function buildChildRelationField(fieldName: string, parentModelName: string, fk: SqlForeignKeyIR, optional: boolean, relationName?: string, hostTable?: SqlTableIR): RelationField;
 //#endregion
-export { toEnumName as _, PslPrinterOptions as a, PslTypeResolution as c, deriveBackRelationFieldName as d, deriveRelationFieldName as f, toEnumMemberName as g, pluralize as h, InferredRelations as i, RelationField as l, mapDefault as m, DefaultMappingResult as n, PslTypeMap as o, inferRelations as p, EnumInfo as r, PslTypeReference as s, DefaultMappingOptions as t, buildChildRelationField as u, toFieldName as v, toModelName as y };
-//# sourceMappingURL=psl-infer-CuTqC9UV.d.mts.map
+export { buildChildRelationField as a, inferRelations as c, toFieldName as d, toModelName as f, RelationField as i, pluralize as l, InferredRelations as n, deriveBackRelationFieldName as o, PslPrinterOptions as r, deriveRelationFieldName as s, EnumInfo as t, toEnumName as u };
+//# sourceMappingURL=psl-infer-BzjA7U3b.d.mts.map

package/dist/psl-infer-BzjA7U3b.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"psl-infer-BzjA7U3b.d.mts","names":[],"sources":["../../../../2-sql/9-family/dist/psl-infer.d.mts"],"mappings":";;;;;;KAIK;WACM;WACA;;iBAEM,YAAY,oBAAoB;iBAChC,YAAY,qBAAqB;iBACjC,WAAW,qBAAqB;iBAChC,UAAU;iBACV,wBAAwB,8BAA8B;iBACtD,4BAA4B,wBAAwB;;;UAG3D;WACC,WAAW;WACX,aAAa;;UAEd;WACC,SAAS;WACT,iBAAiB;WACjB,WAAW;WACX,mBAAmB,oBAAoB,wBAAwB;;KAErE;WACM;WACA;;;;;;WAMA;;;;;;WAMA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;;WAEA;;;;KAIN;WACM,kBAAkB,6BAA6B;;iBAEzC,eAAe,QAAQ,eAAe,aAAa,cAAc,8BAA8B;;;;;;;;;;;;;;;;;;;iBAmB/F,wBAAwB,mBAAmB,yBAAyB,IAAI,iBAAiB,mBAAmB,uBAAuB,YAAY,aAAa"}

package/dist/psl-infer-DwMyO-IV.mjs

@@ -0,0 +1,195 @@
+import { n as isBackedByColumnKeys, t as backingIndexColumnKeys } from "./foreign-key-materialization-B3HQzQIA.mjs";
+import { t as defaultTableName } from "./default-table-name-BfFY8qYR-lHNcVmY5.mjs";
+import { a as snakeToCamelCase, i as needsEscaping, n as escapeName, o as snakeToPascalCase, r as hasSeparators, t as escapeIfNeeded } from "./psl-names-C3cwe0rg-CsuHOV7E.mjs";
+import { InternalError } from "@prisma/orm-framework/utils/internal-error";
+import pluralizeLib from "pluralize";
+//#region ../../../2-sql/9-family/dist/psl-infer.mjs
+function toModelName(tableName) {
+	let name;
+	if (hasSeparators(tableName)) name = snakeToPascalCase(tableName);
+	else name = tableName.charAt(0).toUpperCase() + tableName.slice(1);
+	if (needsEscaping(name)) return {
+		name: escapeName(name),
+		map: tableName
+	};
+	if (defaultTableName(name) !== tableName) return {
+		name,
+		map: tableName
+	};
+	return { name };
+}
+function toFieldName(columnName) {
+	let name;
+	if (hasSeparators(columnName)) name = snakeToCamelCase(columnName);
+	else name = columnName.charAt(0).toLowerCase() + columnName.slice(1);
+	if (needsEscaping(name)) return {
+		name: escapeName(name),
+		map: columnName
+	};
+	if (name !== columnName) return {
+		name,
+		map: columnName
+	};
+	return { name };
+}
+function toEnumName(pgTypeName) {
+	let name;
+	if (hasSeparators(pgTypeName)) name = snakeToPascalCase(pgTypeName);
+	else name = pgTypeName.charAt(0).toUpperCase() + pgTypeName.slice(1);
+	if (needsEscaping(name)) return {
+		name: escapeName(name),
+		map: pgTypeName
+	};
+	if (name !== pgTypeName) return {
+		name,
+		map: pgTypeName
+	};
+	return { name };
+}
+function pluralize(word) {
+	return pluralizeLib.plural(word);
+}
+function deriveRelationFieldName(fkColumns, referencedTableName) {
+	if (fkColumns.length === 1) {
+		const [col = referencedTableName] = fkColumns;
+		const stripped = col.replace(/_id$/i, "").replace(/Id$/, "");
+		if (stripped.length > 0 && stripped !== col) return escapeIfNeeded(snakeToCamelCase(stripped));
+		return escapeIfNeeded(snakeToCamelCase(referencedTableName));
+	}
+	return escapeIfNeeded(snakeToCamelCase(referencedTableName));
+}
+function deriveBackRelationFieldName(childModelName, isOneToOne) {
+	const base = childModelName.charAt(0).toLowerCase() + childModelName.slice(1);
+	return isOneToOne ? base : pluralize(base);
+}
+const DEFAULT_ON_DELETE = "noAction";
+const DEFAULT_ON_UPDATE = "noAction";
+const REFERENTIAL_ACTION_PSL = {
+	noAction: "NoAction",
+	restrict: "Restrict",
+	cascade: "Cascade",
+	setNull: "SetNull",
+	setDefault: "SetDefault"
+};
+function inferRelations(tables, modelNameMap) {
+	const relationsByTable = /* @__PURE__ */ new Map();
+	const fkCountByPair = /* @__PURE__ */ new Map();
+	for (const table of Object.values(tables)) for (const fk of table.foreignKeys) {
+		const pairKey = `${table.name}→${fk.referencedTable}`;
+		fkCountByPair.set(pairKey, (fkCountByPair.get(pairKey) ?? 0) + 1);
+	}
+	const usedFieldNames = /* @__PURE__ */ new Map();
+	for (const table of Object.values(tables)) {
+		const names = /* @__PURE__ */ new Set();
+		for (const col of Object.values(table.columns)) names.add(col.name);
+		usedFieldNames.set(table.name, names);
+	}
+	for (const table of Object.values(tables)) for (const fk of table.foreignKeys) {
+		const childTableName = table.name;
+		const parentTableName = fk.referencedTable;
+		const childUsed = usedFieldNames.get(childTableName);
+		if (childUsed === void 0) throw new InternalError(`Missing inferred field-name set for table "${childTableName}"`);
+		const childModelName = modelNameMap.get(childTableName) ?? childTableName;
+		const parentModelName = modelNameMap.get(parentTableName) ?? parentTableName;
+		const pairKey = `${childTableName}→${parentTableName}`;
+		const isSelfRelation = childTableName === parentTableName;
+		const needsRelationName = (fkCountByPair.get(pairKey) ?? 0) > 1 || isSelfRelation;
+		const isOneToOne = detectOneToOne(fk, table);
+		const childRelFieldName = resolveUniqueFieldName(deriveRelationFieldName(fk.columns, parentTableName), childUsed, parentModelName);
+		const relationName = needsRelationName ? deriveRelationName(fk, childRelFieldName, parentModelName, isSelfRelation) : void 0;
+		addRelationField(relationsByTable, childTableName, buildChildRelationField(childRelFieldName, parentModelName, fk, fk.columns.some((columnName) => table.columns[columnName]?.nullable ?? false), relationName, table));
+		childUsed.add(childRelFieldName);
+		const parentUsed = usedFieldNames.get(parentTableName) ?? /* @__PURE__ */ new Set();
+		usedFieldNames.set(parentTableName, parentUsed);
+		const backRelFieldName = resolveUniqueFieldName(deriveBackRelationFieldName(childModelName, isOneToOne), parentUsed, childModelName);
+		addRelationField(relationsByTable, parentTableName, {
+			fieldName: backRelFieldName,
+			typeName: childModelName,
+			optional: isOneToOne,
+			list: !isOneToOne,
+			relationName
+		});
+		parentUsed.add(backRelFieldName);
+	}
+	return { relationsByTable };
+}
+function detectOneToOne(fk, table) {
+	const fkCols = [...fk.columns].sort();
+	if (table.primaryKey) {
+		const pkCols = [...table.primaryKey.columns].sort();
+		if (pkCols.length === fkCols.length && pkCols.every((c, i) => c === fkCols[i])) return true;
+	}
+	for (const unique of table.uniques) {
+		const uniqueCols = [...unique.columns].sort();
+		if (uniqueCols.length === fkCols.length && uniqueCols.every((c, i) => c === fkCols[i])) return true;
+	}
+	for (const index of table.indexes) {
+		if (!index.unique || index.partial || index.columns === void 0) continue;
+		const indexCols = [...index.columns].sort();
+		if (indexCols.length === fkCols.length && indexCols.every((c, i) => c === fkCols[i])) return true;
+	}
+	return false;
+}
+function deriveRelationName(fk, childRelationFieldName, parentModelName, isSelfRelation) {
+	if (fk.name) return fk.name;
+	if (isSelfRelation) return `${childRelationFieldName.charAt(0).toUpperCase() + childRelationFieldName.slice(1)}${pluralize(parentModelName)}`;
+	return fk.columns.join("_");
+}
+/**
+* Builds the child-side {@link RelationField} for a single foreign key:
+* `typeName` is the parent model name, `fields`/`references` are the FK's raw
+* columns, and `onDelete`/`onUpdate` are normalized to their PSL spelling.
+* Exported so a caller resolving a foreign key against a model outside
+* `tables` (e.g. a cross-space reference into another contract) can reuse the
+* same normalization instead of duplicating it.
+*
+* `hostTable` is the table the FK is declared on (i.e. `table`, not the
+* referenced parent) — its own indexes/uniques/primary key are what a
+* backing index for this FK would be. When none of them exactly match the
+* FK's source columns (in order), `index: false` is stamped so the emitted
+* `@relation` opts out of the framework's default derived backing-index
+* expectation, matching what `db verify` will find live. Passing the table
+* is optional so existing single-FK callers (e.g. cross-space resolution
+* before a host table reference is threaded through) can omit it and keep
+* the framework default.
+*/
+function buildChildRelationField(fieldName, parentModelName, fk, optional, relationName, hostTable) {
+	const onDelete = fk.onDelete && fk.onDelete !== DEFAULT_ON_DELETE ? fk.onDelete : void 0;
+	const onUpdate = fk.onUpdate && fk.onUpdate !== DEFAULT_ON_UPDATE ? fk.onUpdate : void 0;
+	const index = hostTable && !isBackedByColumnKeys(fk.columns, backingIndexColumnKeys({
+		indexes: hostTable.indexes.filter((i) => i.where === void 0),
+		uniques: hostTable.uniques,
+		primaryKey: hostTable.primaryKey
+	})) ? false : void 0;
+	return {
+		fieldName,
+		typeName: parentModelName,
+		referencedTableName: fk.referencedTable,
+		optional,
+		list: false,
+		relationName,
+		fkName: fk.name,
+		fields: fk.columns,
+		references: fk.referencedColumns,
+		onDelete: onDelete ? REFERENTIAL_ACTION_PSL[onDelete] : void 0,
+		onUpdate: onUpdate ? REFERENTIAL_ACTION_PSL[onUpdate] : void 0,
+		index
+	};
+}
+function resolveUniqueFieldName(desired, usedNames, fallbackSuffix) {
+	if (!usedNames.has(desired)) return desired;
+	const withSuffix = `${desired}${fallbackSuffix}`;
+	if (!usedNames.has(withSuffix)) return withSuffix;
+	let counter = 2;
+	while (usedNames.has(`${desired}${counter}`)) counter++;
+	return `${desired}${counter}`;
+}
+function addRelationField(map, tableName, field) {
+	const existing = map.get(tableName);
+	if (existing) existing.push(field);
+	else map.set(tableName, [field]);
+}
+//#endregion
+export { pluralize as a, toModelName as c, inferRelations as i, deriveBackRelationFieldName as n, toEnumName as o, deriveRelationFieldName as r, toFieldName as s, buildChildRelationField as t };
+
+//# sourceMappingURL=psl-infer-DwMyO-IV.mjs.map