@prisma-idb/client-idb 0.0.0

package/dist/idb-orm-zCRkkD_D.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"idb-orm-zCRkkD_D.d.mts","names":[],"sources":["../src/core/types.ts","../src/core/executor.ts","../src/core/model-accessor.ts","../src/core/store-state.ts","../src/core/grouped-accessor.ts","../src/core/store-accessor.ts","../src/core/idb-orm.ts"],"mappings":"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"}

package/dist/managed-client-B_8JZM3h.mjs

@@ -0,0 +1,122 @@
+import { c as withMutationScope, t as idbOrm } from "./idb-orm-Cupnnwum.mjs";
+import { IdbAdapter } from "@prisma-idb/adapter-idb/runtime";
+import { createIDBRuntimeDriver } from "@prisma-idb/driver-idb/runtime";
+import { createIdbRuntime } from "@prisma-idb/runtime-idb/runtime";
+import { idbCodecLookup } from "@prisma-idb/target-idb/runtime";
+//#region src/core/idb-client.ts
+/**
+* Creates a typed IDB client from a contract and a database name.
+*
+* Assembles the full runtime stack (driver → adapter → runtime → ORM) internally.
+* Equivalent to `postgres({ contract, url })` in `@prisma/orm-postgres/runtime`.
+*
+* The IDB database version is not exposed — it is managed by the migration runner
+* per ADR 001. The driver opens at the current database version, which is correct
+* for a runtime that only reads/writes (no DDL).
+*
+* @example
+* ```ts
+* import { createIdbClient } from '@prisma-idb/client-idb/client';
+* import contract from './contract';
+*
+* export const db = createIdbClient({ contract, dbName: 'my-app' });
+*
+* // Later:
+* const users = await db.orm.users.all().toArray();
+* ```
+*/
+function createIdbClient(options) {
+	const driver = createIDBRuntimeDriver(options.dbName, void 0, options.factory !== void 0 ? { factory: options.factory } : void 0).create();
+	const adapter = new IdbAdapter(idbCodecLookup);
+	const runtime = createIdbRuntime({
+		adapter,
+		driver,
+		contract: options.contract,
+		...options.middleware !== void 0 && options.middleware.length > 0 ? { middleware: options.middleware } : {}
+	});
+	return {
+		orm: idbOrm({
+			contract: options.contract,
+			executor: runtime
+		}),
+		withTransaction: (storeNames, fn) => withMutationScope(runtime, storeNames, fn),
+		verifyMarker: () => runtime.verifyMarker(),
+		async close() {
+			await runtime.close();
+		},
+		[Symbol.asyncDispose]() {
+			return this.close();
+		}
+	};
+}
+//#endregion
+//#region src/core/managed-client.ts
+/**
+* Wraps `open` (a client factory, e.g. `() => createAutoMigratingIdbClient({...})`)
+* with a module-scoped singleton: `get()` opens once and caches the result,
+* `close()` releases it, `reset()` closes and wipes the underlying database.
+*
+* @example
+* ```ts
+* import { createManagedIdbClient } from '@prisma-idb/client-idb/client';
+*
+* const db = createManagedIdbClient(
+*   () => createAutoMigratingIdbClient({ contractSpace, dbName: 'my-app' }),
+*   { dbName: 'my-app' }
+* );
+*
+* const client = await db.get();
+* // ... on logout:
+* await db.reset();
+* ```
+*/
+function createManagedIdbClient(open, options) {
+	const { dbName, idbFactory = indexedDB } = options;
+	let client = null;
+	let clientPromise = null;
+	let resetPromise = null;
+	async function get() {
+		if (resetPromise) await resetPromise;
+		if (client) return client;
+		clientPromise ??= open().catch((err) => {
+			clientPromise = null;
+			throw err;
+		});
+		const fresh = await clientPromise;
+		client = fresh;
+		return fresh;
+	}
+	async function close() {
+		if (!client) return;
+		await client.close();
+		client = null;
+		clientPromise = null;
+	}
+	async function reset() {
+		if (resetPromise) return resetPromise;
+		resetPromise = (async () => {
+			if (clientPromise) await clientPromise.catch(() => {});
+			await close();
+			await new Promise((resolve, reject) => {
+				const req = idbFactory.deleteDatabase(dbName);
+				req.onsuccess = () => resolve();
+				req.onerror = () => reject(req.error);
+				req.onblocked = () => {};
+			});
+		})();
+		try {
+			await resetPromise;
+		} finally {
+			resetPromise = null;
+		}
+	}
+	return {
+		get,
+		close,
+		reset
+	};
+}
+//#endregion
+export { createIdbClient as n, createManagedIdbClient as t };
+
+//# sourceMappingURL=managed-client-B_8JZM3h.mjs.map

