@prisma-idb/adapter-idb 0.12.0 → 0.13.0

package/README.md

@@ -10,6 +10,12 @@ npm install --save-dev @prisma-idb/adapter-idb
 
 Part of [Prisma 8 IDB](https://prisma-idb.dev/docs/prisma-8), a typed IndexedDB client for Prisma 8. Start with the [Quick Start](https://prisma-idb.dev/docs/prisma-8/getting-started). For how the packages fit together, see [ARCHITECTURE.md](https://github.com/prisma-idb/prisma-idb/blob/main/packages/prisma-orm/docs/ARCHITECTURE.md).
 
+## Lowered query identity
+
+The adapter preserves the driver operation and adds `queryIdentity` when the query AST provides a serializable filter or sort specification. The identities are canonical strings. Sort identity preserves field priority as well as direction. The driver ignores this metadata; middleware uses it for cache identity.
+
+An AST supplied by a custom query builder must describe the plan's filter and comparator closures, including those in range-split child scans. Missing or unsupported structured values leave the corresponding closure opaque. The runtime then prevents cache reuse for that closure. Middleware receives the lowered plan, rather than the original `ast`.
+
 ## License
 
 MIT

package/dist/runtime.d.mts

@@ -1,7 +1,7 @@
 import { RuntimeAdapterDescriptor, RuntimeAdapterInstance } from "@prisma/orm-framework/components/execution";
 import { CodecCallContext, CodecLookup } from "@prisma/orm-framework/components/codec";
-import { IdbPlanBody } from "@prisma-idb/driver-idb/runtime";
 import { QueryPlan } from "@prisma/orm-framework/components/runtime";
+import { IdbPlanBody } from "@prisma-idb/driver-idb/runtime";
 //#region src/core/idb-filter-expr.d.ts
 /**
  * Filter expression AST for IDB queries.
@@ -40,15 +40,16 @@ interface IdbNotExpr {
   readonly expr: IdbFilterExpr;
 }
 /**
- * Null check. Distinct from `eq null` because IDB serialises absent
- * fields as `undefined`; a null check treats `null` and `undefined`
- * as equivalent (matching the shorthand `where({ field: null })`).
+ * Explicit null check. Like `eq(null)` and `neq(null)`, it treats null
+ * and absent fields as equivalent and always returns true or false.
+ * Other nullable comparisons can be unknown until the full filter is evaluated.
  */
 interface IdbNullCheckExpr {
   readonly kind: "null-check";
   readonly field: string;
   readonly isNull: boolean;
 }
+/** A field predicate, logical combination, or null check in the IDB filter AST. */
 type IdbFilterExpr = IdbFieldFilter | IdbAndExpr | IdbOrExpr | IdbNotExpr | IdbNullCheckExpr;
 /** Build a frozen field-filter node. */
 declare const fieldFilter: (field: string, op: IdbFilterOp, value: unknown) => IdbFieldFilter;
@@ -216,11 +217,11 @@ declare const __idbQueryPlanRow: unique symbol;
  * adds the IDB execution plan as `idbPlan`. Because IDB has no query language
  * of its own, the plan already carries the execution-ready {@link IdbPlanBody}
  * — there is no AST compilation step as in SQL. The adapter's `lower()` step
- * passes that body through to the driver unchanged.
+ * preserves that body and adds semantic identities for structured row closures.
  *
  * The optional `ast` field carries a lightweight {@link IdbQueryAst} describing
  * the query intent. It is populated by the ORM lane (`client-idb`) so middleware
- * can inspect query structure without parsing opaque plan bodies. This mirrors
+ * can derive cache identity without inspecting closure source code. This mirrors
  * the upstream pattern where {@link SqlQueryPlan} carries an `ast: AnyQueryAst`.
  *
  * @template Row - The TypeScript row shape inferred from the lane builder.
@@ -233,13 +234,29 @@ interface IdbQueryPlan<Row = unknown> extends QueryPlan<Row> {
   /**
    * Optional lightweight AST describing the query intent.
    *
-   * Available to middleware via `plan.ast`. Absent for plans constructed
-   * outside the ORM lane (e.g. direct driver usage).
+   * The adapter uses this to populate `queryIdentity` on the lowered plan.
+   * Middleware receives that lowered plan, rather than this AST. Absent for
+   * plans constructed outside the ORM lane. The AST must describe the
+   * filter and comparator closures in `idbPlan`.
    */
   readonly ast?: IdbQueryAst;
   /** Phantom row brand — matches the `_row` slot on the base QueryPlan. */
   readonly [__idbQueryPlanRow]?: Row;
 }
+/**
+ * Execution-ready plan with canonical identities for structured row closures.
+ *
+ * The driver ignores this metadata. Middleware can use it to distinguish
+ * captured filter values and comparator field priority and directions.
+ * For range-split batches, the identity also describes each child scan's
+ * closures. Missing identities mean those closures must be treated as opaque.
+ */
+type IdbLoweredPlan = IdbPlanBody & {
+  readonly queryIdentity?: {
+    readonly filter?: string;
+    readonly comparator?: string;
+  };
+};
 //#endregion
 //#region src/core/runtime-adapter-instance.d.ts
 /**
@@ -260,7 +277,7 @@ interface IdbLowererContext<TContract = unknown> extends CodecCallContext {
  *
  * Extends the generic `RuntimeAdapterInstance` marker with the IDB-specific
  * `lower()` method. `lower()` is the core of the adapter: it translates an
- * {@link IdbQueryPlan} (IDB execution plan + meta) into an {@link IdbPlanBody}
+ * {@link IdbQueryPlan} (IDB execution plan + meta) into an {@link IdbLoweredPlan}
  * (one of the strongly-typed IDB operation plans) that the driver can execute
  * directly against `window.indexedDB`.
  *
@@ -278,25 +295,34 @@ interface IdbRuntimeAdapterInstance extends RuntimeAdapterInstance<"idb", "idb">
    *   `AbortSignal` for cooperative cancellation.
    * @returns The IDB plan body describing the exact IDB operation(s) to run.
    */
-  lower(plan: IdbQueryPlan, ctx: IdbLowererContext): Promise<IdbPlanBody>;
+  lower(plan: IdbQueryPlan, ctx: IdbLowererContext): Promise<IdbLoweredPlan>;
 }
 //#endregion
 //#region src/core/filter-eval.d.ts
-/** Evaluate an AST node against a single row. Returns `true` to keep the row. */
-declare function evaluateFilter(expr: IdbFilterExpr, row: Record<string, unknown>): boolean;
+/** Codec metadata determines which string fields have numeric Decimal semantics. */
+type FilterFieldMetadata = Readonly<Record<string, {
+  readonly codecId?: string | undefined;
+  readonly collection?: boolean;
+}>>;
+/** Reject invalid Decimal operands even when no stored row reaches the evaluator. */
+declare function assertValidDecimalFilter(expr: IdbFilterExpr, fields: FilterFieldMetadata): void;
+/** Evaluate an AST node against a single row. Only SQL TRUE keeps the row. */
+declare function evaluateFilter(expr: IdbFilterExpr, row: Record<string, unknown>, fields?: FilterFieldMetadata): boolean;
 //#endregion
 //#region src/core/idb-adapter.d.ts
 /**
  * Concrete IDB runtime adapter.
  *
  * Implements {@link IdbRuntimeAdapterInstance} — the `lower()` method that
- * translates an {@link IdbQueryPlan} into an {@link IdbPlanBody} ready for
+ * translates an {@link IdbQueryPlan} into an {@link IdbLoweredPlan} ready for
  * the driver.
  *
- * `lower()` is a structural passthrough: the `idbPlan` carried by
+ * `lower()` preserves the driver operation: the `idbPlan` carried by
  * `IdbQueryPlan` is already execution-ready because IDB has no query
  * language to compile from. Every current `idb/*` codec is an identity
- * transform for stored values, so no field needs encoding.
+ * transform for stored values, so no field needs encoding. Structured AST
+ * filters and sort specifications become canonical closure identities for
+ * middleware; the driver remains independent of the query layer.
  *
  * The `codecs` constructor parameter matches the framework adapter shape and
  * is the extension point for field encoding with non-identity codecs.
@@ -306,11 +332,12 @@ declare class IdbAdapter implements IdbRuntimeAdapterInstance {
   readonly familyId: "idb";
   readonly targetId: "idb";
   constructor(codecs: CodecLookup);
-  lower(plan: IdbQueryPlan, ctx: IdbLowererContext): Promise<IdbPlanBody>;
+  /** Preserve the driver operation and carry structured closure identity through lowering. */
+  lower(plan: IdbQueryPlan, ctx: IdbLowererContext): Promise<IdbLoweredPlan>;
 }
 //#endregion
 //#region src/exports/runtime.d.ts
 declare const idbRuntimeAdapterDescriptor: RuntimeAdapterDescriptor<"idb", "idb", IdbRuntimeAdapterInstance>;
 //#endregion
