@prisma-idb/adapter-idb 0.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Prisma IDB
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,24 @@
+# `@prisma-idb/adapter-idb`
+
+> Part of the [`@prisma-idb`](https://prisma-idb.dev/) driver stack for Prisma 8.
+
+**adapter-idb** is the translation layer. It lowers the Prisma query AST into an opaque IDB plan body that the driver can execute.
+
+## Stack position
+
+```
+family-idb  (CLI / config)
+client-idb  (ORM query builder)
+runtime-idb (RuntimeCore)
+adapter-idb ← you are here (query AST → IDB plan)
+driver-idb  (window.indexedDB wrapper)
+target-idb  (identity + migrations)
+```
+
+## Usage
+
+Consumed internally by the rest of the `@prisma-idb` family. You generally do not install this package directly — use [`@prisma-idb/family-idb`](https://www.npmjs.com/package/@prisma-idb/family-idb) as your entry point.
+
+## License
+
+MIT

package/dist/control.d.mts

@@ -0,0 +1,6 @@
+import { ControlAdapterDescriptor } from "@prisma/orm-framework/components/control";
+//#region src/exports/control.d.ts
+declare const idbControlAdapterDescriptor: ControlAdapterDescriptor<"idb", "idb">;
+//#endregion
+export { idbControlAdapterDescriptor as default };
+//# sourceMappingURL=control.d.mts.map

package/dist/control.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"control.d.mts","names":[],"sources":["../src/exports/control.ts"],"mappings":";;cAOM,6BAA6B"}

package/dist/control.mjs

@@ -0,0 +1,15 @@
+import { t as idbAdapterDescriptorMeta } from "./descriptor-meta-DRDNlZjA.mjs";
+//#region src/exports/control.ts
+const idbControlAdapterDescriptor = {
+	...idbAdapterDescriptorMeta,
+	create(_stack) {
+		return {
+			familyId: "idb",
+			targetId: "idb"
+		};
+	}
+};
+//#endregion
+export { idbControlAdapterDescriptor as default };
+
+//# sourceMappingURL=control.mjs.map

package/dist/control.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"control.mjs","names":[],"sources":["../src/exports/control.ts"],"sourcesContent":["import type {\n  ControlAdapterDescriptor,\n  ControlAdapterInstance,\n  ControlStack,\n} from \"@prisma/orm-framework/components/control\";\nimport { idbAdapterDescriptorMeta } from \"../core/descriptor-meta\";\n\nconst idbControlAdapterDescriptor: ControlAdapterDescriptor<\"idb\", \"idb\"> = {\n  ...idbAdapterDescriptorMeta,\n  create(_stack: ControlStack<\"idb\", \"idb\">): ControlAdapterInstance<\"idb\", \"idb\"> {\n    return { familyId: \"idb\", targetId: \"idb\" };\n  },\n};\n\nexport default idbControlAdapterDescriptor;\n"],"mappings":";;AAOA,MAAM,8BAAsE;CAC1E,GAAG;CACH,OAAO,QAA0E;EAC/E,OAAO;GAAE,UAAU;GAAO,UAAU;EAAM;CAC5C;AACF"}

package/dist/descriptor-meta-DRDNlZjA.mjs

@@ -0,0 +1,22 @@
+//#region src/core/descriptor-meta.ts
+const idbAdapterDescriptorMeta = {
+	kind: "adapter",
+	familyId: "idb",
+	targetId: "idb",
+	id: "idb",
+	version: "0.0.1",
+	capabilities: { idb: {
+		/** IDB's `upgradeneeded` callback IS a version-change transaction. */
+		transactionalDDL: true,
+		/** DDL can ONLY run inside `upgradeneeded` — never at query time. */
+		ddlOnlyInUpgrade: true,
+		/** IDB has no RETURNING clause. */
+		returning: false,
+		/** Compound keys are forbidden by sync ownership invariants. */
+		compoundKeys: false
+	} }
+};
+//#endregion
+export { idbAdapterDescriptorMeta as t };
+
+//# sourceMappingURL=descriptor-meta-DRDNlZjA.mjs.map

