@prisma-next-idb/runtime-idb 0.1.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/dist/runtime.d.mts

@@ -0,0 +1,116 @@
+import { AsyncIterableResult, RuntimeExecuteOptions, RuntimeMiddleware, RuntimeMiddlewareContext } from "@prisma-next/framework-components/runtime";
+import { IdbQueryPlan, IdbRuntimeAdapterInstance } from "@prisma-next-idb/adapter-idb/runtime";
+import { IdbPlanBody, IdbRuntimeDriverInstance, IdbTransactionScope } from "@prisma-next-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.
+ *
+ * `execute()` accepts an {@link IdbQueryPlan} and returns an
+ * `AsyncIterableResult<Row>` — an async iterable that also fulfils as a
+ * `Row[]` when awaited.
+ */
+interface IdbRuntime {
+  execute<Row>(plan: IdbQueryPlan & {
+    readonly _row?: Row;
+  }, options?: RuntimeExecuteOptions): AsyncIterableResult<Row>;
+  /**
+   * 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.execute(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":";;;;;;;;AA4BA;;;;;;;;AACmB;;;;ACZnB;;;;;;;;;;UDWiB,aAAA,SAAsB,iBAAiB,CAAC,WAAA;EAAA,SAC9C,QAAA;AAAA;;;;AADX;;UCXiB,iBAAA;EDWuC;EAAA,SCT7C,OAAA,EAAS,yBAAA;EDSqC;EAAA,SCP9C,MAAA,EAAQ,wBAAA;EDQA;AAAA;;;;ACZnB;;;;EDYmB,SCER,QAAA,EAAU,MAAA;EAAA;EAAA,SAEV,UAAA,YAAsB,aAAA;EAMhB;;;;;EAAA,SAAN,GAAA,GAAM,wBAAA;AAAA;;;;;;;;UAUA,UAAA;EACf,OAAA,MAAa,IAAA,EAAM,YAAA;IAAA,SAA0B,IAAA,GAAO,GAAA;EAAA,GAAO,OAAA,GAAU,qBAAA,GAAwB,mBAAA,CAAoB,GAAA;EAA9F;;;;;;;;;;EAWnB,WAAA,CAAY,UAAA,YAAsB,IAAA,GAAO,kBAAA,GAAqB,OAAA,CAAQ,mBAAA;EAgBtD;;;;;;;;;;;;;;EADhB,YAAA,IAAgB,OAAA;EAChB,KAAA,IAAS,OAAA;AAAA;;;;;;AAAO;AA2LlB;;;;;iBAAgB,gBAAA,CAAiB,OAAA,EAAS,iBAAA,GAAoB,UAAU"}

package/dist/runtime.mjs

@@ -0,0 +1,154 @@
+import { RuntimeCore } from "@prisma-next/framework-components/runtime";
+import { canonicalStringify } from "@prisma-next/utils/canonical-stringify";
+import { hashContent } from "@prisma-next/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).
+*/
+/**
+* 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
+* `@prisma-next/middleware-cache`.
+*
+* 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
+* - `execute()` — the concrete 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);
+		super({
+			middleware: [...options.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.
+	*/
+	runDriver(exec) {
+		return this.#driver.execute(exec);
+	}
+	/**
+	* Execute an IDB query plan and return a typed async-iterable result.
+	*
+	* 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.
+	*/
+	execute(plan, options) {
+		return super.execute(plan, options);
+	}
+	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.execute(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-next/framework-components/codec\";\nimport {\n  AsyncIterableResult,\n  RuntimeCore,\n  type ExecutionPlan,\n  type RuntimeExecuteOptions,\n  type RuntimeMiddlewareContext,\n} from \"@prisma-next/framework-components/runtime\";\nimport { canonicalStringify } from \"@prisma-next/utils/canonical-stringify\";\nimport { hashContent } from \"@prisma-next/utils/hash-content\";\nimport type { IdbLowererContext, IdbQueryPlan, IdbRuntimeAdapterInstance } from \"@prisma-next-idb/adapter-idb/runtime\";\nimport type { IdbPlanBody, IdbRuntimeDriverInstance, IdbTransactionScope } from \"@prisma-next-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 * `execute()` accepts an {@link IdbQueryPlan} and returns an\n * `AsyncIterableResult<Row>` — an async iterable that also fulfils as a\n * `Row[]` when awaited.\n */\nexport interface IdbRuntime {\n  execute<Row>(plan: IdbQueryPlan & { readonly _row?: Row }, options?: RuntimeExecuteOptions): AsyncIterableResult<Row>;\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).\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 * `@prisma-next/middleware-cache`.\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    // execute() path, which is exactly the \"runtime\" scope. There is no IDB\n    // 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 * - `execute()` — the concrete 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    super({ middleware: [...(options.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  protected override runDriver(exec: IdbPlanBody): AsyncIterable<Record<string, unknown>> {\n    return this.#driver.execute(exec);\n  }\n\n  /**\n   * Execute an IDB query plan and return a typed async-iterable result.\n   *\n   * Rows are yielded as-is from the driver (identity pass-through).\n   * All current `idb/*` codecs are identity transforms — no per-field\n   * decoding is needed. When per-field codec decoding is added (e.g.\n   * decoding `idb/date@1` stored values back to `Date` instances, or\n   * custom codec output types), it wires up here.\n   */\n  override execute<Row>(\n    plan: IdbQueryPlan & { readonly _row?: Row },\n    options?: RuntimeExecuteOptions\n  ): AsyncIterableResult<Row> {\n    return super.execute(plan, options);\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.execute(plan)\n * await runtime.close();\n * ```\n */\nexport function createIdbRuntime(options: IdbRuntimeOptions): IdbRuntime {\n  return new IdbRuntimeImpl(options);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AAoGA,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;;;;;;;;;;;AAYA,IAAM,iBAAN,cAA6B,YAA4E;CACvG;CACA;CACA;CAEA,YAAY,SAA4B;EACtC,MAAM,MAAM,QAAQ,OAAO,uBAAuB,QAAQ,QAAQ;EAClE,MAAM;GAAE,YAAY,CAAC,GAAI,QAAQ,cAAc,CAAC,CAAE;GAAG;EAAI,CAAC;EAC1D,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;;;;CAKA,UAA6B,MAA2D;EACtF,OAAO,KAAKC,QAAQ,QAAQ,IAAI;CAClC;;;;;;;;;;CAWA,QACE,MACA,SAC0B;EAC1B,OAAO,MAAM,QAAQ,MAAM,OAAO;CACpC;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,50 @@
+{
+  "name": "@prisma-next-idb/runtime-idb",
+  "version": "0.1.0",
+  "description": "Prisma Next IDB family — runtime (RuntimeCore subclass that wires adapter + driver)",
+  "license": "MIT",
+  "files": [
+    "dist"
+  ],
+  "keywords": [
+    "prisma",
+    "prisma-next",
+    "indexeddb",
+    "offline-first",
+    "idb"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/prisma-idb/idb-client-generator.git",
+    "directory": "packages/prisma-next/runtime-idb"
+  },
+  "homepage": "https://prisma-idb.dev/",
+  "bugs": {
+    "url": "https://github.com/prisma-idb/idb-client-generator/issues"
+  },
+  "type": "module",
+  "exports": {
+    "./runtime": "./dist/runtime.mjs",
+    "./package.json": "./package.json"
+  },
+  "dependencies": {
+    "@prisma-next/framework-components": "^0.14.0",
+    "@prisma-next/utils": "^0.14.0",
+    "@prisma-next-idb/adapter-idb": "0.1.0",
+    "@prisma-next-idb/driver-idb": "0.1.0"
+  },
+  "devDependencies": {
+    "fake-indexeddb": "^6.2.5",
+    "tsdown": "^0.22.3",
+    "typescript": "^6.0.3",
+    "vitest": "^4.1.9"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "dev": "tsdown --watch",
+    "check": "tsc --noEmit",
+    "test": "vitest run",
+    "lint": "prettier --check . && eslint .",
+    "format": "prettier --write ."
+  }
+}