package/dist/managed-client-B_8JZM3h.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"managed-client-B_8JZM3h.mjs","names":[],"sources":["../src/core/idb-client.ts","../src/core/managed-client.ts"],"sourcesContent":["import { IdbAdapter } from \"@prisma-idb/adapter-idb/runtime\";\nimport { createIDBRuntimeDriver } from \"@prisma-idb/driver-idb/runtime\";\nimport type { IdbTransactionScope } from \"@prisma-idb/driver-idb/runtime\";\nimport type { IdbMiddleware } from \"@prisma-idb/runtime-idb/runtime\";\nimport { createIdbRuntime } from \"@prisma-idb/runtime-idb/runtime\";\nimport { idbCodecLookup } from \"@prisma-idb/target-idb/runtime\";\nimport { withMutationScope } from \"./mutation-scope\";\nimport { idbOrm } from \"./idb-orm\";\nimport type { IdbOrmClient } from \"./idb-orm\";\nimport type { IdbContract } from \"./types\";\n\nexport interface IdbClientOptions<TContract extends IdbContract> {\n  readonly contract: TContract;\n  readonly dbName: string;\n  // No version — the migration runner owns the IDB version integer (ADR 001).\n  /** IDB factory override — primarily for tests and custom browser realms. */\n  readonly factory?: IDBFactory;\n  readonly middleware?: readonly IdbMiddleware[];\n}\n\nexport interface IdbClient<TContract extends IdbContract> {\n  readonly orm: IdbOrmClient<TContract>;\n  /**\n   * Run `fn` inside a single multi-store readwrite IDB transaction.\n   *\n   * Opens the transaction, passes an `IdbTransactionScope` to `fn`, then\n   * commits on success or rolls back on error. Equivalent to calling\n   * `withMutationScope(runtime, storeNames, fn)`.\n   *\n   * Useful from test harnesses and from any caller that has an `IdbClient`\n   * but not the raw runtime reference.\n   */\n  withTransaction<T>(storeNames: string[], fn: (scope: IdbTransactionScope) => Promise<T>): Promise<T>;\n  verifyMarker(): Promise<boolean>;\n  close(): Promise<void>;\n  [Symbol.asyncDispose](): Promise<void>;\n}\n\n/**\n * Creates a typed IDB client from a contract and a database name.\n *\n * Assembles the full runtime stack (driver → adapter → runtime → ORM) internally.\n * Equivalent to `postgres({ contract, url })` in `@prisma/orm-postgres/runtime`.\n *\n * The IDB database version is not exposed — it is managed by the migration runner\n * per ADR 001. The driver opens at the current database version, which is correct\n * for a runtime that only reads/writes (no DDL).\n *\n * @example\n * ```ts\n * import { createIdbClient } from '@prisma-idb/client-idb/client';\n * import contract from './contract';\n *\n * export const db = createIdbClient({ contract, dbName: 'my-app' });\n *\n * // Later:\n * const users = await db.orm.users.all().toArray();\n * ```\n */\nexport function createIdbClient<TContract extends IdbContract>(\n  options: IdbClientOptions<TContract>\n): IdbClient<TContract> {\n  const driver = createIDBRuntimeDriver(\n    options.dbName,\n    undefined,\n    options.factory !== undefined ? { factory: options.factory } : undefined\n  ).create();\n  const adapter = new IdbAdapter(idbCodecLookup);\n  const runtime = createIdbRuntime({\n    adapter,\n    driver,\n    contract: options.contract as Record<string, unknown>,\n    ...(options.middleware !== undefined && options.middleware.length > 0 ? { middleware: options.middleware } : {}),\n  });\n  const orm = idbOrm({ contract: options.contract, executor: runtime });\n\n  return {\n    orm,\n    withTransaction: <T>(storeNames: string[], fn: (scope: IdbTransactionScope) => Promise<T>) =>\n      withMutationScope(runtime, storeNames, fn),\n    verifyMarker: () => runtime.verifyMarker(),\n    async close() {\n      await runtime.close();\n    },\n    [Symbol.asyncDispose]() {\n      return this.close();\n    },\n  };\n}\n","/**\n * `createManagedIdbClient` — a singleton, race-safe wrapper around any IDB\n * client factory (`createIdbClient`, `createAutoMigratingIdbClient`, or a\n * sync-extension factory like `createAutoMigratingSyncIdbClient` — anything\n * returning a `close(): Promise<void>`-shaped client).\n *\n * Every consumer of this package that wants a module-level singleton client\n * plus a \"wipe local data\" reset (e.g. on logout) needs the same race-safety:\n * `reset()` must never call `indexedDB.deleteDatabase` while a `get()` open\n * is still in flight, since a still-opening connection would block (or worse,\n * leave a stale handle once that open resolves after the delete). This was\n * previously hand-rolled per app with diverging correctness; see ADR-less\n * discussion in the kanban example's `db.ts` history.\n */\n\nexport interface ManagedIdbClientOptions {\n  /** IDB database name — passed to `indexedDB.deleteDatabase` on `reset()`. */\n  readonly dbName: string;\n  /** IDB factory override — primarily for tests. Defaults to `indexedDB`. */\n  readonly idbFactory?: IDBFactory;\n}\n\nexport interface ManagedIdbClient<TClient> {\n  /** Opens the client on first call and caches it; concurrent calls share one open. */\n  get(): Promise<TClient>;\n  /** Closes the cached client, if any. Safe to call when nothing is open. */\n  close(): Promise<void>;\n  /**\n   * Closes and deletes the database — waits out any `get()` open already in\n   * flight first. `onblocked` (another tab still has the DB open) is NOT\n   * terminal — per spec, the delete request stays pending, and still fires\n   * `onsuccess` once every blocking connection closes — so this promise\n   * stays pending through it too, settling only once `deleteDatabase`\n   * actually reaches `onsuccess` or `onerror`. Neither resolving early\n   * (claims success before the old data is actually gone) nor rejecting\n   * early (reports failure on a delete that may still succeed) would be\n   * accurate.\n   */\n  reset(): Promise<void>;\n}\n\n/**\n * Wraps `open` (a client factory, e.g. `() => createAutoMigratingIdbClient({...})`)\n * with a module-scoped singleton: `get()` opens once and caches the result,\n * `close()` releases it, `reset()` closes and wipes the underlying database.\n *\n * @example\n * ```ts\n * import { createManagedIdbClient } from '@prisma-idb/client-idb/client';\n *\n * const db = createManagedIdbClient(\n *   () => createAutoMigratingIdbClient({ contractSpace, dbName: 'my-app' }),\n *   { dbName: 'my-app' }\n * );\n *\n * const client = await db.get();\n * // ... on logout:\n * await db.reset();\n * ```\n */\nexport function createManagedIdbClient<TClient extends { close(): Promise<void> }>(\n  open: () => Promise<TClient>,\n  options: ManagedIdbClientOptions\n): ManagedIdbClient<TClient> {\n  const { dbName, idbFactory = indexedDB } = options;\n\n  let client: TClient | null = null;\n  let clientPromise: Promise<TClient> | null = null;\n  // Gate between get() and reset() — set synchronously (no `await` before\n  // either reads/writes it) so the two never interleave: see module doc comment.\n  let resetPromise: Promise<void> | null = null;\n\n  async function get(): Promise<TClient> {\n    if (resetPromise) await resetPromise;\n    if (client) return client;\n    clientPromise ??= open().catch((err: unknown) => {\n      // Clear on rejection so a later get() call retries instead of\n      // re-awaiting the same rejected promise forever.\n      clientPromise = null;\n      throw err;\n    });\n\n    const fresh = await clientPromise;\n    client = fresh;\n    return fresh;\n  }\n\n  async function close(): Promise<void> {\n    if (!client) return;\n    await client.close();\n    client = null;\n    clientPromise = null;\n  }\n\n  async function reset(): Promise<void> {\n    if (resetPromise) return resetPromise;\n    resetPromise = (async () => {\n      if (clientPromise) await clientPromise.catch(() => {});\n      await close();\n      await new Promise<void>((resolve, reject) => {\n        const req = idbFactory.deleteDatabase(dbName);\n        req.onsuccess = () => resolve();\n        req.onerror = () => reject(req.error as Error);\n        // Deliberately no-op: `onblocked` only means the request is waiting\n        // on another open connection, not that it failed — `onsuccess` (or\n        // `onerror`) still fires later once that connection closes. Settling\n        // here either way would misreport the outcome; see the `reset()`\n        // doc comment above.\n        req.onblocked = () => {};\n      });\n    })();\n    try {\n      await resetPromise;\n    } finally {\n      resetPromise = null;\n    }\n  }\n\n  return { get, close, reset };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;AA2DA,SAAgB,gBACd,SACsB;CACtB,MAAM,SAAS,uBACb,QAAQ,QACR,KAAA,GACA,QAAQ,YAAY,KAAA,IAAY,EAAE,SAAS,QAAQ,QAAQ,IAAI,KAAA,CACjE,CAAC,CAAC,OAAO;CACT,MAAM,UAAU,IAAI,WAAW,cAAc;CAC7C,MAAM,UAAU,iBAAiB;EAC/B;EACA;EACA,UAAU,QAAQ;EAClB,GAAI,QAAQ,eAAe,KAAA,KAAa,QAAQ,WAAW,SAAS,IAAI,EAAE,YAAY,QAAQ,WAAW,IAAI,CAAC;CAChH,CAAC;CAGD,OAAO;EACL,KAHU,OAAO;GAAE,UAAU,QAAQ;GAAU,UAAU;EAAQ,CAG/D;EACF,kBAAqB,YAAsB,OACzC,kBAAkB,SAAS,YAAY,EAAE;EAC3C,oBAAoB,QAAQ,aAAa;EACzC,MAAM,QAAQ;GACZ,MAAM,QAAQ,MAAM;EACtB;EACA,CAAC,OAAO,gBAAgB;GACtB,OAAO,KAAK,MAAM;EACpB;CACF;AACF;;;;;;;;;;;;;;;;;;;;;;AC5BA,SAAgB,uBACd,MACA,SAC2B;CAC3B,MAAM,EAAE,QAAQ,aAAa,cAAc;CAE3C,IAAI,SAAyB;CAC7B,IAAI,gBAAyC;CAG7C,IAAI,eAAqC;CAEzC,eAAe,MAAwB;EACrC,IAAI,cAAc,MAAM;EACxB,IAAI,QAAQ,OAAO;EACnB,kBAAkB,KAAK,CAAC,CAAC,OAAO,QAAiB;GAG/C,gBAAgB;GAChB,MAAM;EACR,CAAC;EAED,MAAM,QAAQ,MAAM;EACpB,SAAS;EACT,OAAO;CACT;CAEA,eAAe,QAAuB;EACpC,IAAI,CAAC,QAAQ;EACb,MAAM,OAAO,MAAM;EACnB,SAAS;EACT,gBAAgB;CAClB;CAEA,eAAe,QAAuB;EACpC,IAAI,cAAc,OAAO;EACzB,gBAAgB,YAAY;GAC1B,IAAI,eAAe,MAAM,cAAc,YAAY,CAAC,CAAC;GACrD,MAAM,MAAM;GACZ,MAAM,IAAI,SAAe,SAAS,WAAW;IAC3C,MAAM,MAAM,WAAW,eAAe,MAAM;IAC5C,IAAI,kBAAkB,QAAQ;IAC9B,IAAI,gBAAgB,OAAO,IAAI,KAAc;IAM7C,IAAI,kBAAkB,CAAC;GACzB,CAAC;EACH,EAAA,CAAG;EACH,IAAI;GACF,MAAM;EACR,UAAU;GACR,eAAe;EACjB;CACF;CAEA,OAAO;EAAE;EAAK;EAAO;CAAM;AAC7B"}