package/dist/descriptor-meta-DRDNlZjA.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"descriptor-meta-DRDNlZjA.mjs","names":[],"sources":["../src/core/descriptor-meta.ts"],"sourcesContent":["import type { AdapterDescriptor } from \"@prisma/orm-framework/components/components\";\n\nexport const idbAdapterDescriptorMeta = {\n  kind: \"adapter\",\n  familyId: \"idb\",\n  targetId: \"idb\",\n  id: \"idb\",\n  version: \"0.0.1\",\n  capabilities: {\n    idb: {\n      /** IDB's `upgradeneeded` callback IS a version-change transaction. */\n      transactionalDDL: true,\n      /** DDL can ONLY run inside `upgradeneeded` — never at query time. */\n      ddlOnlyInUpgrade: true,\n      /** IDB has no RETURNING clause. */\n      returning: false,\n      /** Compound keys are forbidden by sync ownership invariants. */\n      compoundKeys: false,\n    },\n  },\n} satisfies AdapterDescriptor<\"idb\", \"idb\">;\n"],"mappings":";AAEA,MAAa,2BAA2B;CACtC,MAAM;CACN,UAAU;CACV,UAAU;CACV,IAAI;CACJ,SAAS;CACT,cAAc,EACZ,KAAK;;EAEH,kBAAkB;;EAElB,kBAAkB;;EAElB,WAAW;;EAEX,cAAc;CAChB,EACF;AACF"}

package/dist/runtime.d.mts

