@prisma-idb/runtime-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/runtime-idb`
+
+> Part of the [`@prisma-idb`](https://prisma-idb.dev/) driver stack — IndexedDB for [Prisma 8](https://www.prisma.io/blog/prisma-next-call-for-extension-authors).
+
+**runtime-idb** is the `RuntimeCore` subclass that wires together the adapter and driver into a complete Prisma 8 runtime.
+
+## Stack position
+
+```
+family-idb  (CLI / config)
+client-idb  (ORM query builder)
+runtime-idb ← you are here (RuntimeCore)
+adapter-idb (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/runtime.d.mts

@@ -0,0 +1,119 @@
+import { AsyncIterableResult, RuntimeExecuteOptions, RuntimeMiddleware, RuntimeMiddlewareContext, RuntimeStatementStats } from "@prisma/orm-framework/components/runtime";
+import { IdbQueryPlan, IdbRuntimeAdapterInstance } from "@prisma-idb/adapter-idb/runtime";
+import { IdbPlanBody, IdbRuntimeDriverInstance, IdbTransactionScope } from "@prisma-idb/driver-idb/runtime";
+//#region src/idb-middleware.d.ts
+/**
+ * IDB-family middleware.
+ *
+ * Extends the generic `RuntimeMiddleware<IdbPlanBody>` marker. `familyId` is
+ * optional so generic cross-family middleware (e.g. telemetry) — which carry
+ * no `familyId` — remain assignable. When present, it must be `'idb'`; the
+ * runtime can reject mismatches at construction time via
+ * `checkMiddlewareCompatibility`.
+ *
+ * Mirrors the vendor `MongoMiddleware` / `SqlMiddleware` pattern.
+ *
+ * ## `onRow` backpressure limitation
+ *
+ * Unlike SQL/Mongo drivers, the IDB driver uses collect-then-yield: all rows
+ * are materialized inside the IDB transaction before any are delivered to the
+ * middleware pipeline (see ADR 006). This means:
+ *
+ * - `onRow` fires after the full cursor scan has completed and all rows are in
+ *   memory. Throwing or aborting inside `onRow` does NOT reduce the number of
+ *   rows read from the object store.
+ * - Use `take(n)` on the query builder to bound materialization, not early
+ *   exit from `onRow`.
+ * - Observation-only hooks (telemetry, cache population, logging) work
+ *   correctly — they just receive rows from an already-complete scan.
+ */
+interface IdbMiddleware extends RuntimeMiddleware<IdbPlanBody> {
+  readonly familyId?: "idb";
+}
+//#endregion
+//#region src/idb-runtime.d.ts
+/**
+ * Options for creating an IDB runtime instance.
+ */
+interface IdbRuntimeOptions {
+  /** Instantiated IDB adapter — provides `lower()`. */
+  readonly adapter: IdbRuntimeAdapterInstance;
+  /** Instantiated IDB driver — provides `execute()` and `close()`. */
+  readonly driver: IdbRuntimeDriverInstance;
+  /**
+   * The resolved IDB contract.
+   *
+   * Threaded through to the adapter's `lower()` as part of
+   * {@link IdbLowererContext} so per-field codec encoding can
+   * resolve field→codec mappings from the storage schema. Also used
+   * to build the real {@link RuntimeMiddlewareContext} so middleware
+   * can inspect contract data.
+   */
+  readonly contract: Record<string, unknown>;
+  /** Optional middleware chain. */
+  readonly middleware?: readonly IdbMiddleware[];
+  /**
+   * Middleware execution context.
+   *
+   * When omitted, a real context is derived from `contract`.
+   */
+  readonly ctx?: RuntimeMiddlewareContext;
+}
+/**
+ * Public IDB runtime interface.
+ *
+ * `query()` accepts an {@link IdbQueryPlan} and returns an
+ * `AsyncIterableResult<Row>` — an async iterable that also fulfils as a
+ * `Row[]` when awaited. `execute()` runs the same plan for its side effects
+ * and resolves a {@link RuntimeStatementStats} (`{ affectedRows }`) instead
+ * of rows — mirrors the upstream `RuntimeCore` query()/execute() split
+ * (rc.4).
+ */
+interface IdbRuntime {
+  query<Row>(plan: IdbQueryPlan & {
+    readonly _row?: Row;
+  }, options?: RuntimeExecuteOptions): AsyncIterableResult<Row>;
+  execute(plan: IdbQueryPlan, options?: RuntimeExecuteOptions): Promise<RuntimeStatementStats>;
+  /**
+   * Open a multi-store IDB transaction and return an `IdbTransactionScope`.
+   *
+   * The scope's `execute(plan)` runs `IdbAtomicPlan`s directly inside the
+   * transaction — middleware is bypassed (Issue #6 fix: cache middleware
+   * never fires for reads inside a transaction). `commit()` resolves on
+   * `tx.oncomplete`; `rollback()` calls `tx.abort()`.
+   *
+   * Used by `withMutationScope()` in `client-idb`.
+   */
+  transaction(storeNames: string[], mode?: IDBTransactionMode): Promise<IdbTransactionScope>;
+  /**
+   * Verify that the live IDB database's contract marker matches the
+   * contract this runtime was created with.
+   *
+   * Reads the `_prisma_next_marker` store and compares the stored
+   * `storageHash` against the contract's `storage.storageHash`.
+   * Returns `true` when the marker exists and matches, `false` when
+   * the marker is absent or mismatched.
+   *
+   * Call this after construction and before executing queries to
+   * detect schema drift. A missing marker means the database was
+   * never initialised (run `db migrate` first). A mismatched marker
+   * means the database schema has diverged from the contract.
+   */
+  verifyMarker(): Promise<boolean>;
+  close(): Promise<void>;
+}
+/**
+ * Create an IDB runtime instance.
+ *
+ * @example
+ * ```ts
+ * const driver = createIDBRuntimeDriver("my-app").create();
+ * const runtime = createIdbRuntime({ adapter, driver, contract });
+ * await runtime.query(plan)
+ * await runtime.close();
+ * ```
+ */
+declare function createIdbRuntime(options: IdbRuntimeOptions): IdbRuntime;
+//#endregion
+export { type IdbMiddleware, type IdbRuntime, type IdbRuntimeOptions, createIdbRuntime };
+//# sourceMappingURL=runtime.d.mts.map

package/dist/runtime.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime.d.mts","names":[],"sources":["../src/idb-middleware.ts","../src/idb-runtime.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;UA4BiB,sBAAsB,kBAAkB;WAC9C;;;;;;;UCVM;;WAEN,SAAS;;WAET,QAAQ;;;;;;;;;;WAUR,UAAU;;WAEV,sBAAsB;;;;;;WAMtB,MAAM;;;;;;;;;;;;UAaA;EACf,MAAM,KAAK,MAAM;aAA0B,OAAO;KAAO,UAAU,wBAAwB,oBAAoB;EAC/G,QAAQ,MAAM,cAAc,UAAU,wBAAwB,QAAQ;;;;;;;;;;;EAWtE,YAAY,sBAAsB,OAAO,qBAAqB,QAAQ;;;;;;;;;;;;;;;EAetE,gBAAgB;EAChB,SAAS;;;;;;;;;;;;;iBAkNK,iBAAiB,SAAS,oBAAoB"}

package/dist/runtime.mjs

@@ -0,0 +1,176 @@
+import { RuntimeCore, checkMiddlewareCompatibility } from "@prisma/orm-framework/components/runtime";
+import { canonicalStringify } from "@prisma/orm-framework/utils/canonical-stringify";
+import { hashContent } from "@prisma/orm-framework/utils/hash-content";
+//#region src/idb-runtime.ts
+/**
+* Build a real {@link RuntimeMiddlewareContext} from the contract
+* so middleware can inspect contract data (plan meta hashes, model
+* names, storage layout) and compute content hashes for cache keys.
+*
+* `contentHash` mirrors the vendor SQL/Mongo runtimes: it
+* canonicalizes the execution plan's structural identity fields
+* and SHA-512 hashes them via WebCrypto. The resulting digest is
+* a bounded, opaque cache key suitable for middleware like
+* a cross-family cache middleware.
+*
+* Non-serializable fields (in-memory filter functions, comparators,
+* `IDBKeyRange` objects) are reduced to their deterministic shape
+* so that two semantically identical plans produce the same hash.
+*/
+function buildMiddlewareContext(contract) {
+	return {
+		contract,
+		mode: "permissive",
+		planExecutionId: crypto.randomUUID(),
+		now: () => Date.now(),
+		log: {
+			info: () => void 0,
+			warn: () => void 0,
+			error: () => void 0
+		},
+		scope: "runtime",
+		contentHash: async (exec) => {
+			const plan = exec;
+			const hashable = {};
+			for (const [key, value] of Object.entries(plan)) if (key === "meta") hashable["meta"] = { storageHash: value?.["storageHash"] };
+			else if (typeof value === "function") continue;
+			else if (typeof IDBKeyRange !== "undefined" && value instanceof IDBKeyRange || isIdbKeyRange(value)) hashable[key] = keyRangeIdentity(value);
+			else hashable[key] = value;
+			return hashContent(canonicalStringify(hashable));
+		}
+	};
+}
+/** Check for IDBKeyRange-like objects (e.g. from fake-indexeddb). */
+function isIdbKeyRange(value) {
+	return typeof value === "object" && value !== null && "lower" in value && "upper" in value && "lowerOpen" in value && "upperOpen" in value;
+}
+/** Extract a deterministic identity from an IDBKeyRange. */
+function keyRangeIdentity(range) {
+	return {
+		lower: range.lower,
+		upper: range.upper,
+		lowerOpen: range.lowerOpen,
+		upperOpen: range.upperOpen
+	};
+}
+/**
+* IDB runtime — the `RuntimeCore` subclass for IndexedDB.
+*
+* Wires together:
+* - `lower(plan, ctx)` — delegates to `adapter.lower()` with the contract
+*   threaded via {@link IdbLowererContext}, producing an `IdbPlanBody`
+* - `runDriver(exec)` — delegates to `driver.execute()` to run the plan against IDB
+* - `query()` — the concrete row-returning template method from `RuntimeCore`,
+*   backed by `runDriver()`
+* - `runExecute(exec)` — drains `runDriver()` and counts rows into a
+*   `RuntimeStatementStats`; backs `execute()`, the concrete
+*   statement-terminal template method from `RuntimeCore`
+* - `close()` — closes the IDB connection via `driver.close()`
+*/
+var IdbRuntimeImpl = class extends RuntimeCore {
+	#adapter;
+	#driver;
+	#contract;
+	constructor(options) {
+		const ctx = options.ctx ?? buildMiddlewareContext(options.contract);
+		const middleware = [...options.middleware ?? []];
+		for (const mw of middleware) checkMiddlewareCompatibility(mw, "idb", "idb");
+		super({
+			middleware,
+			ctx
+		});
+		this.#adapter = options.adapter;
+		this.#driver = options.driver;
+		this.#contract = options.contract;
+	}
+	/**
+	* Lower an IDB query plan to an IDB plan body via the adapter.
+	*
+	* Threads the contract through {@link IdbLowererContext} so per-field
+	* codec encoding can resolve field→codec mappings from the contract's
+	* storage schema.
+	*/
+	lower(plan, ctx) {
+		const lowererCtx = {
+			...ctx,
+			contract: this.#contract
+		};
+		return this.#adapter.lower(plan, lowererCtx);
+	}
+	/**
+	* Execute a lowered IDB plan body via the driver.
+	*
+	* Backs `query()` (inherited concretely from `RuntimeCore`) — rows are
+	* yielded as-is from the driver (identity pass-through). All current
+	* `idb/*` codecs are identity transforms — no per-field decoding is
+	* needed. When per-field codec decoding is added (e.g. decoding
+	* `idb/date@1` stored values back to `Date` instances, or custom codec
+	* output types), it wires up here.
+	*/
+	runDriver(exec) {
+		return this.#driver.execute(exec);
+	}
+	/**
+	* Backs `execute()` (inherited concretely from `RuntimeCore`) — IDB has no
+	* native "affected-row count without returning rows" concept, so this
+	* drains `runDriver()`'s row stream and counts. The driver already
+	* materializes every op's touched rows in memory before yielding (see
+	* `IdbRuntimeDriverInstance.execute()`'s collect-then-yield strategy), so
+	* draining here has no extra cost beyond what a `query()` call over the
+	* same plan would already pay.
+	*
+	* This counts *rows the driver yields*, which correctly equals "ops
+	* applied" for every atomic plan kind: `add`/`put`/`update` each echo the
+	* one row they touched, `scan-write` echoes every matched row, and
+	* `delete` (`execute/ops.ts`'s `execDelete`) walks a cursor over its
+	* key/range and echoes each row it deletes — so a delete matching zero
+	* keys correctly resolves `{ affectedRows: 0 }` and one matching N keys
+	* (a range delete) resolves `{ affectedRows: N }`. For a `batch` plan,
+	* `affectedRows` is the sum of rows every op in the batch yields,
+	* *including read ops* (`key-get`/`index-get`/`cursor-scan`) if the batch
+	* happens to contain any — it's a row count across the whole plan, not a
+	* write-only count.
+	*/
+	async runExecute(exec) {
+		let affectedRows = 0;
+		for await (const _row of this.runDriver(exec)) affectedRows++;
+		return { affectedRows };
+	}
+	async transaction(storeNames, mode = "readwrite") {
+		return this.#driver.transaction(storeNames, mode);
+	}
+	async close() {
+		await this.#driver.close();
+	}
+	/**
+	* Verify that the live IDB marker matches the contract.
+	*
+	* Compares the stored `storageHash` against `contract.storage.storageHash`.
+	* A fresh database (no marker store) returns `false` — the caller should
+	* ensure migrations have been applied before running queries.
+	*/
+	async verifyMarker() {
+		const marker = await this.#driver.readMarker();
+		if (marker === null) return false;
+		const contractHash = this.#contract["storage"]?.["storageHash"];
+		return typeof contractHash === "string" && marker.storageHash === contractHash;
+	}
+};
+/**
+* Create an IDB runtime instance.
+*
+* @example
+* ```ts
+* const driver = createIDBRuntimeDriver("my-app").create();
+* const runtime = createIdbRuntime({ adapter, driver, contract });
+* await runtime.query(plan)
+* await runtime.close();
+* ```
+*/
+function createIdbRuntime(options) {
+	return new IdbRuntimeImpl(options);
+}
+//#endregion
+export { createIdbRuntime };
+
+//# sourceMappingURL=runtime.mjs.map

package/dist/runtime.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime.mjs","names":["meta","#adapter","#driver","#contract"],"sources":["../src/idb-runtime.ts"],"sourcesContent":["import type { CodecCallContext } from \"@prisma/orm-framework/components/codec\";\nimport {\n  AsyncIterableResult,\n  checkMiddlewareCompatibility,\n  RuntimeCore,\n  type ExecutionPlan,\n  type RuntimeExecuteOptions,\n  type RuntimeMiddlewareContext,\n  type RuntimeStatementStats,\n} from \"@prisma/orm-framework/components/runtime\";\nimport { canonicalStringify } from \"@prisma/orm-framework/utils/canonical-stringify\";\nimport { hashContent } from \"@prisma/orm-framework/utils/hash-content\";\nimport type { IdbLowererContext, IdbQueryPlan, IdbRuntimeAdapterInstance } from \"@prisma-idb/adapter-idb/runtime\";\nimport type { IdbPlanBody, IdbRuntimeDriverInstance, IdbTransactionScope } from \"@prisma-idb/driver-idb/runtime\";\nimport type { IdbMiddleware } from \"./idb-middleware\";\n\n/**\n * Options for creating an IDB runtime instance.\n */\nexport interface IdbRuntimeOptions {\n  /** Instantiated IDB adapter — provides `lower()`. */\n  readonly adapter: IdbRuntimeAdapterInstance;\n  /** Instantiated IDB driver — provides `execute()` and `close()`. */\n  readonly driver: IdbRuntimeDriverInstance;\n  /**\n   * The resolved IDB contract.\n   *\n   * Threaded through to the adapter's `lower()` as part of\n   * {@link IdbLowererContext} so per-field codec encoding can\n   * resolve field→codec mappings from the storage schema. Also used\n   * to build the real {@link RuntimeMiddlewareContext} so middleware\n   * can inspect contract data.\n   */\n  readonly contract: Record<string, unknown>;\n  /** Optional middleware chain. */\n  readonly middleware?: readonly IdbMiddleware[];\n  /**\n   * Middleware execution context.\n   *\n   * When omitted, a real context is derived from `contract`.\n   */\n  readonly ctx?: RuntimeMiddlewareContext;\n}\n\n/**\n * Public IDB runtime interface.\n *\n * `query()` accepts an {@link IdbQueryPlan} and returns an\n * `AsyncIterableResult<Row>` — an async iterable that also fulfils as a\n * `Row[]` when awaited. `execute()` runs the same plan for its side effects\n * and resolves a {@link RuntimeStatementStats} (`{ affectedRows }`) instead\n * of rows — mirrors the upstream `RuntimeCore` query()/execute() split\n * (rc.4).\n */\nexport interface IdbRuntime {\n  query<Row>(plan: IdbQueryPlan & { readonly _row?: Row }, options?: RuntimeExecuteOptions): AsyncIterableResult<Row>;\n  execute(plan: IdbQueryPlan, options?: RuntimeExecuteOptions): Promise<RuntimeStatementStats>;\n  /**\n   * Open a multi-store IDB transaction and return an `IdbTransactionScope`.\n   *\n   * The scope's `execute(plan)` runs `IdbAtomicPlan`s directly inside the\n   * transaction — middleware is bypassed (Issue #6 fix: cache middleware\n   * never fires for reads inside a transaction). `commit()` resolves on\n   * `tx.oncomplete`; `rollback()` calls `tx.abort()`.\n   *\n   * Used by `withMutationScope()` in `client-idb`.\n   */\n  transaction(storeNames: string[], mode?: IDBTransactionMode): Promise<IdbTransactionScope>;\n  /**\n   * Verify that the live IDB database's contract marker matches the\n   * contract this runtime was created with.\n   *\n   * Reads the `_prisma_next_marker` store and compares the stored\n   * `storageHash` against the contract's `storage.storageHash`.\n   * Returns `true` when the marker exists and matches, `false` when\n   * the marker is absent or mismatched.\n   *\n   * Call this after construction and before executing queries to\n   * detect schema drift. A missing marker means the database was\n   * never initialised (run `db migrate` first). A mismatched marker\n   * means the database schema has diverged from the contract.\n   */\n  verifyMarker(): Promise<boolean>;\n  close(): Promise<void>;\n}\n\n/**\n * Build a real {@link RuntimeMiddlewareContext} from the contract\n * so middleware can inspect contract data (plan meta hashes, model\n * names, storage layout) and compute content hashes for cache keys.\n *\n * `contentHash` mirrors the vendor SQL/Mongo runtimes: it\n * canonicalizes the execution plan's structural identity fields\n * and SHA-512 hashes them via WebCrypto. The resulting digest is\n * a bounded, opaque cache key suitable for middleware like\n * a cross-family cache middleware.\n *\n * Non-serializable fields (in-memory filter functions, comparators,\n * `IDBKeyRange` objects) are reduced to their deterministic shape\n * so that two semantically identical plans produce the same hash.\n */\nfunction buildMiddlewareContext(contract: Record<string, unknown>): RuntimeMiddlewareContext {\n  return {\n    contract,\n    mode: \"permissive\",\n    // v0.12.0: per-execute correlation id required on the middleware context.\n    // The default ctx is built once per runtime; consumers needing per-execute\n    // ids should supply their own `ctx`.\n    planExecutionId: crypto.randomUUID(),\n    now: () => Date.now(),\n    log: {\n      info: () => undefined,\n      warn: () => undefined,\n      error: () => undefined,\n    },\n    // Always \"runtime\": IdbTransactionScope.execute() bypasses the middleware\n    // chain entirely, so middleware is only ever invoked from the top-level\n    // query()/execute() paths, which is exactly the \"runtime\" scope. There is\n    // no IDB connection pool, so \"connection\" is not applicable either.\n    scope: \"runtime\",\n    contentHash: async (exec: ExecutionPlan) => {\n      // Reduce the plan to its structural identity for hashing.\n      // Exclude functions (IdbRowFilter, IdbRowComparator) and\n      // collapse IDBKeyRange to its bounds so deterministic\n      // comparisons work.\n      const plan = exec as unknown as Record<string, unknown>;\n      const hashable: Record<string, unknown> = {};\n      for (const [key, value] of Object.entries(plan)) {\n        if (key === \"meta\") {\n          // meta.storageHash is the primary identity field\n          const meta = value as Record<string, unknown> | undefined;\n          hashable[\"meta\"] = { storageHash: meta?.[\"storageHash\"] };\n        } else if (typeof value === \"function\") {\n          // Skip in-memory filters/comparators — not hashable\n          continue;\n        } else if ((typeof IDBKeyRange !== \"undefined\" && value instanceof IDBKeyRange) || isIdbKeyRange(value)) {\n          // Collapse IDBKeyRange to its bounds\n          hashable[key] = keyRangeIdentity(value as IDBKeyRange);\n        } else {\n          hashable[key] = value;\n        }\n      }\n      return hashContent(canonicalStringify(hashable));\n    },\n  };\n}\n\n/** Check for IDBKeyRange-like objects (e.g. from fake-indexeddb). */\nfunction isIdbKeyRange(value: unknown): value is IDBKeyRange {\n  return (\n    typeof value === \"object\" &&\n    value !== null &&\n    \"lower\" in value &&\n    \"upper\" in value &&\n    \"lowerOpen\" in value &&\n    \"upperOpen\" in value\n  );\n}\n\n/** Extract a deterministic identity from an IDBKeyRange. */\nfunction keyRangeIdentity(range: IDBKeyRange): Record<string, unknown> {\n  return {\n    lower: range.lower,\n    upper: range.upper,\n    lowerOpen: range.lowerOpen,\n    upperOpen: range.upperOpen,\n  };\n}\n\n/**\n * IDB runtime — the `RuntimeCore` subclass for IndexedDB.\n *\n * Wires together:\n * - `lower(plan, ctx)` — delegates to `adapter.lower()` with the contract\n *   threaded via {@link IdbLowererContext}, producing an `IdbPlanBody`\n * - `runDriver(exec)` — delegates to `driver.execute()` to run the plan against IDB\n * - `query()` — the concrete row-returning template method from `RuntimeCore`,\n *   backed by `runDriver()`\n * - `runExecute(exec)` — drains `runDriver()` and counts rows into a\n *   `RuntimeStatementStats`; backs `execute()`, the concrete\n *   statement-terminal template method from `RuntimeCore`\n * - `close()` — closes the IDB connection via `driver.close()`\n */\nclass IdbRuntimeImpl extends RuntimeCore<IdbQueryPlan, IdbPlanBody, IdbMiddleware> implements IdbRuntime {\n  readonly #adapter: IdbRuntimeAdapterInstance;\n  readonly #driver: IdbRuntimeDriverInstance;\n  readonly #contract: Record<string, unknown>;\n\n  constructor(options: IdbRuntimeOptions) {\n    const ctx = options.ctx ?? buildMiddlewareContext(options.contract);\n    const middleware = [...(options.middleware ?? [])];\n    for (const mw of middleware) {\n      checkMiddlewareCompatibility(mw, \"idb\", \"idb\");\n    }\n    super({ middleware, ctx });\n    this.#adapter = options.adapter;\n    this.#driver = options.driver;\n    this.#contract = options.contract;\n  }\n\n  /**\n   * Lower an IDB query plan to an IDB plan body via the adapter.\n   *\n   * Threads the contract through {@link IdbLowererContext} so per-field\n   * codec encoding can resolve field→codec mappings from the contract's\n   * storage schema.\n   */\n  protected override lower(plan: IdbQueryPlan, ctx: CodecCallContext): Promise<IdbPlanBody> {\n    const lowererCtx: IdbLowererContext = {\n      ...ctx,\n      contract: this.#contract,\n    };\n    return this.#adapter.lower(plan, lowererCtx);\n  }\n\n  /**\n   * Execute a lowered IDB plan body via the driver.\n   *\n   * Backs `query()` (inherited concretely from `RuntimeCore`) — rows are\n   * yielded as-is from the driver (identity pass-through). All current\n   * `idb/*` codecs are identity transforms — no per-field decoding is\n   * needed. When per-field codec decoding is added (e.g. decoding\n   * `idb/date@1` stored values back to `Date` instances, or custom codec\n   * output types), it wires up here.\n   */\n  protected override runDriver(exec: IdbPlanBody): AsyncIterable<Record<string, unknown>> {\n    return this.#driver.execute(exec);\n  }\n\n  /**\n   * Backs `execute()` (inherited concretely from `RuntimeCore`) — IDB has no\n   * native \"affected-row count without returning rows\" concept, so this\n   * drains `runDriver()`'s row stream and counts. The driver already\n   * materializes every op's touched rows in memory before yielding (see\n   * `IdbRuntimeDriverInstance.execute()`'s collect-then-yield strategy), so\n   * draining here has no extra cost beyond what a `query()` call over the\n   * same plan would already pay.\n   *\n   * This counts *rows the driver yields*, which correctly equals \"ops\n   * applied\" for every atomic plan kind: `add`/`put`/`update` each echo the\n   * one row they touched, `scan-write` echoes every matched row, and\n   * `delete` (`execute/ops.ts`'s `execDelete`) walks a cursor over its\n   * key/range and echoes each row it deletes — so a delete matching zero\n   * keys correctly resolves `{ affectedRows: 0 }` and one matching N keys\n   * (a range delete) resolves `{ affectedRows: N }`. For a `batch` plan,\n   * `affectedRows` is the sum of rows every op in the batch yields,\n   * *including read ops* (`key-get`/`index-get`/`cursor-scan`) if the batch\n   * happens to contain any — it's a row count across the whole plan, not a\n   * write-only count.\n   */\n  protected override async runExecute(exec: IdbPlanBody): Promise<RuntimeStatementStats> {\n    let affectedRows = 0;\n    for await (const _row of this.runDriver(exec)) {\n      affectedRows++;\n    }\n    return { affectedRows };\n  }\n\n  async transaction(storeNames: string[], mode: IDBTransactionMode = \"readwrite\"): Promise<IdbTransactionScope> {\n    return this.#driver.transaction(storeNames, mode);\n  }\n\n  override async close(): Promise<void> {\n    await this.#driver.close();\n  }\n\n  /**\n   * Verify that the live IDB marker matches the contract.\n   *\n   * Compares the stored `storageHash` against `contract.storage.storageHash`.\n   * A fresh database (no marker store) returns `false` — the caller should\n   * ensure migrations have been applied before running queries.\n   */\n  async verifyMarker(): Promise<boolean> {\n    const marker = await this.#driver.readMarker();\n    if (marker === null) return false;\n    const contractStorage = this.#contract[\"storage\"] as Record<string, unknown> | undefined;\n    const contractHash = contractStorage?.[\"storageHash\"];\n    return typeof contractHash === \"string\" && marker.storageHash === contractHash;\n  }\n}\n\n/**\n * Create an IDB runtime instance.\n *\n * @example\n * ```ts\n * const driver = createIDBRuntimeDriver(\"my-app\").create();\n * const runtime = createIdbRuntime({ adapter, driver, contract });\n * await runtime.query(plan)\n * await runtime.close();\n * ```\n */\nexport function createIdbRuntime(options: IdbRuntimeOptions): IdbRuntime {\n  return new IdbRuntimeImpl(options);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAqGA,SAAS,uBAAuB,UAA6D;CAC3F,OAAO;EACL;EACA,MAAM;EAIN,iBAAiB,OAAO,WAAW;EACnC,WAAW,KAAK,IAAI;EACpB,KAAK;GACH,YAAY,KAAA;GACZ,YAAY,KAAA;GACZ,aAAa,KAAA;EACf;EAKA,OAAO;EACP,aAAa,OAAO,SAAwB;GAK1C,MAAM,OAAO;GACb,MAAM,WAAoC,CAAC;GAC3C,KAAK,MAAM,CAAC,KAAK,UAAU,OAAO,QAAQ,IAAI,GAC5C,IAAI,QAAQ,QAGV,SAAS,UAAU,EAAE,aAAaA,QAAO,eAAe;QACnD,IAAI,OAAO,UAAU,YAE1B;QACK,IAAK,OAAO,gBAAgB,eAAe,iBAAiB,eAAgB,cAAc,KAAK,GAEpG,SAAS,OAAO,iBAAiB,KAAoB;QAErD,SAAS,OAAO;GAGpB,OAAO,YAAY,mBAAmB,QAAQ,CAAC;EACjD;CACF;AACF;;AAGA,SAAS,cAAc,OAAsC;CAC3D,OACE,OAAO,UAAU,YACjB,UAAU,QACV,WAAW,SACX,WAAW,SACX,eAAe,SACf,eAAe;AAEnB;;AAGA,SAAS,iBAAiB,OAA6C;CACrE,OAAO;EACL,OAAO,MAAM;EACb,OAAO,MAAM;EACb,WAAW,MAAM;EACjB,WAAW,MAAM;CACnB;AACF;;;;;;;;;;;;;;;AAgBA,IAAM,iBAAN,cAA6B,YAA4E;CACvG;CACA;CACA;CAEA,YAAY,SAA4B;EACtC,MAAM,MAAM,QAAQ,OAAO,uBAAuB,QAAQ,QAAQ;EAClE,MAAM,aAAa,CAAC,GAAI,QAAQ,cAAc,CAAC,CAAE;EACjD,KAAK,MAAM,MAAM,YACf,6BAA6B,IAAI,OAAO,KAAK;EAE/C,MAAM;GAAE;GAAY;EAAI,CAAC;EACzB,KAAKC,WAAW,QAAQ;EACxB,KAAKC,UAAU,QAAQ;EACvB,KAAKC,YAAY,QAAQ;CAC3B;;;;;;;;CASA,MAAyB,MAAoB,KAA6C;EACxF,MAAM,aAAgC;GACpC,GAAG;GACH,UAAU,KAAKA;EACjB;EACA,OAAO,KAAKF,SAAS,MAAM,MAAM,UAAU;CAC7C;;;;;;;;;;;CAYA,UAA6B,MAA2D;EACtF,OAAO,KAAKC,QAAQ,QAAQ,IAAI;CAClC;;;;;;;;;;;;;;;;;;;;;;CAuBA,MAAyB,WAAW,MAAmD;EACrF,IAAI,eAAe;EACnB,WAAW,MAAM,QAAQ,KAAK,UAAU,IAAI,GAC1C;EAEF,OAAO,EAAE,aAAa;CACxB;CAEA,MAAM,YAAY,YAAsB,OAA2B,aAA2C;EAC5G,OAAO,KAAKA,QAAQ,YAAY,YAAY,IAAI;CAClD;CAEA,MAAe,QAAuB;EACpC,MAAM,KAAKA,QAAQ,MAAM;CAC3B;;;;;;;;CASA,MAAM,eAAiC;EACrC,MAAM,SAAS,MAAM,KAAKA,QAAQ,WAAW;EAC7C,IAAI,WAAW,MAAM,OAAO;EAE5B,MAAM,eADkB,KAAKC,UAAU,UACH,GAAG;EACvC,OAAO,OAAO,iBAAiB,YAAY,OAAO,gBAAgB;CACpE;AACF;;;;;;;;;;;;AAaA,SAAgB,iBAAiB,SAAwC;CACvE,OAAO,IAAI,eAAe,OAAO;AACnC"}

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "@prisma-idb/runtime-idb",
+  "version": "0.0.0",
+  "description": "Prisma 8 IDB family — runtime (RuntimeCore subclass that wires adapter + driver)",
+  "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/runtime-idb"
+  },
+  "homepage": "https://prisma-idb.dev/",
+  "bugs": {
+    "url": "https://github.com/prisma-idb/prisma-idb/issues"
+  },
+  "type": "module",
+  "exports": {
+    "./runtime": "./dist/runtime.mjs",
+    "./package.json": "./package.json"
+  },
+  "dependencies": {
+    "@prisma/orm-framework": "8.0.0-rc.5",
+    "@prisma-idb/adapter-idb": "0.0.0",
+    "@prisma-idb/driver-idb": "0.0.0"
+  },
+  "devDependencies": {
+    "fake-indexeddb": "^6.2.5",
+    "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 ."
+  }
+}