package/dist/managed-client-kdyHm72t.d.mts

@@ -0,0 +1,115 @@
+import { b as IdbContract, t as IdbOrmClient } from "./idb-orm-zCRkkD_D.mjs";
+import { IdbTransactionScope } from "@prisma-idb/driver-idb/runtime";
+import { IdbMiddleware } from "@prisma-idb/runtime-idb/runtime";
+//#region src/core/idb-client.d.ts
+interface IdbClientOptions<TContract extends IdbContract> {
+  readonly contract: TContract;
+  readonly dbName: string;
+  /** IDB factory override — primarily for tests and custom browser realms. */
+  readonly factory?: IDBFactory;
+  readonly middleware?: readonly IdbMiddleware[];
+}
+interface IdbClient<TContract extends IdbContract> {
+  readonly orm: IdbOrmClient<TContract>;
+  /**
+   * Run `fn` inside a single multi-store readwrite IDB transaction.
+   *
+   * Opens the transaction, passes an `IdbTransactionScope` to `fn`, then
+   * commits on success or rolls back on error. Equivalent to calling
+   * `withMutationScope(runtime, storeNames, fn)`.
+   *
+   * Useful from test harnesses and from any caller that has an `IdbClient`
+   * but not the raw runtime reference.
+   */
+  withTransaction<T>(storeNames: string[], fn: (scope: IdbTransactionScope) => Promise<T>): Promise<T>;
+  verifyMarker(): Promise<boolean>;
+  close(): Promise<void>;
+  [Symbol.asyncDispose](): Promise<void>;
+}
+/**
+ * Creates a typed IDB client from a contract and a database name.
+ *
+ * Assembles the full runtime stack (driver → adapter → runtime → ORM) internally.
+ * Equivalent to `postgres({ contract, url })` in `@prisma/orm-postgres/runtime`.
+ *
+ * The IDB database version is not exposed — it is managed by the migration runner
+ * per ADR 001. The driver opens at the current database version, which is correct
+ * for a runtime that only reads/writes (no DDL).
+ *
+ * @example
+ * ```ts
+ * import { createIdbClient } from '@prisma-idb/client-idb/client';
+ * import contract from './contract';
+ *
+ * export const db = createIdbClient({ contract, dbName: 'my-app' });
+ *
+ * // Later:
+ * const users = await db.orm.users.all().toArray();
+ * ```
+ */
+declare function createIdbClient<TContract extends IdbContract>(options: IdbClientOptions<TContract>): IdbClient<TContract>;
+//#endregion
+//#region src/core/managed-client.d.ts
+/**
+ * `createManagedIdbClient` — a singleton, race-safe wrapper around any IDB
+ * client factory (`createIdbClient`, `createAutoMigratingIdbClient`, or a
+ * sync-extension factory like `createAutoMigratingSyncIdbClient` — anything
+ * returning a `close(): Promise<void>`-shaped client).
+ *
+ * Every consumer of this package that wants a module-level singleton client
+ * plus a "wipe local data" reset (e.g. on logout) needs the same race-safety:
+ * `reset()` must never call `indexedDB.deleteDatabase` while a `get()` open
+ * is still in flight, since a still-opening connection would block (or worse,
+ * leave a stale handle once that open resolves after the delete). This was
+ * previously hand-rolled per app with diverging correctness; see ADR-less
+ * discussion in the kanban example's `db.ts` history.
+ */
+interface ManagedIdbClientOptions {
+  /** IDB database name — passed to `indexedDB.deleteDatabase` on `reset()`. */
+  readonly dbName: string;
+  /** IDB factory override — primarily for tests. Defaults to `indexedDB`. */
+  readonly idbFactory?: IDBFactory;
+}
+interface ManagedIdbClient<TClient> {
+  /** Opens the client on first call and caches it; concurrent calls share one open. */
+  get(): Promise<TClient>;
+  /** Closes the cached client, if any. Safe to call when nothing is open. */
+  close(): Promise<void>;
+  /**
+   * Closes and deletes the database — waits out any `get()` open already in
+   * flight first. `onblocked` (another tab still has the DB open) is NOT
+   * terminal — per spec, the delete request stays pending, and still fires
+   * `onsuccess` once every blocking connection closes — so this promise
+   * stays pending through it too, settling only once `deleteDatabase`
+   * actually reaches `onsuccess` or `onerror`. Neither resolving early
+   * (claims success before the old data is actually gone) nor rejecting
+   * early (reports failure on a delete that may still succeed) would be
+   * accurate.
+   */
+  reset(): Promise<void>;
+}
+/**
+ * Wraps `open` (a client factory, e.g. `() => createAutoMigratingIdbClient({...})`)
+ * with a module-scoped singleton: `get()` opens once and caches the result,
+ * `close()` releases it, `reset()` closes and wipes the underlying database.
+ *
+ * @example
+ * ```ts
+ * import { createManagedIdbClient } from '@prisma-idb/client-idb/client';
+ *
+ * const db = createManagedIdbClient(
+ *   () => createAutoMigratingIdbClient({ contractSpace, dbName: 'my-app' }),
+ *   { dbName: 'my-app' }
+ * );
+ *
+ * const client = await db.get();
+ * // ... on logout:
+ * await db.reset();
+ * ```
+ */
+declare function createManagedIdbClient<TClient extends {
+  close(): Promise<void>;
+}>(open: () => Promise<TClient>, options: ManagedIdbClientOptions): ManagedIdbClient<TClient>;
+//#endregion
+export { IdbClientOptions as a, IdbClient as i, ManagedIdbClientOptions as n, createIdbClient as o, createManagedIdbClient as r, ManagedIdbClient as t };
+//# sourceMappingURL=managed-client-kdyHm72t.d.mts.map