@@ -0,0 +1,320 @@
+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";
+//#region src/core/idb-filter-expr.d.ts
+/**
+ * Filter expression AST for IDB queries.
+ *
+ * Plain frozen objects (not classes) — IDB has no codec trait gating to
+ * worry about and no visitor pattern needed (a recursive `evaluateFilter`
+ * is plenty). Mirrors the design of Prisma ORM's Mongo family
+ * (`MongoFieldFilter`, `MongoAndExpr`, ...) and the SQL ORM's `BinaryExpr`,
+ * but with the class machinery stripped out.
+ *
+ * The AST is carried on `IdbQueryAst` (intent layer) and lowered into an
+ * `IdbRowFilter` closure that the driver applies during cursor scans —
+ * keeping the driver free of any AST imports.
+ */
+type IdbFilterOp = "eq" | "neq" | "gt" | "lt" | "gte" | "lte" | "in" | "notIn" | "contains" | "startsWith" | "endsWith";
+/** Comparison / membership predicate on a single field. */
+interface IdbFieldFilter {
+  readonly kind: "field";
+  readonly field: string;
+  readonly op: IdbFilterOp;
+  readonly value: unknown;
+}
+/** Conjunction. Empty `exprs` is truthy (vacuously true). */
+interface IdbAndExpr {
+  readonly kind: "and";
+  readonly exprs: ReadonlyArray<IdbFilterExpr>;
+}
+/** Disjunction. Empty `exprs` is falsy. */
+interface IdbOrExpr {
+  readonly kind: "or";
+  readonly exprs: ReadonlyArray<IdbFilterExpr>;
+}
+/** Logical NOT. */
+interface IdbNotExpr {
+  readonly kind: "not";
+  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 })`).
+ */
+interface IdbNullCheckExpr {
+  readonly kind: "null-check";
+  readonly field: string;
+  readonly isNull: boolean;
+}
+type IdbFilterExpr = IdbFieldFilter | IdbAndExpr | IdbOrExpr | IdbNotExpr | IdbNullCheckExpr;
+/** Build a frozen field-filter node. */
+declare const fieldFilter: (field: string, op: IdbFilterOp, value: unknown) => IdbFieldFilter;
+/** Build a frozen AND combinator with a frozen `exprs` array. */
+declare const andExpr: (exprs: ReadonlyArray<IdbFilterExpr>) => IdbAndExpr;
+/** Build a frozen OR combinator with a frozen `exprs` array. */
+declare const orExpr: (exprs: ReadonlyArray<IdbFilterExpr>) => IdbOrExpr;
+/** Build a frozen NOT combinator. */
+declare const notExpr: (expr: IdbFilterExpr) => IdbNotExpr;
+/** Build a frozen null-check node. */
+declare const nullCheckExpr: (field: string, isNull: boolean) => IdbNullCheckExpr;
+/**
+ * Convert a shorthand equality object (e.g. `{ active: true, email: "x" }`)
+ * into the canonical AST form. `undefined` entries are dropped; `null`
+ * values become null-checks rather than literal-null equalities (IDB
+ * stores absent fields as `undefined`, so a literal-null equality misses).
+ *
+ * Returns `undefined` when the input has no usable entries — callers can
+ * skip filter installation in that case rather than testing an empty
+ * AND node every row.
+ */
+declare function shorthandToFilterExpr(filters: Record<string, unknown>): IdbFilterExpr | undefined;
+//#endregion
+//#region src/core/idb-query-ast.d.ts
+/**
+ * Discriminated union of all IDB query AST nodes.
+ *
+ * Each node describes one logical operation. The fields are intentionally
+ * higher-level than the plan body types — they use model names, field names,
+ * and filter shapes rather than store names and key ranges.
+ */
+type IdbQueryAst = IdbFindManyAst | IdbFindUniqueAst | IdbCreateAst | IdbDeleteAst | IdbUpdateAst | IdbUpdateAllAst | IdbUpdateCountAst | IdbCreateAllAst | IdbCreateCountAst | IdbDeleteAllAst | IdbDeleteCountAst | IdbCountAst | IdbAggregateAst | IdbGroupByAst;
+/** Full cursor scan with optional filtering, ordering, and pagination. */
+interface IdbFindManyAst {
+  readonly kind: "findMany";
+  /** The model (store) being queried. */
+  readonly modelName: string;
+  /** Where filter expression, lifted from shorthand or callback form. */
+  readonly where?: IdbFilterExpr;
+  /** Sort order, if any. Maps field name to direction. */
+  readonly orderBy?: Record<string, "asc" | "desc">;
+  /** Number of rows to skip (OFFSET). */
+  readonly skip?: number;
+  /** Maximum number of rows to return (LIMIT). */
+  readonly take?: number;
+}
+/** Primary-key or unique-index lookup (O(1)). */
+interface IdbFindUniqueAst {
+  readonly kind: "findUnique";
+  /** The model (store) being queried. */
+  readonly modelName: string;
+  /** The key value to look up. */
+  readonly key: unknown;
+}
+/** Insert a single record. */
+interface IdbCreateAst {
+  readonly kind: "create";
+  /** The model (store) being inserted into. */
+  readonly modelName: string;
+  /** The record data to insert. */
+  readonly data: Record<string, unknown>;
+}
+/** Delete a record by primary key. */
+interface IdbDeleteAst {
+  readonly kind: "delete";
+  /** The model (store) being deleted from. */
+  readonly modelName: string;
+  /** The key value of the record to delete. */
+  readonly key: unknown;
+}
+/** Update the first matching record (cursor scan, take:1). Returns updated row or null. */
+interface IdbUpdateAst {
+  readonly kind: "update";
+  readonly modelName: string;
+  readonly patch: Record<string, unknown>;
+  readonly where?: IdbFilterExpr;
+}
+/** Update all matching records. Returns updated rows as AsyncIterableResult. */
+interface IdbUpdateAllAst {
+  readonly kind: "updateAll";
+  readonly modelName: string;
+  readonly patch: Record<string, unknown>;
+  readonly where?: IdbFilterExpr;
+}
+/** Update all matching records. Returns count only. */
+interface IdbUpdateCountAst {
+  readonly kind: "updateCount";
+  readonly modelName: string;
+  readonly patch: Record<string, unknown>;
+  readonly where?: IdbFilterExpr;
+}
+/** Batch insert multiple records. Returns inserted rows as AsyncIterableResult. */
+interface IdbCreateAllAst {
+  readonly kind: "createAll";
+  readonly modelName: string;
+  readonly data: Record<string, unknown>[];
+}
+/** Batch insert multiple records. Returns count only. */
+interface IdbCreateCountAst {
+  readonly kind: "createCount";
+  readonly modelName: string;
+  readonly data: Record<string, unknown>[];
+}
+/** Delete all matching records. Returns deleted rows as AsyncIterableResult. */
+interface IdbDeleteAllAst {
+  readonly kind: "deleteAll";
+  readonly modelName: string;
+  readonly where?: IdbFilterExpr;
+}
+/** Delete all matching records. Returns count only. */
+interface IdbDeleteCountAst {
+  readonly kind: "deleteCount";
+  readonly modelName: string;
+  readonly where?: IdbFilterExpr;
+}
+/** Count matching records. */
+interface IdbCountAst {
+  readonly kind: "count";
+  readonly modelName: string;
+  readonly where?: IdbFilterExpr;
+}
+/** One aggregation request inside an {@link IdbAggregateAst} / {@link IdbGroupByAst}. */
+interface IdbAggregateRequest {
+  /** Aggregate function: `count` | `sum` | `avg` | `min` | `max`. */
+  readonly fn: string;
+  /** Target field for numeric reducers; absent for `count`. */
+  readonly field?: string;
+}
+/**
+ * In-memory aggregate over the matching rows (count/sum/avg/min/max).
+ *
+ * IDB has no aggregation API, so this is computed by the client after a cursor
+ * scan materialises the rows. The AST is attached to that scan plan so cache /
+ * logging middleware can observe the aggregate intent.
+ */
+interface IdbAggregateAst {
+  readonly kind: "aggregate";
+  readonly modelName: string;
+  readonly where?: IdbFilterExpr;
+  /** Requested aggregates keyed by their result alias. */
+  readonly aggregates: Readonly<Record<string, IdbAggregateRequest>>;
+}
+/**
+ * In-memory grouped aggregate (`groupBy(...).aggregate(...)`).
+ *
+ * Like {@link IdbAggregateAst} but partitions the materialised rows by the
+ * `by` fields before reducing each group.
+ */
+interface IdbGroupByAst {
+  readonly kind: "groupBy";
+  readonly modelName: string;
+  readonly where?: IdbFilterExpr;
+  /** Group key fields, in declaration order. */
+  readonly by: readonly string[];
+  /** Requested aggregates keyed by their result alias. */
+  readonly aggregates: Readonly<Record<string, IdbAggregateRequest>>;
+}
+//#endregion
+//#region src/core/idb-query-plan.d.ts
+declare const __idbQueryPlanRow: unique symbol;
+/**
+ * IDB pre-lowering query plan produced by lanes before lowering.
+ *
+ * Extends the framework-level {@link QueryPlan}<Row> marker (`meta + _row`) and
+ * 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
+ * handles codec encoding of field values (e.g. `idb/date@1` → `Date`) and
+ * returns the (possibly re-encoded) `IdbPlanBody` to the driver.
+ *
+ * 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
+ * the upstream pattern where {@link SqlQueryPlan} carries an `ast: AnyQueryAst`.
+ *
+ * @template Row - The TypeScript row shape inferred from the lane builder.
+ *   Phantom-typed: never read at runtime, but constrains the return type of
+ *   `runtime.query()`.
+ */
+interface IdbQueryPlan<Row = unknown> extends QueryPlan<Row> {
+  /** The execution-ready IDB plan produced by the lane builder. */
+  readonly idbPlan: IdbPlanBody;
+  /**
+   * 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).
+   */
+  readonly ast?: IdbQueryAst;
+  /** Phantom row brand — matches the `_row` slot on the base QueryPlan. */
+  readonly [__idbQueryPlanRow]?: Row;
+}
+//#endregion
+//#region src/core/runtime-adapter-instance.d.ts
+/**
+ * Lowering context passed to the adapter's `lower()` method.
+ *
+ * Extends the framework's {@link CodecCallContext} (which carries an optional
+ * `AbortSignal` for cooperative cancellation) with the resolved IDB contract.
+ * The contract provides the per-store field→codec schema for per-field
+ * codec encoding (e.g. resolving which codec to use for a `DateTime` field).
+ *
+ * Upstream equivalent: `LowererContext<TContract>` from
+ * Prisma ORM's SQL relational query AST.
+ */
+interface IdbLowererContext<TContract = unknown> extends CodecCallContext {
+  /** The resolved IDB contract carrying the full storage schema. */
+  readonly contract: TContract;
+}
+/**
+ * Runtime adapter instance for IndexedDB.
+ *
+ * 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}
+ * (one of the strongly-typed IDB operation plans) that the driver can execute
+ * directly against `window.indexedDB`.
+ *
+ * The concrete implementation is {@link import('./idb-adapter').IdbAdapter}.
+ * This interface exists so `runtime-idb` has a stable contract to depend on
+ * when building `IdbRuntimeImpl`.
+ */
+interface IdbRuntimeAdapterInstance extends RuntimeAdapterInstance<"idb", "idb"> {
+  /**
+   * Lower an IDB query plan to an IDB execution plan.
+   *
+   * @param plan - The pre-lowering query plan from a Prisma lane. Carries the
+   *   execution-ready `IdbPlanBody` plus plan metadata.
+   * @param ctx  - Lowering context with the resolved contract (for per-field
+   *   codec resolution via the contract's storage schema) and an optional
+   *   `AbortSignal` for cooperative cancellation.
+   * @returns The IDB plan body describing the exact IDB operation(s) to run.
+   */
+  lower(plan: IdbQueryPlan, ctx: IdbLowererContext): Promise<IdbPlanBody>;
+}
+//#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;
+//#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
+ * the driver.
+ *
+ * `lower()` is a structural passthrough: the `idbPlan` carried by
+ * `IdbQueryPlan` is already execution-ready because IDB has no query
+ * language to compile from. The `codecs` lookup and `ctx.contract` are
+ * available for per-field codec encoding when custom codecs (e.g.
+ * `idb/date@1`) need to transform field values before they reach the
+ * driver. Since all current `idb/*` codecs are identity transforms, the
+ * passthrough output is correct for the standard type set.
+ */
+declare class IdbAdapter implements IdbRuntimeAdapterInstance {
+  #private;
+  readonly familyId: "idb";
+  readonly targetId: "idb";
+  constructor(codecs: CodecLookup);
+  lower(plan: IdbQueryPlan, ctx: IdbLowererContext): Promise<IdbPlanBody>;
+}
+//#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 };
+//# sourceMappingURL=runtime.d.mts.map