-export { IdbAdapter, type IdbAggregateAst, type IdbAggregateRequest, type IdbAndExpr, type IdbCountAst, type IdbCreateAllAst, type IdbCreateAst, type IdbCreateCountAst, type IdbDeleteAllAst, type IdbDeleteAst, type IdbDeleteCountAst, type IdbFieldFilter, type IdbFilterExpr, type IdbFilterOp, type IdbFindManyAst, type IdbFindUniqueAst, type IdbGroupByAst, type IdbLowererContext, type IdbNotExpr, type IdbNullCheckExpr, type IdbOrExpr, type IdbQueryAst, type IdbQueryPlan, type IdbRuntimeAdapterInstance, type IdbUpdateAllAst, type IdbUpdateAst, type IdbUpdateCountAst, andExpr, idbRuntimeAdapterDescriptor as default, evaluateFilter, fieldFilter, notExpr, nullCheckExpr, orExpr, shorthandToFilterExpr };
+export { IdbAdapter, type IdbAggregateAst, type IdbAggregateRequest, type IdbAndExpr, type IdbCountAst, type IdbCreateAllAst, type IdbCreateAst, type IdbCreateCountAst, type IdbDeleteAllAst, type IdbDeleteAst, type IdbDeleteCountAst, type IdbFieldFilter, type IdbFilterExpr, type IdbFilterOp, type IdbFindManyAst, type IdbFindUniqueAst, type IdbGroupByAst, type IdbLoweredPlan, type IdbLowererContext, type IdbNotExpr, type IdbNullCheckExpr, type IdbOrExpr, type IdbQueryAst, type IdbQueryPlan, type IdbRuntimeAdapterInstance, type IdbUpdateAllAst, type IdbUpdateAst, type IdbUpdateCountAst, andExpr, assertValidDecimalFilter, idbRuntimeAdapterDescriptor as default, evaluateFilter, fieldFilter, notExpr, nullCheckExpr, orExpr, shorthandToFilterExpr };
 //# sourceMappingURL=runtime.d.mts.map

package/dist/runtime.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"runtime.d.mts","names":[],"sources":["../src/core/idb-filter-expr.ts","../src/core/idb-query-ast.ts","../src/core/idb-query-plan.ts","../src/core/runtime-adapter-instance.ts","../src/core/filter-eval.ts","../src/core/idb-adapter.ts","../src/exports/runtime.ts"],"mappings":";;;;;;;;;;;;;;;;;;KAcY;;UAIK;WACN;WACA;WACA,IAAI;WACJ;;;UAIM;WACN;WACA,OAAO,cAAc;;;UAIf;WACN;WACA,OAAO,cAAc;;;UAIf;WACN;WACA,MAAM;;;;;;;UAQA;WACN;WACA;WACA;;KAGC,gBAAgB,iBAAiB,aAAa,YAAY,aAAa;;cAKtE,cAAe,eAAe,IAAI,aAAa,mBAAiB;;cAIhE,UAAW,OAAO,cAAc,mBAAiB;;cAIjD,SAAU,OAAO,cAAc,mBAAiB;;cAIhD,UAAW,MAAM,kBAAgB;;cAGjC,gBAAiB,eAAe,oBAAkB;;;;;;;;;;;iBAe/C,sBAAsB,SAAS,0BAA0B;;;;;;;;;;KCnE7D,cACR,iBACA,mBACA,eACA,eACA,eACA,kBACA,oBACA,kBACA,oBACA,kBACA,oBACA,cACA,kBACA;;UAGa;WACN;;WAEA;;WAEA,QAAQ;;WAER,UAAU;;WAEV;;WAEA;;;UAIM;WACN;;WAEA;;WAEA;;;UAIM;WACN;;WAEA;;WAEA,MAAM;;;UAIA;WACN;;WAEA;;WAEA;;;UAIM;WACN;WACA;WACA,OAAO;WACP,QAAQ;;;UAIF;WACN;WACA;WACA,OAAO;WACP,QAAQ;;;UAIF;WACN;WACA;WACA,OAAO;WACP,QAAQ;;;UAIF;WACN;WACA;WACA,MAAM;;;UAIA;WACN;WACA;WACA,MAAM;;;UAIA;WACN;WACA;WACA,QAAQ;;;UAIF;WACN;WACA;WACA,QAAQ;;;UAIF;WACN;WACA;WACA,QAAQ;;;UAIF;;WAEN;;WAEA;;;;;;;;;UAUM;WACN;WACA;WACA,QAAQ;;WAER,YAAY,SAAS,eAAe;;;;;;;;UAS9B;WACN;WACA;WACA,QAAQ;;WAER;;WAEA,YAAY,SAAS,eAAe;;;;cC1KjC;;;;;;;;;;;;;;;;;;;UAoBG,aAAa,uBAAuB,UAAU;;WAEpD,SAAS;;;;;;;WAOT,MAAM;;YAEL,qBAAqB;;;;;;;;;;;;;UCtBhB,kBAAkB,6BAA6B;;WAErD,UAAU;;;;;;;;;;;;;;;UAgBJ,kCAAkC;;;;;;;;;;EAUjD,MAAM,MAAM,cAAc,KAAK,oBAAoB,QAAQ;;;;;iBCvB7C,eAAe,MAAM,eAAe,KAAK;;;;;;;;;;;;;;;;;;cCC5C,sBAAsB;;WACxB;WACA;EAIG,YAAA,QAAQ;EAIpB,MAAM,MAAM,cAAc,KAAK,oBAAoB,QAAQ;;;;cCSvD,6BAA6B,uCAAuC"}
+{"version":3,"file":"runtime.d.mts","names":[],"sources":["../src/core/idb-filter-expr.ts","../src/core/idb-query-ast.ts","../src/core/idb-query-plan.ts","../src/core/runtime-adapter-instance.ts","../src/core/filter-eval.ts","../src/core/idb-adapter.ts","../src/exports/runtime.ts"],"mappings":";;;;;;;;;;;;;;;;;;KAcY;;UAIK;WACN;WACA;WACA,IAAI;WACJ;;;UAIM;WACN;WACA,OAAO,cAAc;;;UAIf;WACN;WACA,OAAO,cAAc;;;UAIf;WACN;WACA,MAAM;;;;;;;UAQA;WACN;WACA;WACA;;;KAIC,gBAAgB,iBAAiB,aAAa,YAAY,aAAa;;cAKtE,cAAe,eAAe,IAAI,aAAa,mBAAiB;;cAIhE,UAAW,OAAO,cAAc,mBAAiB;;cAIjD,SAAU,OAAO,cAAc,mBAAiB;;cAIhD,UAAW,MAAM,kBAAgB;;cAGjC,gBAAiB,eAAe,oBAAkB;;;;;;;;;;;iBAe/C,sBAAsB,SAAS,0BAA0B;;;;;;;;;;KCpE7D,cACR,iBACA,mBACA,eACA,eACA,eACA,kBACA,oBACA,kBACA,oBACA,kBACA,oBACA,cACA,kBACA;;UAGa;WACN;;WAEA;;WAEA,QAAQ;;WAER,UAAU;;WAEV;;WAEA;;;UAIM;WACN;;WAEA;;WAEA;;;UAIM;WACN;;WAEA;;WAEA,MAAM;;;UAIA;WACN;;WAEA;;WAEA;;;UAIM;WACN;WACA;WACA,OAAO;WACP,QAAQ;;;UAIF;WACN;WACA;WACA,OAAO;WACP,QAAQ;;;UAIF;WACN;WACA;WACA,OAAO;WACP,QAAQ;;;UAIF;WACN;WACA;WACA,MAAM;;;UAIA;WACN;WACA;WACA,MAAM;;;UAIA;WACN;WACA;WACA,QAAQ;;;UAIF;WACN;WACA;WACA,QAAQ;;;UAIF;WACN;WACA;WACA,QAAQ;;;UAIF;;WAEN;;WAEA;;;;;;;;;UAUM;WACN;WACA;WACA,QAAQ;;WAER,YAAY,SAAS,eAAe;;;;;;;;UAS9B;WACN;WACA;WACA,QAAQ;;WAER;;WAEA,YAAY,SAAS,eAAe;;;;cC1KjC;;;;;;;;;;;;;;;;;;;UAoBG,aAAa,uBAAuB,UAAU;;WAEpD,SAAS;;;;;;;;;WAST,MAAM;;YAEL,qBAAqB;;;;;;;;;;KAWrB,iBAAiB;WAClB;aACE;aACA;;;;;;;;;;;;;;UCvCI,kBAAkB,6BAA6B;;WAErD,UAAU;;;;;;;;;;;;;;;UAgBJ,kCAAkC;;;;;;;;;;EAUjD,MAAM,MAAM,cAAc,KAAK,oBAAoB,QAAQ;;;;;KCjBjD,sBAAsB,SAChC;WAA0B;WAAuC;;;iBAInD,yBAAyB,MAAM,eAAe,QAAQ;;iBAwBtD,eACd,MAAM,eACN,KAAK,yBACL,SAAQ;;;;;;;;;;;;;;;;;;;;cClCG,sBAAsB;;WACxB;WACA;EAIG,YAAA,QAAQ;;EAKpB,MAAM,MAAM,cAAc,KAAK,oBAAoB,QAAQ;;;;cCMvD,6BAA6B,uCAAuC"}