package/dist/managed-client-kdyHm72t.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"managed-client-kdyHm72t.d.mts","names":[],"sources":["../src/core/idb-client.ts","../src/core/managed-client.ts"],"mappings":";;;;UAWiB,iBAAiB,kBAAkB;WACzC,UAAU;WACV;;WAGA,UAAU;WACV,sBAAsB;;UAGhB,UAAU,kBAAkB;WAClC,KAAK,aAAa;;;;;;;;;;;EAW3B,gBAAgB,GAAG,sBAAsB,KAAK,OAAO,wBAAwB,QAAQ,KAAK,QAAQ;EAClG,gBAAgB;EAChB,SAAS;GACR,OAAO,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;iBAwBX,gBAAgB,kBAAkB,aAChD,SAAS,iBAAiB,aACzB,UAAU;;;;;;;;;;;;;;;;;UC9CI;;WAEN;;WAEA,aAAa;;UAGP,iBAAiB;;EAEhC,OAAO,QAAQ;;EAEf,SAAS;;;;;;;;;;;;EAYT,SAAS;;;;;;;;;;;;;;;;;;;;;iBAsBK,uBAAuB;EAAkB,SAAS;GAChE,YAAY,QAAQ,UACpB,SAAS,0BACR,iBAAiB"}

package/dist/orm.d.mts

