@prisma-idb/client-idb 0.9.0 → 0.10.0

package/dist/idb-orm-gEKHfG4H.d.mts

@@ -0,0 +1,399 @@
+import { C as NoIncludes, D as ReferenceRelKeys, E as PatchInput, M as SelectedRow, O as RelatedModelOf, P as WhereFilter, S as MutationUpdateInput, T as OrderBySpec, a as IdbAggregateBuilder, c as IdbAggregateSpec, g as IncludeSpec, i as DefaultModelRow, l as IdbContract, o as IdbAggregateResult, p as IdbStorage, r as CreateInput, t as IdbQueryExecutor, v as KeyType, x as MutationCreateInput } from "./executor-CevtdBfz.mjs";
+import { AsyncIterableResult } from "@prisma/orm-framework/components/runtime";
+import { IdbFieldFilter, IdbFilterExpr, IdbNullCheckExpr } from "@prisma-idb/adapter-idb/runtime";
+import { Contract } from "@prisma/orm-framework/contract/types";
+//#region src/core/model-accessor.d.ts
+/**
+ * Operator surface available on every field. All return frozen AST nodes
+ * — they are values, not statements, so chaining and logical combinators
+ * compose naturally.
+ */
+interface IdbFieldAccessor<T> {
+  eq(value: T): IdbFieldFilter;
+  neq(value: T): IdbFieldFilter;
+  gt(value: T): IdbFieldFilter;
+  lt(value: T): IdbFieldFilter;
+  gte(value: T): IdbFieldFilter;
+  lte(value: T): IdbFieldFilter;
+  in(values: ReadonlyArray<T>): IdbFieldFilter;
+  notIn(values: ReadonlyArray<T>): IdbFieldFilter;
+  contains(sub: string): IdbFieldFilter;
+  startsWith(sub: string): IdbFieldFilter;
+  endsWith(sub: string): IdbFieldFilter;
+  isNull(): IdbNullCheckExpr;
+  isNotNull(): IdbNullCheckExpr;
+}
+/**
+ * The accessor object handed to a `where(fn)` callback. Each key resolves
+ * to an {@link IdbFieldAccessor} typed against the field's output type.
+ *
+ * The Proxy makes every string key resolve to an accessor at runtime; the
+ * type narrows the visible surface to the model's declared fields so the
+ * developer gets autocomplete.
+ */
+type IdbModelAccessor<TContract, ModelName extends string> = { readonly [K in keyof DefaultModelRow<TContract, ModelName>]-?: IdbFieldAccessor<DefaultModelRow<TContract, ModelName>[K]>; };
+//#endregion
+//#region src/core/store-state.d.ts
+/**
+ * One entry in {@link IdbAccessorState.includes} — describes how a single
+ * `.include()`d relation should be materialised.
+ *
+ * - `collection`: load the related rows, applying the refined `state`
+ *   (its `filters` / `orderBy` / `skip` / `take`) to the child scan.
+ *   `state` is `emptyAccessorState()` for an unrefined `.include(rel)`.
+ * - `scalar`: reduce the related rows to a single number (Phase 6.5 supports
+ *   `count`). The `state.filters` still constrain which children are counted.
+ *
+ * Mirrors the `IncludeExpr` / `IncludeScalar` split from
+ * Prisma ORM's SQL client, collapsed to the two shapes IDB
+ * needs (no SQL column mapping, no `combine()` branches).
+ */
+type IncludeEntry = {
+  readonly kind: "collection";
+  readonly state: IdbAccessorState;
+} | {
+  readonly kind: "scalar";
+  readonly fn: "count";
+  readonly state: IdbAccessorState;
+};
+/**
+ * Marker returned by the child accessor's `.count()` terminal when it is
+ * called inside an `include()` refinement callback. Carries the refined
+ * child `state` so the relation loader counts only the matching children.
+ *
+ * Detected by {@link isIncludeScalar}; mirrors `IncludeScalar` from the
+ * vendor `sql-orm-client/include-descriptors.ts`.
+ */
+interface IdbIncludeScalar {
+  readonly kind: "includeScalar";
+  readonly fn: "count";
+  readonly state: IdbAccessorState;
+}
+/**
+ * Immutable state carried by each {@link IdbStoreAccessorImpl} node in the
+ * builder chain.
+ *
+ * Every mutating method (`.where()`, `.take()`, etc.) returns a cloned
+ * instance with an updated state rather than mutating in place, making the
+ * accessor safe to reuse across multiple query branches.
+ */
+interface IdbAccessorState {
+  /**
+   * Accumulated filter expressions. Multiple `.where()` calls compose
+   * with AND semantics — the planner wraps them in an `andExpr` when
+   * lowering. Each entry is already either an `IdbFieldFilter`, a
+   * combinator, or a `null-check` node — never raw shorthand records.
+   */
+  readonly filters: ReadonlyArray<IdbFilterExpr>;
+  /** Sort spec: field → direction. Applied as an in-memory comparator. */
+  readonly orderBy?: Record<string, "asc" | "desc">;
+  /** OFFSET (number of rows to skip). */
+  readonly skip?: number;
+  /** LIMIT (maximum number of rows to return). */
+  readonly take?: number;
+  /**
+   * Relations that have been `.include()`d — keys are relation names, values
+   * describe how to materialise each (collection vs scalar count, plus any
+   * refinement state). See {@link IncludeEntry}.
+   */
+  readonly includes: Record<string, IncludeEntry>;
+  /**
+   * Fields kept by `.select()`. `undefined` means "all fields". When set,
+   * the materialised rows are projected down to these fields (plus any
+   * included relation keys) after the scan and relation loads complete.
+   */
+  readonly selectedFields?: ReadonlyArray<string>;
+}
+//#endregion
+//#region src/core/grouped-accessor.d.ts
+/**
+ * One grouped-aggregate result row: the group-key fields picked from the model
+ * row, intersected with the aggregate aliases.
+ */
+type GroupedResultRow<TContract, ModelName extends string, Fields extends readonly string[], Spec extends IdbAggregateSpec> = Pick<DefaultModelRow<TContract, ModelName>, Fields[number] & keyof DefaultModelRow<TContract, ModelName>> & IdbAggregateResult<Spec>;
+/**
+ * Grouped-aggregate builder returned by `accessor.groupBy(...)`.
+ *
+ * Port of the vendor `GroupedCollection` (`sql-orm-client/grouped-collection.ts`),
+ * but purely in-memory: there is no SQL compilation, so `aggregate()`
+ * materialises the matching rows, partitions them by the group-key fields, and
+ * reduces each partition with the requested selectors.
+ */
+interface IdbGroupedAccessor<TContract, ModelName extends string, Fields extends readonly string[]> {
+  /**
+   * Reduce each group to one row of `{ ...groupKeyFields, ...aggregates }`.
+   *
+   * @example
+   * ```ts
+   * const byUser = await db.posts
+   *   .where({ published: true })
+   *   .groupBy("authorId")
+   *   .aggregate((agg) => ({ count: agg.count(), totalViews: agg.sum("views") }));
+   * // [{ authorId: "u1", count: 3, totalViews: 120 }, ...]
+   * ```
+   */
+  aggregate<Spec extends IdbAggregateSpec>(fn: (agg: IdbAggregateBuilder<TContract, ModelName>) => Spec): Promise<Array<GroupedResultRow<TContract, ModelName, Fields, Spec>>>;
+}
+//#endregion
+//#region src/core/store-accessor.d.ts
+/** Callback form of `.where(fn)` — receives the typed model accessor proxy. */
+type WhereCallback<TContract, ModelName extends string> = (m: IdbModelAccessor<TContract, ModelName>) => IdbFilterExpr;
+/** Tuple of one-or-more field names of a model (for `select()` / `groupBy()`). */
+type FieldTuple<TContract, ModelName extends string> = readonly [keyof DefaultModelRow<TContract, ModelName> & string, ...(keyof DefaultModelRow<TContract, ModelName> & string)[]];
+/**
+ * The child accessor handed to an `include()` refinement callback.
+ *
+ * Exposes the chainable narrowing methods (`where` / `orderBy` / `take` /
+ * `skip`) plus the scalar `count()` reducer. Mirrors the vendor
+ * `IncludeRefinementCollection`: chainable methods return the same refinement
+ * surface so `count()` stays reachable after a `where()`, and `count()` returns
+ * an {@link IdbIncludeScalar} marker rather than the async terminal `count()`
+ * found on the top-level accessor.
+ */
+interface IdbIncludeRefinementAccessor<TContract, ModelName extends string> {
+  where(filter: WhereFilter<TContract, ModelName> | WhereCallback<TContract, ModelName>): IdbIncludeRefinementAccessor<TContract, ModelName>;
+  orderBy(spec: OrderBySpec<TContract, ModelName>): IdbIncludeRefinementAccessor<TContract, ModelName>;
+  take(n: number): IdbIncludeRefinementAccessor<TContract, ModelName>;
+  skip(n: number): IdbIncludeRefinementAccessor<TContract, ModelName>;
+  count(): IdbIncludeScalar;
+}
+/** Refinement callback type for a given relation key `K`. */
+type IncludeRefineFn<TContract, ModelName extends string, K extends string, R> = (collection: IdbIncludeRefinementAccessor<TContract, RelatedModelOf<TContract, ModelName, K>>) => R;
+/**
+ * Immutable query-builder for a single IDB object store.
+ *
+ * Each method that narrows the query (`.where()`, `.take()`, etc.) returns a
+ * new, independent accessor instance — the original is never mutated. This
+ * mirrors the `MongoCollection` pattern from Prisma ORM's Mongo family.
+ *
+ * @template TContract   - The full IDB contract (with or without type maps).
+ * @template ModelName   - The model (store) this accessor targets.
+ * @template TIncludes   - Tracks which relations have been included via
+ *   `.include()` calls, so the return type widens progressively.
+ * @template TSelected   - Field names kept by `.select()`. `never` (the
+ *   default) means "all fields"; otherwise the row narrows to these fields
+ *   (plus any included relations).
+ */
+interface IdbStoreAccessor<TContract, ModelName extends string, TIncludes extends IncludeSpec<TContract, ModelName> = NoIncludes, TSelected extends string = never> {
+  /**
+   * Add a filter (ANDed with any previous `.where()` calls).
+   *
+   * Two forms:
+   *
+   * - **Shorthand**: `where({ field: value })` — multi-key shorthand
+   *   objects compose as AND. `null` values become null-checks rather
+   *   than literal-null equalities so absent fields match.
+   * - **Callback**: `where((m) => m.field.op(value))` — receives the
+   *   typed model accessor proxy and returns an `IdbFilterExpr` built
+   *   via the operator surface. Combinators (`and`, `or`, `not` from
+   *   `@prisma-idb/client-idb/orm`) compose nodes.
+   */
+  where(filter: WhereFilter<TContract, ModelName> | WhereCallback<TContract, ModelName>): IdbStoreAccessor<TContract, ModelName, TIncludes, TSelected>;
+  /** Set the sort order. Replaces any previous `.orderBy()` call. */
+  orderBy(spec: OrderBySpec<TContract, ModelName>): IdbStoreAccessor<TContract, ModelName, TIncludes, TSelected>;
+  /** Limit the number of rows returned. */
+  take(n: number): IdbStoreAccessor<TContract, ModelName, TIncludes, TSelected>;
+  /** Skip the first `n` rows (OFFSET). */
+  skip(n: number): IdbStoreAccessor<TContract, ModelName, TIncludes, TSelected>;
+  /**
+   * Include a reference relation in the returned rows.
+   *
+   * The relation is loaded via a single batch cursor scan after the main
+   * query — O(1) round trips to IDB per included relation regardless of
+   * the number of parent rows. The return type gains the relation field
+   * automatically.
+   *
+   * An optional refinement callback narrows the loaded relation:
+   *
+   * - return the (chained) collection to apply `where` / `orderBy` /
+   *   `take` / `skip` to the related rows (per-parent for `1:N`);
+   * - return `collection.count()` to reduce a to-many relation to the
+   *   number of matching children (the field becomes a `number`).
+   *
+   * @example
+   * ```ts
+   * db.users.include("posts", (posts) => posts.where({ published: true }).take(5))
+   * db.users.include("posts", (posts) => posts.count())
+   * ```
+   */
+  include<K extends ReferenceRelKeys<TContract, ModelName>>(relation: K, refineFn?: IncludeRefineFn<TContract, ModelName, K, IdbIncludeRefinementAccessor<TContract, RelatedModelOf<TContract, ModelName, K>>>): IdbStoreAccessor<TContract, ModelName, TIncludes & Record<K, true>, TSelected>;
+  include<K extends ReferenceRelKeys<TContract, ModelName>>(relation: K, refineFn: IncludeRefineFn<TContract, ModelName, K, IdbIncludeScalar>): IdbStoreAccessor<TContract, ModelName, TIncludes & Record<K, "scalar">, TSelected>;
+  /**
+   * Project the row down to a subset of scalar fields. Any previously
+   * `.include()`d relations are preserved on the result; only the scalar
+   * fields are narrowed.
+   *
+   * @example
+   * ```ts
+   * const summaries = await db.users.select("id", "email").all();
+   * // typeof summaries[number] === { id: string; email: string }
+   * ```
+   */
+  select<Fields extends FieldTuple<TContract, ModelName>>(...fields: Fields): IdbStoreAccessor<TContract, ModelName, TIncludes, Fields[number]>;
+  /** Return all matching rows as an async iterable (also awaitable as `Row[]`). */
+  all(): AsyncIterableResult<SelectedRow<TContract, ModelName, TIncludes, TSelected>>;
+  /** Return the first matching row, or `null` if none match. */
+  first(): Promise<SelectedRow<TContract, ModelName, TIncludes, TSelected> | null>;
+  /**
+   * Run an in-memory aggregate (count/sum/avg/min/max) over the rows matching
+   * the accumulated `.where()` filter. Returns one result object keyed by the
+   * aliases supplied in the spec.
+   *
+   * @example
+   * ```ts
+   * const stats = await db.posts.where({ published: true }).aggregate((agg) => ({
+   *   total: agg.count(),
+   *   avgViews: agg.avg("views"),
+   * }));
+   * ```
+   */
+  aggregate<Spec extends IdbAggregateSpec>(fn: (agg: IdbAggregateBuilder<TContract, ModelName>) => Spec): Promise<IdbAggregateResult<Spec>>;
+  /**
+   * Switch to grouped-aggregate mode. The returned {@link IdbGroupedAccessor}'s
+   * `.aggregate(...)` terminal produces one row per group with the chosen key
+   * fields plus the requested aggregates.
+   *
+   * @example
+   * ```ts
+   * const byUser = await db.posts
+   *   .where({ published: true })
+   *   .groupBy("authorId")
+   *   .aggregate((agg) => ({ count: agg.count(), totalViews: agg.sum("views") }));
+   * ```
+   */
+  groupBy<Fields extends FieldTuple<TContract, ModelName>>(...fields: Fields): IdbGroupedAccessor<TContract, ModelName, Fields>;
+  /**
+   * Insert a record into the store and return the stored row.
+   *
+   * The primary key field is optional in `data` — pass it to use a
+   * client-generated ID (`cuid`, `uuid`) or omit it for auto-increment stores.
+   *
+   * Relation fields accept a mutation callback:
+   * `posts: (rel) => rel.create([...])` or `author: (rel) => rel.connect({ id })`.
+   * When any relation callback is present, all writes are wrapped in a single
+   * multi-store IDB transaction (requires IdbRuntime, not a plain executor).
+   */
+  create(data: MutationCreateInput<TContract, ModelName>): Promise<DefaultModelRow<TContract, ModelName>>;
+  /** Look up a single row by primary key. Returns `null` if not found. */
+  findUnique(key: KeyType<TContract, ModelName>): Promise<DefaultModelRow<TContract, ModelName> | null>;
+  /** Delete the row with the given primary key. */
+  delete(key: KeyType<TContract, ModelName>): Promise<void>;
+  /**
+   * Update the first row matching the accumulated `.where()` filter.
+   * Returns the merged row, or `null` if no row matches.
+   *
+   * Relation fields accept `connect` or `disconnect` callbacks. When any
+   * relation callback is present, all writes run in a single multi-store
+   * IDB transaction (requires IdbRuntime).
+   */
+  update(patch: MutationUpdateInput<TContract, ModelName>): Promise<DefaultModelRow<TContract, ModelName> | null>;
+  /**
+   * Update all rows matching the accumulated `.where()` filter and return
+   * them as an `AsyncIterableResult` (also awaitable as `Row[]`).
+   */
+  updateAll(patch: PatchInput<TContract, ModelName>): AsyncIterableResult<DefaultModelRow<TContract, ModelName>>;
+  /**
+   * Update all rows matching the accumulated `.where()` filter.
+   * Returns the count of updated rows.
+   */
+  updateCount(patch: PatchInput<TContract, ModelName>): Promise<number>;
+  /**
+   * Insert or update a single record.
+   *
+   * - If a row matching `where` exists: shallow-merge `update` onto it and
+   *   return the merged row.
+   * - If no matching row exists: insert `create` and return it.
+   */
+  upsert(args: {
+    create: CreateInput<TContract, ModelName>;
+    update: PatchInput<TContract, ModelName>;
+    where: WhereFilter<TContract, ModelName>;
+  }): Promise<DefaultModelRow<TContract, ModelName>>;
+  /**
+   * Insert multiple records in a single atomic transaction.
+   * Returns all inserted rows as an `AsyncIterableResult`.
+   */
+  createAll(data: CreateInput<TContract, ModelName>[]): AsyncIterableResult<DefaultModelRow<TContract, ModelName>>;
+  /**
+   * Insert multiple records in a single atomic transaction.
+   * Returns the count of inserted rows.
+   */
+  createCount(data: CreateInput<TContract, ModelName>[]): Promise<number>;
+  /**
+   * Delete all rows matching the accumulated `.where()` filter.
+   * Returns the deleted rows as an `AsyncIterableResult`.
+   */
+  deleteAll(): AsyncIterableResult<DefaultModelRow<TContract, ModelName>>;
+  /**
+   * Delete all rows matching the accumulated `.where()` filter.
+   * Returns the count of deleted rows.
+   */
+  deleteCount(): Promise<number>;
+  /**
+   * Count all rows matching the accumulated `.where()` filter.
+   * With no filter, counts all rows in the store.
+   *
+   * **Note — `skip`/`take` are respected**: unlike Prisma's SQL `count()`,
+   * which ignores pagination, this implementation reuses the same cursor-scan
+   * plan as `all()`. That means `where(...).take(5).count()` returns at most 5,
+   * not the total number of matching rows. Use `where(...).count()` without
+   * `take`/`skip` when you need an unbounded total.
+   */
+  count(): Promise<number>;
+}
+//#endregion
+//#region src/core/idb-orm.d.ts
+/**
+ * The ORM client object returned by {@link idbOrm}.
+ *
+ * Keys are the root keys from `contract.roots` (e.g. `"users"`, `"posts"`).
+ * Each value is an {@link IdbStoreAccessor} targeting the corresponding model.
+ *
+ * @example
+ * ```ts
+ * const db = idbOrm({ contract, executor: runtime });
+ * const users = await db.users.all(); // IdbStoreAccessor<..., "User">
+ * ```
+ */
+type IdbOrmClient<TContract extends Contract<IdbStorage>> = { readonly [K in string & keyof TContract["roots"]]: TContract["roots"][K] extends {
+  model: infer ModelName extends string;
+} ? IdbStoreAccessor<TContract, ModelName> : never; };
+/**
+ * Options for {@link idbOrm}.
+ */
+interface IdbOrmOptions<TContract extends IdbContract> {
+  /** The resolved IDB contract (with or without attached type maps). */
+  readonly contract: TContract;
+  /**
+   * The query executor.
+   *
+   * Any object with a compatible `query()` signature satisfies this —
+   * most commonly an `IdbRuntime` created via `createIdbRuntime()`.
+   */
+  readonly executor: IdbQueryExecutor;
+}
+/**
+ * Create a typed IDB ORM client from a contract and executor.
+ *
+ * The client exposes one `IdbStoreAccessor` per entry in `contract.roots`.
+ * Only roots-declared stores are accessible at the top level — other stores
+ * can be reached via `.include()` on any accessor.
+ *
+ * @example
+ * ```ts
+ * import { idbOrm } from "@prisma-idb/client-idb/orm";
+ * import { createIdbRuntime } from "@prisma-idb/runtime-idb/runtime";
+ * import contract from "./prisma/idb-contract";
+ *
+ * const runtime = createIdbRuntime({ adapter, driver });
+ * const db = idbOrm({ contract, executor: runtime });
+ *
+ * // Typed query builder:
+ * const alice = await db.users.where({ email: "alice@example.com" }).first();
+ * const postsWithAuthor = await db.posts.include("author").all();
+ * ```
+ */
+declare function idbOrm<TContract extends IdbContract>(options: IdbOrmOptions<TContract>): IdbOrmClient<TContract>;
+//#endregion
+export { IdbStoreAccessor as a, IdbGroupedAccessor as c, IdbModelAccessor as d, IdbIncludeRefinementAccessor as i, IdbIncludeScalar as l, IdbOrmOptions as n, WhereCallback as o, idbOrm as r, GroupedResultRow as s, IdbOrmClient as t, IdbFieldAccessor as u };
+//# sourceMappingURL=idb-orm-gEKHfG4H.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"idb-orm-gEKHfG4H.d.mts","names":[],"sources":["../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/internal.d.mts

