@prisma/orm-family-sql 8.0.0-rc.11-dev.9 → 8.0.0-rc.11-dev.11

package/dist/{diff-CN1ou7vM.d.mts.map → diff-CFhK3Q3k.d.mts.map}

@@ -1 +1 @@
-{"version":3,"file":"diff-CN1ou7vM.d.mts","names":[],"sources":["../../../../2-sql/9-family/dist/diff.d.mts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;iBAmBiB,+BAA+B,OAAO,iBAAiB,gBAAgB,qBAAqB,yBAAyB;;;;;;;;;;;;;iBAarH,qBAAqB,OAAO,iBAAiB,gBAAgB,qBAAqB,yBAAyB;UAClH;;WAEC,iBAAiB;;WAEjB,uBAAuB,OAAO,oBAAoB;WAClD;WACA,sBAAsB;;WAEtB,gBAAgB,qBAAqB;;UAEtC;WACC,mBAAmB;WACnB,mBAAmB;;;;;;;;;iBASb,sBAAsB,OAAO,sBAAsB;UAC1D;WACC,UAAU,SAAS;;;;;;;WAOnB,gBAAgB;aACd,QAAQ;;WAEV,YAAY,oBAAoB;;;;;;;;;UASjC;WACC,mBAAmB;WACnB,mBAAmB;;iBAEb,0BAA0B,OAAO,0BAA0B;UAClE;WACC,UAAU,SAAS;WACnB,QAAQ;WACR;WACA,qBAAqB,cAAc;;WAEnC,YAAY;;WAEZ,gBAAgB,qBAAqB;;;;;;;;;iBAS/B,sBAAsB,OAAO,6BAA6B"}
+{"version":3,"file":"diff-CFhK3Q3k.d.mts","names":[],"sources":["../../../../2-sql/9-family/dist/diff.d.mts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;iBAmBiB,+BAA+B,OAAO,iBAAiB,gBAAgB,qBAAqB,yBAAyB;;;;;;;;;;;;;iBAarH,qBAAqB,OAAO,iBAAiB,gBAAgB,qBAAqB,yBAAyB;UAClH;;WAEC,iBAAiB;;WAEjB,uBAAuB,OAAO,oBAAoB;WAClD;WACA,sBAAsB;;WAEtB,gBAAgB,qBAAqB;;UAEtC;WACC,mBAAmB;WACnB,mBAAmB;;;;;;;;;iBASb,sBAAsB,OAAO,sBAAsB;UAC1D;WACC,UAAU,SAAS;;;;;;;WAOnB,gBAAgB;aACd,QAAQ;;WAEV,YAAY,oBAAoB;;;;;;;;;UASjC;WACC,mBAAmB;WACnB,mBAAmB;;iBAEb,0BAA0B,OAAO,0BAA0B;UAClE;WACC,UAAU,SAAS;WACnB,QAAQ;WACR;WACA,qBAAqB,cAAc;;WAEnC,YAAY;;WAEZ,gBAAgB,qBAAqB;;;;;;;;;iBAS/B,sBAAsB,OAAO,6BAA6B"}

package/dist/{expression-mku9I7Ue.d.mts → expression-BtebKpK2.d.mts}

@@ -2,9 +2,9 @@ import { c as SqlStorage } from "./sql-storage-8LqxeLAY-DH4DdUXx.mjs";
 import { S as QueryOperationReturn } from "./types-BDUG29Df-LE85dIXP.mjs";
 import "./types-C36_3E6_.mjs";
 import { t as SqlLoweringSpec } from "./index-CLAshwKN.mjs";
-import { Ct as RawQueryColumn, St as RawQueryAst, T as CodecRef$1, Tt as RawSqlLiteral, _t as ParamRef, s as AnyExpression } from "./types-v3qxLLxo-Clw_yBAh.mjs";
+import { Ct as RawQueryColumn, St as RawQueryAst, T as CodecRef$1, Tt as RawSqlLiteral, _t as ParamRef, s as AnyExpression } from "./types-DhYcyD0K-Brj7SwFA.mjs";
 import { l as SqlStatementStats } from "./driver-types-BQtRkOJ0-Bv2RPSfr.mjs";
-import { t as SqlQueryPlan } from "./plan-CDxduYaN-B2kMLIQQ.mjs";
+import { n as SqlQueryPlan } from "./plan-oIjoMLQN-Cgljp0gc.mjs";
 import { Contract } from "@prisma/orm-framework/contract/types";
 import { ParamSpec } from "@prisma/orm-framework/operations";
 //#region ../../../2-sql/4-lanes/relational-core/dist/exports/expression.d.mts
@@ -92,7 +92,7 @@ type TraitExpression<Traits extends readonly string[], Nullable extends boolean,
 /**
  * Resolve a raw value or an Expression into an AST expression node.
  *
- * When `value` is an Expression (duck-typed by its `buildAst` method), the AST it wraps is returned. Otherwise the value is embedded as a ParamRef tagged with the caller-supplied {@link CodecRef} (when known). The runtime resolves the ref via `contractCodecs.forCodecRef(codec)`; content-keyed memoisation collapses repeated lookups for the same logical column onto one shared codec.
+ * When `value` is an object with a callable `buildAst`, the AST it wraps is returned. Otherwise the value is embedded as a ParamRef tagged with the caller-supplied {@link CodecRef} (when known). The runtime resolves the ref via `contractCodecs.forCodecRef(codec)`; content-keyed memoisation collapses repeated lookups for the same logical column onto one shared codec.
  *
  * Operation implementations that compare a column-bound expression to a user value derive the column's {@link CodecRef} from the column-bound side (via {@link codecOf}) and forward it here so encode-side dispatch resolves to the per-instance codec for parameterized codec ids (`vector(1024)` vs. `vector(1536)`).
  */
@@ -107,13 +107,13 @@ declare function param<T>(value: T, opts: {
  * Derive the {@link CodecRef} carried by an expression-like value.
  *
  * Resolution order:
- * 1. `wrapper.codec` — explicit column-bound {@link CodecRef} stamped at field-proxy time.
- * 2. `wrapper.returnType.codec` — scope-level codec when the scope was built from contract storage.
- * 3. `{ codecId: wrapper.returnType.codecId }` — minimal ref derived from the expression's declared codec id (covers synthetic expressions like `count()` whose returnType has a known codec id but no explicit column binding).
+ * 1. `wrapper.returnType.codec` — scope-level codec when the scope was built from contract storage.
+ * 2. `{ codecId: wrapper.returnType.codecId }` — minimal ref derived from the expression's declared codec id (covers synthetic expressions like `count()` whose returnType has a known codec id but no explicit column binding).
  *
  * Returns `undefined` for raw scalar values (non-expression-like).
  */
 declare function codecOf(value: unknown): CodecRef$1 | undefined;
+declare function isExpression(value: unknown): value is Expression<ScopeField>;
 interface BuildOperationSpec<R extends ScopeField> {
   readonly method: string;
   /**
@@ -262,5 +262,5 @@ type RawSqlInterpolation = RawExprInterpolation | RawRowQuery;
 declare function createRawSql(adapter: RawCodecInferer, planContext: RawPlanContext): RawSqlStatementTag;
 declare function createRawSql(adapter: RawCodecInferer): RawSqlTag;
 //#endregion
-export { buildOperation as C, toExpr as D, param as E, TraitExpression as S, createRawSql as T, RawSqlStatementBuilder as _, CodecValue as a, ScalarListExpression as b, RawAffectedCountQuery as c, RawRow as d, RawRowQuery as f, RawSqlInterpolation as g, RawSqlBuilder as h, CodecTypesBase as i, RawCodecInferer as l, RawRowSpecEntry as m, BuildOperationSpec as n, Expression as o, RawRowSpec as p, CodecExpression as r, NoReservedRowColumn as s, AffectedCount as t, RawPlanContext as u, RawSqlStatementTag as v, codecOf as w, ScopeField as x, RawSqlTag as y };
-//# sourceMappingURL=expression-mku9I7Ue.d.mts.map
+export { buildOperation as C, param as D, isExpression as E, toExpr as O, TraitExpression as S, createRawSql as T, RawSqlStatementBuilder as _, CodecValue as a, ScalarListExpression as b, RawAffectedCountQuery as c, RawRow as d, RawRowQuery as f, RawSqlInterpolation as g, RawSqlBuilder as h, CodecTypesBase as i, RawCodecInferer as l, RawRowSpecEntry as m, BuildOperationSpec as n, Expression as o, RawRowSpec as p, CodecExpression as r, NoReservedRowColumn as s, AffectedCount as t, RawPlanContext as u, RawSqlStatementTag as v, codecOf as w, ScopeField as x, RawSqlTag as y };
+//# sourceMappingURL=expression-BtebKpK2.d.mts.map

package/dist/expression-BtebKpK2.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"expression-BtebKpK2.d.mts","names":[],"sources":["../../../../2-sql/4-lanes/relational-core/dist/exports/expression.d.mts"],"mappings":";;;;;;;;;;;KAQK;EACH;EACA;;;;;;;;EAQA;;;;EAIA,QAAQ;;KAEL,iBAAiB;WACX;WACA;;;;;KAKN,WAAW,UAAU,cAAc;WAC7B,YAAY;EACrB,YAAY;;KAET,kBAAkB,WAAW;WACvB;IACP,+CAA+C,WAAW,cAAc,GAAG;WACpE,cAAc;KACpB,iCAAiC,KAAK,2BAA2B;KACjE,WAAW,KAAK;;;;;KAKhB,WAAW,wBAAwB,0BAA0B,WAAW;WAClE;OACJ,sBAAsB,KAAK,GAAG,6BAA6B,WAAW;;;;;;;;;;;;;;;KAexE,gBAAgB,wBAAwB,0BAA0B,WAAW;WACvE;MACL;EACJ,SAAS;EACT,UAAU;EACV;KACG,WAAW,SAAS,UAAU;;;;;;;KAO9B,qBAAqB,wBAAwB,4BAA4B;EAC5E,SAAS;EACT,UAAU;EACV;;;;;;;KAOG,gBAAgB,kCAAkC,0BAA0B,WAAW;WACjF;MACL,gBAAgB,kBAAkB,IAAI,SAAS,UAAU;;;;;;;;iBAQ9C,OAAO,gBAAgB,QAAQ,aAAW;;;;iBAI1C,MAAM,GAAG,OAAO,GAAG;EAClC;IACE;;;;;;;;;;iBAUa,QAAQ,iBAAiB;iBACzB,aAAa,iBAAiB,SAAS,WAAW;UACzD,mBAAmB,UAAU;WAC5B;;;;WAIA,gBAAgB,kBAAkB;WAClC,SAAS,IAAI;WACb,UAAU;;;;;iBAKJ,eAAe,UAAU,YAAY,MAAM,mBAAmB,KAAK,WAAW;;;;;;;;;;;;;UAarF;EACR,WAAW,OAAO;;;UAGV;EACR,QAAQ,kBAAkB,MAAM,IAAI;IAClC,SAAS;IACT;;EAEF,QAAQ,kBAAkB,2BAA2B;aAC1C,SAAS;aACT,WAAW;MAClB;IACF,SAAS;IACT,UAAU;;;;;;;;;KAST;WACM;WACA;;;;;;;;;KASN;WACM;;;KAGN,aAAa,SAAS,eAAe,oBAAoB;;;;;;KAMzD,OAAO,aAAa,0BAA0B,WAAW;;;;;UAKpD;WACC,UAAU,SAAS;WACnB;;;;;;;;;;UAUD,YAAY,eAAe,aAAa,SAAS,eAAe,mBAAmB,SAAS,eAAe;;;;;;;;;WAS1G,SAAS;EAClB,YAAY;EACZ,SAAS,aAAa;;cAEV;;;;;;;;;;UAUJ,sBAAsB;YACpB;;;;;;;;UAQF;EACR,SAAS,aAAa;;;;;;;UAOd,+BAA+B;EACvC,WAAW,aAAa,YAAY,MAAM,OAAO,YAAY,OAAO;EACpE,iBAAiB;;;KAGd,aAAa,SAAS,yBAAyB,QAAQ,0BAA0B;;KAEjF,sBAAsB,SAAS,yBAAyB,QAAQ,0BAA0B;;KAE1F,uBAAuB,WAAW,cAAc,WAAW;;KAE3D,sBAAsB,uBAAuB;;;;;;;;iBAQjC,aAAa,SAAS,iBAAiB,aAAa,iBAAiB;iBACrE,aAAa,SAAS,kBAAkB"}

package/dist/{expression-B2Ox7zKM.mjs → expression-CiiHMYqY.mjs}

@@ -1,4 +1,4 @@
-import { E as OperationExpr, M as RawExpr, N as RawQueryAst, k as ParamRef } from "./types-Dt4e_jC--COeP8xzN.mjs";
+import { E as OperationExpr, M as RawExpr, N as RawQueryAst, k as ParamRef } from "./types-CWwta5EN-BS4OsQAL.mjs";
 import { t as planFromAst } from "./plan-Dh0LbYIv-Crx5-ThG.mjs";
 import { runtimeError } from "@prisma/orm-framework/components/runtime";
 import { invariant } from "@prisma/orm-framework/utils/assertions";
@@ -6,12 +6,12 @@ import { invariant } from "@prisma/orm-framework/utils/assertions";
 /**
 * Resolve a raw value or an Expression into an AST expression node.
 *
-* When `value` is an Expression (duck-typed by its `buildAst` method), the AST it wraps is returned. Otherwise the value is embedded as a ParamRef tagged with the caller-supplied {@link CodecRef} (when known). The runtime resolves the ref via `contractCodecs.forCodecRef(codec)`; content-keyed memoisation collapses repeated lookups for the same logical column onto one shared codec.
+* When `value` is an object with a callable `buildAst`, the AST it wraps is returned. Otherwise the value is embedded as a ParamRef tagged with the caller-supplied {@link CodecRef} (when known). The runtime resolves the ref via `contractCodecs.forCodecRef(codec)`; content-keyed memoisation collapses repeated lookups for the same logical column onto one shared codec.
 *
 * Operation implementations that compare a column-bound expression to a user value derive the column's {@link CodecRef} from the column-bound side (via {@link codecOf}) and forward it here so encode-side dispatch resolves to the per-instance codec for parameterized codec ids (`vector(1024)` vs. `vector(1536)`).
 */
 function toExpr(value, codec) {
-	if (isExpressionLike(value)) return value.buildAst();
+	if (isExpression(value)) return value.buildAst();
 	if (codec === void 0) throw runtimeError("RUNTIME.PARAM_REF_CODEC_REQUIRED", `Cannot construct a ParamRef for a ${value === null ? "null" : typeof value} value without an explicit codec. Provide a CodecRef at the call site or use a column-bound builder path.`);
 	return ParamRef.of(value, { codec });
 }
@@ -25,20 +25,16 @@ function param(value, opts) {
 * Derive the {@link CodecRef} carried by an expression-like value.
 *
 * Resolution order:
-* 1. `wrapper.codec` — explicit column-bound {@link CodecRef} stamped at field-proxy time.
-* 2. `wrapper.returnType.codec` — scope-level codec when the scope was built from contract storage.
-* 3. `{ codecId: wrapper.returnType.codecId }` — minimal ref derived from the expression's declared codec id (covers synthetic expressions like `count()` whose returnType has a known codec id but no explicit column binding).
+* 1. `wrapper.returnType.codec` — scope-level codec when the scope was built from contract storage.
+* 2. `{ codecId: wrapper.returnType.codecId }` — minimal ref derived from the expression's declared codec id (covers synthetic expressions like `count()` whose returnType has a known codec id but no explicit column binding).
 *
 * Returns `undefined` for raw scalar values (non-expression-like).
 */
 function codecOf(value) {
-	if (!isExpressionLike(value)) return void 0;
-	const wrapper = value;
-	if (wrapper.codec) return wrapper.codec;
-	if (wrapper.returnType?.codec) return wrapper.returnType.codec;
-	if (wrapper.returnType?.codecId) return { codecId: wrapper.returnType.codecId };
+	if (!isExpression(value)) return void 0;
+	return value.returnType?.codec ?? (value.returnType?.codecId ? { codecId: value.returnType.codecId } : void 0);
 }
-function isExpressionLike(value) {
+function isExpression(value) {
 	return typeof value === "object" && value !== null && "buildAst" in value && typeof value.buildAst === "function";
 }
 /**
@@ -59,7 +55,7 @@ function buildOperation(spec) {
 	};
 }
 function resolveInterpolation(adapter, value) {
-	if (isExpressionLike(value)) return value.buildAst();
+	if (isExpression(value)) return value.buildAst();
 	if (value instanceof ParamRef) return value;
 	if (typeof value === "number" || typeof value === "bigint" || typeof value === "string" || typeof value === "boolean" || value instanceof Uint8Array) return ParamRef.of(value, { codec: { codecId: adapter.inferCodec(value) } });
 	throw runtimeError("RUNTIME.RAW_SQL_UNSUPPORTED_INTERPOLATION", "unsupported JS value type for raw-SQL interpolation: wrap this value in `param(...)` with an explicit codec");
@@ -147,6 +143,6 @@ var RawSqlStatementBuilderImpl = class extends RawSqlBuilderImpl {
 	}
 };
 //#endregion
-export { toExpr as a, param as i, codecOf as n, createRawSql as r, buildOperation as t };
+export { param as a, isExpression as i, codecOf as n, toExpr as o, createRawSql as r, buildOperation as t };
 
-//# sourceMappingURL=expression-B2Ox7zKM.mjs.map
+//# sourceMappingURL=expression-CiiHMYqY.mjs.map

package/dist/expression-CiiHMYqY.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"expression-CiiHMYqY.mjs","names":[],"sources":["../../../../2-sql/4-lanes/relational-core/dist/exports/expression.mjs"],"sourcesContent":["import { E as OperationExpr, M as RawExpr, N as RawQueryAst, k as ParamRef } from \"../types-CWwta5EN.mjs\";\nimport { t as planFromAst } from \"../plan-Dh0LbYIv.mjs\";\nimport { runtimeError } from \"@internal/framework-components/runtime\";\nimport { invariant } from \"@internal/utils/assertions\";\n//#region src/expression.ts\n/**\n* Resolve a raw value or an Expression into an AST expression node.\n*\n* When `value` is an object with a callable `buildAst`, the AST it wraps is returned. Otherwise the value is embedded as a ParamRef tagged with the caller-supplied {@link CodecRef} (when known). The runtime resolves the ref via `contractCodecs.forCodecRef(codec)`; content-keyed memoisation collapses repeated lookups for the same logical column onto one shared codec.\n*\n* Operation implementations that compare a column-bound expression to a user value derive the column's {@link CodecRef} from the column-bound side (via {@link codecOf}) and forward it here so encode-side dispatch resolves to the per-instance codec for parameterized codec ids (`vector(1024)` vs. `vector(1536)`).\n*/\nfunction toExpr(value, codec) {\n\tif (isExpression(value)) return value.buildAst();\n\tif (codec === void 0) throw runtimeError(\"RUNTIME.PARAM_REF_CODEC_REQUIRED\", `Cannot construct a ParamRef for a ${value === null ? \"null\" : typeof value} value without an explicit codec. Provide a CodecRef at the call site or use a column-bound builder path.`);\n\treturn ParamRef.of(value, { codec });\n}\n/**\n* Construct a `ParamRef` for a value whose codec identity is known at call time. Use this when interpolating a value into a raw SQL expression and the codec cannot be inferred from context — e.g. `param(myDate, { codecId: 'pg/timestamptz-temporal@1' })`.\n*/\nfunction param(value, opts) {\n\treturn ParamRef.of(value, { codec: { codecId: opts.codecId } });\n}\n/**\n* Derive the {@link CodecRef} carried by an expression-like value.\n*\n* Resolution order:\n* 1. `wrapper.returnType.codec` — scope-level codec when the scope was built from contract storage.\n* 2. `{ codecId: wrapper.returnType.codecId }` — minimal ref derived from the expression's declared codec id (covers synthetic expressions like `count()` whose returnType has a known codec id but no explicit column binding).\n*\n* Returns `undefined` for raw scalar values (non-expression-like).\n*/\nfunction codecOf(value) {\n\tif (!isExpression(value)) return void 0;\n\treturn value.returnType?.codec ?? (value.returnType?.codecId ? { codecId: value.returnType.codecId } : void 0);\n}\nfunction isExpression(value) {\n\treturn typeof value === \"object\" && value !== null && \"buildAst\" in value && typeof value.buildAst === \"function\";\n}\n/**\n* Construct an OperationExpr AST node and wrap it as a typed Expression. Operation implementations use this to turn their user-facing arguments into the AST node the compilation pipeline eventually lowers to SQL.\n*/\nfunction buildOperation(spec) {\n\tconst [self, ...rest] = spec.args;\n\tconst op = new OperationExpr({\n\t\tmethod: spec.method,\n\t\tself,\n\t\targs: rest.length > 0 ? rest : void 0,\n\t\treturns: spec.returns,\n\t\tlowering: spec.lowering\n\t});\n\treturn {\n\t\treturnType: spec.returns,\n\t\tbuildAst: () => op\n\t};\n}\nfunction resolveInterpolation(adapter, value) {\n\tif (isExpression(value)) return value.buildAst();\n\tif (value instanceof ParamRef) return value;\n\tif (typeof value === \"number\" || typeof value === \"bigint\" || typeof value === \"string\" || typeof value === \"boolean\" || value instanceof Uint8Array) return ParamRef.of(value, { codec: { codecId: adapter.inferCodec(value) } });\n\tthrow runtimeError(\"RUNTIME.RAW_SQL_UNSUPPORTED_INTERPOLATION\", \"unsupported JS value type for raw-SQL interpolation: wrap this value in `param(...)` with an explicit codec\");\n}\nfunction isRawRowQuery(value) {\n\treturn typeof value === \"object\" && value !== null && \"buildAst\" in value && typeof value.buildAst === \"function\" && \"build\" in value && typeof value.build === \"function\";\n}\nfunction templateParts(adapter, strings, values) {\n\tconst parts = [strings[0] ?? \"\"];\n\tvalues.forEach((value, i) => {\n\t\tif (isRawRowQuery(value)) parts.push(...value.buildAst().parts);\n\t\telse parts.push(resolveInterpolation(adapter, value));\n\t\tparts.push(strings[i + 1] ?? \"\");\n\t});\n\treturn parts;\n}\n/**\n* Normalizes each authored entry to a {@link RawQueryColumn}. The record is\n* assembled with `Object.fromEntries`, which defines each key as an own\n* property: a spec built at runtime with a `__proto__` key reaches the AST,\n* which refuses it by name, rather than silently setting the record's\n* prototype and leaving the column to vanish.\n*/\nfunction resolveRowSpec(spec) {\n\treturn Object.fromEntries(Object.entries(spec).map(([name, entry]) => [name, typeof entry === \"string\" ? {\n\t\tcodecId: entry,\n\t\tnullable: false\n\t} : {\n\t\tcodecId: entry.codecId,\n\t\tnullable: entry.nullable ?? false\n\t}]));\n}\nfunction createRawSql(adapter, planContext) {\n\tif (planContext === void 0) return (strings, ...values) => new RawSqlBuilderImpl(templateParts(adapter, strings, values));\n\tconst context = planContext;\n\treturn (strings, ...values) => new RawSqlStatementBuilderImpl(templateParts(adapter, strings, values), context);\n}\nvar RawSqlBuilderImpl = class {\n\tparts;\n\tconstructor(parts) {\n\t\tthis.parts = parts;\n\t}\n\treturns(spec) {\n\t\tconst codecId = typeof spec === \"string\" ? spec : spec.codecId;\n\t\tconst nullable = typeof spec === \"string\" ? false : spec.nullable ?? false;\n\t\tconst paramSpec = {\n\t\t\tcodecId,\n\t\t\tnullable\n\t\t};\n\t\tconst node = new RawExpr({\n\t\t\tparts: this.parts,\n\t\t\treturns: paramSpec\n\t\t});\n\t\treturn {\n\t\t\treturnType: {\n\t\t\t\tcodecId,\n\t\t\t\tnullable\n\t\t\t},\n\t\t\tbuildAst: () => node\n\t\t};\n\t}\n};\nvar RawSqlStatementBuilderImpl = class extends RawSqlBuilderImpl {\n\tplanContext;\n\tconstructor(parts, planContext) {\n\t\tsuper(parts);\n\t\tthis.planContext = planContext;\n\t}\n\treturnsRow(spec) {\n\t\tconst node = RawQueryAst.rows(this.parts, resolveRowSpec(spec));\n\t\tconst result = node.result;\n\t\tinvariant(result.kind === \"rows\", \"RawQueryAst.rows built a non-rows result\");\n\t\treturn {\n\t\t\treturns: result.columns,\n\t\t\tbuildAst: () => node,\n\t\t\tbuild: () => this.planFor(node)\n\t\t};\n\t}\n\taffectedCount() {\n\t\tconst node = RawQueryAst.affectedCount(this.parts);\n\t\treturn { build: () => this.planFor(node) };\n\t}\n\tplanFor(node) {\n\t\treturn planFromAst(node, this.planContext.contract, this.planContext.laneId);\n\t}\n};\n//#endregion\nexport { buildOperation, codecOf, createRawSql, isExpression, param, toExpr };\n\n//# sourceMappingURL=expression.mjs.map"],"mappings":";;;;;;;;;;;;AAYA,SAAS,OAAO,OAAO,OAAO;CAC7B,IAAI,aAAa,KAAK,GAAG,OAAO,MAAM,SAAS;CAC/C,IAAI,UAAU,KAAK,GAAG,MAAM,aAAa,oCAAoC,qCAAqC,UAAU,OAAO,SAAS,OAAO,MAAM,0GAA0G;CACnQ,OAAO,SAAS,GAAG,OAAO,EAAE,MAAM,CAAC;AACpC;;;;AAIA,SAAS,MAAM,OAAO,MAAM;CAC3B,OAAO,SAAS,GAAG,OAAO,EAAE,OAAO,EAAE,SAAS,KAAK,QAAQ,EAAE,CAAC;AAC/D;;;;;;;;;;AAUA,SAAS,QAAQ,OAAO;CACvB,IAAI,CAAC,aAAa,KAAK,GAAG,OAAO,KAAK;CACtC,OAAO,MAAM,YAAY,UAAU,MAAM,YAAY,UAAU,EAAE,SAAS,MAAM,WAAW,QAAQ,IAAI,KAAK;AAC7G;AACA,SAAS,aAAa,OAAO;CAC5B,OAAO,OAAO,UAAU,YAAY,UAAU,QAAQ,cAAc,SAAS,OAAO,MAAM,aAAa;AACxG;;;;AAIA,SAAS,eAAe,MAAM;CAC7B,MAAM,CAAC,MAAM,GAAG,QAAQ,KAAK;CAC7B,MAAM,KAAK,IAAI,cAAc;EAC5B,QAAQ,KAAK;EACb;EACA,MAAM,KAAK,SAAS,IAAI,OAAO,KAAK;EACpC,SAAS,KAAK;EACd,UAAU,KAAK;CAChB,CAAC;CACD,OAAO;EACN,YAAY,KAAK;EACjB,gBAAgB;CACjB;AACD;AACA,SAAS,qBAAqB,SAAS,OAAO;CAC7C,IAAI,aAAa,KAAK,GAAG,OAAO,MAAM,SAAS;CAC/C,IAAI,iBAAiB,UAAU,OAAO;CACtC,IAAI,OAAO,UAAU,YAAY,OAAO,UAAU,YAAY,OAAO,UAAU,YAAY,OAAO,UAAU,aAAa,iBAAiB,YAAY,OAAO,SAAS,GAAG,OAAO,EAAE,OAAO,EAAE,SAAS,QAAQ,WAAW,KAAK,EAAE,EAAE,CAAC;CACjO,MAAM,aAAa,6CAA6C,6GAA6G;AAC9K;AACA,SAAS,cAAc,OAAO;CAC7B,OAAO,OAAO,UAAU,YAAY,UAAU,QAAQ,cAAc,SAAS,OAAO,MAAM,aAAa,cAAc,WAAW,SAAS,OAAO,MAAM,UAAU;AACjK;AACA,SAAS,cAAc,SAAS,SAAS,QAAQ;CAChD,MAAM,QAAQ,CAAC,QAAQ,MAAM,EAAE;CAC/B,OAAO,SAAS,OAAO,MAAM;EAC5B,IAAI,cAAc,KAAK,GAAG,MAAM,KAAK,GAAG,MAAM,SAAS,CAAC,CAAC,KAAK;OACzD,MAAM,KAAK,qBAAqB,SAAS,KAAK,CAAC;EACpD,MAAM,KAAK,QAAQ,IAAI,MAAM,EAAE;CAChC,CAAC;CACD,OAAO;AACR;;;;;;;;AAQA,SAAS,eAAe,MAAM;CAC7B,OAAO,OAAO,YAAY,OAAO,QAAQ,IAAI,CAAC,CAAC,KAAK,CAAC,MAAM,WAAW,CAAC,MAAM,OAAO,UAAU,WAAW;EACxG,SAAS;EACT,UAAU;CACX,IAAI;EACH,SAAS,MAAM;EACf,UAAU,MAAM,YAAY;CAC7B,CAAC,CAAC,CAAC;AACJ;AACA,SAAS,aAAa,SAAS,aAAa;CAC3C,IAAI,gBAAgB,KAAK,GAAG,QAAQ,SAAS,GAAG,WAAW,IAAI,kBAAkB,cAAc,SAAS,SAAS,MAAM,CAAC;CACxH,MAAM,UAAU;CAChB,QAAQ,SAAS,GAAG,WAAW,IAAI,2BAA2B,cAAc,SAAS,SAAS,MAAM,GAAG,OAAO;AAC/G;AACA,IAAI,oBAAoB,MAAM;CAC7B;CACA,YAAY,OAAO;EAClB,KAAK,QAAQ;CACd;CACA,QAAQ,MAAM;EACb,MAAM,UAAU,OAAO,SAAS,WAAW,OAAO,KAAK;EACvD,MAAM,WAAW,OAAO,SAAS,WAAW,QAAQ,KAAK,YAAY;EACrE,MAAM,YAAY;GACjB;GACA;EACD;EACA,MAAM,OAAO,IAAI,QAAQ;GACxB,OAAO,KAAK;GACZ,SAAS;EACV,CAAC;EACD,OAAO;GACN,YAAY;IACX;IACA;GACD;GACA,gBAAgB;EACjB;CACD;AACD;AACA,IAAI,6BAA6B,cAAc,kBAAkB;CAChE;CACA,YAAY,OAAO,aAAa;EAC/B,MAAM,KAAK;EACX,KAAK,cAAc;CACpB;CACA,WAAW,MAAM;EAChB,MAAM,OAAO,YAAY,KAAK,KAAK,OAAO,eAAe,IAAI,CAAC;EAC9D,MAAM,SAAS,KAAK;EACpB,UAAU,OAAO,SAAS,QAAQ,0CAA0C;EAC5E,OAAO;GACN,SAAS,OAAO;GAChB,gBAAgB;GAChB,aAAa,KAAK,QAAQ,IAAI;EAC/B;CACD;CACA,gBAAgB;EACf,MAAM,OAAO,YAAY,cAAc,KAAK,KAAK;EACjD,OAAO,EAAE,aAAa,KAAK,QAAQ,IAAI,EAAE;CAC1C;CACA,QAAQ,MAAM;EACb,OAAO,YAAY,MAAM,KAAK,YAAY,UAAU,KAAK,YAAY,MAAM;CAC5E;AACD"}

package/dist/family.d.mts

@@ -1,13 +1,13 @@
 import { n as resolveStorageTable, t as ResolvedStorageTable } from "./resolve-storage-table-Nyrgk4h8.mjs";
-import { i as SqlControlAdapter, n as Lowerer, o as arraysEqual, r as NativeTypeNormalizer, t as ExecuteRequestLowerer } from "./control-adapter-C99J7aEF-GODO43Ai.mjs";
-import { A as SqlPlannerSuccessResult, C as SqlMigrationRunnerSuccessValue, D as SqlPlannerConflictLocation, E as SqlPlannerConflictKind, O as SqlPlannerFailureResult, S as SqlMigrationRunnerResult, T as SqlPlannerConflict, _ as SqlMigrationRunner, a as FieldEvent, b as SqlMigrationRunnerExecuteOptions, c as SqlControlAdapterDescriptor, d as SqlMigrationPlanContractInfo, f as SqlMigrationPlanOperation, g as SqlMigrationPlannerPlanOptions, h as SqlMigrationPlanner, i as ExpandNativeTypeInput, j as StorageTypePlanResult, k as SqlPlannerResult, l as SqlControlExtensionDescriptor, m as SqlMigrationPlanOperationTarget, n as CodecControlHooks, o as FieldEventContext, p as SqlMigrationPlanOperationStep, r as CreateSqlMigrationPlanOptions, s as ResolveIdentityValueInput, u as SqlMigrationPlan, v as SqlMigrationRunnerErrorCode, w as SqlPlanTargetDetails, x as SqlMigrationRunnerFailure, y as SqlMigrationRunnerExecuteCallbacks } from "./types-IqZMLrFC-BIRftuU7.mjs";
+import { i as SqlControlAdapter, n as Lowerer, o as arraysEqual, r as NativeTypeNormalizer, t as ExecuteRequestLowerer } from "./control-adapter-C99J7aEF-CUDc48SO.mjs";
+import { A as SqlPlannerSuccessResult, C as SqlMigrationRunnerSuccessValue, D as SqlPlannerConflictLocation, E as SqlPlannerConflictKind, O as SqlPlannerFailureResult, S as SqlMigrationRunnerResult, T as SqlPlannerConflict, _ as SqlMigrationRunner, a as FieldEvent, b as SqlMigrationRunnerExecuteOptions, c as SqlControlAdapterDescriptor, d as SqlMigrationPlanContractInfo, f as SqlMigrationPlanOperation, g as SqlMigrationPlannerPlanOptions, h as SqlMigrationPlanner, i as ExpandNativeTypeInput, j as StorageTypePlanResult, k as SqlPlannerResult, l as SqlControlExtensionDescriptor, m as SqlMigrationPlanOperationTarget, n as CodecControlHooks, o as FieldEventContext, p as SqlMigrationPlanOperationStep, r as CreateSqlMigrationPlanOptions, s as ResolveIdentityValueInput, u as SqlMigrationPlan, v as SqlMigrationRunnerErrorCode, w as SqlPlanTargetDetails, x as SqlMigrationRunnerFailure, y as SqlMigrationRunnerExecuteCallbacks } from "./types-IqZMLrFC-BQmtKloA.mjs";
 import { n as SqlSchemaDiffInput, r as SqlSchemaDiffResult, t as SqlSchemaDiffFn } from "./schema-differ-DpG_gnur-BICVtTHY.mjs";
-import { A as partitionCallsByControlPolicy, B as temporalStringAuthoringPresets, C as buildNativeTypeExpander, D as createMigrationPlan, E as controlPolicyForCall, F as runnerFailure, I as runnerSuccess, L as temporalAuthoringPresets, M as planFieldEventOperations, N as plannerFailure, O as detectDestructiveChanges, P as plannerSuccess, R as temporalCodecPreset, S as assembleAuthoringContributions, T as contractToSchemaIR, V as timestampNowControlDescriptor, _ as SqlControlTargetDescriptor, a as EnumNamespaceSchemaResolver, b as TargetMigrationsCapability, c as MigrationOperationPolicy, d as MigrationPlanner, f as MigrationPlannerConflict, g as SqlControlFamilyInstance, h as PlanFieldEventOperationsOptions, i as DefaultResolver, j as partitionIssuesByControlPolicy, k as extractCodecControlHooks, l as MigrationPlan, m as NativeTypeExpander, n as ControlPolicySubject, o as INIT_ADDITIVE_POLICY, p as MigrationPlannerResult, r as DefaultRenderer, s as MigrationOperationClass, t as ContractToSchemaIROptions, u as MigrationPlanOperation, v as SqlDescribedContractSpace, w as contractNamespaceToSchemaIR, y as SuppressionRecord, z as temporalCodecPresetWithPrecision } from "./control-b-6t8eI_.mjs";
-import "./control-adapter-DzTFiMaG.mjs";
-import { a as VerifySqlSchemaByDiffInput, c as computeSqlDiffVerdict, i as StorageTypeVerdictInput, l as computeStorageTypeVerdict, n as SqlDiffVerdictInput, o as classifyDiffSubjectGranularity, r as StorageTypeVerdict, s as classifySqlDiffIssue, t as SqlDiffVerdict, u as verifySqlSchemaByDiff } from "./diff-CN1ou7vM.mjs";
+import { A as partitionCallsByControlPolicy, B as temporalStringAuthoringPresets, C as buildNativeTypeExpander, D as createMigrationPlan, E as controlPolicyForCall, F as runnerFailure, I as runnerSuccess, L as temporalAuthoringPresets, M as planFieldEventOperations, N as plannerFailure, O as detectDestructiveChanges, P as plannerSuccess, R as temporalCodecPreset, S as assembleAuthoringContributions, T as contractToSchemaIR, V as timestampNowControlDescriptor, _ as SqlControlTargetDescriptor, a as EnumNamespaceSchemaResolver, b as TargetMigrationsCapability, c as MigrationOperationPolicy, d as MigrationPlanner, f as MigrationPlannerConflict, g as SqlControlFamilyInstance, h as PlanFieldEventOperationsOptions, i as DefaultResolver, j as partitionIssuesByControlPolicy, k as extractCodecControlHooks, l as MigrationPlan, m as NativeTypeExpander, n as ControlPolicySubject, o as INIT_ADDITIVE_POLICY, p as MigrationPlannerResult, r as DefaultRenderer, s as MigrationOperationClass, t as ContractToSchemaIROptions, u as MigrationPlanOperation, v as SqlDescribedContractSpace, w as contractNamespaceToSchemaIR, y as SuppressionRecord, z as temporalCodecPresetWithPrecision } from "./control-CYQ2U777.mjs";
+import "./control-adapter-BPttH3He.mjs";
+import { a as VerifySqlSchemaByDiffInput, c as computeSqlDiffVerdict, i as StorageTypeVerdictInput, l as computeStorageTypeVerdict, n as SqlDiffVerdictInput, o as classifyDiffSubjectGranularity, r as StorageTypeVerdict, s as classifySqlDiffIssue, t as SqlDiffVerdict, u as verifySqlSchemaByDiff } from "./diff-CFhK3Q3k.mjs";
 import { i as SqlSchemaVerifierBase, n as SqlContractSerializerBase, r as SqlEntityHydrationFactory, t as SqlContractSerializer } from "./ir-R9GE8gsm.mjs";
-import { t as SqlMigration } from "./migration-Bhce5i_m.mjs";
+import { t as SqlMigration } from "./migration-CkjRhB8h.mjs";
 import { _ as toEnumMemberName, a as PslPrinterOptions, b as toModelName, c as PslTypeResolution, d as deriveBackRelationFieldName, f as deriveRelationFieldName, g as pluralize, h as parseRawDefault, i as InferredRelations, l as RelationField, m as mapDefault, n as DefaultMappingResult, o as PslTypeMap, p as inferRelations, r as EnumInfo, s as PslTypeReference, t as DefaultMappingOptions, u as buildChildRelationField, v as toEnumName, y as toFieldName } from "./psl-infer-CCAD6FWA.mjs";
-import { a as timestampNowRuntimeGenerator, n as UNBOUND_DOMAIN_NAMESPACE_ID, r as resolveDomainModel, t as ResolvedDomainModel } from "./runtime-CzCx0TKe.mjs";
+import { a as timestampNowRuntimeGenerator, n as UNBOUND_DOMAIN_NAMESPACE_ID, r as resolveDomainModel, t as ResolvedDomainModel } from "./runtime-BhA8jUsk.mjs";
 import { n as parseContractMarkerRow, t as ContractMarkerRow } from "./verify-zDRnw0Rn.mjs";
 export { type CodecControlHooks, type ContractMarkerRow, type ContractToSchemaIROptions, type ControlPolicySubject, type CreateSqlMigrationPlanOptions, type DefaultMappingOptions, type DefaultMappingResult, type DefaultRenderer, type DefaultResolver, type EnumInfo, type EnumNamespaceSchemaResolver, type ExecuteRequestLowerer, type ExpandNativeTypeInput, type FieldEvent, type FieldEventContext, INIT_ADDITIVE_POLICY, type InferredRelations, type Lowerer, SqlMigration as Migration, type MigrationOperationClass, type MigrationOperationPolicy, type MigrationPlan, type MigrationPlanOperation, type MigrationPlanner, type MigrationPlannerConflict, type MigrationPlannerResult, type NativeTypeExpander, type NativeTypeNormalizer, type PlanFieldEventOperationsOptions, type PslPrinterOptions, type PslTypeMap, type PslTypeReference, type PslTypeResolution, type RelationField, type ResolveIdentityValueInput, type ResolvedDomainModel, type ResolvedStorageTable, SqlContractSerializer, SqlContractSerializerBase, type SqlControlAdapter, type SqlControlExtensionDescriptor, type SqlControlFamilyInstance, type SqlControlTargetDescriptor, type SqlDescribedContractSpace, type SqlDiffVerdict, type SqlDiffVerdictInput, type SqlEntityHydrationFactory, type SqlMigrationPlan, type SqlMigrationPlanContractInfo, type SqlMigrationPlanOperation, type SqlMigrationPlanOperationStep, type SqlMigrationPlanOperationTarget, type SqlMigrationPlanner, type SqlMigrationPlannerPlanOptions, type SqlMigrationRunner, type SqlMigrationRunnerErrorCode, type SqlMigrationRunnerExecuteCallbacks, type SqlMigrationRunnerExecuteOptions, type SqlMigrationRunnerFailure, type SqlMigrationRunnerResult, type SqlMigrationRunnerSuccessValue, type SqlPlanTargetDetails, type SqlPlannerConflict, type SqlPlannerConflictKind, type SqlPlannerConflictLocation, type SqlPlannerFailureResult, type SqlPlannerResult, type SqlPlannerSuccessResult, type SqlSchemaDiffFn, type SqlSchemaDiffInput, type SqlSchemaDiffResult, SqlSchemaVerifierBase, type StorageTypePlanResult, type StorageTypeVerdict, type StorageTypeVerdictInput, type SuppressionRecord, type TargetMigrationsCapability, UNBOUND_DOMAIN_NAMESPACE_ID, type VerifySqlSchemaByDiffInput, arraysEqual, assembleAuthoringContributions, buildChildRelationField, buildNativeTypeExpander, classifyDiffSubjectGranularity, classifySqlDiffIssue, computeSqlDiffVerdict, computeStorageTypeVerdict, contractNamespaceToSchemaIR, contractToSchemaIR, controlPolicyForCall, createMigrationPlan, deriveBackRelationFieldName, deriveRelationFieldName, detectDestructiveChanges, extractCodecControlHooks, inferRelations, mapDefault, parseContractMarkerRow, parseRawDefault, partitionCallsByControlPolicy, partitionIssuesByControlPolicy, planFieldEventOperations, plannerFailure, plannerSuccess, pluralize, resolveDomainModel, resolveStorageTable, runnerFailure, runnerSuccess, temporalAuthoringPresets, temporalCodecPreset, temporalCodecPresetWithPrecision, temporalStringAuthoringPresets, timestampNowControlDescriptor, timestampNowRuntimeGenerator, toEnumMemberName, toEnumName, toFieldName, toModelName, verifySqlSchemaByDiff };

package/dist/family__control-adapter.d.mts

@@ -1,3 +1,3 @@
-import { a as SqlControlAdapterDescriptor, i as SqlControlAdapter, n as Lowerer, t as ExecuteRequestLowerer } from "./control-adapter-C99J7aEF-GODO43Ai.mjs";
-import "./control-adapter-DzTFiMaG.mjs";
+import { a as SqlControlAdapterDescriptor, i as SqlControlAdapter, n as Lowerer, t as ExecuteRequestLowerer } from "./control-adapter-C99J7aEF-CUDc48SO.mjs";
+import "./control-adapter-BPttH3He.mjs";
 export type { ExecuteRequestLowerer, Lowerer, SqlControlAdapter, SqlControlAdapterDescriptor };

package/dist/family__control.d.mts

@@ -1,4 +1,4 @@
-import { A as SqlPlannerSuccessResult, C as SqlMigrationRunnerSuccessValue, D as SqlPlannerConflictLocation, E as SqlPlannerConflictKind, O as SqlPlannerFailureResult, S as SqlMigrationRunnerResult, T as SqlPlannerConflict, _ as SqlMigrationRunner, a as FieldEvent, b as SqlMigrationRunnerExecuteOptions, c as SqlControlAdapterDescriptor, d as SqlMigrationPlanContractInfo, f as SqlMigrationPlanOperation, g as SqlMigrationPlannerPlanOptions, h as SqlMigrationPlanner, i as ExpandNativeTypeInput, j as StorageTypePlanResult, k as SqlPlannerResult, l as SqlControlExtensionDescriptor, m as SqlMigrationPlanOperationTarget, n as CodecControlHooks, o as FieldEventContext, p as SqlMigrationPlanOperationStep, r as CreateSqlMigrationPlanOptions, s as ResolveIdentityValueInput, u as SqlMigrationPlan, v as SqlMigrationRunnerErrorCode, w as SqlPlanTargetDetails, x as SqlMigrationRunnerFailure, y as SqlMigrationRunnerExecuteCallbacks } from "./types-IqZMLrFC-BIRftuU7.mjs";
+import { A as SqlPlannerSuccessResult, C as SqlMigrationRunnerSuccessValue, D as SqlPlannerConflictLocation, E as SqlPlannerConflictKind, O as SqlPlannerFailureResult, S as SqlMigrationRunnerResult, T as SqlPlannerConflict, _ as SqlMigrationRunner, a as FieldEvent, b as SqlMigrationRunnerExecuteOptions, c as SqlControlAdapterDescriptor, d as SqlMigrationPlanContractInfo, f as SqlMigrationPlanOperation, g as SqlMigrationPlannerPlanOptions, h as SqlMigrationPlanner, i as ExpandNativeTypeInput, j as StorageTypePlanResult, k as SqlPlannerResult, l as SqlControlExtensionDescriptor, m as SqlMigrationPlanOperationTarget, n as CodecControlHooks, o as FieldEventContext, p as SqlMigrationPlanOperationStep, r as CreateSqlMigrationPlanOptions, s as ResolveIdentityValueInput, u as SqlMigrationPlan, v as SqlMigrationRunnerErrorCode, w as SqlPlanTargetDetails, x as SqlMigrationRunnerFailure, y as SqlMigrationRunnerExecuteCallbacks } from "./types-IqZMLrFC-BQmtKloA.mjs";
 import { n as SqlSchemaDiffInput, r as SqlSchemaDiffResult, t as SqlSchemaDiffFn } from "./schema-differ-DpG_gnur-BICVtTHY.mjs";
-import { A as partitionCallsByControlPolicy, B as temporalStringAuthoringPresets, C as buildNativeTypeExpander, D as createMigrationPlan, E as controlPolicyForCall, F as runnerFailure, I as runnerSuccess, L as temporalAuthoringPresets, M as planFieldEventOperations, N as plannerFailure, O as detectDestructiveChanges, P as plannerSuccess, R as temporalCodecPreset, S as assembleAuthoringContributions, T as contractToSchemaIR, V as timestampNowControlDescriptor, _ as SqlControlTargetDescriptor, a as EnumNamespaceSchemaResolver, b as TargetMigrationsCapability, c as MigrationOperationPolicy, d as MigrationPlanner, f as MigrationPlannerConflict, g as SqlControlFamilyInstance, h as PlanFieldEventOperationsOptions, i as DefaultResolver, j as partitionIssuesByControlPolicy, k as extractCodecControlHooks, l as MigrationPlan, m as NativeTypeExpander, n as ControlPolicySubject, o as INIT_ADDITIVE_POLICY, p as MigrationPlannerResult, r as DefaultRenderer, s as MigrationOperationClass, t as ContractToSchemaIROptions, u as MigrationPlanOperation, v as SqlDescribedContractSpace, w as contractNamespaceToSchemaIR, x as _default, y as SuppressionRecord, z as temporalCodecPresetWithPrecision } from "./control-b-6t8eI_.mjs";
+import { A as partitionCallsByControlPolicy, B as temporalStringAuthoringPresets, C as buildNativeTypeExpander, D as createMigrationPlan, E as controlPolicyForCall, F as runnerFailure, I as runnerSuccess, L as temporalAuthoringPresets, M as planFieldEventOperations, N as plannerFailure, O as detectDestructiveChanges, P as plannerSuccess, R as temporalCodecPreset, S as assembleAuthoringContributions, T as contractToSchemaIR, V as timestampNowControlDescriptor, _ as SqlControlTargetDescriptor, a as EnumNamespaceSchemaResolver, b as TargetMigrationsCapability, c as MigrationOperationPolicy, d as MigrationPlanner, f as MigrationPlannerConflict, g as SqlControlFamilyInstance, h as PlanFieldEventOperationsOptions, i as DefaultResolver, j as partitionIssuesByControlPolicy, k as extractCodecControlHooks, l as MigrationPlan, m as NativeTypeExpander, n as ControlPolicySubject, o as INIT_ADDITIVE_POLICY, p as MigrationPlannerResult, r as DefaultRenderer, s as MigrationOperationClass, t as ContractToSchemaIROptions, u as MigrationPlanOperation, v as SqlDescribedContractSpace, w as contractNamespaceToSchemaIR, x as _default, y as SuppressionRecord, z as temporalCodecPresetWithPrecision } from "./control-CYQ2U777.mjs";
 export { type CodecControlHooks, type ContractToSchemaIROptions, type ControlPolicySubject, type CreateSqlMigrationPlanOptions, type DefaultRenderer, type DefaultResolver, type EnumNamespaceSchemaResolver, type ExpandNativeTypeInput, type FieldEvent, type FieldEventContext, INIT_ADDITIVE_POLICY, type MigrationOperationClass, type MigrationOperationPolicy, type MigrationPlan, type MigrationPlanOperation, type MigrationPlanner, type MigrationPlannerConflict, type MigrationPlannerResult, type NativeTypeExpander, type PlanFieldEventOperationsOptions, type ResolveIdentityValueInput, type SqlControlAdapterDescriptor, type SqlControlExtensionDescriptor, type SqlControlFamilyInstance, type SqlControlTargetDescriptor, type SqlDescribedContractSpace, type SqlMigrationPlan, type SqlMigrationPlanContractInfo, type SqlMigrationPlanOperation, type SqlMigrationPlanOperationStep, type SqlMigrationPlanOperationTarget, type SqlMigrationPlanner, type SqlMigrationPlannerPlanOptions, type SqlMigrationRunner, type SqlMigrationRunnerErrorCode, type SqlMigrationRunnerExecuteCallbacks, type SqlMigrationRunnerExecuteOptions, type SqlMigrationRunnerFailure, type SqlMigrationRunnerResult, type SqlMigrationRunnerSuccessValue, type SqlPlanTargetDetails, type SqlPlannerConflict, type SqlPlannerConflictKind, type SqlPlannerConflictLocation, type SqlPlannerFailureResult, type SqlPlannerResult, type SqlPlannerSuccessResult, type SqlSchemaDiffFn, type SqlSchemaDiffInput, type SqlSchemaDiffResult, type StorageTypePlanResult, type SuppressionRecord, type TargetMigrationsCapability, assembleAuthoringContributions, buildNativeTypeExpander, contractNamespaceToSchemaIR, contractToSchemaIR, controlPolicyForCall, createMigrationPlan, _default as default, detectDestructiveChanges, extractCodecControlHooks, partitionCallsByControlPolicy, partitionIssuesByControlPolicy, planFieldEventOperations, plannerFailure, plannerSuccess, runnerFailure, runnerSuccess, temporalAuthoringPresets, temporalCodecPreset, temporalCodecPresetWithPrecision, temporalStringAuthoringPresets, timestampNowControlDescriptor };

package/dist/family__diff.d.mts

@@ -1,3 +1,3 @@
-import { o as arraysEqual, r as NativeTypeNormalizer } from "./control-adapter-C99J7aEF-GODO43Ai.mjs";
-import { a as VerifySqlSchemaByDiffInput, c as computeSqlDiffVerdict, i as StorageTypeVerdictInput, l as computeStorageTypeVerdict, n as SqlDiffVerdictInput, o as classifyDiffSubjectGranularity, r as StorageTypeVerdict, s as classifySqlDiffIssue, t as SqlDiffVerdict, u as verifySqlSchemaByDiff } from "./diff-CN1ou7vM.mjs";
+import { o as arraysEqual, r as NativeTypeNormalizer } from "./control-adapter-C99J7aEF-CUDc48SO.mjs";
+import { a as VerifySqlSchemaByDiffInput, c as computeSqlDiffVerdict, i as StorageTypeVerdictInput, l as computeStorageTypeVerdict, n as SqlDiffVerdictInput, o as classifyDiffSubjectGranularity, r as StorageTypeVerdict, s as classifySqlDiffIssue, t as SqlDiffVerdict, u as verifySqlSchemaByDiff } from "./diff-CFhK3Q3k.mjs";
 export { type NativeTypeNormalizer, type SqlDiffVerdict, type SqlDiffVerdictInput, type StorageTypeVerdict, type StorageTypeVerdictInput, type VerifySqlSchemaByDiffInput, arraysEqual, classifyDiffSubjectGranularity, classifySqlDiffIssue, computeSqlDiffVerdict, computeStorageTypeVerdict, verifySqlSchemaByDiff };

package/dist/family__migration.d.mts

@@ -1,2 +1,2 @@
-import { t as SqlMigration } from "./migration-Bhce5i_m.mjs";
+import { t as SqlMigration } from "./migration-CkjRhB8h.mjs";
 export { SqlMigration as Migration };

package/dist/family__runtime.d.mts

@@ -1,3 +1,3 @@
 import { n as resolveStorageTable, t as ResolvedStorageTable } from "./resolve-storage-table-Nyrgk4h8.mjs";
-import { a as timestampNowRuntimeGenerator, i as sqlRuntimeFamilyDescriptor, n as UNBOUND_DOMAIN_NAMESPACE_ID, r as resolveDomainModel, t as ResolvedDomainModel } from "./runtime-CzCx0TKe.mjs";
+import { a as timestampNowRuntimeGenerator, i as sqlRuntimeFamilyDescriptor, n as UNBOUND_DOMAIN_NAMESPACE_ID, r as resolveDomainModel, t as ResolvedDomainModel } from "./runtime-BhA8jUsk.mjs";
 export { type ResolvedDomainModel, type ResolvedStorageTable, UNBOUND_DOMAIN_NAMESPACE_ID, sqlRuntimeFamilyDescriptor as default, resolveDomainModel, resolveStorageTable, timestampNowRuntimeGenerator };

package/dist/{index-DzBzeTAy.d.mts → index-Bkg5fqsf.d.mts}

@@ -1,13 +1,13 @@
 import { c as SqlStorage } from "./sql-storage-8LqxeLAY-DH4DdUXx.mjs";
 import "./types-C36_3E6_.mjs";
-import { O as ContractCodecRegistry, m as AnyQueryAst, ut as LoweredStatement } from "./types-v3qxLLxo-Clw_yBAh.mjs";
-import { t as Adapter } from "./ast-DuLukI6f.mjs";
-import { t as SqlQueryPlan } from "./plan-CDxduYaN-B2kMLIQQ.mjs";
-import { t as SqlExecutionPlan } from "./sql-execution-plan--jKyLpe5-Bcz9QM2s.mjs";
-import "./plan-C7VP7jOh.mjs";
-import { n as CodecDescriptorRegistry } from "./query-lane-context-Qa-eddrE-BQV6J9nV.mjs";
-import "./query-lane-context-CGdMIEuv.mjs";
-import { k as SqlMiddleware } from "./prepared-statement-9QpkE6JG-B9xqBu5T.mjs";
+import { O as ContractCodecRegistry, m as AnyQueryAst, ut as LoweredStatement } from "./types-DhYcyD0K-Brj7SwFA.mjs";
+import { t as Adapter } from "./ast-BAsreJBG.mjs";
+import { n as SqlQueryPlan } from "./plan-oIjoMLQN-Cgljp0gc.mjs";
+import { t as SqlExecutionPlan } from "./sql-execution-plan-2C68q5Jo-5sJRnbj0.mjs";
+import "./plan-DT6ur9_C.mjs";
+import { n as CodecDescriptorRegistry } from "./query-lane-context-cqWxvUWZ-DU48PEoC.mjs";
+import "./query-lane-context-Dra2wgIo.mjs";
+import { k as SqlMiddleware } from "./prepared-statement-9QpkE6JG-3LY-d6pU.mjs";
 import { Contract } from "@prisma/orm-framework/contract/types";
 import { AfterExecuteResult as AfterExecuteResult$1, AfterQueryResult as AfterQueryResult$1, ExecuteInterceptResult as ExecuteInterceptResult$1, QueryInterceptResult as QueryInterceptResult$1, RuntimeLog as Log } from "@prisma/orm-framework/components/runtime";
 //#region ../../../2-sql/5-runtime/dist/index.d.mts
@@ -81,4 +81,4 @@ interface LintsOptions {
 declare function lints(options?: LintsOptions): SqlMiddleware;
 //#endregion
 export { LintsOptions as a, budgets as c, lints as d, lowerSqlPlan as f, ExecuteInterceptResult$1 as i, createAstCodecRegistry as l, validateContractCodecMappings as m, AfterQueryResult$1 as n, Log as o, validateCodecRegistryCompleteness as p, BudgetsOptions as r, QueryInterceptResult$1 as s, AfterExecuteResult$1 as t, extractCodecIds as u };
-//# sourceMappingURL=index-DzBzeTAy.d.mts.map
+//# sourceMappingURL=index-Bkg5fqsf.d.mts.map

package/dist/{index-DzBzeTAy.d.mts.map → index-Bkg5fqsf.d.mts.map}

@@ -1 +1 @@
-{"version":3,"file":"index-DzBzeTAy.d.mts","names":[],"sources":["../../../../2-sql/5-runtime/dist/index.d.mts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;iBAiBiB,uBAAuB,aAAa,0BAA0B;;;iBAG9D,gBAAgB,UAAU,SAAS,cAAc;iBACjD,8BAA8B,UAAU,yBAAyB,UAAU,SAAS;iBACpF,kCAAkC,UAAU,yBAAyB,UAAU,SAAS;;;;;;;;;;;;iBAYxF,aAAa,KAAK,SAAS,QAAQ,aAAa,SAAS,aAAa,mBAAmB,UAAU,SAAS,aAAa,WAAW,aAAa,OAAO,iBAAiB;;;UAGhL;WACC;WACA;WACA,YAAY;WACZ;WACA;aACE;aACA;;;iBAGI,QAAQ,UAAU,iBAAiB;;;UAG1C;WACC;aACE;aACA;aACA;aACA;aACA;;WAEF;;;;;;;;;;;;;;;;iBAgBM,MAAM,UAAU,eAAe"}
+{"version":3,"file":"index-Bkg5fqsf.d.mts","names":[],"sources":["../../../../2-sql/5-runtime/dist/index.d.mts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;iBAiBiB,uBAAuB,aAAa,0BAA0B;;;iBAG9D,gBAAgB,UAAU,SAAS,cAAc;iBACjD,8BAA8B,UAAU,yBAAyB,UAAU,SAAS;iBACpF,kCAAkC,UAAU,yBAAyB,UAAU,SAAS;;;;;;;;;;;;iBAYxF,aAAa,KAAK,SAAS,QAAQ,aAAa,SAAS,aAAa,mBAAmB,UAAU,SAAS,aAAa,WAAW,aAAa,OAAO,iBAAiB;;;UAGhL;WACC;WACA;WACA,YAAY;WACZ;WACA;aACE;aACA;;;iBAGI,QAAQ,UAAU,iBAAiB;;;UAG1C;WACC;aACE;aACA;aACA;aACA;aACA;;WAEF;;;;;;;;;;;;;;;;iBAgBM,MAAM,UAAU,eAAe"}

package/dist/{middleware-AhTz1BOW-CtQWS4mb.d.mts → middleware-CAQqWuBd-pOZt5VBK.d.mts}

@@ -1,6 +1,6 @@
-import { t as SqlExecutionPlan } from "./sql-execution-plan--jKyLpe5-Bcz9QM2s.mjs";
+import { t as SqlExecutionPlan } from "./sql-execution-plan-2C68q5Jo-5sJRnbj0.mjs";
 import { ParamRefMutator } from "@prisma/orm-framework/components/runtime";
-//#region ../../../2-sql/4-lanes/relational-core/dist/middleware-AhTz1BOW.d.mts
+//#region ../../../2-sql/4-lanes/relational-core/dist/middleware-CAQqWuBd.d.mts
 //#region src/middleware/param-ref-mutator.d.ts
 /**
  * Brand applied to {@link ParamRefHandle} so user-constructed handles
@@ -116,4 +116,4 @@ interface SqlParamRefMutatorInternal<TCodecMap extends Record<string, unknown> =
 declare function createSqlParamRefMutator<TCodecMap extends Record<string, unknown> = Record<string, unknown>>(plan: SqlExecutionPlan): SqlParamRefMutatorInternal<TCodecMap>;
 //#endregion
 export { SqlParamRefMutatorInternal as a, SqlParamRefMutator as i, ParamRefEntryUnion as n, createSqlParamRefMutator as o, ParamRefHandle as r, ParamRefEntry as t };
-//# sourceMappingURL=middleware-AhTz1BOW-CtQWS4mb.d.mts.map
+//# sourceMappingURL=middleware-CAQqWuBd-pOZt5VBK.d.mts.map

package/dist/{middleware-AhTz1BOW-CtQWS4mb.d.mts.map → middleware-CAQqWuBd-pOZt5VBK.d.mts.map}

@@ -1 +1 @@
-{"version":3,"file":"middleware-AhTz1BOW-CtQWS4mb.d.mts","names":[],"sources":["../../../../2-sql/4-lanes/relational-core/dist/middleware-AhTz1BOW.d.mts"],"mappings":";;;;;;;;;;;;;;cAac;;;;;;;;;;UAUJ,eAAe;YACb,sBAAsB;;;;;;;UAOxB,cAAc;WACb,KAAK,eAAe;WACpB;WACA,SAAS;;;;;;;;;;KAUf,mBAAmB,kBAAkB,8BAA8B,WAAW,qBAAqB,cAAc,YAAY,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;UAyB9I,mBAAmB,kBAAkB,0BAA0B,iCAAiC;;EAExG,WAAW,iBAAiB,mBAAmB;;;;;;;EAO/C,aAAa,uBAAuB,oBAAoB,KAAK,eAAe,WAAW,UAAU,UAAU;EAC3G,aAAa,KAAK,2BAA2B;;EAE7C,cAAc,SAAS;aACZ,KAAK,sBAAsB;aAC3B;;;;;;;;;;;;;UAaH,2BAA2B,kBAAkB,0BAA0B,iCAAiC,mBAAmB;EACnI;;;;;;;;;;;;;;;;;iBAiBe,yBAAyB,kBAAkB,0BAA0B,yBAAyB,MAAM,mBAAmB,2BAA2B"}
+{"version":3,"file":"middleware-CAQqWuBd-pOZt5VBK.d.mts","names":[],"sources":["../../../../2-sql/4-lanes/relational-core/dist/middleware-CAQqWuBd.d.mts"],"mappings":";;;;;;;;;;;;;;cAac;;;;;;;;;;UAUJ,eAAe;YACb,sBAAsB;;;;;;;UAOxB,cAAc;WACb,KAAK,eAAe;WACpB;WACA,SAAS;;;;;;;;;;KAUf,mBAAmB,kBAAkB,8BAA8B,WAAW,qBAAqB,cAAc,YAAY,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;UAyB9I,mBAAmB,kBAAkB,0BAA0B,iCAAiC;;EAExG,WAAW,iBAAiB,mBAAmB;;;;;;;EAO/C,aAAa,uBAAuB,oBAAoB,KAAK,eAAe,WAAW,UAAU,UAAU;EAC3G,aAAa,KAAK,2BAA2B;;EAE7C,cAAc,SAAS;aACZ,KAAK,sBAAsB;aAC3B;;;;;;;;;;;;;UAaH,2BAA2B,kBAAkB,0BAA0B,iCAAiC,mBAAmB;EACnI;;;;;;;;;;;;;;;;;iBAiBe,yBAAyB,kBAAkB,0BAA0B,yBAAyB,MAAM,mBAAmB,2BAA2B"}

package/dist/middleware-ERea8Bpj.d.mts

@@ -0,0 +1 @@
+import "./middleware-CAQqWuBd-pOZt5VBK.mjs";

package/dist/{migration-Bhce5i_m.d.mts → migration-CkjRhB8h.d.mts}

@@ -1,6 +1,6 @@
 import { c as SqlStorage } from "./sql-storage-8LqxeLAY-DH4DdUXx.mjs";
 import "./types-C36_3E6_.mjs";
-import { f as SqlMigrationPlanOperation, w as SqlPlanTargetDetails } from "./types-IqZMLrFC-BIRftuU7.mjs";
+import { f as SqlMigrationPlanOperation, w as SqlPlanTargetDetails } from "./types-IqZMLrFC-BQmtKloA.mjs";
 import { Contract } from "@prisma/orm-framework/contract/types";
 import { Migration } from "@prisma/orm-toolchain/migration-tools/migration";
 //#region ../../../2-sql/9-family/dist/migration.d.mts
@@ -41,4 +41,4 @@ declare abstract class SqlMigration<TDetails extends SqlPlanTargetDetails, TTarg
 }
 //#endregion
 export { SqlMigration as t };
-//# sourceMappingURL=migration-Bhce5i_m.d.mts.map
+//# sourceMappingURL=migration-CkjRhB8h.d.mts.map

package/dist/{migration-Bhce5i_m.d.mts.map → migration-CkjRhB8h.d.mts.map}

@@ -1 +1 @@
-{"version":3,"file":"migration-Bhce5i_m.d.mts","names":[],"sources":["../../../../2-sql/9-family/dist/migration.d.mts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;uBA0BuB,aAAa,iBAAiB,sBAAsB,mCAAmC,cAAc,SAAS,cAAc,SAAS,aAAa,YAAY,SAAS,cAAc,SAAS,qBAAqB,UAAU,0BAA0B,kBAAkB,WAAW,OAAO;;;;;;;;;;;MAW5S"}
+{"version":3,"file":"migration-CkjRhB8h.d.mts","names":[],"sources":["../../../../2-sql/9-family/dist/migration.d.mts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;uBA0BuB,aAAa,iBAAiB,sBAAsB,mCAAmC,cAAc,SAAS,cAAc,SAAS,aAAa,YAAY,SAAS,cAAc,SAAS,qBAAqB,UAAU,0BAA0B,kBAAkB,WAAW,OAAO;;;;;;;;;;;MAW5S"}

package/dist/orm-client.d.mts

@@ -2,15 +2,19 @@ import { t as StorageColumn } from "./storage-table-DSeWszOL-CI-cItEK.mjs";
 import { c as SqlStorage } from "./sql-storage-8LqxeLAY-DH4DdUXx.mjs";
 import { f as ExtractFieldOutputTypes, l as ExtractAggregateTypes, p as ExtractQueryOperationTypes, u as ExtractCodecTypes } from "./types-BDUG29Df-LE85dIXP.mjs";
 import "./types-C36_3E6_.mjs";
-import { It as WhereArg, T as CodecRef$1, a as AndExpr, g as BinaryExpr, gt as OrderByItem, ht as OrExpr, pt as NullCheckExpr, r as AggregateFn, s as AnyExpression } from "./types-v3qxLLxo-Clw_yBAh.mjs";
-import "./ast-DuLukI6f.mjs";
-import { o as Expression } from "./expression-mku9I7Ue.mjs";
-import { r as ExecutionContext } from "./query-lane-context-Qa-eddrE-BQV6J9nV.mjs";
-import "./query-lane-context-CGdMIEuv.mjs";
-import { h as RuntimeScope, o as ComputeColumnJsType } from "./types-CyxGtOOh-BJnoWm0f.mjs";
-import "./types-DvsoMNLs.mjs";
+import { It as WhereArg, T as CodecRef$1, a as AndExpr, g as BinaryExpr, gt as OrderByItem, ht as OrExpr, ot as LimitOffsetValue, pt as NullCheckExpr, r as AggregateFn, s as AnyExpression } from "./types-DhYcyD0K-Brj7SwFA.mjs";
+import "./ast-BAsreJBG.mjs";
+import { n as SqlQueryPlan, t as Preparable } from "./plan-oIjoMLQN-Cgljp0gc.mjs";
+import { S as TraitExpression, i as CodecTypesBase, o as Expression } from "./expression-BtebKpK2.mjs";
+import "./plan-DT6ur9_C.mjs";
+import { r as ExecutionContext } from "./query-lane-context-cqWxvUWZ-DU48PEoC.mjs";
+import "./query-lane-context-Dra2wgIo.mjs";
+import { h as RuntimeScope, o as ComputeColumnJsType } from "./types-thCvr3t--BKg5flQM.mjs";
+import "./types-DL0mGtxm.mjs";
+import { l as ParamsFromDeclaration, m as PreparedStatement, p as PreparedFor, r as Declaration, t as BindSiteParams, w as RuntimeQueryable$1, y as Runtime } from "./prepared-statement-9QpkE6JG-3LY-d6pU.mjs";
+import "./index-Bkg5fqsf.mjs";
 import { Contract } from "@prisma/orm-framework/contract/types";
-import { AnnotationValue, AsyncIterableResult, MetaBuilder, OperationKind } from "@prisma/orm-framework/components/runtime";
+import { AnnotationValue, AsyncIterableResult, MetaBuilder, OperationKind, ResultType, RuntimeExecuteOptions } from "@prisma/orm-framework/components/runtime";
 import { SimplifyDeep } from "@prisma/orm-framework/utils/simplify-deep";
 //#region ../../../3-extensions/sql-orm-client/dist/index.d.mts
 //#region src/types.d.ts
@@ -69,8 +73,8 @@ interface CollectionState {
   readonly distinct: readonly string[] | undefined;
   readonly distinctOn: readonly string[] | undefined;
   readonly selectedFields: readonly string[] | undefined;
-  readonly limit: number | undefined;
-  readonly offset: number | undefined;
+  readonly limit: LimitOffsetValue | undefined;
+  readonly offset: LimitOffsetValue | undefined;
   readonly variantName: string | undefined;
   /**
    * Annotations attached to this query at terminal-call time.
@@ -137,14 +141,27 @@ interface CollectionContext<TContract extends Contract<SqlStorage>> {
   readonly runtime: RuntimeQueryable;
   readonly context: ExecutionContext<TContract>;
 }
-type ComparisonMethodFns<T> = {
-  eq(value: T): AnyExpression;
-  neq(value: T): AnyExpression;
+type PredicateOperand<T, CodecId extends string> = T | Expression<{
+  codecId: CodecId;
+  nullable: false;
+  many?: never;
+}>;
+type ComparisonMethodFns<T, CodecId extends string = never> = {
+  eq(value: T | Expression<{
+    codecId: CodecId;
+    nullable: boolean;
+    many?: never;
+  }>): AnyExpression;
+  neq(value: T | Expression<{
+    codecId: CodecId;
+    nullable: boolean;
+    many?: never;
+  }>): AnyExpression;
   gt(value: T): AnyExpression;
   lt(value: T): AnyExpression;
   gte(value: T): AnyExpression;
   lte(value: T): AnyExpression;
-  like(pattern: string): AnyExpression;
+  like(pattern: PredicateOperand<string, CodecId>): AnyExpression;
   in(values: readonly T[]): AnyExpression;
   notIn(values: readonly T[]): AnyExpression;
   isNull(): AnyExpression;
@@ -157,7 +174,7 @@ type ComparisonMethodFns<T> = {
  *
  * - `traits: []` → always available (isNull, isNotNull)
  */
-type ComparisonMethods<T, Traits> = { [K in keyof ComparisonMethodsMeta as [ComparisonMethodsMeta[K]['traits'][number]] extends [Traits] ? K : never]: ComparisonMethodFns<T>[K]; };
+type ComparisonMethods<T, Traits, CodecId extends string = never> = { [K in keyof ComparisonMethodsMeta as [ComparisonMethodsMeta[K]['traits'][number]] extends [Traits] ? K : never]: ComparisonMethodFns<PredicateOperand<T, CodecId>, CodecId>[K]; };
 type QueryOperationReturnTraits<Returns, TCodecTypes extends Record<string, unknown>> = Returns extends {
   readonly codecId: infer Id extends string;
 } ? Id extends keyof TCodecTypes ? TCodecTypes[Id] extends {
@@ -273,7 +290,7 @@ type RelationFilterAccessor<TContract extends Contract<SqlStorage>, RelatedNsId
 type ScalarModelAccessor<TContract extends Contract<SqlStorage>, ModelName extends string, NsId extends string = never> = { [K in keyof FieldsOf<TContract, ModelName, NsId> & string]: Expression<{
   codecId: FieldCodecId<TContract, ModelName, K, NsId>;
   nullable: FieldNullable<TContract, ModelName, K, NsId>;
-}> & ComparisonMethods<FieldJsType<TContract, ModelName, K, NsId>, FieldTraits<TContract, ModelName, K, NsId>> & FieldOperations<TContract, NsId, ModelName, K>; };
+}> & ComparisonMethods<FieldJsType<TContract, ModelName, K, NsId>, FieldTraits<TContract, ModelName, K, NsId>, FieldCodecId<TContract, ModelName, K, NsId>> & FieldOperations<TContract, NsId, ModelName, K>; };
 type RelationModelAccessor<TContract extends Contract<SqlStorage>, ModelName extends string, NsId extends string = never> = { [K in RelationNames<TContract, ModelName, NsId>]: RelationFilterAccessor<TContract, RelationTargetNamespace<TContract, ModelName, K, NsId>, RelatedModelName<TContract, ModelName, K, NsId> & string>; };
 type ModelAccessor<TContract extends Contract<SqlStorage>, ModelName extends string, NsId extends string = never> = ScalarModelAccessor<TContract, ModelName, NsId> & RelationModelAccessor<TContract, ModelName, NsId>;
 /**
@@ -472,7 +489,11 @@ type HavingMethod<TContract extends Contract<SqlStorage>, ModelName extends stri
  * methods.
  */
 type HavingBuilder<TContract extends Contract<SqlStorage>, ModelName extends string, NsId extends string = never> = string extends AggregateOperationNames<TContract> ? AggregateOperationsUnavailable : { readonly [Op in AggregateOperationNames<TContract> & AggregateFn]: HavingMethod<TContract, ModelName, Op, NsId>; };
-type ShorthandWhereFilter<TContract extends Contract<SqlStorage>, NsId extends DomainNamespaceId<TContract>, ModelName extends string> = Partial<{ [K in keyof DefaultModelRow<TContract, ModelName, NsId> & string]: DefaultModelRow<TContract, ModelName, NsId>[K] | null | undefined; }>;
+type ShorthandWhereFilter<TContract extends Contract<SqlStorage>, NsId extends DomainNamespaceId<TContract>, ModelName extends string> = Partial<{ [K in keyof DefaultModelRow<TContract, ModelName, NsId> & string]: DefaultModelRow<TContract, ModelName, NsId>[K] | ('equality' extends FieldTraits<TContract, ModelName, K, NsId> ? Expression<{
+  codecId: FieldCodecId<TContract, ModelName, K, NsId>;
+  nullable: boolean;
+  many?: never;
+}> : never) | null | undefined; }>;
 type NamespaceModelsOf<TContract extends Contract<SqlStorage>, NsId extends string> = NsId extends keyof TContract['domain']['namespaces'] ? TContract['domain']['namespaces'][NsId]['models'] extends (infer M extends Record<string, unknown>) ? M : Record<string, never> : Record<string, never>;
 type ScannedModelDef<TContract extends Contract<SqlStorage>, ModelName extends string> = { [Ns in keyof TContract['domain']['namespaces']]: ModelName extends keyof TContract['domain']['namespaces'][Ns]['models'] ? TContract['domain']['namespaces'][Ns]['models'][ModelName] : never; }[keyof TContract['domain']['namespaces']];
 type ModelDef<TContract extends Contract<SqlStorage>, ModelName extends string, NsId extends string = never> = [NsId] extends [never] ? ScannedModelDef<TContract, ModelName> : ModelName extends keyof NamespaceModelsOf<TContract, NsId> ? NamespaceModelsOf<TContract, NsId>[ModelName] : never;
@@ -756,7 +777,8 @@ type IncludeRefinementValue<TContract extends Contract<SqlStorage>, ParentModelN
  * A refined to-one include is nullable whatever the relation's `nullable` flag
  * says: the refinement's filter can exclude the related row.
  */
-type RefinedIncludeRelationValue<TContract extends Contract<SqlStorage>, ParentModelName extends string, RelName extends string, IncludedRow, NsId extends string = never> = IsToManyRelation<TContract, ParentModelName, RelName, NsId> extends true ? IncludedRow[] : IncludedRow | null;
+type RefinedIncludeRelationValue<TContract extends Contract<SqlStorage>, ParentModelName extends string, RelName extends string, IncludedRow, NsId extends string = never> = RelationCardinality<TContract, ParentModelName, RelName, NsId> extends '1:1' | 'N:1' ? IncludedRow | null : IncludedRow[];
+type WhereInput<TContract extends Contract<SqlStorage>, NsId extends string, ModelName extends string, VariantName extends string | undefined = undefined> = ((model: VariantAwareModelAccessor<TContract, ModelName, VariantName, NsId>) => WhereArg) | ShorthandWhereFilter<TContract, NsId, ModelName>;
 //#endregion
 //#region src/grouped-collection.d.ts
 interface GroupedCollectionInit {
@@ -813,6 +835,14 @@ declare class GroupedCollection<TContract extends Contract<SqlStorage>, ModelNam
   aggregate<Spec extends AggregateSpec>(fn: (aggregate: AggregateBuilder<TContract, ModelName, NsId>) => Spec, configure?: (meta: MetaBuilder<'read'>) => void): Promise<Array<GroupedAggregateRow<TContract, ModelName, GroupFields, NsId, Spec>>>;
 }
 //#endregion
+//#region src/prepared-collection.d.ts
+interface PreparedCollection<TContract extends Contract<SqlStorage>, ModelName extends string, Row, State extends CollectionTypeState> {
+  all(configure?: (meta: MetaBuilder<'read'>) => void): Preparable<Record<string, unknown>, AsyncIterableResult<Row>>;
+  first(): Preparable<Record<string, unknown>, Promise<Row | null>>;
+  first(filter: undefined, configure: (meta: MetaBuilder<'read'>) => void): Preparable<Record<string, unknown>, Promise<Row | null>>;
+  first(filter: WhereInput<TContract, State['nsId'], ModelName, State['variantName']>, configure?: (meta: MetaBuilder<'read'>) => void): Preparable<Record<string, unknown>, Promise<Row | null>>;
+}
+//#endregion
 //#region src/collection.d.ts
 type WhereDirectInput = WhereArg;
 declare class CollectionImpl<TContract extends Contract<SqlStorage>, ModelName extends string, Row = SimplifyDeep<InferRootRow<TContract, ModelName>>, State extends CollectionTypeState = DefaultCollectionTypeState> implements RowSelection<Row> {
@@ -828,7 +858,7 @@ declare class CollectionImpl<TContract extends Contract<SqlStorage>, ModelName e
   /** @internal */
   readonly tableName: string;
   /** @internal */
-  readonly namespaceId: string;
+  readonly namespaceId: State['nsId'];
   /** @internal */
   readonly state: CollectionState;
   /** @internal */
@@ -1036,7 +1066,7 @@ declare class CollectionImpl<TContract extends Contract<SqlStorage>, ModelName e
    * const firstTen = await db.orm.User.orderBy((u) => u.id.asc()).limit(10).all();
    * ```
    */
-  limit(n: number): Collection<TContract, ModelName, Row, State>;
+  limit(n: number | TraitExpression<readonly ['numeric'], false, ExtractCodecTypes<TContract>>): Collection<TContract, ModelName, Row, State>;
   /**
    * Apply `OFFSET n`. Replaces any previous offset set on this collection.
    *
@@ -1048,7 +1078,7 @@ declare class CollectionImpl<TContract extends Contract<SqlStorage>, ModelName e
    *   .all();
    * ```
    */
-  offset(n: number): Collection<TContract, ModelName, Row, State>;
+  offset(n: number | TraitExpression<readonly ['numeric'], false, ExtractCodecTypes<TContract>>): Collection<TContract, ModelName, Row, State>;
   /**
    * Read terminal: execute the query and stream every matching row.
    *
@@ -1085,6 +1115,7 @@ declare class CollectionImpl<TContract extends Contract<SqlStorage>, ModelName e
    * ```
    */
   all(configure?: (meta: MetaBuilder<'read'>) => void): AsyncIterableResult<Row>;
+  get prepared(): PreparedCollection<TContract, ModelName, Row, State>;
   /**
    * Read terminal: return the first matching row, or `null` if none
    * match. Optionally accepts a filter (callback or shorthand object)
@@ -1111,8 +1142,7 @@ declare class CollectionImpl<TContract extends Contract<SqlStorage>, ModelName e
    */
   first(): Promise<Row | null>;
   first(filter: undefined, configure: (meta: MetaBuilder<'read'>) => void): Promise<Row | null>;
-  first(filter: (model: VariantAwareModelAccessor<TContract, ModelName, State['variantName'], State['nsId']>) => WhereArg, configure?: (meta: MetaBuilder<'read'>) => void): Promise<Row | null>;
-  first(filter: ShorthandWhereFilter<TContract, State['nsId'], ModelName>, configure?: (meta: MetaBuilder<'read'>) => void): Promise<Row | null>;
+  first(filter: WhereInput<TContract, State['nsId'], ModelName, State['variantName']>, configure?: (meta: MetaBuilder<'read'>) => void): Promise<Row | null>;
   /**
    * Read terminal: run an aggregate query (count, sum, avg, min, max)
    * built via the `AggregateBuilder` callback. Returns one object
@@ -1446,5 +1476,13 @@ type NamespacedClientMap<TContract extends Contract<SqlStorage>, Collections ext
 type OrmClient<TContract extends Contract<SqlStorage>, Collections extends Partial<Record<string, AnyCollectionClass>>> = NamespacedClientMap<TContract, Collections>;
 declare function orm<TContract extends Contract<SqlStorage>, Collections extends Partial<Record<string, AnyCollectionClass>> = Record<never, never>>(options: OrmOptions<TContract, Collections>): OrmClient<TContract, Collections>;
 //#endregion
-export { type AggregateBuilder, type AggregateResult, type AggregateSpec, Collection, type CollectionContext, type CollectionModelName, type CollectionState, type CollectionTypeState, type ComparisonMethods, type CreateInput, type DefaultCollectionTypeState, type DefaultModelRow, GroupedCollection, type IncludeExpr, type ModelAccessor, type NumericFieldNames, type OrmOptions, type RelatedModelName, type RelationFilterAccessor, type RelationMutator, type RelationNames, type RelationPredicate, type RelationPredicateInput, type RelationsOf, type RuntimeQueryable, type ShorthandWhereFilter, type UniqueConstraintCriterion, all, and, createModelAccessor, emptyState, not, or, orm };
+//#region src/prepared-row-query.d.ts
+interface PreparedRowQuery<Params, Result> {
+  query(target: RuntimeQueryable$1, params: Params, options?: RuntimeExecuteOptions): Result;
+}
+type PreparedFrom<Params, Q extends SqlQueryPlan | Preparable<unknown, unknown>> = Q extends Preparable<unknown, infer Result> ? PreparedRowQuery<Params, Result> : PreparedFor<Params, ResultType<Q>>;
+declare function prepareQuery<D extends Declaration<CT>, Q extends SqlQueryPlan | Preparable<unknown, unknown>, CT extends CodecTypesBase>(runtime: Runtime, declaration: D, callback: (params: BindSiteParams<D>) => Q): Promise<PreparedFrom<ParamsFromDeclaration<D, CT>, Q>>;
+declare function createPreparedRowQuery<Params, DbRow, Result>(description: Preparable<DbRow, Result>, statement: PreparedStatement<Params, DbRow>): PreparedRowQuery<Params, Result>;
+//#endregion
+export { type AggregateBuilder, type AggregateResult, type AggregateSpec, Collection, type CollectionContext, type CollectionModelName, type CollectionState, type CollectionTypeState, type ComparisonMethods, type CreateInput, type DefaultCollectionTypeState, type DefaultModelRow, GroupedCollection, type IncludeExpr, type ModelAccessor, type NumericFieldNames, type OrmOptions, type PreparedCollection, type PreparedFrom, type PreparedRowQuery, type RelatedModelName, type RelationFilterAccessor, type RelationMutator, type RelationNames, type RelationPredicate, type RelationPredicateInput, type RelationsOf, type RuntimeQueryable, type ShorthandWhereFilter, type UniqueConstraintCriterion, all, and, createModelAccessor, createPreparedRowQuery, emptyState, not, or, orm, prepareQuery };
 //# sourceMappingURL=orm-client.d.mts.map