@@ -0,0 +1,85 @@
+import { A as MutationUpdateInput, B as SelectedRow, C as IncludeFields, D as KeyType, E as IncludedRow, F as ReferenceRelKeys, H as WhereFilter, I as RelatedModelOf, L as RelationMutationConnect, M as NumericFieldNames, N as OrderBySpec, O as ModelKeyPath, P as PatchInput, R as RelationMutationCreate, S as IdbRelationMutator, T as IncludeSpec, U as getKeyPath, V as SortDirection, W as getStoreName, _ as IdbAggregateResult, a as IdbStoreAccessor, b as IdbContract, c as IdbGroupedAccessor, d as IdbModelAccessor, f as IdbQueryExecutor, g as IdbAggregateBuilder, h as DefaultModelRow, i as IdbIncludeRefinementAccessor, j as NoIncludes, k as MutationCreateInput, l as IdbIncludeScalar, m as CreateInput, n as IdbOrmOptions, o as WhereCallback, p as AggregateFn, r as idbOrm, s as GroupedResultRow, t as IdbOrmClient, u as IdbFieldAccessor, v as IdbAggregateSelector, w as IncludeMarker, x as IdbRelationMutation, y as IdbAggregateSpec, z as RelationMutationDisconnect } from "./idb-orm-zCRkkD_D.mjs";
+import { IdbAndExpr, IdbAndExpr as IdbAndExpr$1, IdbFieldFilter, IdbFilterExpr, IdbFilterExpr as IdbFilterExpr$1, IdbFilterOp, IdbNotExpr, IdbNotExpr as IdbNotExpr$1, IdbNullCheckExpr, IdbOrExpr, IdbOrExpr as IdbOrExpr$1 } from "@prisma-idb/adapter-idb/runtime";
+import { IdbTransactionScope } from "@prisma-idb/driver-idb/runtime";
+//#region src/core/filters.d.ts
+/** Variadic AND. `and()` (no args) is vacuously true. */
+declare function and(...exprs: ReadonlyArray<IdbFilterExpr$1>): IdbAndExpr$1;
+/** Variadic OR. `or()` (no args) is vacuously false. */
+declare function or(...exprs: ReadonlyArray<IdbFilterExpr$1>): IdbOrExpr$1;
+/** Logical NOT. */
+declare function not(expr: IdbFilterExpr$1): IdbNotExpr$1;
+//#endregion
+//#region src/core/mutation-scope.d.ts
+/**
+ * Extends the basic {@link IdbQueryExecutor} with multi-store transaction
+ * support. `IdbRuntime` satisfies this interface — `runtime.transaction()`
+ * delegates to `driver.transaction()` which opens the IDB transaction.
+ */
+interface IdbQueryExecutorWithTransaction extends IdbQueryExecutor {
+  /**
+   * Open a multi-store IDB transaction and return a scope object.
+   *
+   * The returned scope's `execute()` runs `IdbAtomicPlan`s directly inside
+   * the transaction — no new transaction is opened per call, and the
+   * middleware chain is bypassed. `commit()` resolves when `tx.oncomplete`
+   * fires; `rollback()` calls `tx.abort()`.
+   */
+  transaction(storeNames: string[], mode?: IDBTransactionMode): Promise<IdbTransactionScope>;
+}
+/**
+ * Run a callback inside a single multi-store IDB readwrite transaction.
+ *
+ * Opens the transaction, passes the `IdbTransactionScope` to `run`, then:
+ * - On success: awaits `scope.commit()` (waits for `tx.oncomplete`).
+ * - On error: calls `scope.rollback()` and rethrows.
+ *
+ * The callback receives the low-level scope, not the ORM accessor.
+ * Use this for multi-store atomic writes that span several object stores.
+ */
+declare function withMutationScope<T>(executor: IdbQueryExecutorWithTransaction, storeNames: string[], run: (scope: IdbTransactionScope) => Promise<T>): Promise<T>;
+//#endregion
+//#region src/core/relation-mutator.d.ts
+declare function createRelationMutator<TContract extends IdbContract, ModelName extends string>(): IdbRelationMutator<TContract, ModelName>;
+declare function isRelationMutationDescriptor(value: unknown): value is IdbRelationMutation<IdbContract, string>;
+declare function isRelationMutationCallback(value: unknown): value is (mutator: IdbRelationMutator<IdbContract, string>) => IdbRelationMutation<IdbContract, string>;
+//#endregion
+//#region src/core/mutation-executor.d.ts
+/**
+ * Returns true if `data` contains at least one field that is both a known
+ * relation name for `modelName` and a function (a mutation callback).
+ */
+declare function hasNestedMutationCallbacks(contract: IdbContract, modelName: string, data: Record<string, unknown>): boolean;
+/**
+ * Transitively walks the `onDelete` cascade graph from `modelName`, collecting
+ * every store a recursive delete might touch. `cascade` edges are walked
+ * further (a cascaded child's own children may themselves cascade);
+ * `restrict`/`setNull`/`setDefault` edges still need their store added (each
+ * is read or written once) but don't recurse further, since none of them
+ * delete the child row. Guarded by a model-level visited set — required
+ * because IDB must declare every store a transaction might touch before it
+ * opens, so this static walk must terminate even on a self-referential model
+ * or a cycle of mutually-cascading models.
+ */
+declare function collectDeleteStoreNames(contract: IdbContract, modelName: string): string[];
+/**
+ * Enforces every `onDelete` action declared on `modelName`'s child relations
+ * against one specific `row` about to be deleted. `cascade` recurses into
+ * each matched child's own `onDelete` relations *before* deleting it — so a
+ * multi-hop chain (`User --cascade--> Post --cascade--> Comment`) is fully
+ * torn down, and a `restrict` several hops deep still aborts the whole
+ * transaction (recursing before deleting means the delete never happens if a
+ * deeper hop throws). `setNull`/`setDefault` are leaf actions: the child row
+ * survives, so recursion never continues past them.
+ *
+ * `visited` (keyed by `storeName::key`) guards against row-level cycles — two
+ * specific rows whose FKs point at each other through a self-referential or
+ * mutually-cascading relation graph. Callers should leave it at its default
+ * (a fresh `Set` per top-level call) so independent rows deleted in the same
+ * `deleteAll()` batch don't cross-suppress each other's cascades; it's only
+ * ever passed explicitly by this function's own recursive calls, to keep one
+ * shared guard across a single row's full recursive descent.
+ */
+declare function applyReferentialActionsForRow(scope: IdbTransactionScope, contract: IdbContract, modelName: string, row: Record<string, unknown>, visited?: Set<string>): Promise<void>;
+//#endregion
+export { type AggregateFn, type CreateInput, type DefaultModelRow, type GroupedResultRow, type IdbAggregateBuilder, type IdbAggregateResult, type IdbAggregateSelector, type IdbAggregateSpec, type IdbAndExpr, type IdbContract, type IdbFieldAccessor, type IdbFieldFilter, type IdbFilterExpr, type IdbFilterOp, type IdbGroupedAccessor, type IdbIncludeRefinementAccessor, type IdbIncludeScalar, type IdbModelAccessor, type IdbNotExpr, type IdbNullCheckExpr, type IdbOrExpr, type IdbOrmClient, type IdbOrmOptions, type IdbQueryExecutor, type IdbQueryExecutorWithTransaction, type IdbRelationMutation, type IdbRelationMutator, type IdbStoreAccessor, type IncludeFields, type IncludeMarker, type IncludeSpec, type IncludedRow, type KeyType, type ModelKeyPath, type MutationCreateInput, type MutationUpdateInput, type NoIncludes, type NumericFieldNames, type OrderBySpec, type PatchInput, type ReferenceRelKeys, type RelatedModelOf, type RelationMutationConnect, type RelationMutationCreate, type RelationMutationDisconnect, type SelectedRow, type SortDirection, type WhereCallback, type WhereFilter, and, applyReferentialActionsForRow, collectDeleteStoreNames, createRelationMutator, getKeyPath, getStoreName, hasNestedMutationCallbacks, idbOrm, isRelationMutationCallback, isRelationMutationDescriptor, not, or, withMutationScope };
+//# sourceMappingURL=orm.d.mts.map