@@ -0,0 +1,39 @@
+import { l as IdbContract } from "./executor-CevtdBfz.mjs";
+import "./mutation-scope-pOn0QzvV.mjs";
+import { IdbFilterExpr } from "@prisma-idb/adapter-idb/runtime";
+import { IdbTransactionScope } from "@prisma-idb/driver-idb/runtime";
+//#region src/core/mutation-executor.d.ts
+/**
+ * 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 { applyReferentialActionsForRow, collectDeleteStoreNames };
+//# sourceMappingURL=internal.d.mts.map

package/dist/internal.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"internal.d.mts","names":[],"sources":["../src/core/mutation-executor.ts"],"mappings":";;;;;;;;;;;;;;;;iBAy3CgB,wBAAwB,UAAU,aAAa;;;;;;;;;;;;;;;;;;;iBAsCzC,8BACpB,OAAO,qBACP,UAAU,aACV,mBACA,KAAK,yBACL,UAAS,cACR"}

package/dist/internal.mjs

@@ -0,0 +1,2 @@
+import { r as collectDeleteStoreNames, t as applyReferentialActionsForRow } from "./mutation-executor-CD5n_kKT.mjs";
+export { applyReferentialActionsForRow, collectDeleteStoreNames };

package/dist/{managed-client-CJD9lBx5.d.mts → managed-client-B_xGXdjz.d.mts}

@@ -1,4 +1,5 @@
-import { b as IdbContract, t as IdbOrmClient } from "./idb-orm-MOH1S3ES.mjs";
+import { l as IdbContract } from "./executor-CevtdBfz.mjs";
+import { t as IdbOrmClient } from "./idb-orm-gEKHfG4H.mjs";
 import { IdbTransactionScope } from "@prisma-idb/driver-idb/runtime";
 import { IdbMiddleware } from "@prisma-idb/runtime-idb/runtime";
 //#region src/core/idb-client.d.ts
@@ -112,4 +113,4 @@ declare function createManagedIdbClient<TClient extends {
 }>(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-CJD9lBx5.d.mts.map
+//# sourceMappingURL=managed-client-B_xGXdjz.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"managed-client-B_xGXdjz.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/{managed-client-DofL09P8.mjs → managed-client-Cp01irrm.mjs}

@@ -1,4 +1,5 @@
-import { c as withMutationScope, t as idbOrm } from "./idb-orm-C8yXJp6R.mjs";
+import { y as withMutationScope } from "./mutation-executor-CD5n_kKT.mjs";
+import { t as idbOrm } from "./idb-orm-DsfllvzD.mjs";
 import { IdbAdapter } from "@prisma-idb/adapter-idb/runtime";
 import { idbCodecLookup } from "@prisma-idb/target-idb/runtime";
 import { createIDBRuntimeDriver } from "@prisma-idb/driver-idb/runtime";
@@ -119,4 +120,4 @@ function createManagedIdbClient(open, options) {
 //#endregion
 export { createIdbClient as n, createManagedIdbClient as t };
 
-//# sourceMappingURL=managed-client-DofL09P8.mjs.map
+//# sourceMappingURL=managed-client-Cp01irrm.mjs.map

package/dist/{managed-client-DofL09P8.mjs.map → managed-client-Cp01irrm.mjs.map}

@@ -1 +1 @@
-{"version":3,"file":"managed-client-DofL09P8.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"}
+{"version":3,"file":"managed-client-Cp01irrm.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"}