package/dist/runtime.d.mts.map

@@ -0,0 +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;;;;;;;;;;;;;;;;;;;;UAqBG,aAAa,uBAAuB,UAAU;;WAEpD,SAAS;;;;;;;WAOT,MAAM;;YAEL,qBAAqB;;;;;;;;;;;;;;;UCrBhB,kBAAkB,6BAA6B;;WAErD,UAAU;;;;;;;;;;;;;;;UAgBJ,kCAAkC;;;;;;;;;;;EAWjD,MAAM,MAAM,cAAc,KAAK,oBAAoB,QAAQ;;;;;iBC3B7C,eAAe,MAAM,eAAe,KAAK;;;;;;;;;;;;;;;;;;cCE5C,sBAAsB;;WACxB;WACA;EAIG,YAAA,QAAQ;EAIpB,MAAM,MAAM,cAAc,KAAK,oBAAoB,QAAQ;;;;cCSvD,6BAA6B,uCAAuC"}

package/dist/runtime.mjs

@@ -0,0 +1,145 @@
+import { t as idbAdapterDescriptorMeta } from "./descriptor-meta-DRDNlZjA.mjs";
+import { idbCodecLookup } from "@prisma-idb/target-idb/runtime";
+//#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
+* the driver.
+*
+* `lower()` is a structural passthrough: the `idbPlan` carried by
+* `IdbQueryPlan` is already execution-ready because IDB has no query
+* language to compile from. The `codecs` lookup and `ctx.contract` are
+* available for per-field codec encoding when custom codecs (e.g.
+* `idb/date@1`) need to transform field values before they reach the
+* driver. Since all current `idb/*` codecs are identity transforms, the
+* passthrough output is correct for the standard type set.
+*/
+var IdbAdapter = class {
+	familyId = "idb";
+	targetId = "idb";
+	#codecs;
+	constructor(codecs) {
+		this.#codecs = codecs;
+	}
+	lower(plan, ctx) {
+		this.#codecs;
+		ctx.contract;
+		ctx.signal;
+		return Promise.resolve(plan.idbPlan);
+	}
+};
+//#endregion
+//#region src/core/idb-filter-expr.ts
+/** Build a frozen field-filter node. */
+const fieldFilter = (field, op, value) => Object.freeze({
+	kind: "field",
+	field,
+	op,
+	value
+});
+/** Build a frozen AND combinator with a frozen `exprs` array. */
+const andExpr = (exprs) => Object.freeze({
+	kind: "and",
+	exprs: Object.freeze([...exprs])
+});
+/** Build a frozen OR combinator with a frozen `exprs` array. */
+const orExpr = (exprs) => Object.freeze({
+	kind: "or",
+	exprs: Object.freeze([...exprs])
+});
+/** Build a frozen NOT combinator. */
+const notExpr = (expr) => Object.freeze({
+	kind: "not",
+	expr
+});
+/** Build a frozen null-check node. */
+const nullCheckExpr = (field, isNull) => Object.freeze({
+	kind: "null-check",
+	field,
+	isNull
+});
+/**
+* Convert a shorthand equality object (e.g. `{ active: true, email: "x" }`)
+* into the canonical AST form. `undefined` entries are dropped; `null`
+* values become null-checks rather than literal-null equalities (IDB
+* stores absent fields as `undefined`, so a literal-null equality misses).
+*
+* Returns `undefined` when the input has no usable entries — callers can
+* skip filter installation in that case rather than testing an empty
+* AND node every row.
+*/
+function shorthandToFilterExpr(filters) {
+	const exprs = [];
+	for (const [field, value] of Object.entries(filters)) {
+		if (value === void 0) continue;
+		if (value === null) {
+			exprs.push(nullCheckExpr(field, true));
+			continue;
+		}
+		exprs.push(fieldFilter(field, "eq", value));
+	}
+	if (exprs.length === 0) return void 0;
+	return exprs.length === 1 ? exprs[0] : andExpr(exprs);
+}
+//#endregion
+//#region src/core/filter-eval.ts
+/** Evaluate an AST node against a single row. Returns `true` to keep the row. */
+function evaluateFilter(expr, row) {
+	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 "null-check": {
+			const v = row[expr.field];
+			const isNullish = v === null || v === void 0;
+			return expr.isNull ? isNullish : !isNullish;
+		}
+	}
+}
+function evalFieldOp(field, op, value, row) {
+	const cell = row[field];
+	switch (op) {
+		case "eq":
+			if (value === null) return cell === null || cell === void 0;
+			return cell === value;
+		case "neq":
+			if (value === null) return cell !== null && cell !== void 0;
+			return cell !== value;
+		case "gt": return cell !== void 0 && cell !== null && cell > value;
+		case "lt": return cell !== void 0 && cell !== null && cell < value;
+		case "gte": return cell !== void 0 && cell !== null && cell >= value;
+		case "lte": return cell !== void 0 && cell !== null && cell <= value;
+		case "in":
+			if (!Array.isArray(value)) return false;
+			for (const v of value) if (cell === v) return true;
+			return false;
+		case "notIn":
+			if (!Array.isArray(value)) return true;
+			for (const v of value) if (cell === v) return false;
+			return true;
+		case "contains": return cell !== void 0 && cell !== null && String(cell).includes(String(value));
+		case "startsWith": return cell !== void 0 && cell !== null && String(cell).startsWith(String(value));
+		case "endsWith": return cell !== void 0 && cell !== null && String(cell).endsWith(String(value));
+		default: return false;
+	}
+}
+//#endregion
+//#region src/exports/runtime.ts
+const idbRuntimeAdapterDescriptor = {
+	...idbAdapterDescriptorMeta,
+	create(_stack) {
+		return new IdbAdapter(idbCodecLookup);
+	}
+};
+//#endregion
+export { IdbAdapter, andExpr, idbRuntimeAdapterDescriptor as default, evaluateFilter, fieldFilter, notExpr, nullCheckExpr, orExpr, shorthandToFilterExpr };
+
+//# sourceMappingURL=runtime.mjs.map