package/dist/orm.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"orm.d.mts","names":[],"sources":["../src/core/filters.ts","../src/core/mutation-scope.ts","../src/core/relation-mutator.ts","../src/core/mutation-executor.ts"],"mappings":";;;;;iBAqBgB,OAAO,OAAO,cAAc,mBAAiB;;iBAK7C,MAAM,OAAO,cAAc,mBAAiB;;iBAK5C,IAAI,MAAM,kBAAgB;;;;;;;;UCFzB,wCAAwC;;;;;;;;;EASvD,YAAY,sBAAsB,OAAO,qBAAqB,QAAQ;;;;;;;;;;;;iBAelD,kBAAkB,GACtC,UAAU,iCACV,sBACA,MAAM,OAAO,wBAAwB,QAAQ,KAC5C,QAAQ;;;iBC/BK,sBAAsB,kBAAkB,aAAa,6BAA6B,mBAChG,WACA;iBAsBc,6BAA6B,iBAAiB,SAAS,oBAAoB;iBAM3E,2BACd,iBACC,UAAU,SAAS,mBAAmB,yBAAyB,oBAAoB;;;;;;;iBC0EtE,2BACd,UAAU,aACV,mBACA,MAAM;;;;;;;;;;;;iBAymCQ,wBAAwB,UAAU,aAAa;;;;;;;;;;;;;;;;;;;iBAuCzC,8BACpB,OAAO,qBACP,UAAU,aACV,mBACA,KAAK,yBACL,UAAS,cACR"}