package/dist/runtime.mjs

@@ -1,17 +1,20 @@
 import { t as idbAdapterDescriptorMeta } from "./descriptor-meta-Dxdc_q_O.mjs";
-import { compareFieldValues, fieldValuesEqual, idbCodecLookup } from "@prisma-idb/target-idb/runtime";
+import { compareDecimalValues, compareFieldValues, fieldValuesEqual, idbCodecLookup, isDecimalString } from "@prisma-idb/target-idb/runtime";
+import { canonicalStringify } from "@prisma/orm-framework/utils/canonical-stringify";
 //#region src/core/idb-adapter.ts
 /**
 * Concrete IDB runtime adapter.
 *
 * Implements {@link IdbRuntimeAdapterInstance} — the `lower()` method that
-* translates an {@link IdbQueryPlan} into an {@link IdbPlanBody} ready for
+* translates an {@link IdbQueryPlan} into an {@link IdbLoweredPlan} ready for
 * the driver.
 *
-* `lower()` is a structural passthrough: the `idbPlan` carried by
+* `lower()` preserves the driver operation: the `idbPlan` carried by
 * `IdbQueryPlan` is already execution-ready because IDB has no query
 * language to compile from. Every current `idb/*` codec is an identity
-* transform for stored values, so no field needs encoding.
+* transform for stored values, so no field needs encoding. Structured AST
+* filters and sort specifications become canonical closure identities for
+* middleware; the driver remains independent of the query layer.
 *
 * The `codecs` constructor parameter matches the framework adapter shape and
 * is the extension point for field encoding with non-identity codecs.
@@ -23,13 +26,34 @@ var IdbAdapter = class {
 	constructor(codecs) {
 		this.#codecs = codecs;
 	}
+	/** Preserve the driver operation and carry structured closure identity through lowering. */
 	lower(plan, ctx) {
 		this.#codecs;
 		ctx.contract;
 		ctx.signal;
-		return Promise.resolve(plan.idbPlan);
+		const ast = plan.ast;
+		if (ast === void 0) return Promise.resolve(plan.idbPlan);
+		const filter = "where" in ast ? closureIdentity(ast.where) : void 0;
+		const comparator = "orderBy" in ast && ast.orderBy !== void 0 ? closureIdentity(Object.entries(ast.orderBy)) : void 0;
+		if (filter === void 0 && comparator === void 0) return Promise.resolve(plan.idbPlan);
+		return Promise.resolve({
+			...plan.idbPlan,
+			queryIdentity: {
+				...filter === void 0 ? {} : { filter },
+				...comparator === void 0 ? {} : { comparator }
+			}
+		});
 	}
 };
+/** Leave unsupported structured values opaque so identity generation cannot break a query. */
+function closureIdentity(value) {
+	if (value === void 0) return void 0;
+	try {
+		return canonicalStringify(value);
+	} catch {
+		return;
+	}
+}
 //#endregion
 //#region src/core/idb-filter-expr.ts
 /** Build a frozen field-filter node. */