package/dist/runtime.mjs.map

@@ -0,0 +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. The `codecs` lookup and `ctx.contract` are\n * available for per-field codec encoding when custom codecs (e.g.\n * `idb/date@1`) need to transform field values before they reach the\n * driver. Since all current `idb/*` codecs are identity transforms, the\n * passthrough output is correct for the standard type set.\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    // Passthrough: idbPlan is execution-ready as-is since IDB has no query\n    // language. When per-field codec encoding is added, walk\n    // plan.idbPlan's record/key fields here, resolve each field's codec via\n    // this.#codecs + ctx.contract's per-store schema, and call\n    // codec.encode(value, ctx) to produce the wire value.\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, preserving the layering rule in ARCHITECTURE.md.\n *\n * Comparisons use JS semantics (numeric vs string ordering is governed\n * by `<`/`>` on whatever the stored value type is). String operations\n * coerce both sides via `String(...)` so they work on numbers too — the\n * IDB driver stores values via the structured-clone algorithm, so a\n * field that contains an integer is genuinely a JS `number`.\n */\n\nimport type { IdbFilterExpr } 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: string, 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 cell === value;\n    case \"neq\":\n      if (value === null) return cell !== null && cell !== undefined;\n      return cell !== value;\n    case \"gt\":\n      return cell !== undefined && cell !== null && (cell as number | string) > (value as number | string);\n    case \"lt\":\n      return cell !== undefined && cell !== null && (cell as number | string) < (value as number | string);\n    case \"gte\":\n      return cell !== undefined && cell !== null && (cell as number | string) >= (value as number | string);\n    case \"lte\":\n      return cell !== undefined && cell !== null && (cell as number | string) <= (value as number | string);\n    case \"in\": {\n      if (!Array.isArray(value)) return false;\n      for (const v of value) {\n        if (cell === v) return true;\n      }\n      return false;\n    }\n    case \"notIn\": {\n      if (!Array.isArray(value)) return true;\n      for (const v of value) {\n        if (cell === v) return false;\n      }\n      return true;\n    }\n    case \"contains\":\n      return cell !== undefined && cell !== null && String(cell).includes(String(value));\n    case \"startsWith\":\n      return cell !== undefined && cell !== null && String(cell).startsWith(String(value));\n    case \"endsWith\":\n      return cell !== undefined && cell !== null && String(cell).endsWith(String(value));\n    default:\n      return false;\n  }\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;EAMtE,KAAUA;EACV,IAAS;EACT,IAAS;EACT,OAAO,QAAQ,QAAQ,KAAK,OAAO;CACrC;AACF;;;;ACkBA,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;;;;ACnFA,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,IAAY,OAAgB,KAAuC;CACrG,MAAM,OAAO,IAAI;CACjB,QAAQ,IAAR;EACE,KAAK;GAIH,IAAI,UAAU,MAAM,OAAO,SAAS,QAAQ,SAAS,KAAA;GACrD,OAAO,SAAS;EAClB,KAAK;GACH,IAAI,UAAU,MAAM,OAAO,SAAS,QAAQ,SAAS,KAAA;GACrD,OAAO,SAAS;EAClB,KAAK,MACH,OAAO,SAAS,KAAA,KAAa,SAAS,QAAS,OAA4B;EAC7E,KAAK,MACH,OAAO,SAAS,KAAA,KAAa,SAAS,QAAS,OAA4B;EAC7E,KAAK,OACH,OAAO,SAAS,KAAA,KAAa,SAAS,QAAS,QAA6B;EAC9E,KAAK,OACH,OAAO,SAAS,KAAA,KAAa,SAAS,QAAS,QAA6B;EAC9E,KAAK;GACH,IAAI,CAAC,MAAM,QAAQ,KAAK,GAAG,OAAO;GAClC,KAAK,MAAM,KAAK,OACd,IAAI,SAAS,GAAG,OAAO;GAEzB,OAAO;EAET,KAAK;GACH,IAAI,CAAC,MAAM,QAAQ,KAAK,GAAG,OAAO;GAClC,KAAK,MAAM,KAAK,OACd,IAAI,SAAS,GAAG,OAAO;GAEzB,OAAO;EAET,KAAK,YACH,OAAO,SAAS,KAAA,KAAa,SAAS,QAAQ,OAAO,IAAI,CAAC,CAAC,SAAS,OAAO,KAAK,CAAC;EACnF,KAAK,cACH,OAAO,SAAS,KAAA,KAAa,SAAS,QAAQ,OAAO,IAAI,CAAC,CAAC,WAAW,OAAO,KAAK,CAAC;EACrF,KAAK,YACH,OAAO,SAAS,KAAA,KAAa,SAAS,QAAQ,OAAO,IAAI,CAAC,CAAC,SAAS,OAAO,KAAK,CAAC;EACnF,SACE,OAAO;CACX;AACF;;;ACjDA,MAAM,8BAAiG;CACrG,GAAG;CACH,OAAO,QAAiE;EAMtE,OAAO,IAAI,WAAW,cAAc;CACtC;AACF"}

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "@prisma-idb/adapter-idb",
+  "version": "0.0.0",
+  "description": "Prisma 8 IDB family — adapter (lowers query AST to opaque IDB plan body)",
+  "license": "MIT",
+  "files": [
+    "dist"
+  ],
+  "keywords": [
+    "prisma",
+    "prisma-8",
+    "indexeddb",
+    "offline-first",
+    "idb"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/prisma-idb/prisma-idb.git",
+    "directory": "packages/prisma-orm/adapter-idb"
+  },
+  "homepage": "https://prisma-idb.dev/",
+  "bugs": {
+    "url": "https://github.com/prisma-idb/prisma-idb/issues"
+  },
+  "type": "module",
+  "exports": {
+    "./control": "./dist/control.mjs",
+    "./runtime": "./dist/runtime.mjs",
+    "./package.json": "./package.json"
+  },
+  "dependencies": {
+    "@prisma/orm-framework": "8.0.0-rc.5",
+    "@prisma-idb/driver-idb": "0.0.0",
+    "@prisma-idb/target-idb": "0.0.0"
+  },
+  "devDependencies": {
+    "tsdown": "^0.22.14",
+    "typescript": "^6.0.3",
+    "vitest": "^4.1.10"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "dev": "tsdown --watch",
+    "check": "tsc --noEmit",
+    "test": "vitest run",
+    "lint": "prettier --check . && eslint .",
+    "format": "prettier --write ."
+  }
+}