package/dist/orm.mjs

@@ -0,0 +1,28 @@
+import { a as createRelationMutator, c as withMutationScope, i as hasNestedMutationCallbacks, l as getKeyPath, n as applyReferentialActionsForRow, o as isRelationMutationCallback, r as collectDeleteStoreNames, s as isRelationMutationDescriptor, t as idbOrm, u as getStoreName } from "./idb-orm-Cupnnwum.mjs";
+import { andExpr, notExpr, orExpr } from "@prisma-idb/adapter-idb/runtime";
+//#region src/core/filters.ts
+/**
+* User-facing logical combinators for the IDB ORM.
+*
+* `and(a, b, ...)`, `or(a, b, ...)`, `not(e)` — thin wrappers over the
+* frozen factory helpers in `adapter-idb` that exist so callers don't
+* have to import from the adapter package directly. Mirrors the
+* `where { AND, OR, NOT }` shape Prisma users are already familiar with,
+* exposed as plain functions to keep the AST construction explicit.
+*/
+/** Variadic AND. `and()` (no args) is vacuously true. */
+function and(...exprs) {
+	return andExpr(exprs);
+}
+/** Variadic OR. `or()` (no args) is vacuously false. */
+function or(...exprs) {
+	return orExpr(exprs);
+}
+/** Logical NOT. */
+function not(expr) {
+	return notExpr(expr);
+}
+//#endregion
+export { and, applyReferentialActionsForRow, collectDeleteStoreNames, createRelationMutator, getKeyPath, getStoreName, hasNestedMutationCallbacks, idbOrm, isRelationMutationCallback, isRelationMutationDescriptor, not, or, withMutationScope };
+
+//# sourceMappingURL=orm.mjs.map