@@ -93,56 +117,97 @@ function shorthandToFilterExpr(filters) {
 * passes that to the driver. The driver therefore never imports the
 * adapter's AST types, and keeps no dependency on the adapter.
 *
-* Equality and ordering compare values the way IndexedDB compares keys, so
-* a filter gives the same answer whether it runs here or through an index
+* Decimal metadata selects exact numeric comparison. Other fields compare
+* values the way IndexedDB compares keys, so a filter agrees with an index
 * key range. Plain `===` would never match two equal `Date`s or byte arrays,
 * because values read back from IndexedDB are fresh objects. String
 * operations coerce both sides via `String(...)` so they work on numbers too.
 */
-/** Evaluate an AST node against a single row. Returns `true` to keep the row. */
-function evaluateFilter(expr, row) {
+/** Reject invalid Decimal operands even when no stored row reaches the evaluator. */
+function assertValidDecimalFilter(expr, fields) {
+	if (expr.kind === "and" || expr.kind === "or") expr.exprs.forEach((child) => assertValidDecimalFilter(child, fields));
+	else if (expr.kind === "not") assertValidDecimalFilter(expr.expr, fields);
+	else if (expr.kind === "field" && isDecimalField(fields, expr.field)) {
+		if (expr.op === "contains" || expr.op === "startsWith" || expr.op === "endsWith") return;
+		const values = expr.op === "in" || expr.op === "notIn" ? expr.value : [expr.value];
+		if (Array.isArray(values) && values.some((value) => isPresent(value) && !isDecimalString(value))) throw new TypeError(`Expected finite Decimal text for field "${expr.field}"`);
+	}
+}
+/** Identify scalar Decimal fields without reinterpreting string or collection values. */
+function isDecimalField(fields, field) {
+	return fields[field]?.codecId === "idb/decimal@1" && !fields[field]?.collection;
+}
+/** Evaluate an AST node against a single row. Only SQL TRUE keeps the row. */
+function evaluateFilter(expr, row, fields = {}) {
+	return evaluatePredicate(expr, row, fields) === true;
+}
+/** Preserve unknown through logical composition so negation cannot admit null comparisons. */
+function evaluatePredicate(expr, row, fields) {
 	switch (expr.kind) {
-		case "field": return evalFieldOp(expr.field, expr.op, expr.value, row);
-		case "and":
-			for (const e of expr.exprs) if (!evaluateFilter(e, row)) return false;
-			return true;
-		case "or":
-			if (expr.exprs.length === 0) return false;
-			for (const e of expr.exprs) if (evaluateFilter(e, row)) return true;
-			return false;
-		case "not": return !evaluateFilter(expr.expr, row);
+		case "field": return evalFieldOp(expr.field, expr.op, expr.value, row, fields);
+		case "and": {
+			let result = true;
+			for (const e of expr.exprs) {
+				const child = evaluatePredicate(e, row, fields);
+				if (child === false) return false;
+				if (child === null) result = null;
+			}
+			return result;
+		}
+		case "or": {
+			let result = false;
+			for (const e of expr.exprs) {
+				const child = evaluatePredicate(e, row, fields);
+				if (child === true) return true;
+				if (child === null) result = null;
+			}
+			return result;
+		}
+		case "not": {
+			const result = evaluatePredicate(expr.expr, row, fields);
+			return result === null ? null : !result;
+		}
 		case "null-check": {
-			const v = row[expr.field];
-			const isNullish = v === null || v === void 0;
+			const isNullish = !isPresent(row[expr.field]);
 			return expr.isNull ? isNullish : !isNullish;
 		}
 	}
 }
-function evalFieldOp(field, op, value, row) {
+/** Evaluate one field predicate with the same comparisons used by index-backed queries. */
+function evalFieldOp(field, op, value, row, fields) {
 	const cell = row[field];
+	if (value === null && (op === "eq" || op === "neq")) return op === "eq" ? !isPresent(cell) : isPresent(cell);
+	const decimal = isDecimalField(fields, field);
+	const compare = decimal ? compareDecimalValues : compareFieldValues;
+	const equal = decimal ? (a, b) => compareDecimalValues(a, b) === 0 : fieldValuesEqual;
+	if (op === "in" || op === "notIn") {
+		const result = evaluateMembership(cell, value, equal);
+		if (result === null) return null;
+		return op === "in" ? result : !result;
+	}
+	if (!isPresent(cell) || !isPresent(value)) return null;
 	switch (op) {
-		case "eq":
-			if (value === null) return cell === null || cell === void 0;
-			return fieldValuesEqual(cell, value);
-		case "neq":
-			if (value === null) return cell !== null && cell !== void 0;
-			return !fieldValuesEqual(cell, value);
-		case "gt": return isPresent(cell) && isPresent(value) && compareFieldValues(cell, value) > 0;
-		case "lt": return isPresent(cell) && isPresent(value) && compareFieldValues(cell, value) < 0;
-		case "gte": return isPresent(cell) && isPresent(value) && compareFieldValues(cell, value) >= 0;
-		case "lte": return isPresent(cell) && isPresent(value) && compareFieldValues(cell, value) <= 0;
-		case "in":
-			if (!Array.isArray(value)) return false;
-			return value.some((v) => fieldValuesEqual(cell, v));
-		case "notIn":
-			if (!Array.isArray(value)) return true;
-			return !value.some((v) => fieldValuesEqual(cell, v));
-		case "contains": return isPresent(cell) && String(cell).includes(String(value));
-		case "startsWith": return isPresent(cell) && String(cell).startsWith(String(value));
-		case "endsWith": return isPresent(cell) && String(cell).endsWith(String(value));
+		case "eq": return equal(cell, value);
+		case "neq": return !equal(cell, value);
+		case "gt": return compare(cell, value) > 0;
+		case "lt": return compare(cell, value) < 0;
+		case "gte": return compare(cell, value) >= 0;
+		case "lte": return compare(cell, value) <= 0;
+		case "contains": return String(cell).includes(String(value));
+		case "startsWith": return String(cell).startsWith(String(value));
+		case "endsWith": return String(cell).endsWith(String(value));
 		default: return false;
 	}
 }
+/** Match SQL IN: empty lists are false; otherwise null operands leave an unmatched result unknown. */
+function evaluateMembership(cell, values, equal) {
+	if (!Array.isArray(values) || values.length === 0) return false;
+	if (!isPresent(cell)) return null;
+	let result = false;
+	for (const value of values) if (!isPresent(value)) result = null;
+	else if (equal(cell, value)) return true;
+	return result;
+}
 function isPresent(value) {
 	return value !== null && value !== void 0;
 }
@@ -150,11 +215,12 @@ function isPresent(value) {
 //#region src/exports/runtime.ts
 const idbRuntimeAdapterDescriptor = {
 	...idbAdapterDescriptorMeta,
+	/** Build an adapter with the codec registry shared by the IDB runtime stack. */
 	create(_stack) {
 		return new IdbAdapter(idbCodecLookup);
 	}
 };
 //#endregion
-export { IdbAdapter, andExpr, idbRuntimeAdapterDescriptor as default, evaluateFilter, fieldFilter, notExpr, nullCheckExpr, orExpr, shorthandToFilterExpr };
+export { IdbAdapter, andExpr, assertValidDecimalFilter, idbRuntimeAdapterDescriptor as default, evaluateFilter, fieldFilter, notExpr, nullCheckExpr, orExpr, shorthandToFilterExpr };
 
 //# sourceMappingURL=runtime.mjs.map

package/dist/runtime.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"runtime.mjs","names":["#codecs"],"sources":["../src/core/idb-adapter.ts","../src/core/idb-filter-expr.ts","../src/core/filter-eval.ts","../src/exports/runtime.ts"],"sourcesContent":["import type { CodecLookup } from \"@prisma/orm-framework/components/codec\";\nimport type { IdbPlanBody } from \"@prisma-idb/driver-idb/runtime\";\nimport type { IdbQueryPlan } from \"./idb-query-plan\";\nimport type { IdbLowererContext, IdbRuntimeAdapterInstance } from \"./runtime-adapter-instance\";\n\n/**\n * Concrete IDB runtime adapter.\n *\n * Implements {@link IdbRuntimeAdapterInstance} — the `lower()` method that\n * translates an {@link IdbQueryPlan} into an {@link IdbPlanBody} ready for\n * the driver.\n *\n * `lower()` is a structural passthrough: the `idbPlan` carried by\n * `IdbQueryPlan` is already execution-ready because IDB has no query\n * language to compile from. Every current `idb/*` codec is an identity\n * transform for stored values, so no field needs encoding.\n *\n * The `codecs` constructor parameter matches the framework adapter shape and\n * is the extension point for field encoding with non-identity codecs.\n */\nexport class IdbAdapter implements IdbRuntimeAdapterInstance {\n  readonly familyId = \"idb\" as const;\n  readonly targetId = \"idb\" as const;\n\n  readonly #codecs: CodecLookup;\n\n  constructor(codecs: CodecLookup) {\n    this.#codecs = codecs;\n  }\n\n  lower(plan: IdbQueryPlan, ctx: IdbLowererContext): Promise<IdbPlanBody> {\n    // If a codec ever transforms stored values, encode plan.idbPlan's\n    // record and key fields here: resolve each field's codec through\n    // this.#codecs and ctx.contract, then call codec.encode(value, ctx).\n    void this.#codecs; // codec registry for per-field encoding\n    void ctx.contract; // contract storage schema (field→codec resolution)\n    void ctx.signal; // AbortSignal for cooperative cancellation\n    return Promise.resolve(plan.idbPlan);\n  }\n}\n","/**\n * Filter expression AST for IDB queries.\n *\n * Plain frozen objects (not classes) — IDB has no codec trait gating to\n * worry about and no visitor pattern needed (a recursive `evaluateFilter`\n * is plenty). Mirrors the design of Prisma ORM's Mongo family\n * (`MongoFieldFilter`, `MongoAndExpr`, ...) and the SQL ORM's `BinaryExpr`,\n * but with the class machinery stripped out.\n *\n * The AST is carried on `IdbQueryAst` (intent layer) and lowered into an\n * `IdbRowFilter` closure that the driver applies during cursor scans —\n * keeping the driver free of any AST imports.\n */\n\nexport type IdbFilterOp =\n  \"eq\" | \"neq\" | \"gt\" | \"lt\" | \"gte\" | \"lte\" | \"in\" | \"notIn\" | \"contains\" | \"startsWith\" | \"endsWith\";\n\n/** Comparison / membership predicate on a single field. */\nexport interface IdbFieldFilter {\n  readonly kind: \"field\";\n  readonly field: string;\n  readonly op: IdbFilterOp;\n  readonly value: unknown;\n}\n\n/** Conjunction. Empty `exprs` is truthy (vacuously true). */\nexport interface IdbAndExpr {\n  readonly kind: \"and\";\n  readonly exprs: ReadonlyArray<IdbFilterExpr>;\n}\n\n/** Disjunction. Empty `exprs` is falsy. */\nexport interface IdbOrExpr {\n  readonly kind: \"or\";\n  readonly exprs: ReadonlyArray<IdbFilterExpr>;\n}\n\n/** Logical NOT. */\nexport interface IdbNotExpr {\n  readonly kind: \"not\";\n  readonly expr: IdbFilterExpr;\n}\n\n/**\n * Null check. Distinct from `eq null` because IDB serialises absent\n * fields as `undefined`; a null check treats `null` and `undefined`\n * as equivalent (matching the shorthand `where({ field: null })`).\n */\nexport interface IdbNullCheckExpr {\n  readonly kind: \"null-check\";\n  readonly field: string;\n  readonly isNull: boolean;\n}\n\nexport type IdbFilterExpr = IdbFieldFilter | IdbAndExpr | IdbOrExpr | IdbNotExpr | IdbNullCheckExpr;\n\n// ── Factory helpers ───────────────────────────────────────────────────────────\n\n/** Build a frozen field-filter node. */\nexport const fieldFilter = (field: string, op: IdbFilterOp, value: unknown): IdbFieldFilter =>\n  Object.freeze({ kind: \"field\", field, op, value });\n\n/** Build a frozen AND combinator with a frozen `exprs` array. */\nexport const andExpr = (exprs: ReadonlyArray<IdbFilterExpr>): IdbAndExpr =>\n  Object.freeze({ kind: \"and\", exprs: Object.freeze([...exprs]) });\n\n/** Build a frozen OR combinator with a frozen `exprs` array. */\nexport const orExpr = (exprs: ReadonlyArray<IdbFilterExpr>): IdbOrExpr =>\n  Object.freeze({ kind: \"or\", exprs: Object.freeze([...exprs]) });\n\n/** Build a frozen NOT combinator. */\nexport const notExpr = (expr: IdbFilterExpr): IdbNotExpr => Object.freeze({ kind: \"not\", expr });\n\n/** Build a frozen null-check node. */\nexport const nullCheckExpr = (field: string, isNull: boolean): IdbNullCheckExpr =>\n  Object.freeze({ kind: \"null-check\", field, isNull });\n\n// ── Shorthand → expression ────────────────────────────────────────────────────\n\n/**\n * Convert a shorthand equality object (e.g. `{ active: true, email: \"x\" }`)\n * into the canonical AST form. `undefined` entries are dropped; `null`\n * values become null-checks rather than literal-null equalities (IDB\n * stores absent fields as `undefined`, so a literal-null equality misses).\n *\n * Returns `undefined` when the input has no usable entries — callers can\n * skip filter installation in that case rather than testing an empty\n * AND node every row.\n */\nexport function shorthandToFilterExpr(filters: Record<string, unknown>): IdbFilterExpr | undefined {\n  const exprs: IdbFilterExpr[] = [];\n  for (const [field, value] of Object.entries(filters)) {\n    if (value === undefined) continue;\n    if (value === null) {\n      exprs.push(nullCheckExpr(field, true));\n      continue;\n    }\n    exprs.push(fieldFilter(field, \"eq\", value));\n  }\n  if (exprs.length === 0) return undefined;\n  return exprs.length === 1 ? exprs[0]! : andExpr(exprs);\n}\n","/**\n * Pure-JS evaluator for {@link IdbFilterExpr}.\n *\n * The driver's `IdbRowFilter` type stays as `(row) => boolean` — the\n * accessor builds a closure that calls `evaluateFilter(expr, row)` and\n * passes that to the driver. The driver therefore never imports the\n * adapter's AST types, and keeps no dependency on the adapter.\n *\n * Equality and ordering compare values the way IndexedDB compares keys, so\n * a filter gives the same answer whether it runs here or through an index\n * key range. Plain `===` would never match two equal `Date`s or byte arrays,\n * because values read back from IndexedDB are fresh objects. String\n * operations coerce both sides via `String(...)` so they work on numbers too.\n */\n\nimport { compareFieldValues, fieldValuesEqual } from \"@prisma-idb/target-idb/runtime\";\nimport type { IdbFilterExpr, IdbFilterOp } from \"./idb-filter-expr\";\n\n/** Evaluate an AST node against a single row. Returns `true` to keep the row. */\nexport function evaluateFilter(expr: IdbFilterExpr, row: Record<string, unknown>): boolean {\n  switch (expr.kind) {\n    case \"field\":\n      return evalFieldOp(expr.field, expr.op, expr.value, row);\n    case \"and\": {\n      for (const e of expr.exprs) {\n        if (!evaluateFilter(e, row)) return false;\n      }\n      return true;\n    }\n    case \"or\": {\n      if (expr.exprs.length === 0) return false;\n      for (const e of expr.exprs) {\n        if (evaluateFilter(e, row)) return true;\n      }\n      return false;\n    }\n    case \"not\":\n      return !evaluateFilter(expr.expr, row);\n    case \"null-check\": {\n      const v = row[expr.field];\n      const isNullish = v === null || v === undefined;\n      return expr.isNull ? isNullish : !isNullish;\n    }\n  }\n}\n\nfunction evalFieldOp(field: string, op: IdbFilterOp, value: unknown, row: Record<string, unknown>): boolean {\n  const cell = row[field];\n  switch (op) {\n    case \"eq\":\n      // `eq` treats null and undefined as equivalent so the shorthand path\n      // (`{ field: someValue }`) keeps working when stored rows omit the\n      // field. Literal-null equality goes through `null-check` instead.\n      if (value === null) return cell === null || cell === undefined;\n      return fieldValuesEqual(cell, value);\n    case \"neq\":\n      if (value === null) return cell !== null && cell !== undefined;\n      return !fieldValuesEqual(cell, value);\n    case \"gt\":\n      return isPresent(cell) && isPresent(value) && compareFieldValues(cell, value) > 0;\n    case \"lt\":\n      return isPresent(cell) && isPresent(value) && compareFieldValues(cell, value) < 0;\n    case \"gte\":\n      return isPresent(cell) && isPresent(value) && compareFieldValues(cell, value) >= 0;\n    case \"lte\":\n      return isPresent(cell) && isPresent(value) && compareFieldValues(cell, value) <= 0;\n    case \"in\": {\n      if (!Array.isArray(value)) return false;\n      return value.some((v) => fieldValuesEqual(cell, v));\n    }\n    case \"notIn\": {\n      if (!Array.isArray(value)) return true;\n      return !value.some((v) => fieldValuesEqual(cell, v));\n    }\n    case \"contains\":\n      return isPresent(cell) && String(cell).includes(String(value));\n    case \"startsWith\":\n      return isPresent(cell) && String(cell).startsWith(String(value));\n    case \"endsWith\":\n      return isPresent(cell) && String(cell).endsWith(String(value));\n    default:\n      return false;\n  }\n}\n\nfunction isPresent(value: unknown): boolean {\n  return value !== null && value !== undefined;\n}\n","import type { RuntimeAdapterDescriptor, ExecutionStack } from \"@prisma/orm-framework/components/execution\";\nimport { idbCodecLookup } from \"@prisma-idb/target-idb/runtime\";\nimport { idbAdapterDescriptorMeta } from \"../core/descriptor-meta\";\nimport { IdbAdapter } from \"../core/idb-adapter\";\nimport type { IdbRuntimeAdapterInstance } from \"../core/runtime-adapter-instance\";\n\nexport type { IdbRuntimeAdapterInstance, IdbLowererContext } from \"../core/runtime-adapter-instance\";\nexport type { IdbQueryPlan } from \"../core/idb-query-plan\";\nexport type {\n  IdbQueryAst,\n  IdbFindManyAst,\n  IdbFindUniqueAst,\n  IdbCreateAst,\n  IdbDeleteAst,\n  IdbUpdateAst,\n  IdbUpdateAllAst,\n  IdbUpdateCountAst,\n  IdbCreateAllAst,\n  IdbCreateCountAst,\n  IdbDeleteAllAst,\n  IdbDeleteCountAst,\n  IdbCountAst,\n  IdbAggregateAst,\n  IdbGroupByAst,\n  IdbAggregateRequest,\n} from \"../core/idb-query-ast\";\nexport type {\n  IdbFilterExpr,\n  IdbFieldFilter,\n  IdbAndExpr,\n  IdbOrExpr,\n  IdbNotExpr,\n  IdbNullCheckExpr,\n  IdbFilterOp,\n} from \"../core/idb-filter-expr\";\nexport { fieldFilter, andExpr, orExpr, notExpr, nullCheckExpr, shorthandToFilterExpr } from \"../core/idb-filter-expr\";\nexport { evaluateFilter } from \"../core/filter-eval\";\nexport { IdbAdapter } from \"../core/idb-adapter\";\n\nconst idbRuntimeAdapterDescriptor: RuntimeAdapterDescriptor<\"idb\", \"idb\", IdbRuntimeAdapterInstance> = {\n  ...idbAdapterDescriptorMeta,\n  create(_stack: ExecutionStack<\"idb\", \"idb\">): IdbRuntimeAdapterInstance {\n    // Construct the adapter with the real IDB codec lookup so per-field\n    // encoding works when non-identity codecs are added. The current set\n    // is all-identity, so output behavior is unchanged; this wiring makes\n    // the descriptor-built adapter match the hand-constructed one in\n    // `createIdbClient`.\n    return new IdbAdapter(idbCodecLookup);\n  },\n};\n\nexport default idbRuntimeAdapterDescriptor;\n"],"mappings":";;;;;;;;;;;;;;;;;;AAoBA,IAAa,aAAb,MAA6D;CAC3D,WAAoB;CACpB,WAAoB;CAEpB;CAEA,YAAY,QAAqB;EAC/B,KAAKA,UAAU;CACjB;CAEA,MAAM,MAAoB,KAA8C;EAItE,KAAUA;EACV,IAAS;EACT,IAAS;EACT,OAAO,QAAQ,QAAQ,KAAK,OAAO;CACrC;AACF;;;;ACoBA,MAAa,eAAe,OAAe,IAAiB,UAC1D,OAAO,OAAO;CAAE,MAAM;CAAS;CAAO;CAAI;AAAM,CAAC;;AAGnD,MAAa,WAAW,UACtB,OAAO,OAAO;CAAE,MAAM;CAAO,OAAO,OAAO,OAAO,CAAC,GAAG,KAAK,CAAC;AAAE,CAAC;;AAGjE,MAAa,UAAU,UACrB,OAAO,OAAO;CAAE,MAAM;CAAM,OAAO,OAAO,OAAO,CAAC,GAAG,KAAK,CAAC;AAAE,CAAC;;AAGhE,MAAa,WAAW,SAAoC,OAAO,OAAO;CAAE,MAAM;CAAO;AAAK,CAAC;;AAG/F,MAAa,iBAAiB,OAAe,WAC3C,OAAO,OAAO;CAAE,MAAM;CAAc;CAAO;AAAO,CAAC;;;;;;;;;;;AAcrD,SAAgB,sBAAsB,SAA6D;CACjG,MAAM,QAAyB,CAAC;CAChC,KAAK,MAAM,CAAC,OAAO,UAAU,OAAO,QAAQ,OAAO,GAAG;EACpD,IAAI,UAAU,KAAA,GAAW;EACzB,IAAI,UAAU,MAAM;GAClB,MAAM,KAAK,cAAc,OAAO,IAAI,CAAC;GACrC;EACF;EACA,MAAM,KAAK,YAAY,OAAO,MAAM,KAAK,CAAC;CAC5C;CACA,IAAI,MAAM,WAAW,GAAG,OAAO,KAAA;CAC/B,OAAO,MAAM,WAAW,IAAI,MAAM,KAAM,QAAQ,KAAK;AACvD;;;;;;;;;;;;;;;;;;AClFA,SAAgB,eAAe,MAAqB,KAAuC;CACzF,QAAQ,KAAK,MAAb;EACE,KAAK,SACH,OAAO,YAAY,KAAK,OAAO,KAAK,IAAI,KAAK,OAAO,GAAG;EACzD,KAAK;GACH,KAAK,MAAM,KAAK,KAAK,OACnB,IAAI,CAAC,eAAe,GAAG,GAAG,GAAG,OAAO;GAEtC,OAAO;EAET,KAAK;GACH,IAAI,KAAK,MAAM,WAAW,GAAG,OAAO;GACpC,KAAK,MAAM,KAAK,KAAK,OACnB,IAAI,eAAe,GAAG,GAAG,GAAG,OAAO;GAErC,OAAO;EAET,KAAK,OACH,OAAO,CAAC,eAAe,KAAK,MAAM,GAAG;EACvC,KAAK,cAAc;GACjB,MAAM,IAAI,IAAI,KAAK;GACnB,MAAM,YAAY,MAAM,QAAQ,MAAM,KAAA;GACtC,OAAO,KAAK,SAAS,YAAY,CAAC;EACpC;CACF;AACF;AAEA,SAAS,YAAY,OAAe,IAAiB,OAAgB,KAAuC;CAC1G,MAAM,OAAO,IAAI;CACjB,QAAQ,IAAR;EACE,KAAK;GAIH,IAAI,UAAU,MAAM,OAAO,SAAS,QAAQ,SAAS,KAAA;GACrD,OAAO,iBAAiB,MAAM,KAAK;EACrC,KAAK;GACH,IAAI,UAAU,MAAM,OAAO,SAAS,QAAQ,SAAS,KAAA;GACrD,OAAO,CAAC,iBAAiB,MAAM,KAAK;EACtC,KAAK,MACH,OAAO,UAAU,IAAI,KAAK,UAAU,KAAK,KAAK,mBAAmB,MAAM,KAAK,IAAI;EAClF,KAAK,MACH,OAAO,UAAU,IAAI,KAAK,UAAU,KAAK,KAAK,mBAAmB,MAAM,KAAK,IAAI;EAClF,KAAK,OACH,OAAO,UAAU,IAAI,KAAK,UAAU,KAAK,KAAK,mBAAmB,MAAM,KAAK,KAAK;EACnF,KAAK,OACH,OAAO,UAAU,IAAI,KAAK,UAAU,KAAK,KAAK,mBAAmB,MAAM,KAAK,KAAK;EACnF,KAAK;GACH,IAAI,CAAC,MAAM,QAAQ,KAAK,GAAG,OAAO;GAClC,OAAO,MAAM,MAAM,MAAM,iBAAiB,MAAM,CAAC,CAAC;EAEpD,KAAK;GACH,IAAI,CAAC,MAAM,QAAQ,KAAK,GAAG,OAAO;GAClC,OAAO,CAAC,MAAM,MAAM,MAAM,iBAAiB,MAAM,CAAC,CAAC;EAErD,KAAK,YACH,OAAO,UAAU,IAAI,KAAK,OAAO,IAAI,CAAC,CAAC,SAAS,OAAO,KAAK,CAAC;EAC/D,KAAK,cACH,OAAO,UAAU,IAAI,KAAK,OAAO,IAAI,CAAC,CAAC,WAAW,OAAO,KAAK,CAAC;EACjE,KAAK,YACH,OAAO,UAAU,IAAI,KAAK,OAAO,IAAI,CAAC,CAAC,SAAS,OAAO,KAAK,CAAC;EAC/D,SACE,OAAO;CACX;AACF;AAEA,SAAS,UAAU,OAAyB;CAC1C,OAAO,UAAU,QAAQ,UAAU,KAAA;AACrC;;;AChDA,MAAM,8BAAiG;CACrG,GAAG;CACH,OAAO,QAAiE;EAMtE,OAAO,IAAI,WAAW,cAAc;CACtC;AACF"}
+{"version":3,"file":"runtime.mjs","names":["#codecs"],"sources":["../src/core/idb-adapter.ts","../src/core/idb-filter-expr.ts","../src/core/filter-eval.ts","../src/exports/runtime.ts"],"sourcesContent":["import type { CodecLookup } from \"@prisma/orm-framework/components/codec\";\nimport { canonicalStringify } from \"@prisma/orm-framework/utils/canonical-stringify\";\nimport type { IdbLoweredPlan, IdbQueryPlan } from \"./idb-query-plan\";\nimport type { IdbLowererContext, IdbRuntimeAdapterInstance } from \"./runtime-adapter-instance\";\n\n/**\n * Concrete IDB runtime adapter.\n *\n * Implements {@link IdbRuntimeAdapterInstance} — the `lower()` method that\n * translates an {@link IdbQueryPlan} into an {@link IdbLoweredPlan} ready for\n * the driver.\n *\n * `lower()` preserves the driver operation: the `idbPlan` carried by\n * `IdbQueryPlan` is already execution-ready because IDB has no query\n * language to compile from. Every current `idb/*` codec is an identity\n * transform for stored values, so no field needs encoding. Structured AST\n * filters and sort specifications become canonical closure identities for\n * middleware; the driver remains independent of the query layer.\n *\n * The `codecs` constructor parameter matches the framework adapter shape and\n * is the extension point for field encoding with non-identity codecs.\n */\nexport class IdbAdapter implements IdbRuntimeAdapterInstance {\n  readonly familyId = \"idb\" as const;\n  readonly targetId = \"idb\" as const;\n\n  readonly #codecs: CodecLookup;\n\n  constructor(codecs: CodecLookup) {\n    this.#codecs = codecs;\n  }\n\n  /** Preserve the driver operation and carry structured closure identity through lowering. */\n  lower(plan: IdbQueryPlan, ctx: IdbLowererContext): Promise<IdbLoweredPlan> {\n    // If a codec ever transforms stored values, encode plan.idbPlan's\n    // record and key fields here: resolve each field's codec through\n    // this.#codecs and ctx.contract, then call codec.encode(value, ctx).\n    void this.#codecs; // codec registry for per-field encoding\n    void ctx.contract; // contract storage schema (field→codec resolution)\n    void ctx.signal; // AbortSignal for cooperative cancellation\n    const ast = plan.ast;\n    if (ast === undefined) return Promise.resolve(plan.idbPlan);\n\n    const filter = \"where\" in ast ? closureIdentity(ast.where) : undefined;\n    // Comparators visit fields in declaration order. Canonicalizing the record\n    // itself would sort its keys and lose the priority of multi-field sorts.\n    const comparator =\n      \"orderBy\" in ast && ast.orderBy !== undefined ? closureIdentity(Object.entries(ast.orderBy)) : undefined;\n    if (filter === undefined && comparator === undefined) return Promise.resolve(plan.idbPlan);\n\n    return Promise.resolve({\n      ...plan.idbPlan,\n      queryIdentity: {\n        ...(filter === undefined ? {} : { filter }),\n        ...(comparator === undefined ? {} : { comparator }),\n      },\n    });\n  }\n}\n\n/** Leave unsupported structured values opaque so identity generation cannot break a query. */\nfunction closureIdentity(value: unknown): string | undefined {\n  if (value === undefined) return undefined;\n  try {\n    return canonicalStringify(value);\n  } catch {\n    return undefined;\n  }\n}\n","/**\n * Filter expression AST for IDB queries.\n *\n * Plain frozen objects (not classes) — IDB has no codec trait gating to\n * worry about and no visitor pattern needed (a recursive `evaluateFilter`\n * is plenty). Mirrors the design of Prisma ORM's Mongo family\n * (`MongoFieldFilter`, `MongoAndExpr`, ...) and the SQL ORM's `BinaryExpr`,\n * but with the class machinery stripped out.\n *\n * The AST is carried on `IdbQueryAst` (intent layer) and lowered into an\n * `IdbRowFilter` closure that the driver applies during cursor scans —\n * keeping the driver free of any AST imports.\n */\n\nexport type IdbFilterOp =\n  \"eq\" | \"neq\" | \"gt\" | \"lt\" | \"gte\" | \"lte\" | \"in\" | \"notIn\" | \"contains\" | \"startsWith\" | \"endsWith\";\n\n/** Comparison / membership predicate on a single field. */\nexport interface IdbFieldFilter {\n  readonly kind: \"field\";\n  readonly field: string;\n  readonly op: IdbFilterOp;\n  readonly value: unknown;\n}\n\n/** Conjunction. Empty `exprs` is truthy (vacuously true). */\nexport interface IdbAndExpr {\n  readonly kind: \"and\";\n  readonly exprs: ReadonlyArray<IdbFilterExpr>;\n}\n\n/** Disjunction. Empty `exprs` is falsy. */\nexport interface IdbOrExpr {\n  readonly kind: \"or\";\n  readonly exprs: ReadonlyArray<IdbFilterExpr>;\n}\n\n/** Logical NOT. */\nexport interface IdbNotExpr {\n  readonly kind: \"not\";\n  readonly expr: IdbFilterExpr;\n}\n\n/**\n * Explicit null check. Like `eq(null)` and `neq(null)`, it treats null\n * and absent fields as equivalent and always returns true or false.\n * Other nullable comparisons can be unknown until the full filter is evaluated.\n */\nexport interface IdbNullCheckExpr {\n  readonly kind: \"null-check\";\n  readonly field: string;\n  readonly isNull: boolean;\n}\n\n/** A field predicate, logical combination, or null check in the IDB filter AST. */\nexport type IdbFilterExpr = IdbFieldFilter | IdbAndExpr | IdbOrExpr | IdbNotExpr | IdbNullCheckExpr;\n\n// ── Factory helpers ───────────────────────────────────────────────────────────\n\n/** Build a frozen field-filter node. */\nexport const fieldFilter = (field: string, op: IdbFilterOp, value: unknown): IdbFieldFilter =>\n  Object.freeze({ kind: \"field\", field, op, value });\n\n/** Build a frozen AND combinator with a frozen `exprs` array. */\nexport const andExpr = (exprs: ReadonlyArray<IdbFilterExpr>): IdbAndExpr =>\n  Object.freeze({ kind: \"and\", exprs: Object.freeze([...exprs]) });\n\n/** Build a frozen OR combinator with a frozen `exprs` array. */\nexport const orExpr = (exprs: ReadonlyArray<IdbFilterExpr>): IdbOrExpr =>\n  Object.freeze({ kind: \"or\", exprs: Object.freeze([...exprs]) });\n\n/** Build a frozen NOT combinator. */\nexport const notExpr = (expr: IdbFilterExpr): IdbNotExpr => Object.freeze({ kind: \"not\", expr });\n\n/** Build a frozen null-check node. */\nexport const nullCheckExpr = (field: string, isNull: boolean): IdbNullCheckExpr =>\n  Object.freeze({ kind: \"null-check\", field, isNull });\n\n// ── Shorthand → expression ────────────────────────────────────────────────────\n\n/**\n * Convert a shorthand equality object (e.g. `{ active: true, email: \"x\" }`)\n * into the canonical AST form. `undefined` entries are dropped; `null`\n * values become null-checks rather than literal-null equalities (IDB\n * stores absent fields as `undefined`, so a literal-null equality misses).\n *\n * Returns `undefined` when the input has no usable entries — callers can\n * skip filter installation in that case rather than testing an empty\n * AND node every row.\n */\nexport function shorthandToFilterExpr(filters: Record<string, unknown>): IdbFilterExpr | undefined {\n  const exprs: IdbFilterExpr[] = [];\n  for (const [field, value] of Object.entries(filters)) {\n    if (value === undefined) continue;\n    if (value === null) {\n      exprs.push(nullCheckExpr(field, true));\n      continue;\n    }\n    exprs.push(fieldFilter(field, \"eq\", value));\n  }\n  if (exprs.length === 0) return undefined;\n  return exprs.length === 1 ? exprs[0]! : andExpr(exprs);\n}\n","/**\n * Pure-JS evaluator for {@link IdbFilterExpr}.\n *\n * The driver's `IdbRowFilter` type stays as `(row) => boolean` — the\n * accessor builds a closure that calls `evaluateFilter(expr, row)` and\n * passes that to the driver. The driver therefore never imports the\n * adapter's AST types, and keeps no dependency on the adapter.\n *\n * Decimal metadata selects exact numeric comparison. Other fields compare\n * values the way IndexedDB compares keys, so a filter agrees with an index\n * key range. Plain `===` would never match two equal `Date`s or byte arrays,\n * because values read back from IndexedDB are fresh objects. String\n * operations coerce both sides via `String(...)` so they work on numbers too.\n */\n\nimport {\n  compareDecimalValues,\n  compareFieldValues,\n  fieldValuesEqual,\n  isDecimalString,\n} from \"@prisma-idb/target-idb/runtime\";\nimport type { IdbFilterExpr, IdbFilterOp } from \"./idb-filter-expr\";\n\n/** Codec metadata determines which string fields have numeric Decimal semantics. */\nexport type FilterFieldMetadata = Readonly<\n  Record<string, { readonly codecId?: string | undefined; readonly collection?: boolean }>\n>;\n\n/** Reject invalid Decimal operands even when no stored row reaches the evaluator. */\nexport function assertValidDecimalFilter(expr: IdbFilterExpr, fields: FilterFieldMetadata): void {\n  if (expr.kind === \"and\" || expr.kind === \"or\") {\n    expr.exprs.forEach((child) => assertValidDecimalFilter(child, fields));\n  } else if (expr.kind === \"not\") {\n    assertValidDecimalFilter(expr.expr, fields);\n  } else if (expr.kind === \"field\" && isDecimalField(fields, expr.field)) {\n    // Text operators inspect the stored spelling and need no numeric operand.\n    if (expr.op === \"contains\" || expr.op === \"startsWith\" || expr.op === \"endsWith\") return;\n    const values = expr.op === \"in\" || expr.op === \"notIn\" ? expr.value : [expr.value];\n    if (Array.isArray(values) && values.some((value) => isPresent(value) && !isDecimalString(value))) {\n      throw new TypeError(`Expected finite Decimal text for field \"${expr.field}\"`);\n    }\n  }\n}\n\n/** Identify scalar Decimal fields without reinterpreting string or collection values. */\nfunction isDecimalField(fields: FilterFieldMetadata, field: string): boolean {\n  return fields[field]?.codecId === \"idb/decimal@1\" && !fields[field]?.collection;\n}\n\n/** SQL predicate result before the outer WHERE boundary discards unknown. */\ntype PredicateResult = boolean | null;\n\n/** Evaluate an AST node against a single row. Only SQL TRUE keeps the row. */\nexport function evaluateFilter(\n  expr: IdbFilterExpr,\n  row: Record<string, unknown>,\n  fields: FilterFieldMetadata = {}\n): boolean {\n  return evaluatePredicate(expr, row, fields) === true;\n}\n\n/** Preserve unknown through logical composition so negation cannot admit null comparisons. */\nfunction evaluatePredicate(\n  expr: IdbFilterExpr,\n  row: Record<string, unknown>,\n  fields: FilterFieldMetadata\n): PredicateResult {\n  switch (expr.kind) {\n    case \"field\":\n      return evalFieldOp(expr.field, expr.op, expr.value, row, fields);\n    case \"and\": {\n      let result: PredicateResult = true;\n      for (const e of expr.exprs) {\n        const child = evaluatePredicate(e, row, fields);\n        if (child === false) return false;\n        if (child === null) result = null;\n      }\n      return result;\n    }\n    case \"or\": {\n      let result: PredicateResult = false;\n      for (const e of expr.exprs) {\n        const child = evaluatePredicate(e, row, fields);\n        if (child === true) return true;\n        if (child === null) result = null;\n      }\n      return result;\n    }\n    case \"not\": {\n      const result = evaluatePredicate(expr.expr, row, fields);\n      return result === null ? null : !result;\n    }\n    case \"null-check\": {\n      const isNullish = !isPresent(row[expr.field]);\n      return expr.isNull ? isNullish : !isNullish;\n    }\n  }\n}\n\n/** Evaluate one field predicate with the same comparisons used by index-backed queries. */\nfunction evalFieldOp(\n  field: string,\n  op: IdbFilterOp,\n  value: unknown,\n  row: Record<string, unknown>,\n  fields: FilterFieldMetadata\n): PredicateResult {\n  const cell = row[field];\n  // Upstream eq(null) and neq(null) are explicit null checks, not SQL comparisons.\n  if (value === null && (op === \"eq\" || op === \"neq\")) {\n    return op === \"eq\" ? !isPresent(cell) : isPresent(cell);\n  }\n  const decimal = isDecimalField(fields, field);\n  const compare = decimal ? compareDecimalValues : compareFieldValues;\n  const equal = decimal ? (a: unknown, b: unknown) => compareDecimalValues(a, b) === 0 : fieldValuesEqual;\n  if (op === \"in\" || op === \"notIn\") {\n    const result = evaluateMembership(cell, value, equal);\n    if (result === null) return null;\n    return op === \"in\" ? result : !result;\n  }\n  if (!isPresent(cell) || !isPresent(value)) return null;\n\n  switch (op) {\n    case \"eq\":\n      return equal(cell, value);\n    case \"neq\":\n      return !equal(cell, value);\n    case \"gt\":\n      return compare(cell, value) > 0;\n    case \"lt\":\n      return compare(cell, value) < 0;\n    case \"gte\":\n      return compare(cell, value) >= 0;\n    case \"lte\":\n      return compare(cell, value) <= 0;\n    case \"contains\":\n      return String(cell).includes(String(value));\n    case \"startsWith\":\n      return String(cell).startsWith(String(value));\n    case \"endsWith\":\n      return String(cell).endsWith(String(value));\n    default:\n      return false;\n  }\n}\n\n/** Match SQL IN: empty lists are false; otherwise null operands leave an unmatched result unknown. */\nfunction evaluateMembership(\n  cell: unknown,\n  values: unknown,\n  equal: (a: unknown, b: unknown) => boolean\n): PredicateResult {\n  if (!Array.isArray(values) || values.length === 0) return false;\n  if (!isPresent(cell)) return null;\n  let result: PredicateResult = false;\n  for (const value of values) {\n    if (!isPresent(value)) result = null;\n    else if (equal(cell, value)) return true;\n  }\n  return result;\n}\n\nfunction isPresent(value: unknown): boolean {\n  return value !== null && value !== undefined;\n}\n","import type { RuntimeAdapterDescriptor, ExecutionStack } from \"@prisma/orm-framework/components/execution\";\nimport { idbCodecLookup } from \"@prisma-idb/target-idb/runtime\";\nimport { idbAdapterDescriptorMeta } from \"../core/descriptor-meta\";\nimport { IdbAdapter } from \"../core/idb-adapter\";\nimport type { IdbRuntimeAdapterInstance } from \"../core/runtime-adapter-instance\";\n\nexport type { IdbRuntimeAdapterInstance, IdbLowererContext } from \"../core/runtime-adapter-instance\";\nexport type { IdbQueryPlan, IdbLoweredPlan } from \"../core/idb-query-plan\";\nexport type {\n  IdbQueryAst,\n  IdbFindManyAst,\n  IdbFindUniqueAst,\n  IdbCreateAst,\n  IdbDeleteAst,\n  IdbUpdateAst,\n  IdbUpdateAllAst,\n  IdbUpdateCountAst,\n  IdbCreateAllAst,\n  IdbCreateCountAst,\n  IdbDeleteAllAst,\n  IdbDeleteCountAst,\n  IdbCountAst,\n  IdbAggregateAst,\n  IdbGroupByAst,\n  IdbAggregateRequest,\n} from \"../core/idb-query-ast\";\nexport type {\n  IdbFilterExpr,\n  IdbFieldFilter,\n  IdbAndExpr,\n  IdbOrExpr,\n  IdbNotExpr,\n  IdbNullCheckExpr,\n  IdbFilterOp,\n} from \"../core/idb-filter-expr\";\nexport { fieldFilter, andExpr, orExpr, notExpr, nullCheckExpr, shorthandToFilterExpr } from \"../core/idb-filter-expr\";\nexport { evaluateFilter, assertValidDecimalFilter } from \"../core/filter-eval\";\nexport { IdbAdapter } from \"../core/idb-adapter\";\n\nconst idbRuntimeAdapterDescriptor: RuntimeAdapterDescriptor<\"idb\", \"idb\", IdbRuntimeAdapterInstance> = {\n  ...idbAdapterDescriptorMeta,\n  /** Build an adapter with the codec registry shared by the IDB runtime stack. */\n  create(_stack: ExecutionStack<\"idb\", \"idb\">): IdbRuntimeAdapterInstance {\n    // Construct the adapter with the real IDB codec lookup so per-field\n    // encoding works when non-identity codecs are added. The current set\n    // is all-identity, so output behavior is unchanged; this wiring makes\n    // the descriptor-built adapter match the hand-constructed one in\n    // `createIdbClient`.\n    return new IdbAdapter(idbCodecLookup);\n  },\n};\n\nexport default idbRuntimeAdapterDescriptor;\n"],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prisma-idb/adapter-idb",
-  "version": "0.12.0",
+  "version": "0.13.0",
   "description": "Prisma 8 IDB family — adapter (lowers query AST to opaque IDB plan body)",
   "license": "MIT",
   "files": [
@@ -29,9 +29,9 @@
     "./package.json": "./package.json"
   },
   "dependencies": {
-    "@prisma-idb/driver-idb": "0.12.0",
-    "@prisma-idb/target-idb": "0.12.0",
-    "@prisma/orm-framework": "8.0.0-rc.12"
+    "@prisma-idb/driver-idb": "0.13.0",
+    "@prisma-idb/target-idb": "0.13.0",
+    "@prisma/orm-framework": "8.0.0-rc.18"
   },
   "devDependencies": {
     "tsdown": "^0.22.14",