package/dist/orm.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"orm.mjs","names":[],"sources":["../src/core/filters.ts"],"sourcesContent":["/**\n * User-facing logical combinators for the IDB ORM.\n *\n * `and(a, b, ...)`, `or(a, b, ...)`, `not(e)` — thin wrappers over the\n * frozen factory helpers in `adapter-idb` that exist so callers don't\n * have to import from the adapter package directly. Mirrors the\n * `where { AND, OR, NOT }` shape Prisma users are already familiar with,\n * exposed as plain functions to keep the AST construction explicit.\n */\n\nimport {\n  andExpr,\n  notExpr,\n  orExpr,\n  type IdbAndExpr,\n  type IdbFilterExpr,\n  type IdbNotExpr,\n  type IdbOrExpr,\n} from \"@prisma-idb/adapter-idb/runtime\";\n\n/** Variadic AND. `and()` (no args) is vacuously true. */\nexport function and(...exprs: ReadonlyArray<IdbFilterExpr>): IdbAndExpr {\n  return andExpr(exprs);\n}\n\n/** Variadic OR. `or()` (no args) is vacuously false. */\nexport function or(...exprs: ReadonlyArray<IdbFilterExpr>): IdbOrExpr {\n  return orExpr(exprs);\n}\n\n/** Logical NOT. */\nexport function not(expr: IdbFilterExpr): IdbNotExpr {\n  return notExpr(expr);\n}\n"],"mappings":";;;;;;;;;;;;;AAqBA,SAAgB,IAAI,GAAG,OAAiD;CACtE,OAAO,QAAQ,KAAK;AACtB;;AAGA,SAAgB,GAAG,GAAG,OAAgD;CACpE,OAAO,OAAO,KAAK;AACrB;;AAGA,SAAgB,IAAI,MAAiC;CACnD,OAAO,QAAQ,IAAI;AACrB"}

package/package.json

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