@prisma-idb/client-idb 0.11.0 → 0.13.0

package/dist/mutation-executor-IuJmyWEG.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"mutation-executor-IuJmyWEG.mjs","names":["_exhaustive","keyToken","keyEquals"],"sources":["../src/core/types.ts","../src/core/planner/catalog.ts","../src/core/decimal-identity.ts","../src/core/query-shaping.ts","../src/core/enum-validation.ts","../src/core/record-validation.ts","../src/core/mutation-defaults.ts","../src/core/planner/plan.ts","../src/core/planner/lower.ts","../src/core/mutation-scope.ts","../src/core/relation-mutator.ts","../src/core/mutation-executor.ts"],"sourcesContent":["import type { Contract, ContractModelBase, ContractReferenceRelation } from \"@prisma/orm-framework/contract/types\";\nimport { domainModelsAtDefaultNamespace } from \"@prisma/orm-framework/contract/types\";\nimport type {\n  ExtractIdbFieldInputTypes,\n  ExtractIdbFieldOutputTypes,\n  IdbKeyPath,\n  IdbModelStorage,\n  IdbStorage,\n} from \"@prisma-idb/target-idb/pack\";\n\n// Key comparison lives in target-idb so adapter-idb's filter evaluator can\n// share it. Re-exported here for the modules and public exports that already\n// import it from this file.\nexport { fieldValueToken, fieldValuesEqual, isValidIdbKey, keyEquals, keyToken } from \"@prisma-idb/target-idb/runtime\";\n\n// Re-export so consumers that only import from client-idb don't need a\n// separate target-idb dependency.\nexport type { IdbKeyPath };\n\n// Re-export for consumers who only import from client-idb\nexport type { IdbStorage };\n\n// ── Model-map extraction from the domain plane ───────────────────────────────\n\n/**\n * Extract the model map from a contract by traversing the domain namespace.\n *\n * Models live under `domain.namespaces[ns].models`. For a single-namespace\n * contract this resolves to the typed model map; falls back to\n * `Record<string, ContractModelBase>` for un-typed/multi-namespace inputs.\n */\ntype ModelsOf<TContract> = TContract extends { readonly domain: { readonly namespaces: infer NS } }\n  ? NS[keyof NS] extends { readonly models: infer M }\n    ? M extends Record<string, ContractModelBase>\n      ? M\n      : Record<string, ContractModelBase>\n    : Record<string, ContractModelBase>\n  : Record<string, ContractModelBase>;\n\n// ── IdbContract convenience alias ─────────────────────────────────────────────\n\n/**\n * A `Contract` narrowed to the IDB storage shape. Accepts any contract whose\n * `storage` block includes an `stores` record, regardless of the model set or\n * whether type maps are attached.\n */\nexport type IdbContract = Contract<IdbStorage>;\n\n// ── Row type resolution (full type-maps path) ─────────────────────────────────\n\n/**\n * Resolve the output row type for a model from the contract's type maps.\n *\n * When `fieldOutputTypes` is parameterised (the emitted contract carries\n * `IdbContractWithTypeMaps<Base, IdbTypeMaps<Codecs, FieldOutputTypes, ...>>`),\n * each field gets the exact TypeScript type emitted by the family (e.g. `Date`\n * for `idb/date@1`).\n *\n * Falls back to `Record<string, unknown>` when type maps are absent (plain\n * `IdbContract` or when the model name is not in the type maps).\n */\n// FieldOutputTypes = { __unbound__: { User: {...} } } — union over namespace values\n// to get the flat model map, then look up ModelName.\ntype NsFieldOutputTypes<TContract> = ExtractIdbFieldOutputTypes<TContract>[keyof ExtractIdbFieldOutputTypes<TContract>];\n\n/** Resolve a model output row when type maps bind it, or keep an untyped record. */\ntype ResolvedOutputRow<TContract, ModelName extends string> = string extends keyof ExtractIdbFieldOutputTypes<TContract>\n  ? Record<string, unknown>\n  : NsFieldOutputTypes<TContract> extends Record<string, unknown>\n    ? ModelName extends keyof NsFieldOutputTypes<TContract>\n      ? { -readonly [K in keyof NsFieldOutputTypes<TContract>[ModelName]]: NsFieldOutputTypes<TContract>[ModelName][K] }\n      : Record<string, unknown>\n    : Record<string, unknown>;\n\n/**\n * Resolve the input row type for a model from the contract's type maps.\n *\n * Mirrors `ResolvedOutputRow` but uses `fieldInputTypes` — the input types\n * used for `create()`, `where()`, and mutation payloads.\n */\ntype NsFieldInputTypes<TContract> = ExtractIdbFieldInputTypes<TContract>[keyof ExtractIdbFieldInputTypes<TContract>];\n\n/** Resolve a model input row from its bound input type map. */\ntype ResolvedInputRow<TContract, ModelName extends string> = string extends keyof ExtractIdbFieldInputTypes<TContract>\n  ? Record<string, unknown>\n  : NsFieldInputTypes<TContract> extends Record<string, unknown>\n    ? ModelName extends keyof NsFieldInputTypes<TContract>\n      ? { -readonly [K in keyof NsFieldInputTypes<TContract>[ModelName]]: NsFieldInputTypes<TContract>[ModelName][K] }\n      : Record<string, unknown>\n    : Record<string, unknown>;\n\n// ── Public row types ──────────────────────────────────────────────────────────\n\n/** The full TypeScript row shape returned by `all()`, `first()`, and `create()`. */\nexport type DefaultModelRow<TContract, ModelName extends string> = ResolvedOutputRow<TContract, ModelName>;\n\n// ── Where filter ──────────────────────────────────────────────────────────────\n\n/**\n * Partial equality filter applied as an in-memory predicate during cursor scans.\n *\n * All fields are optional — only provided fields are checked. Values use the\n * output types (from `fieldOutputTypes`) since the values are compared against\n * decoded row data.\n */\nexport type WhereFilter<TContract, ModelName extends string> = {\n  readonly [K in keyof DefaultModelRow<TContract, ModelName>]?: DefaultModelRow<TContract, ModelName>[K];\n};\n\n// ── KeyPath / KeyType ─────────────────────────────────────────────────────────\n\n/**\n * The union of a model's `keyPath` field name(s), extracted from\n * the domain model's `storage.keyPath`. For a single-field key this\n * is just that field name; for a compound key it's the union of every member\n * field name (NOT an ordered tuple — see {@link ModelKeyPathOrdered} for the\n * order-preserving form `KeyType` needs).\n *\n * A plain union is what `Omit`/`Pick` need, where order doesn't matter.\n */\nexport type ModelKeyPath<TContract, ModelName extends string> = ModelName extends keyof ModelsOf<TContract>\n  ? ModelsOf<TContract>[ModelName] extends { storage: { keyPath: infer P } }\n    ? P extends string\n      ? P\n      : P extends readonly string[]\n        ? P[number]\n        : never\n    : never\n  : never;\n\n/**\n * Like {@link ModelKeyPath}, but preserves declaration order as a tuple\n * (`readonly [\"a\", \"b\"]`, not the unioned `\"a\" | \"b\"`). A single-field key is\n * normalized to a 1-tuple (`readonly [\"id\"]`) so `KeyType` below can branch\n * on tuple shape uniformly. Needed because `findUnique`/`delete` accept the\n * key as a positional array for compound-key models (mirroring the\n * `IDBValidKey` array form IDB itself expects), which requires order, unlike\n * `ModelKeyPath`'s Omit/Pick usage.\n */\nexport type ModelKeyPathOrdered<TContract, ModelName extends string> = ModelName extends keyof ModelsOf<TContract>\n  ? ModelsOf<TContract>[ModelName] extends { storage: { keyPath: infer P } }\n    ? P extends string\n      ? readonly [P]\n      : P extends readonly string[]\n        ? P\n        : never\n    : never\n  : never;\n\n/** Maps an ordered tuple of key field names to their resolved output types, preserving position. */\ntype KeyTupleType<TContract, ModelName extends string, Fields extends readonly string[]> = {\n  [I in keyof Fields]: Fields[I] extends keyof ResolvedOutputRow<TContract, ModelName>\n    ? ResolvedOutputRow<TContract, ModelName>[Fields[I] & keyof ResolvedOutputRow<TContract, ModelName>]\n    : IDBValidKey;\n};\n\n/**\n * `true` only when `T` is exactly `never` — the tuple-wrap defeats\n * conditional-type distributivity (without it, `never extends never ? A : B`\n * called with a naked, union-distributing `T` short-circuits to `never`\n * itself rather than evaluating `A`/`B`). Needed because `never` is also a\n * structural subtype of every other concrete type (including a 2+-element\n * tuple type), so a plain `ModelKeyPathOrdered<...> extends readonly\n * [string, string, ...string[]]` check would incorrectly match `never`\n * (the loosely-typed/no-type-maps contract case) as if it were a real\n * compound key.\n */\ntype IsNever<T> = [T] extends [never] ? true : false;\n\n/**\n * TypeScript type of the primary key parameter for `findUnique()`/`delete()`.\n *\n * Single-field keys use the field's resolved output type, such as `string`.\n * Compound-key models get an ordered tuple\n * type (e.g. `[string, Date]` for `@@id([orgId, effectiveFrom])`), matching\n * the `IDBValidKey` array IDB itself expects for a compound key-get — the\n * same value passes straight through to the driver with zero runtime\n * conversion.\n */\nexport type KeyType<TContract, ModelName extends string> =\n  IsNever<ModelKeyPathOrdered<TContract, ModelName>> extends true\n    ? ModelKeyPath<TContract, ModelName> extends keyof ResolvedOutputRow<TContract, ModelName>\n      ? ResolvedOutputRow<TContract, ModelName>[ModelKeyPath<TContract, ModelName>]\n      : IDBValidKey\n    : ModelKeyPathOrdered<TContract, ModelName> extends readonly [infer Single extends string]\n      ? Single extends keyof ResolvedOutputRow<TContract, ModelName>\n        ? ResolvedOutputRow<TContract, ModelName>[Single]\n        : IDBValidKey\n      : KeyTupleType<TContract, ModelName, ModelKeyPathOrdered<TContract, ModelName>>;\n\n// ── Create input ──────────────────────────────────────────────────────────────\n\n/** The object store name for a model, extracted from `contract.domain...storage.storeName` (used to match `execution.mutations.defaults[].ref.entry`). */\ntype ModelStoreName<TContract, ModelName extends string> = ModelName extends keyof ModelsOf<TContract>\n  ? ModelsOf<TContract>[ModelName] extends { readonly storage: { readonly storeName: infer S } }\n    ? S extends string\n      ? S\n      : never\n    : never\n  : never;\n\n/** Whether the model's object store has `autoIncrement: true` in `contract.storage.stores` (set by `@default(autoincrement())`). */\ntype IsAutoIncrementStore<TContract, ModelName extends string> = TContract extends {\n  readonly storage: { readonly stores: infer Stores };\n}\n  ? ModelStoreName<TContract, ModelName> extends keyof Stores\n    ? Stores[ModelStoreName<TContract, ModelName>] extends { readonly autoIncrement: true }\n      ? true\n      : false\n    : false\n  : false;\n\n/**\n * The primary key field `create()` may omit because IDB generates it: the\n * key of a *single-field*-key model whose store has `autoIncrement: true`.\n * IDB's key generator is numeric-only and never runs without\n * `autoIncrement` — an absent key then makes `add()` throw `DataError` —\n * and it can't fill a compound key (`autoIncrement` + array `keyPath` is\n * rejected). App-generated keys (`uuid()`/`cuid()`) are covered separately\n * by {@link FieldsWithCreateDefault}; any other key must be supplied.\n */\ntype OptionalKeyPathField<TContract, ModelName extends string> =\n  IsAutoIncrementStore<TContract, ModelName> extends true\n    ? ModelKeyPathOrdered<TContract, ModelName> extends readonly [infer Single extends string]\n      ? Single\n      : never\n    : never;\n\n/** {@link OptionalKeyPathField}, narrowed to a key that actually exists on the resolved input row (may be absent for models with no typed maps). */\ntype KeyPathField<TContract, ModelName extends string> = OptionalKeyPathField<TContract, ModelName> &\n  keyof ResolvedInputRow<TContract, ModelName>;\n\n/** The flattened `execution.mutations.defaults` array type, or `never` for a contract with no execution section. */\ntype ExecutionDefaultsOf<TContract> = TContract extends {\n  readonly execution: { readonly mutations: { readonly defaults: infer D } };\n}\n  ? D extends readonly unknown[]\n    ? D[number]\n    : never\n  : never;\n\n/**\n * Column names with an `onCreate` execution default for this model's store —\n * e.g. `temporal.updatedAt()`/bare `@updatedAt` fields, or any\n * `@default(...)` field (literal, `now()`, `uuid()`, `cuid()`). These are\n * omittable in `create()` even though the field itself isn't nullable,\n * since the runtime fills them in (`client-idb/src/core/mutation-defaults.ts`).\n */\ntype FieldsWithCreateDefault<TContract, ModelName extends string> = Extract<\n  ExecutionDefaultsOf<TContract>,\n  { readonly ref: { readonly table: ModelStoreName<TContract, ModelName> }; readonly onCreate: unknown }\n>[\"ref\"][\"column\"];\n\n/** {@link FieldsWithCreateDefault}, narrowed to keys that actually exist on the resolved input row (may be absent for models with no typed maps). */\ntype DefaultedInputField<TContract, ModelName extends string> = FieldsWithCreateDefault<TContract, ModelName> &\n  keyof ResolvedInputRow<TContract, ModelName>;\n\n/**\n * Keys of the resolved input row whose contract fields declare `nullable: true`.\n * `create()` stores `null` for one the caller omits (`completeCreateRecord`\n * in `mutation-defaults.ts`). Input types such as JSON's `unknown` can admit\n * `null` even when the contract field is required.\n */\ntype NullableInputField<TContract, ModelName extends string> = ModelName extends keyof ModelsOf<TContract>\n  ? {\n      [K in keyof ResolvedInputRow<TContract, ModelName>]-?: K extends keyof ModelsOf<TContract>[ModelName][\"fields\"]\n        ? IsNever<ModelsOf<TContract>[ModelName][\"fields\"][K]> extends true\n          ? never\n          : ModelsOf<TContract>[ModelName][\"fields\"][K] extends { readonly nullable: true }\n            ? K\n            : never\n        : never;\n    }[keyof ResolvedInputRow<TContract, ModelName>]\n  : never;\n\n/** The fields `create()` may omit: see {@link CreateInput}. */\ntype OmittableCreateField<TContract, ModelName extends string> =\n  | KeyPathField<TContract, ModelName>\n  | DefaultedInputField<TContract, ModelName>\n  | NullableInputField<TContract, ModelName>;\n\n/**\n * Input shape for `create()`: the full input row with an `autoIncrement`\n * primary key made optional (see {@link OptionalKeyPathField}), every field\n * with an `onCreate` execution default — including a `uuid()`/`cuid()` key —\n * and every nullable field also made optional. Any other key field stays\n * required.\n */\nexport type CreateInput<TContract, ModelName extends string> = Omit<\n  ResolvedInputRow<TContract, ModelName>,\n  OmittableCreateField<TContract, ModelName>\n> &\n  Partial<Pick<ResolvedInputRow<TContract, ModelName>, OmittableCreateField<TContract, ModelName>>>;\n\n// ── Relations ─────────────────────────────────────────────────────────────────\n\n/** Extract the relations record for a model. */\ntype ModelRelations<TContract, ModelName extends string> = ModelName extends keyof ModelsOf<TContract>\n  ? ModelsOf<TContract>[ModelName] extends { relations: infer R }\n    ? R extends Record<string, unknown>\n      ? R\n      : Record<string, never>\n    : Record<string, never>\n  : Record<string, never>;\n\n/**\n * Union of relation keys on a model that are `ContractReferenceRelation`s\n * (i.e. cross-store joins, not embedded documents).\n *\n * Used to constrain the `include()` method's `relation` parameter to only\n * valid reference relation names.\n */\nexport type ReferenceRelKeys<TContract, ModelName extends string> = {\n  [K in keyof ModelRelations<TContract, ModelName>]: ModelRelations<\n    TContract,\n    ModelName\n  >[K] extends ContractReferenceRelation\n    ? K\n    : never;\n}[keyof ModelRelations<TContract, ModelName>] &\n  string;\n\n/**\n * TypeScript row type for an included relation.\n *\n * - `1:N` cardinality → `RelatedRow[]`\n * - `N:1` or `1:1` cardinality → `RelatedRow | null`\n */\ntype RelationRowType<TContract, ModelName extends string, RelKey extends string> = RelKey extends keyof ModelRelations<\n  TContract,\n  ModelName\n>\n  ? ModelRelations<TContract, ModelName>[RelKey] extends ContractReferenceRelation\n    ? ModelRelations<TContract, ModelName>[RelKey] extends {\n        to: { model: infer To extends string };\n        cardinality: infer C;\n      }\n      ? C extends \"1:N\"\n        ? DefaultModelRow<TContract, To>[]\n        : DefaultModelRow<TContract, To> | null\n      : never\n    : never\n  : never;\n\n/**\n * Per-relation include marker tracked at the type level.\n *\n * - `true` — the relation is loaded as rows (array for `1:N`, single/null\n *   otherwise), optionally refined by a `where`/`orderBy`/`take` callback.\n * - `\"scalar\"` — the relation is reduced to a `count()`, so the\n *   row field becomes a `number` instead of related rows.\n */\nexport type IncludeMarker = true | \"scalar\";\n\n/** Which relations are included in the current accessor chain. */\nexport type IncludeSpec<TContract, ModelName extends string> = Partial<\n  Record<ReferenceRelKeys<TContract, ModelName>, IncludeMarker>\n>;\n\n/** Empty include spec — no relations included. */\nexport type NoIncludes = Record<never, never>;\n\n/**\n * The relation fields contributed by a set of `.include()` calls.\n *\n * A key is added only when its `TIncludes` marker is set; the field type is\n * `number` for a scalar `count()` include and the cardinality-shaped related\n * row(s) otherwise. Split out from {@link IncludedRow} so {@link SelectedRow}\n * can re-use it on top of a projected (picked) scalar base.\n */\nexport type IncludeFields<TContract, ModelName extends string, TIncludes extends IncludeSpec<TContract, ModelName>> = {\n  -readonly [\n    K in keyof TIncludes & string as TIncludes[K] extends IncludeMarker ? K : never\n  ]: TIncludes[K] extends \"scalar\" ? number : RelationRowType<TContract, ModelName, K>;\n};\n\n/**\n * A row type that merges the base model row with any included relation fields.\n *\n * The extra fields are only added when the corresponding key in `TIncludes` is\n * set, so the type stays narrow until `.include()` is called.\n */\nexport type IncludedRow<\n  TContract,\n  ModelName extends string,\n  TIncludes extends IncludeSpec<TContract, ModelName>,\n> = DefaultModelRow<TContract, ModelName> & IncludeFields<TContract, ModelName, TIncludes>;\n\n/**\n * The row type after an optional `.select()` projection.\n *\n * When `TSelected` is `never` (no `.select()` call) the full {@link IncludedRow}\n * is returned. Otherwise the scalar base is narrowed to the picked fields, with\n * any included relation fields preserved (mirrors the vendor `select()` which\n * keeps relations and narrows only scalar columns).\n */\nexport type SelectedRow<\n  TContract,\n  ModelName extends string,\n  TIncludes extends IncludeSpec<TContract, ModelName>,\n  TSelected extends string,\n> = [TSelected] extends [never]\n  ? IncludedRow<TContract, ModelName, TIncludes>\n  : Pick<DefaultModelRow<TContract, ModelName>, TSelected & keyof DefaultModelRow<TContract, ModelName>> &\n      IncludeFields<TContract, ModelName, TIncludes>;\n\n// ── Patch input ───────────────────────────────────────────────────────────────\n\n// Patches shallow-merge fields, so a dotted key excludes its whole containing\n// field. Distribute over compound-key members to omit every containing field.\n/** The containing field replaced by a shallow patch of a dotted primary-key path. */\ntype KeyPathRoot<Path extends string> = Path extends `${infer Field}.${string}` ? Field : Path;\n\n/** Model fields that a patch may change without replacing primary-key data. */\ntype MutableModelRow<TContract, ModelName extends string> = Omit<\n  DefaultModelRow<TContract, ModelName>,\n  KeyPathRoot<ModelKeyPath<TContract, ModelName>>\n>;\n\n// An empty object type accepts arbitrary fields. When no mutable fields remain,\n// allow empty patches while rejecting every supplied field, including keys.\n/** An optional patch that still rejects extra fields when the row has no mutable fields. */\ntype PartialPatch<Row> = keyof Row extends never ? Record<string, never> : Partial<Row>;\n\n/**\n * Partial update shape for `update()`, `updateAll()`, `updateCount()`, and the\n * `update` arm of `upsert()`. Primary-key fields are excluded. Remaining\n * fields are optional and shallow-merged onto the existing record. The\n * conditional preserves each model's fields when ModelName is a union,\n * while unresolved model names keep the untyped row fallback.\n */\nexport type PatchInput<TContract, ModelName extends string> =\n  IsNever<ModelName> extends true\n    ? Partial<DefaultModelRow<TContract, ModelName>>\n    : ModelName extends string\n      ? PartialPatch<MutableModelRow<TContract, ModelName>>\n      : never;\n\n// ── Relation mutation types ───────────────────────────────────────────────────\n\n/** Extracts the `to` model name for a named relation on a model. */\nexport type RelatedModelOf<\n  TContract,\n  ModelName extends string,\n  RelName extends string,\n> = ModelName extends keyof ModelsOf<TContract>\n  ? ModelsOf<TContract>[ModelName] extends {\n      relations: Record<RelName, { to: { model: infer To extends string } }>;\n    }\n    ? To\n    : string\n  : string;\n\n/** Nested-create descriptor: insert one or more related records. */\nexport interface RelationMutationCreate<TContract, ModelName extends string> {\n  readonly kind: \"create\";\n  readonly data: readonly CreateInput<TContract, ModelName>[];\n}\n\n/** Nested-connect descriptor: link existing records to the parent via FK update. */\nexport interface RelationMutationConnect {\n  readonly kind: \"connect\";\n  readonly criteria: readonly Record<string, unknown>[];\n}\n\n/**\n * Nested-disconnect descriptor: unlink related records by setting FK to null.\n * With no criteria, disconnects all child records from this parent.\n */\nexport interface RelationMutationDisconnect {\n  readonly kind: \"disconnect\";\n  readonly criteria?: readonly Record<string, unknown>[];\n}\n\n/** Discriminated union of all nested relation mutation descriptors. */\nexport type IdbRelationMutation<TContract, ModelName extends string> =\n  RelationMutationCreate<TContract, ModelName> | RelationMutationConnect | RelationMutationDisconnect;\n\n/** Relation mutator object passed to the user's relation callback. */\nexport interface IdbRelationMutator<TContract, ModelName extends string> {\n  create(\n    data: CreateInput<TContract, ModelName> | readonly CreateInput<TContract, ModelName>[]\n  ): RelationMutationCreate<TContract, ModelName>;\n  connect(criteria: Record<string, unknown> | readonly Record<string, unknown>[]): RelationMutationConnect;\n  disconnect(criteria?: readonly Record<string, unknown>[]): RelationMutationDisconnect;\n}\n\n/**\n * Maps each reference relation key to an optional mutation callback.\n *\n * When `ReferenceRelKeys` widens to `string` (a loosely-typed `IdbContract`\n * with no emitted type maps), a naive mapped type would become an index\n * signature `{ [k: string]: callback }` that incorrectly forces *every* field —\n * scalars included — to be a relation callback, so even `create({ name: \"x\" })`\n * would fail to type-check. The `string extends …` guard detects that case and\n * contributes no constraint (`& unknown` is identity), leaving plain scalar\n * payloads valid. Precisely-typed contracts (the emitted `contract.d.ts`)\n * resolve `ReferenceRelKeys` to a finite union and get the full callback typing.\n */\ntype RelationMutationFields<TContract, ModelName extends string> =\n  string extends ReferenceRelKeys<TContract, ModelName>\n    ? unknown\n    : Partial<{\n        [K in ReferenceRelKeys<TContract, ModelName>]: (\n          mutator: IdbRelationMutator<TContract, RelatedModelOf<TContract, ModelName, K>>\n        ) => IdbRelationMutation<TContract, RelatedModelOf<TContract, ModelName, K>>;\n      }>;\n\n/**\n * The `localFields` of all N:1 relations on a model — the FK fields that are\n * owned by this model and can be supplied via a relation callback instead of\n * as a scalar value. Resolves to `never` for loosely-typed contracts where\n * cardinality is not preserved as a literal (e.g. `defineContract` in tests).\n *\n * Mirrors `ChildForeignKeyFieldNames` from `sql-orm-client`, simplified: instead\n * of crawling all models for relations pointing *to* this one, we look at this\n * model's own N:1 relations directly — same field set, one model.\n */\ntype N1LocalFieldNames<TContract, ModelName extends string> = {\n  [K in keyof ModelRelations<TContract, ModelName>]: ModelRelations<TContract, ModelName>[K] extends {\n    readonly cardinality: \"N:1\";\n    readonly on: { readonly localFields: infer Fields extends readonly string[] };\n  }\n    ? Fields[number]\n    : never;\n}[keyof ModelRelations<TContract, ModelName>] &\n  string;\n\n/**\n * Like `CreateInput` but with N:1 FK fields made optional.\n *\n * An N:1 FK field (e.g. `authorId` on `Post`) can be supplied either as a\n * scalar value or via a relation callback (`author: (rel) => rel.connect({id})`).\n * Making it optional here lets callers omit it when using the callback form —\n * the executor populates it from the related record before inserting.\n *\n * Mirrors `NestedCreateInput` from `sql-orm-client`.\n */\ntype NestedCreateInput<TContract, ModelName extends string> = Omit<\n  CreateInput<TContract, ModelName>,\n  N1LocalFieldNames<TContract, ModelName>\n> &\n  Partial<\n    Pick<\n      CreateInput<TContract, ModelName>,\n      N1LocalFieldNames<TContract, ModelName> & keyof CreateInput<TContract, ModelName>\n    >\n  >;\n\n/**\n * Input shape for `create()` with optional relation callbacks.\n * N:1 FK fields (e.g. `authorId`) are optional when using a relation callback.\n * Relation fields accept a callback `(rel) => rel.create([...])` / `rel.connect(...)`.\n */\nexport type MutationCreateInput<TContract, ModelName extends string> = NestedCreateInput<TContract, ModelName> &\n  RelationMutationFields<TContract, ModelName>;\n\n/**\n * Input shape for `update()` with optional relation callbacks.\n * Non-key scalar fields are optional (shallow merge); relation fields accept\n * `connect` or `disconnect` callbacks. Check emptiness after adding relation\n * fields so a key-only scalar row can still accept declared callbacks without\n * an incompatible never index signature.\n */\nexport type MutationUpdateInput<TContract, ModelName extends string> =\n  IsNever<ModelName> extends true\n    ? PatchInput<TContract, ModelName> & RelationMutationFields<TContract, ModelName>\n    : ModelName extends string\n      ? PartialPatch<MutableModelRow<TContract, ModelName> & RelationMutationFields<TContract, ModelName>>\n      : never;\n\n// ── OrderBy spec ─────────────────────────────────────────────────────────────\n\n/** Sort direction for `orderBy()`. */\nexport type SortDirection = \"asc\" | \"desc\";\n\n/** Partial sort spec: field name → direction. */\nexport type OrderBySpec<TContract, ModelName extends string> = Partial<\n  Record<string & keyof DefaultModelRow<TContract, ModelName>, SortDirection>\n>;\n\n// ── Aggregate / groupBy ───────────────────────────────────────────────────────\n\n/** The five aggregation functions, matching the vendor `AggregateFn`. */\nexport type AggregateFn = \"count\" | \"sum\" | \"avg\" | \"min\" | \"max\";\n\n/**\n * Fields eligible for numeric aggregation (`sum`/`avg`/`min`/`max`).\n *\n * For an emitted (precisely-typed) contract this narrows to the fields whose\n * output type is assignable to `number`. For a loosely-typed `IdbContract`\n * (no type maps — `DefaultModelRow` is `Record<string, unknown>`) the row key\n * set widens to `string`, so we allow any field name rather than collapsing to\n * `never`. Runtime validation still requires a declared scalar Int or Float\n * field. Mirrors `NumericFieldNames` from `sql-orm-client`, trait-free.\n */\nexport type NumericFieldNames<TContract, ModelName extends string> = string extends keyof DefaultModelRow<\n  TContract,\n  ModelName\n>\n  ? string\n  : {\n      [K in keyof DefaultModelRow<TContract, ModelName> & string]: NonNullable<\n        DefaultModelRow<TContract, ModelName>[K]\n      > extends number\n        ? K\n        : never;\n    }[keyof DefaultModelRow<TContract, ModelName> & string];\n\ndeclare const idbAggregateResultBrand: unique symbol;\n\n/**\n * A single aggregation selector produced by the {@link IdbAggregateBuilder}.\n *\n * The phantom `Result` brand carries the per-selector result type so\n * {@link IdbAggregateResult} can map each alias back to its value type.\n * Mirrors the vendor `AggregateSelector`.\n */\nexport interface IdbAggregateSelector<Result> {\n  readonly kind: \"aggregate\";\n  readonly fn: AggregateFn;\n  readonly field?: string;\n  readonly [idbAggregateResultBrand]?: Result;\n}\n\n/** A map of result aliases → aggregation selectors (the `aggregate()` spec). */\nexport type IdbAggregateSpec = Record<string, IdbAggregateSelector<unknown>>;\n\n/** The result row shape for an {@link IdbAggregateSpec}: alias → value type. */\nexport type IdbAggregateResult<Spec extends IdbAggregateSpec> = {\n  [K in keyof Spec]: Spec[K] extends IdbAggregateSelector<infer Result> ? Result : never;\n};\n\n/**\n * The builder handed to an `.aggregate(agg => …)` callback. `count()` is always\n * available; the field reducers are constrained to {@link NumericFieldNames}.\n * Mirrors the vendor `AggregateBuilder`, minus the SQL column mapping.\n */\nexport interface IdbAggregateBuilder<TContract, ModelName extends string> {\n  count(): IdbAggregateSelector<number>;\n  sum<F extends NumericFieldNames<TContract, ModelName>>(field: F): IdbAggregateSelector<number | null>;\n  avg<F extends NumericFieldNames<TContract, ModelName>>(field: F): IdbAggregateSelector<number | null>;\n  min<F extends NumericFieldNames<TContract, ModelName>>(field: F): IdbAggregateSelector<number | null>;\n  max<F extends NumericFieldNames<TContract, ModelName>>(field: F): IdbAggregateSelector<number | null>;\n}\n\n// ── Model storage helpers ─────────────────────────────────────────────────────\n\n/**\n * Extract the `storeName` from a model's storage metadata at runtime.\n * Falls back to the model name if `storeName` is absent.\n */\nexport function getStoreName(contract: IdbContract, modelName: string): string {\n  const model = domainModelsAtDefaultNamespace(contract.domain)[modelName];\n  return (model?.storage as IdbModelStorage | undefined)?.storeName ?? modelName;\n}\n\n/**\n * Extract the `keyPath` from a model's storage metadata at runtime.\n * A single field name for the common case; an ordered array of field names\n * for a compound primary key.\n *\n * @throws if the model is unknown or its storage has no `keyPath` — a\n * validated contract always has one, so this only fires on a malformed or\n * hand-built contract, where guessing a key name would silently read/write\n * the wrong key.\n */\nexport function getKeyPath(contract: IdbContract, modelName: string): IdbKeyPath {\n  const model = domainModelsAtDefaultNamespace(contract.domain)[modelName];\n  const keyPath = (model?.storage as IdbModelStorage | undefined)?.keyPath;\n  if (keyPath === undefined) {\n    throw new Error(`Model \"${modelName}\" has no storage.keyPath in the contract.`);\n  }\n  return keyPath;\n}\n\n/**\n * Extracts a row's primary key as an {@link IDBValidKey} — the scalar value\n * at `row[keyPath]` for a single-field key, or an ordered array of the\n * compound key's member field values (matching the array form IDB itself\n * expects for a compound `keyPath`). The one construction site every\n * key-get/put/delete/update call should route through, so compound-key field\n * order stays consistent everywhere.\n */\nexport function extractKeyFromRow(row: Record<string, unknown>, keyPath: IdbKeyPath): IDBValidKey {\n  if (typeof keyPath === \"string\") return row[keyPath] as IDBValidKey;\n  return keyPath.map((field) => row[field]) as IDBValidKey;\n}\n\n/**\n * Resolve a model's named relation to a {@link ContractReferenceRelation} at\n * runtime, or `undefined` when the relation is absent or an embedded relation\n * (no `on` join block). Used by `include()` to find the related model name and\n * cardinality before building the child-accessor refinement.\n */\nexport function getRelation(\n  contract: IdbContract,\n  modelName: string,\n  relName: string\n): ContractReferenceRelation | undefined {\n  const relation = domainModelsAtDefaultNamespace(contract.domain)[modelName]?.relations?.[relName];\n  if (relation === undefined || !(\"on\" in relation)) return undefined;\n  return relation as ContractReferenceRelation;\n}\n","import { domainModelsAtDefaultNamespace } from \"@prisma/orm-framework/contract/types\";\nimport type { IdbKeyPath } from \"@prisma-idb/target-idb/pack\";\nimport { absentAsNull, type AbsentAsNull } from \"@prisma-idb/target-idb/runtime\";\nimport { getStoreName, type IdbContract } from \"../types\";\n\n/** Storage metadata needed to decide whether an index contains every matching row. */\nexport interface CatalogField {\n  readonly codecId: string | undefined;\n  readonly nullable: boolean;\n  readonly collection: boolean;\n}\n\n/** One primary-key or secondary-index source, in declaration order. */\nexport interface CatalogSource {\n  readonly keyPath: IdbKeyPath;\n  readonly fields: readonly string[];\n  readonly indexName?: string;\n  readonly unique: boolean;\n  readonly multiEntry: boolean;\n}\n\n/** Immutable per-store metadata. No IndexedDB handles are retained. */\nexport interface QueryCatalog {\n  readonly storeName: string;\n  readonly primaryKey: CatalogSource;\n  readonly indexes: readonly CatalogSource[];\n  readonly fields: Readonly<Record<string, CatalogField>>;\n  /** Reads a stored row as the contract describes it: an absent nullable field is `null`. */\n  readonly absentAsNull: AbsentAsNull;\n}\n\nconst catalogs = new WeakMap<IdbContract, Map<string, QueryCatalog>>();\n\n/**\n * Build a catalog once per contract identity, store name and model name.\n * Contracts are immutable.\n *\n * Several models can share one store, and each reads the rows differently.\n * Pass the model that owns the request. Omit `modelName` for a store that no\n * app model owns, such as an extension's own store: it has no fields to fill.\n */\nexport function buildCatalog(contract: IdbContract, storeName: string, modelName?: string): QueryCatalog {\n  const cacheKey = `${storeName}\\0${modelName ?? \"\"}`;\n  const cached = catalogs.get(contract)?.get(cacheKey);\n  if (cached) return cached;\n  const store = contract.storage.stores[storeName];\n  if (!store) throw new Error(`Store \"${storeName}\" is not in the contract`);\n  const fields: Record<string, CatalogField> = {};\n  let normalize: AbsentAsNull = (row) => row;\n  if (modelName !== undefined) {\n    const model = domainModelsAtDefaultNamespace(contract.domain)[modelName];\n    if (model === undefined) throw new Error(`Model \"${modelName}\" is not in the contract`);\n    if (getStoreName(contract, modelName) !== storeName) {\n      throw new Error(`Model \"${modelName}\" is not stored in \"${storeName}\"`);\n    }\n    normalize = absentAsNull(contract, modelName);\n    for (const [name, field] of Object.entries(model.fields)) {\n      fields[name] = Object.freeze({\n        codecId: field.type.kind === \"scalar\" ? field.type.codecId : undefined,\n        nullable: field.nullable,\n        collection: Boolean(field.many) || field.dict === true,\n      });\n    }\n  }\n  const catalog: QueryCatalog = Object.freeze({\n    storeName,\n    primaryKey: source(store.keyPath, true, false),\n    indexes: Object.freeze(\n      Object.entries(store.indexes ?? {}).map(([name, index]) =>\n        source(index.keyPath, index.unique, index.multiEntry ?? false, name)\n      )\n    ),\n    fields: Object.freeze(fields),\n    absentAsNull: normalize,\n  });\n  let byStore = catalogs.get(contract);\n  if (!byStore) {\n    byStore = new Map();\n    catalogs.set(contract, byStore);\n  }\n  byStore.set(cacheKey, catalog);\n  return catalog;\n}\n\n/** Freeze a key source and its field order for deterministic access selection. */\nfunction source(keyPath: IdbKeyPath, unique: boolean, multiEntry: boolean, indexName?: string): CatalogSource {\n  const path = typeof keyPath === \"string\" ? keyPath : Object.freeze([...keyPath]);\n  return Object.freeze({\n    keyPath: path,\n    fields: Object.freeze(typeof path === \"string\" ? [path] : [...path]),\n    unique,\n    multiEntry,\n    ...(indexName === undefined ? {} : { indexName }),\n  });\n}\n","import { AsyncIterableResult } from \"@prisma/orm-framework/components/runtime\";\nimport { domainModelsAtDefaultNamespace } from \"@prisma/orm-framework/contract/types\";\nimport type { IdbQueryPlan } from \"@prisma-idb/adapter-idb/runtime\";\nimport {\n  IdbExecuteError,\n  type IdbAtomicPlan,\n  type IdbPlanBody,\n  type IdbTransactionScope,\n} from \"@prisma-idb/driver-idb/runtime\";\nimport { compareDecimalValues, isValidIdbKey, keyEquals, keyToken } from \"@prisma-idb/target-idb/runtime\";\nimport type { IdbQueryExecutor } from \"./executor\";\nimport type { IdbQueryExecutorWithTransaction } from \"./mutation-scope\";\nimport { buildCatalog, type QueryCatalog, type CatalogSource } from \"./planner/catalog\";\nimport { extractKeyFromRow, getStoreName, type IdbContract } from \"./types\";\n\n/** A legacy store or sync metadata set contains several spellings of one Decimal key. */\nexport class IdbDecimalIdentityConflictError extends Error {\n  readonly code = \"DECIMAL_IDENTITY_CONFLICT\";\n\n  constructor(modelName: string) {\n    super(\n      `Several stored keys identify the same Decimal value in model \"${modelName}\". Resolve the conflicting records before retrying.`\n    );\n    this.name = \"IdbDecimalIdentityConflictError\";\n  }\n}\n\n/** Whether a primary key contains a contract-declared Decimal field. */\nexport function hasDecimalPrimaryKey(contract: IdbContract, modelName: string): boolean {\n  const catalog = buildCatalog(contract, getStoreName(contract, modelName), modelName);\n  return hasDecimalFields(catalog, catalog.primaryKey);\n}\n\n/** Compare scalar or compound primary keys using Decimal codecs and native IDB equality elsewhere. */\nexport function decimalKeysEqual(contract: IdbContract, modelName: string, left: unknown, right: unknown): boolean {\n  const catalog = buildCatalog(contract, getStoreName(contract, modelName), modelName);\n  const leftParts = typeof catalog.primaryKey.keyPath === \"string\" ? [left] : left;\n  const rightParts = typeof catalog.primaryKey.keyPath === \"string\" ? [right] : right;\n  if (\n    !Array.isArray(leftParts) ||\n    !Array.isArray(rightParts) ||\n    leftParts.length !== catalog.primaryKey.fields.length ||\n    rightParts.length !== leftParts.length\n  )\n    return false;\n  return catalog.primaryKey.fields.every((field, i) => valuesEqual(catalog, field, leftParts[i], rightParts[i]));\n}\n\n/** Keep an existing Decimal primary-key spelling when the supplied value identifies the same row. */\nexport function preserveDecimalKeySpelling(\n  contract: IdbContract,\n  modelName: string,\n  record: Record<string, unknown>,\n  storedKey: unknown\n): Record<string, unknown> {\n  const catalog = buildCatalog(contract, getStoreName(contract, modelName), modelName);\n  const parts = typeof catalog.primaryKey.keyPath === \"string\" ? [storedKey] : storedKey;\n  if (!Array.isArray(parts) || parts.length !== catalog.primaryKey.fields.length) return record;\n  const result = { ...record };\n  catalog.primaryKey.fields.forEach((field, i) => {\n    if (\n      catalog.fields[field]?.codecId === \"idb/decimal@1\" &&\n      result[field] !== undefined &&\n      valuesEqual(catalog, field, result[field], parts[i])\n    )\n      result[field] = parts[i];\n  });\n  return result;\n}\n\n/** Read the physical key first, then check Decimal aliases without choosing a legacy duplicate. */\nexport async function resolveDecimalKey(\n  scope: Pick<IdbTransactionScope, \"execute\">,\n  contract: IdbContract,\n  modelName: string,\n  key: unknown,\n  snapshot?: readonly Record<string, unknown>[]\n): Promise<Record<string, unknown> | undefined> {\n  if (!isValidIdbKey(key)) return undefined;\n  const storeName = getStoreName(contract, modelName);\n  const decimal = hasDecimalPrimaryKey(contract, modelName);\n  // Reject malformed Decimal operands even when there are no stored rows to compare.\n  if (decimal && !decimalKeysEqual(contract, modelName, key, key)) return undefined;\n  if (!snapshot) {\n    const [exact] = await scope.execute({ kind: \"key-get\", storeName, key } as IdbAtomicPlan);\n    if (!decimal) return exact;\n  }\n  // The physical index cannot reveal aliases, even on an exact hit. A scan\n  // also detects ambiguous databases created before numeric uniqueness checks.\n  const rows = snapshot ?? (await scope.execute({ kind: \"cursor-scan\", storeName } as IdbAtomicPlan));\n  const matches = rows.filter((row) =>\n    decimalKeysEqual(\n      contract,\n      modelName,\n      extractKeyFromRow(row, buildCatalog(contract, storeName, modelName).primaryKey.keyPath),\n      key\n    )\n  );\n  if (matches.length > 1) throw new IdbDecimalIdentityConflictError(modelName);\n  return matches[0];\n}\n\n/** Whether this key source needs numeric equality instead of the native string index. */\nfunction hasDecimalFields(catalog: QueryCatalog, source: CatalogSource): boolean {\n  return source.fields.some((field) => catalog.fields[field]?.codecId === \"idb/decimal@1\");\n}\n\n/** Compare one declared scalar without converting Decimal text through Number. */\nfunction valuesEqual(catalog: QueryCatalog, field: string, left: unknown, right: unknown): boolean {\n  return catalog.fields[field]?.codecId === \"idb/decimal@1\"\n    ? typeof left === \"string\" && typeof right === \"string\" && compareDecimalValues(left, right) === 0\n    : isValidIdbKey(left) && isValidIdbKey(right) && keyEquals(left, right);\n}\n\n/** Numeric unique sources only; ordinary native indexes continue to enforce their own constraints. */\nfunction decimalUniqueSources(catalog: QueryCatalog): CatalogSource[] {\n  return [catalog.primaryKey, ...catalog.indexes].filter(\n    (source) => source.unique && hasDecimalFields(catalog, source)\n  );\n}\n\n/** Match one index entry, excluding absent/null keys just as IndexedDB does. */\nfunction sourceCollides(\n  catalog: QueryCatalog,\n  source: CatalogSource,\n  left: Record<string, unknown>,\n  right: Record<string, unknown>\n): boolean {\n  if (source.multiEntry && source.fields.length === 1) {\n    const field = source.fields[0]!;\n    const a = Array.isArray(left[field]) ? left[field] : [left[field]];\n    const b = Array.isArray(right[field]) ? right[field] : [right[field]];\n    return (a as unknown[]).some((x) => (b as unknown[]).some((y) => valuesEqual(catalog, field, x, y)));\n  }\n  return source.fields.every((field) => valuesEqual(catalog, field, left[field], right[field]));\n}\n\n/** Check new values against every other physical row inside the write transaction. */\nasync function assertUnique(\n  scope: IdbTransactionScope,\n  catalog: QueryCatalog,\n  record: Record<string, unknown>,\n  previousKey: IDBValidKey | undefined,\n  kind: string,\n  modelName: string,\n  snapshot?: readonly Record<string, unknown>[]\n): Promise<void> {\n  const rows =\n    snapshot ?? (await scope.execute({ kind: \"cursor-scan\", storeName: catalog.storeName } as IdbAtomicPlan));\n  const previous = rows.find(\n    (row) => previousKey !== undefined && keyEquals(extractKeyFromRow(row, catalog.primaryKey.keyPath), previousKey)\n  );\n  for (const source of decimalUniqueSources(catalog)) {\n    const matches = rows.filter((row) => sourceCollides(catalog, source, row, record));\n    if (\n      matches.length > 1 ||\n      (previous && rows.filter((row) => sourceCollides(catalog, source, row, previous)).length > 1)\n    )\n      throw new IdbDecimalIdentityConflictError(modelName);\n    if (\n      matches.some(\n        (row) =>\n          previousKey === undefined || !keyEquals(extractKeyFromRow(row, catalog.primaryKey.keyPath), previousKey)\n      )\n    ) {\n      throw new IdbExecuteError(\n        {\n          code: kind === \"add\" ? \"ADD_FAILED\" : \"PUT_FAILED\",\n          planKind: kind,\n          storeName: catalog.storeName,\n          cause: new DOMException(\"Numerically equal Decimal key already exists\", \"ConstraintError\"),\n        },\n        \"Unique constraint failed for a Decimal key\"\n      );\n    }\n  }\n}\n\nconst decimalModelCache = new WeakMap<IdbContract, ReadonlyMap<string, string>>();\n\n/** Cache the contract models whose uniqueness needs more than native string indexes. */\nfunction decimalModels(contract: IdbContract): ReadonlyMap<string, string> {\n  const cached = decimalModelCache.get(contract);\n  if (cached) return cached;\n  const models = new Map<string, string>();\n  for (const modelName of Object.keys(domainModelsAtDefaultNamespace(contract.domain))) {\n    const store = getStoreName(contract, modelName);\n    if (decimalUniqueSources(buildCatalog(contract, store, modelName)).length > 0) models.set(store, modelName);\n  }\n  decimalModelCache.set(contract, models);\n  return models;\n}\n\n/** Wrap the transaction seam so nested, bulk and raw sync writes share the same identity rules. */\nexport function withDecimalIdentityScope(scope: IdbTransactionScope, contract: IdbContract): IdbTransactionScope {\n  const models = decimalModels(contract);\n  if (models.size === 0) return scope;\n  return {\n    commit: () => scope.commit(),\n    rollback: () => scope.rollback(),\n    async execute(plan) {\n      const modelName = models.get(plan.storeName);\n      if (modelName === undefined) return scope.execute(plan);\n      try {\n        return await executeDecimalWrite(scope, contract, modelName, plan);\n      } catch (error) {\n        scope.rollback();\n        throw error;\n      }\n    },\n  };\n}\n\n/** Resolve a keyed write or materialize a scan before enforcing its numeric constraints. */\nasync function executeDecimalWrite(\n  scope: IdbTransactionScope,\n  contract: IdbContract,\n  modelName: string,\n  plan: IdbAtomicPlan,\n  snapshot?: readonly Record<string, unknown>[]\n): Promise<Record<string, unknown>[]> {\n  const catalog = buildCatalog(contract, plan.storeName, modelName);\n  if (plan.kind === \"scan-write\") return executeDecimalScanWrite(scope, contract, modelName, plan);\n  if (plan.kind === \"delete\") {\n    if (!isValidIdbKey(plan.key)) return scope.execute(plan);\n    const row = await resolveDecimalKey(scope, contract, modelName, plan.key, snapshot);\n    return scope.execute({ ...plan, key: row ? extractKeyFromRow(row, catalog.primaryKey.keyPath) : plan.key });\n  }\n  if (plan.kind !== \"add\" && plan.kind !== \"put\" && plan.kind !== \"update\") return scope.execute(plan);\n  const key = plan.kind === \"update\" ? plan.key : extractKeyFromRow(plan.record, catalog.primaryKey.keyPath);\n  const previous = plan.kind === \"add\" ? undefined : await resolveDecimalKey(scope, contract, modelName, key, snapshot);\n  const previousKey = previous && extractKeyFromRow(previous, catalog.primaryKey.keyPath);\n  const record = preserveDecimalKeySpelling(\n    contract,\n    modelName,\n    plan.kind === \"update\" ? { ...previous, ...plan.patch } : plan.record,\n    previousKey\n  );\n  await assertUnique(scope, catalog, record, previousKey, plan.kind, modelName, snapshot);\n  return scope.execute(\n    plan.kind === \"update\"\n      ? {\n          ...plan,\n          key: previousKey ?? plan.key,\n          patch: preserveDecimalKeySpelling(contract, modelName, plan.patch, previousKey),\n        }\n      : { ...plan, record }\n  );\n}\n\n/** Materialize preimages once so moving indexed fields cannot revisit a row. */\nasync function executeDecimalScanWrite(\n  scope: IdbTransactionScope,\n  contract: IdbContract,\n  modelName: string,\n  plan: Extract<IdbAtomicPlan, { kind: \"scan-write\" }>\n): Promise<Record<string, unknown>[]> {\n  const catalog = buildCatalog(contract, plan.storeName, modelName);\n  const { take, ...scan } = plan;\n  const rows = await scope.execute({ ...scan, kind: \"cursor-scan\" });\n  const seen = new Set<string>();\n  const matches = rows\n    .filter((row) => {\n      const token = keyToken(extractKeyFromRow(row, catalog.primaryKey.keyPath));\n      if (seen.has(token)) return false;\n      seen.add(token);\n      return true;\n    })\n    .slice(0, take);\n  // The selected preimages omit rows outside the filter/range. Uniqueness\n  // and legacy-alias checks must still include those rows.\n  if (matches.length === 0) return [];\n  const snapshot =\n    !plan.indexName && !plan.range && !plan.filter\n      ? [...rows]\n      : await scope.execute({ kind: \"cursor-scan\", storeName: plan.storeName } as IdbAtomicPlan);\n  const result: Record<string, unknown>[] = [];\n  for (const row of matches) {\n    const key = extractKeyFromRow(row, catalog.primaryKey.keyPath);\n    const written = await executeDecimalWrite(\n      scope,\n      contract,\n      modelName,\n      plan.write === \"delete\"\n        ? { ...plan, kind: \"delete\", key }\n        : { ...plan, kind: \"update\", key, patch: plan.patch ?? {} },\n      snapshot\n    );\n    result.push(...written);\n    const index = snapshot.findIndex((stored) => keyEquals(extractKeyFromRow(stored, catalog.primaryKey.keyPath), key));\n    if (index >= 0) snapshot.splice(index, 1, ...(plan.write === \"delete\" ? [] : written));\n    else if (plan.write !== \"delete\") snapshot.push(...written);\n  }\n  return result;\n}\n\n/** Decorate only Decimal-key mutations; all other queries retain their existing execution path. */\nexport function withDecimalIdentityExecutor(contract: IdbContract, executor: IdbQueryExecutor): IdbQueryExecutor {\n  const models = decimalModels(contract);\n  if (models.size === 0) return executor;\n  const inner = executor as Partial<IdbQueryExecutorWithTransaction>;\n  /** Only mutations of declared Decimal key sources need a transaction wrapper. */\n  const needsCheck = (plan: IdbAtomicPlan): boolean => {\n    if (![\"add\", \"put\", \"update\", \"delete\", \"scan-write\"].includes(plan.kind)) return false;\n    return models.has(plan.storeName);\n  };\n  /** Keep validation and the write under the caller's transaction and sync interceptor. */\n  const transaction = async (stores: string[], mode?: IDBTransactionMode): Promise<IdbTransactionScope> => {\n    if (typeof inner.transaction !== \"function\")\n      throw new Error(\"Decimal key mutations require a transaction-capable executor\");\n    return withDecimalIdentityScope(await inner.transaction(stores, mode), contract);\n  };\n  return {\n    ...(typeof inner.transaction === \"function\" ? { transaction } : {}),\n    query<Row>(plan: IdbQueryPlan<Row>): AsyncIterableResult<Row> {\n      const body: IdbPlanBody = plan.idbPlan;\n      const ops = body.kind === \"batch\" ? body.ops : [body];\n      if (!ops.some(needsCheck)) return executor.query(plan);\n      return new AsyncIterableResult(\n        (async function* () {\n          const scope = await transaction(body.kind === \"batch\" ? [...body.storeNames] : [body.storeName], \"readwrite\");\n          try {\n            const rows: Record<string, unknown>[] = [];\n            for (const op of ops) rows.push(...(await scope.execute(op)));\n            await scope.commit();\n            for (const row of rows) yield row as Row;\n          } catch (error) {\n            scope.rollback();\n            throw error;\n          }\n        })()\n      );\n    },\n  };\n}\n","import type { IdbFilterExpr } from \"@prisma-idb/adapter-idb/runtime\";\nimport { andExpr } from \"@prisma-idb/adapter-idb/runtime\";\nimport type { IdbRowComparator } from \"@prisma-idb/driver-idb/runtime\";\nimport { compareDecimalValues, compareFieldValues } from \"@prisma-idb/target-idb/runtime\";\nimport type { CatalogField } from \"./planner/catalog\";\n\n/**\n * Combine accumulated filter expressions with AND.\n *\n * Returns `undefined` when no filter is present so callers can skip building a\n * row-filter closure. Shared by {@link IdbStoreAccessorImpl} (top-level scans)\n * and the relation loader (refined `include()` child scans).\n */\nexport function combineFilterExprs(filters: ReadonlyArray<IdbFilterExpr>): IdbFilterExpr | undefined {\n  if (filters.length === 0) return undefined;\n  if (filters.length === 1) return filters[0];\n  return andExpr(filters);\n}\n\n/**\n * Build an in-memory comparator from an `orderBy` spec (field → direction).\n *\n * Returns `undefined` when there is nothing to sort by. Compares fields in\n * declaration order. Decimal fields use exact numeric order; other fields\n * use {@link compareFieldValues}: the same order an\n * IndexedDB index uses, so equal `Date`s tie and fall through to the next\n * field, and `null`s sort last (first when descending).\n */\nexport function buildRowComparator(\n  orderBy: Readonly<Record<string, \"asc\" | \"desc\">> | undefined,\n  fields: Readonly<Record<string, CatalogField>> = {}\n): IdbRowComparator | undefined {\n  if (orderBy === undefined) return undefined;\n  return (a: Record<string, unknown>, b: Record<string, unknown>): number => {\n    for (const [field, dir] of Object.entries(orderBy)) {\n      const metadata = fields[field];\n      const decimal = metadata?.codecId === \"idb/decimal@1\" && !metadata.collection;\n      const present = a[field] != null && b[field] != null;\n      const cmp =\n        decimal && present ? compareDecimalValues(a[field], b[field]) : compareFieldValues(a[field], b[field]);\n      if (cmp === 0) continue;\n      return dir === \"desc\" ? -cmp : cmp;\n    }\n    return 0;\n  };\n}\n","/**\n * Runtime validation of enum-typed fields on create/update data.\n *\n * The generated types already narrow enum fields to their literal union, but\n * nothing below the client checks the values: the `idb/string@1` codec passes\n * any value through and IndexedDB stores whatever it is given. A database with\n * native enums rejects an undeclared value on write, so every write path runs\n * {@link assertEnumValues} on its final data (after mutation defaults are\n * applied) before the write is planned.\n */\nimport type { ContractField } from \"@prisma/orm-framework/contract/types\";\nimport { domainModelsAtDefaultNamespace } from \"@prisma/orm-framework/contract/types\";\nimport type { IdbContract } from \"./types\";\n\n/** The allowed values and nullability of one enum field. */\ntype EnumFieldRule = {\n  readonly enumName: string;\n  readonly values: ReadonlySet<unknown>;\n  readonly nullable: boolean;\n  readonly many: boolean;\n  /** Whether a list field accepts `null` elements. Always `false` for non-list fields. */\n  readonly elementNullable: boolean;\n};\n\n/** Enum validation rules keyed by model field name. */\ntype ModelEnumRules = ReadonlyMap<string, EnumFieldRule>;\n\nconst rulesByContract = new WeakMap<IdbContract, Map<string, ModelEnumRules>>();\n\n/** Resolve an enum reference against its declared namespace before validating writes. */\nfunction resolveEnumRule(contract: IdbContract, field: ContractField): EnumFieldRule | undefined {\n  const ref = field.valueSet;\n  if (ref === undefined || ref.plane !== \"domain\" || ref.entityKind !== \"enum\") return undefined;\n  const contractEnum = contract.domain.namespaces[ref.namespaceId]?.enum?.[ref.entityName];\n  if (contractEnum === undefined) {\n    throw new Error(`Enum \"${ref.entityName}\" referenced by the contract is not declared in its domain.`);\n  }\n  return {\n    enumName: ref.entityName,\n    values: new Set(contractEnum.members.map((member) => member.value)),\n    nullable: field.nullable,\n    // `many` is `true` in older contracts and an object (`{ elementNullable }`) in newer ones.\n    many: Boolean(field.many),\n    elementNullable: typeof field.many === \"object\" && field.many.elementNullable === true,\n  };\n}\n\n/** Cache enum rules by contract identity and model to avoid rebuilding them for each write. */\nfunction getModelEnumRules(contract: IdbContract, modelName: string): ModelEnumRules {\n  let byModel = rulesByContract.get(contract);\n  if (byModel === undefined) {\n    byModel = new Map();\n    rulesByContract.set(contract, byModel);\n  }\n  const cached = byModel.get(modelName);\n  if (cached !== undefined) return cached;\n\n  const rules = new Map<string, EnumFieldRule>();\n  const fields = domainModelsAtDefaultNamespace(contract.domain)[modelName]?.fields ?? {};\n  for (const [fieldName, field] of Object.entries(fields)) {\n    const rule = resolveEnumRule(contract, field);\n    if (rule !== undefined) rules.set(fieldName, rule);\n  }\n  byModel.set(modelName, rules);\n  return rules;\n}\n\nfunction describe(value: unknown): string {\n  return typeof value === \"string\" ? JSON.stringify(value) : `${String(value)} (${typeof value})`;\n}\n\n/** Describe an invalid enum value together with the declared alternatives. */\nfunction invalidValueError(modelName: string, fieldName: string, rule: EnumFieldRule, value: unknown): Error {\n  const expected = [...rule.values].map((v) => JSON.stringify(v)).join(\", \");\n  return new Error(\n    `Invalid value ${describe(value)} for enum field \"${modelName}.${fieldName}\". ` +\n      `Expected one of enum \"${rule.enumName}\": ${expected}.`\n  );\n}\n\n/**\n * Throws if `data` sets an enum field to a value its enum doesn't declare.\n * Fields left `undefined` are not checked. `null` is accepted only on an\n * optional (`Role?`) field; a list (`Role[]`) field must be an array whose\n * every element is a declared value, or `null` when the list allows nullable elements.\n */\nexport function assertEnumValues(contract: IdbContract, modelName: string, data: Record<string, unknown>): void {\n  const rules = getModelEnumRules(contract, modelName);\n  if (rules.size === 0) return;\n  for (const [fieldName, rule] of rules) {\n    const value = data[fieldName];\n    if (value === undefined) continue;\n    if (value === null) {\n      if (rule.nullable) continue;\n      throw new Error(`Enum field \"${modelName}.${fieldName}\" is required and cannot be null.`);\n    }\n    if (rule.many) {\n      if (!Array.isArray(value)) {\n        throw new Error(\n          `Enum list field \"${modelName}.${fieldName}\" expects an array of \"${rule.enumName}\" values, got ${describe(value)}.`\n        );\n      }\n      for (const element of value) {\n        if (element === null && rule.elementNullable) continue;\n        if (!rule.values.has(element)) throw invalidValueError(modelName, fieldName, rule, element);\n      }\n      continue;\n    }\n    if (!rule.values.has(value)) throw invalidValueError(modelName, fieldName, rule, value);\n  }\n}\n","import { validateRecord } from \"@prisma-idb/target-idb/runtime\";\nimport { getKeyPath, getStoreName, type IdbContract } from \"./types\";\n\n/** A local ORM create or update failed the contract's native record validation. */\nexport class IdbRecordValidationError extends Error {\n  constructor(\n    readonly modelName: string,\n    readonly operation: \"create\" | \"update\",\n    readonly issues: readonly string[]\n  ) {\n    super(`Invalid ${operation} record for \"${modelName}\": ${issues.join(\"; \")}`);\n    this.name = \"IdbRecordValidationError\";\n  }\n}\n\n/** Validate final write data, after defaults and relation scalar values are resolved. */\nexport function assertValidRecord(\n  contract: IdbContract,\n  modelName: string,\n  operation: \"create\" | \"update\",\n  data: Record<string, unknown>\n): void {\n  const keyPath = getKeyPath(contract, modelName);\n  const store = contract.storage.stores[getStoreName(contract, modelName)];\n  // Only IndexedDB's native key generator may leave a create field absent.\n  const optionalFields =\n    operation === \"create\" && store?.autoIncrement && typeof keyPath === \"string\" && !Object.hasOwn(data, keyPath)\n      ? [keyPath]\n      : [];\n  const result = validateRecord(contract, modelName, data, { partial: operation === \"update\", optionalFields });\n  if (!result.ok) throw new IdbRecordValidationError(modelName, operation, result.issues);\n}\n","/**\n * Applies `contract.execution.mutations.defaults` (ADR 158) during a\n * create/update — IDB's equivalent of the SQL family's\n * `ExecutionContext.applyMutationDefaults`.\n *\n * Semantics mirror the SQL reference implementation:\n * - a caller-provided value always wins over a default;\n * - an empty update patch skips every `onUpdate` default (no write ⇒ no\n *   `@updatedAt` advance);\n * - `timestampNow`'s value is cached per call so a whole top-level mutation\n *   call (e.g. a `createAll()` batch) shares one generated value across\n *   every row it backs, matching its `'query'`-stability in SQL. Every other\n *   generator (`literal`, `uuidv4`, `uuidv7`, `cuid2`) is deliberately *not*\n *   cached — an id generator must produce a fresh, unique value per\n *   resolution (both across rows in a batch and across distinct defaulted\n *   fields on the same row), and a cache keyed only by generator id would\n *   otherwise leak one field's/row's value onto the next.\n */\nimport type { ExecutionMutationDefault, ExecutionMutationDefaultValue } from \"@prisma/orm-framework/contract/types\";\nimport { generateId } from \"@prisma/orm-framework/ids/runtime\";\nimport type { IdbMutationDefaultGeneratorId } from \"@prisma-idb/target-idb/pack\";\nimport { absentAsNull } from \"@prisma-idb/target-idb/runtime\";\nimport { getStoreName, type IdbContract } from \"./types\";\n\n/** Per-top-level-mutation-call cache, keyed by generator id. Create one with {@link createMutationDefaultsCache}. */\nexport type MutationDefaultsCache = Map<string, unknown>;\n\nexport function createMutationDefaultsCache(): MutationDefaultsCache {\n  return new Map();\n}\n\n/** Generator ids whose value is shared across an entire top-level call. Every other id always regenerates. */\nconst CACHEABLE_GENERATOR_IDS: ReadonlySet<IdbMutationDefaultGeneratorId> = new Set([\"timestampNow\"]);\n\n/** Resolve one declared default with the same generator IDs as the SQL execution layer. */\nfunction computeGeneratedValue(spec: ExecutionMutationDefaultValue): unknown {\n  const id = spec.id as IdbMutationDefaultGeneratorId;\n  switch (id) {\n    case \"timestampNow\":\n      return new Date();\n    case \"literal\":\n      return spec.params?.[\"value\"];\n    case \"uuidv4\":\n    case \"uuidv7\":\n    case \"cuid2\":\n      return generateId(spec.params !== undefined ? { id, params: spec.params } : { id });\n    default: {\n      const _exhaustive: never = id;\n      throw new Error(`Unknown mutation-default generator id \"${String(_exhaustive)}\"`);\n    }\n  }\n}\n\n/** Share query-stable defaults across one mutation while generating fresh IDs for each field. */\nfunction resolveGeneratedValue(spec: ExecutionMutationDefaultValue, cache: MutationDefaultsCache): unknown {\n  const id = spec.id as IdbMutationDefaultGeneratorId;\n  if (!CACHEABLE_GENERATOR_IDS.has(id)) return computeGeneratedValue(spec);\n  const cached = cache.get(id);\n  if (cached !== undefined) return cached;\n  const value = computeGeneratedValue(spec);\n  cache.set(id, value);\n  return value;\n}\n\n/**\n * Fills in every column with an `onCreate` default that `data` doesn't\n * already set. Returns `data` unchanged (same reference) if there's nothing\n * to apply.\n */\nexport function applyCreateDefaults(\n  defaults: readonly ExecutionMutationDefault[] | undefined,\n  storeName: string,\n  data: Record<string, unknown>,\n  cache: MutationDefaultsCache\n): Record<string, unknown> {\n  if (!defaults || defaults.length === 0) return data;\n  let result = data;\n  for (const d of defaults) {\n    if (d.ref.entry !== storeName || !d.onCreate) continue;\n    if (result[d.ref.field] !== undefined) continue;\n    if (result === data) result = { ...data };\n    result[d.ref.field] = resolveGeneratedValue(d.onCreate, cache);\n  }\n  return result;\n}\n\n/**\n * Completes a create record: applies the `onCreate` defaults, then stores\n * `null` for every nullable field the record still lacks. IndexedDB has no\n * column defaults, so this is what keeps stored rows complete while the create\n * input leaves nullable fields optional, as Prisma's does. Call it after any\n * relation values are resolved into `data`, and validate the result.\n */\nexport function completeCreateRecord(\n  contract: IdbContract,\n  modelName: string,\n  data: Record<string, unknown>,\n  cache: MutationDefaultsCache\n): Record<string, unknown> {\n  const withDefaults = applyCreateDefaults(\n    contract.execution?.mutations.defaults,\n    getStoreName(contract, modelName),\n    data,\n    cache\n  );\n  return absentAsNull(contract, modelName)(withDefaults);\n}\n\n/**\n * Fills in every column with an `onUpdate` default that `patch` doesn't\n * already set. A patch with no defined values (empty, or every field\n * explicitly `undefined`) is returned unchanged — no write means no default\n * should fire either (matches SQL's \"empty update payloads skip onUpdate\n * defaults\" rule).\n */\nexport function applyUpdateDefaults(\n  defaults: readonly ExecutionMutationDefault[] | undefined,\n  storeName: string,\n  patch: Record<string, unknown>,\n  cache: MutationDefaultsCache\n): Record<string, unknown> {\n  if (Object.values(patch).every((v) => v === undefined)) return patch;\n  if (!defaults || defaults.length === 0) return patch;\n  let result = patch;\n  for (const d of defaults) {\n    if (d.ref.entry !== storeName || !d.onUpdate) continue;\n    if (result[d.ref.field] !== undefined) continue;\n    if (result === patch) result = { ...patch };\n    result[d.ref.field] = resolveGeneratedValue(d.onUpdate, cache);\n  }\n  return result;\n}\n","import { assertValidDecimalFilter } from \"@prisma-idb/adapter-idb/runtime\";\nimport type { IdbFieldFilter, IdbFilterExpr } from \"@prisma-idb/adapter-idb/runtime\";\nimport type { IdbKeyRangeDescriptor, IdbScanDirection } from \"@prisma-idb/driver-idb/runtime\";\nimport { compareFieldValues, isValidIdbKey, keyEquals } from \"@prisma-idb/target-idb/runtime\";\nimport type { CatalogField, CatalogSource, QueryCatalog } from \"./catalog\";\n\n/** Query inputs relevant to access selection. Pagination is applied by the caller. */\nexport interface PlanRequest {\n  readonly where?: IdbFilterExpr;\n  readonly orderBy?: Readonly<Record<string, \"asc\" | \"desc\">>;\n  readonly take?: number;\n  /** Relation predicates are evaluated outside the scalar filter AST. */\n  readonly hasRelationFilter?: boolean;\n}\n\n/**\n * Disjoint driver-compatible ranges on one source, sorted by ascending key.\n * An absent range means all keys. Reverse the range sequence for `prev` traversal.\n */\nexport type QueryAccess =\n  | { readonly kind: \"full\" }\n  | { readonly kind: \"empty\" }\n  | {\n      readonly kind: \"ranges\";\n      readonly source: CatalogSource;\n      readonly ranges: readonly (IdbKeyRangeDescriptor | undefined)[];\n    };\n\n/** The access is a superset of matches. Always reapply the original filter. */\nexport interface LogicalPlan {\n  readonly access: QueryAccess;\n  readonly exact: boolean;\n  /** Present only when source traversal satisfies the requested single-field order. */\n  readonly direction?: IdbScanDirection;\n}\n\n/** One open or closed endpoint of a field constraint. */\ninterface Bound {\n  readonly value: IDBValidKey;\n  readonly open: boolean;\n}\n/** Intersected points and bounds for one field, with index-coverage information. */\ninterface Constraint {\n  points?: IDBValidKey[];\n  lower?: Bound;\n  upper?: Bound;\n  consumed: number;\n  startsWith?: boolean;\n  rejectsNonKeys?: boolean;\n}\n/** A safe access source and its deterministic selection cost. */\ninterface Candidate {\n  source: CatalogSource;\n  ranges: (IdbKeyRangeDescriptor | undefined)[];\n  cost: number;\n  consumed: number;\n  declaration: number;\n}\n/** Filter atoms and residual predicates used to decide whether an index is safe. */\ninterface Normalized {\n  atoms: IdbFieldFilter[];\n  residual: number;\n  excluded: boolean;\n  empty: boolean;\n}\n\n// Rank selective points before broader ranges; ordering-only scans visit every key.\nconst COST = {\n  UNIQUE_POINT: 0,\n  PRIMARY_POINT: 1,\n  INDEX_POINT: 2,\n  PREFIX_POINT: 3,\n  TWO_SIDED_RANGE: 4,\n  ONE_SIDED_RANGE: 5,\n  ORDER_ONLY_SCAN: 6,\n} as const;\n\n// These encoders also accept non-keys, so index coverage needs a rejecting predicate.\nconst KEY_PARTIAL_CODECS = new Set([\"idb/double@1\", \"idb/date@1\"]);\n\n// Decimal strings are keys, but native key comparisons do not match numeric semantics.\nconst KEY_CODECS = new Set([\"idb/string@1\", \"idb/int32@1\", \"idb/double@1\", \"idb/date@1\", \"idb/bytes@1\"]);\n\n/** Choose the cheapest safe access without opening IndexedDB or probing cardinality. */\nexport function planQuery(catalog: QueryCatalog, request: PlanRequest): LogicalPlan {\n  if (request.where !== undefined) assertValidDecimalFilter(request.where, catalog.fields);\n  const normalized = normalize(request.where);\n  if (normalized.empty) return { access: { kind: \"empty\" }, exact: true };\n  const orders = Object.entries(request.orderBy ?? {});\n  if (normalized.excluded || request.hasRelationFilter || orders.length > 1) return full(false);\n\n  const constraints = new Map<string, Constraint>();\n  for (const atom of normalized.atoms) {\n    let constraint = constraints.get(atom.field);\n    if (!constraint) {\n      constraint = { consumed: 0 };\n      constraints.set(atom.field, constraint);\n    }\n    addAtom(constraint, atom, catalog.fields[atom.field]);\n  }\n  for (const [name, constraint] of constraints) {\n    // Inclusive comparisons can match NaN and invalid dates, which indexes omit.\n    if (keyPartial(catalog.fields[name]) && !constraint.rejectsNonKeys) {\n      delete constraint.lower;\n      delete constraint.upper;\n      constraint.consumed = 0;\n    }\n    if (contradictory(constraint)) return { access: { kind: \"empty\" }, exact: true };\n  }\n\n  const sources = [catalog.primaryKey, ...catalog.indexes];\n  const candidates = sources.flatMap((source, declaration) => {\n    const candidate = filteringCandidate(catalog, source, constraints, declaration);\n    return candidate ? [candidate] : [];\n  });\n  candidates.sort(\n    (a, b) =>\n      a.cost - b.cost ||\n      a.ranges.length - b.ranges.length ||\n      Number(a.source.indexName !== undefined) - Number(b.source.indexName !== undefined) ||\n      a.declaration - b.declaration\n  );\n  let selected = candidates[0];\n  let direction: IdbScanDirection | undefined;\n  if (orders.length === 1 && request.take !== undefined) {\n    const [field, order] = orders[0]!;\n    if (selected) {\n      if (catalog.fields[field]?.codecId !== \"idb/decimal@1\" && sourceOrdersField(selected.source, field, constraints))\n        direction = order === \"asc\" ? \"next\" : \"prev\";\n    } else {\n      const ordering = sources.find(\n        (source) => !source.multiEntry && singleFieldSource(source, field) && completeKeyField(catalog.fields[field])\n      );\n      if (ordering) {\n        selected = {\n          source: ordering,\n          ranges: [undefined],\n          cost: COST.ORDER_ONLY_SCAN,\n          consumed: 0,\n          declaration: sources.indexOf(ordering),\n        };\n        direction = order === \"asc\" ? \"next\" : \"prev\";\n      }\n    }\n  }\n  if (!selected) {\n    const partialOrder = orders.length === 1 && request.take !== undefined && keyPartial(catalog.fields[orders[0]![0]]);\n    return full(normalized.atoms.length + normalized.residual === 0 && !partialOrder);\n  }\n  return {\n    access: { kind: \"ranges\", source: selected.source, ranges: selected.ranges },\n    exact: selected.consumed === normalized.atoms.length && normalized.residual === 0,\n    ...(direction === undefined ? {} : { direction }),\n  };\n}\n\nfunction full(exact: boolean): LogicalPlan {\n  return { access: { kind: \"full\" }, exact };\n}\n\n/** Flatten supported conjunctions and same-field unions while retaining unsupported predicates. */\nfunction normalize(where: IdbFilterExpr | undefined): Normalized {\n  const result: Normalized = { atoms: [], residual: 0, excluded: false, empty: false };\n  /** Collect usable atoms and mark filters that require the full-row path. */\n  function visit(expr: IdbFilterExpr): void {\n    switch (expr.kind) {\n      case \"field\":\n        if (expr.op === \"in\" && (!Array.isArray(expr.value) || expr.value.length === 0)) result.empty = true;\n        result.atoms.push(expr);\n        break;\n      case \"and\":\n        expr.exprs.forEach(visit);\n        break;\n      case \"or\": {\n        if (expr.exprs.length === 0) {\n          result.empty = true;\n          break;\n        }\n        const branches = expr.exprs;\n        const first = branches[0]!;\n        if (\n          first.kind !== \"field\" ||\n          !branches.every(\n            (branch) =>\n              branch.kind === \"field\" && branch.field === first.field && (branch.op === \"eq\" || branch.op === \"in\")\n          )\n        ) {\n          result.excluded = true;\n          break;\n        }\n        const values = branches.flatMap((branch) => {\n          const atom = branch as IdbFieldFilter;\n          return atom.op === \"eq\" ? [atom.value] : Array.isArray(atom.value) ? atom.value : [];\n        });\n        visit({ kind: \"field\", field: first.field, op: \"in\", value: values });\n        break;\n      }\n      case \"not\":\n        result.excluded = true;\n        break;\n      case \"null-check\":\n        result.residual++;\n        break;\n    }\n  }\n  if (where) visit(where);\n  return result;\n}\n\nfunction keyTyped(field: CatalogField | undefined): boolean {\n  return field !== undefined && !field.collection && KEY_CODECS.has(field.codecId ?? \"\");\n}\nfunction keyPartial(field: CatalogField | undefined): boolean {\n  return KEY_PARTIAL_CODECS.has(field?.codecId ?? \"\");\n}\nfunction completeKeyField(field: CatalogField | undefined, constraint?: Constraint): boolean {\n  return keyTyped(field) && field?.nullable === false && (!keyPartial(field) || constraint?.rejectsNonKeys === true);\n}\n/** A compound cursor orders a suffix only within one fixed preceding key. */\nfunction sourceOrdersField(\n  source: CatalogSource,\n  field: string,\n  constraints: ReadonlyMap<string, Constraint>\n): boolean {\n  const position = source.fields.indexOf(field);\n  return position >= 0 && source.fields.slice(0, position).every((name) => constraints.get(name)?.points?.length === 1);\n}\n\nfunction singleFieldSource(source: CatalogSource, field: string): boolean {\n  return source.fields.length === 1 && source.fields[0] === field;\n}\n\n/** Intersect one supported predicate with a field constraint without narrowing unsafe values. */\nfunction addAtom(constraint: Constraint, atom: IdbFieldFilter, field: CatalogField | undefined): void {\n  // Decimal text has numeric equality and order, so native string ranges are unsafe.\n  if (field?.codecId === \"idb/decimal@1\") return;\n  if (atom.op === \"eq\" || atom.op === \"in\") {\n    const values: unknown[] = atom.op === \"eq\" ? [atom.value] : Array.isArray(atom.value) ? atom.value : [];\n    if (!values.every(isValidIdbKey)) return;\n    const points = uniqueKeys(values);\n    constraint.points =\n      constraint.points === undefined\n        ? points\n        : constraint.points.filter((point) => points.some((value) => keyEquals(point, value)));\n    constraint.rejectsNonKeys = true;\n    constraint.consumed++;\n    return;\n  }\n  if (!keyTyped(field)) return;\n  if (atom.op === \"startsWith\") {\n    if (field?.codecId !== \"idb/string@1\" || typeof atom.value !== \"string\") return;\n    intersectBound(constraint, \"lower\", { value: atom.value, open: false });\n    const upper = stringSuccessor(atom.value);\n    if (upper !== undefined) intersectBound(constraint, \"upper\", { value: upper, open: true });\n    constraint.startsWith = true;\n    constraint.consumed++;\n  } else if ([\"gt\", \"gte\", \"lt\", \"lte\"].includes(atom.op) && isValidIdbKey(atom.value)) {\n    const side = atom.op === \"gt\" || atom.op === \"gte\" ? \"lower\" : \"upper\";\n    const strict = atom.op === \"gt\" || atom.op === \"lt\";\n    intersectBound(constraint, side, { value: atom.value, open: strict });\n    if (strict) constraint.rejectsNonKeys = true;\n    constraint.consumed++;\n  }\n}\n\nfunction uniqueKeys(values: IDBValidKey[]): IDBValidKey[] {\n  const sorted = [...values].sort(compareFieldValues);\n  return sorted.filter((value, i) => i === 0 || compareFieldValues(sorted[i - 1], value) !== 0);\n}\n/** Keep the tighter endpoint when several comparisons constrain the same field. */\nfunction intersectBound(constraint: Constraint, side: \"lower\" | \"upper\", bound: Bound): void {\n  const previous = constraint[side];\n  const comparison = previous === undefined ? 0 : compareFieldValues(bound.value, previous.value);\n  if (!previous || (side === \"lower\" ? comparison > 0 : comparison < 0) || (comparison === 0 && bound.open)) {\n    constraint[side] = bound;\n  }\n}\n/** Check a point against both endpoints, including open-bound equality. */\nfunction insideBounds(value: IDBValidKey, constraint: Constraint): boolean {\n  const lower = constraint.lower;\n  const upper = constraint.upper;\n  if (lower && (compareFieldValues(value, lower.value) < 0 || (lower.open && keyEquals(value, lower.value))))\n    return false;\n  if (upper && (compareFieldValues(value, upper.value) > 0 || (upper.open && keyEquals(value, upper.value))))\n    return false;\n  return true;\n}\n/** Discard points outside the bounds and detect ranges that cannot match. */\nfunction contradictory(constraint: Constraint): boolean {\n  if (constraint.points) {\n    constraint.points = constraint.points.filter((value) => insideBounds(value, constraint));\n    return constraint.points.length === 0;\n  }\n  if (!constraint.lower || !constraint.upper) return false;\n  const comparison = compareFieldValues(constraint.lower.value, constraint.upper.value);\n  return comparison > 0 || (comparison === 0 && (constraint.lower.open || constraint.upper.open));\n}\n\n/** Build a safe source range only when its index contains every possible match. */\nfunction filteringCandidate(\n  catalog: QueryCatalog,\n  source: CatalogSource,\n  constraints: ReadonlyMap<string, Constraint>,\n  declaration: number\n): Candidate | undefined {\n  if (source.multiEntry || source.fields.length === 0) return undefined;\n  if (source.fields.some((name) => keyPartial(catalog.fields[name]) && !constraints.get(name)?.rejectsNonKeys))\n    return undefined;\n  let prefixes: IDBValidKey[][] = [[]];\n  let consumed = 0;\n  let position = 0;\n  while (position < source.fields.length) {\n    const constraint = constraints.get(source.fields[position]!);\n    if (constraint?.points === undefined) break;\n    // Avoid allocating an unbounded Cartesian product. A full scan is always safe.\n    if (prefixes.length * constraint.points.length > 1024) return undefined;\n    prefixes = prefixes.flatMap((prefix) => constraint.points!.map((point) => [...prefix, point]));\n    consumed += constraint.consumed;\n    position++;\n  }\n  const constraint = constraints.get(source.fields[position] ?? \"\");\n  const hasRange = constraint !== undefined && (constraint.lower !== undefined || constraint.upper !== undefined);\n  if (position === 0 && !hasRange) return undefined;\n  const used = position + Number(hasRange);\n  if (!source.fields.slice(used).every((field) => completeKeyField(catalog.fields[field], constraints.get(field))))\n    return undefined;\n  const compound = typeof source.keyPath !== \"string\";\n  if (position === source.fields.length) {\n    return {\n      source,\n      ranges: prefixes.map((prefix) => ({ kind: \"only\", key: compound ? prefix : prefix[0]! })),\n      cost:\n        source.indexName !== undefined && source.unique\n          ? COST.UNIQUE_POINT\n          : source.indexName === undefined\n            ? COST.PRIMARY_POINT\n            : COST.INDEX_POINT,\n      consumed,\n      declaration,\n    };\n  }\n  if (hasRange) consumed += constraint.consumed;\n  const ranges = prefixes.map((prefix) =>\n    compound ? compoundRange(prefix, constraint, source.fields.length - used) : scalarRange(constraint!)\n  );\n  // A literal outside the stored scalar type can sort above the compound sentinel.\n  if (\n    ranges.some(\n      (range) =>\n        range.kind === \"bound\" &&\n        (compareFieldValues(range.lower, range.upper) > 0 ||\n          (keyEquals(range.lower, range.upper) && (range.lowerOpen || range.upperOpen)))\n    )\n  )\n    return undefined;\n  const cost = hasRange\n    ? constraint.lower && constraint.upper && !constraint.startsWith\n      ? COST.TWO_SIDED_RANGE\n      : COST.ONE_SIDED_RANGE\n    : COST.PREFIX_POINT;\n  return { source, ranges, cost, consumed, declaration };\n}\n\n/** Convert scalar endpoints into the matching driver range descriptor. */\nfunction scalarRange(constraint: Constraint): IdbKeyRangeDescriptor {\n  if (constraint.lower && constraint.upper)\n    return {\n      kind: \"bound\",\n      lower: constraint.lower.value,\n      upper: constraint.upper.value,\n      lowerOpen: constraint.lower.open,\n      upperOpen: constraint.upper.open,\n    };\n  if (constraint.lower) return { kind: \"lower\", key: constraint.lower.value, open: constraint.lower.open };\n  return { kind: \"upper\", key: constraint.upper!.value, open: constraint.upper!.open };\n}\n\n/** Bound a compound prefix and suffix using IndexedDB key ordering. */\nfunction compoundRange(\n  prefix: IDBValidKey[],\n  constraint: Constraint | undefined,\n  trailing: number\n): IdbKeyRangeDescriptor {\n  const lower = constraint?.lower;\n  const upper = constraint?.upper;\n  // [] sorts above every scalar key codec. Nested-array codecs are excluded for trailing fields.\n  const lowerKey = lower\n    ? [...prefix, lower.value, ...(lower.open && trailing > 0 ? [[]] : [])]\n    : prefix.length\n      ? prefix\n      : [-Infinity];\n  const upperKey = upper ? [...prefix, upper.value, ...(!upper.open && trailing > 0 ? [[]] : [])] : [...prefix, []];\n  return {\n    kind: \"bound\",\n    lower: lowerKey,\n    upper: upperKey,\n    lowerOpen: lower?.open ?? false,\n    upperOpen: upper ? upper.open || trailing > 0 : true,\n  };\n}\n\n/** Find the exclusive upper bound of a UTF-16 prefix, if one exists. */\nfunction stringSuccessor(prefix: string): string | undefined {\n  for (let i = prefix.length - 1; i >= 0; i--) {\n    const code = prefix.charCodeAt(i);\n    if (code < 0xffff) return prefix.slice(0, i) + String.fromCharCode(code + 1);\n  }\n  return undefined;\n}\n","import type { PlanMeta } from \"@prisma/orm-framework/contract/types\";\nimport { evaluateFilter } from \"@prisma-idb/adapter-idb/runtime\";\nimport type { IdbAtomicPlan, IdbKeyRangeDescriptor, IdbPlanBody, IdbRowFilter } from \"@prisma-idb/driver-idb/runtime\";\nimport { buildRowComparator } from \"../query-shaping\";\nimport type { QueryCatalog } from \"./catalog\";\nimport type { LogicalPlan, PlanRequest } from \"./plan\";\n\n/**\n * The row filter shared by every lowered read and write. The driver runs it on stored rows, so it\n * reads each row as the contract describes it first: a filter on `null` matches a row that\n * lacks the field.\n */\nfunction rowFilter(catalog: QueryCatalog, request: PlanRequest, additionalFilter?: IdbRowFilter): IdbRowFilter {\n  return (stored) => {\n    const row = catalog.absentAsNull(stored);\n    return (\n      (request.where === undefined || evaluateFilter(request.where, row, catalog.fields)) &&\n      (additionalFilter === undefined || additionalFilter(row))\n    );\n  };\n}\n\n/** Row shaping inputs. Pagination applies after the full filter. */\nexport interface RowsRequest extends PlanRequest {\n  readonly skip?: number;\n}\n\n/** One driver operation and the synchronous shaping of its combined result. */\nexport interface LoweredRows {\n  readonly idbPlan: IdbPlanBody;\n  finish(rows: Record<string, unknown>[]): Record<string, unknown>[];\n}\n\n/**\n * Lower row access without creating IDBKeyRange objects or awaiting work.\n * Run `finish` after the executor has materialized all returned rows.\n * Without `orderBy`, row order and pagination selection are unspecified.\n * Rows tied on every ordering field may appear in any order, including at\n * pagination boundaries. Add a unique ordering field for deterministic pages.\n */\nexport function lowerRows(\n  catalog: QueryCatalog,\n  logical: LogicalPlan,\n  meta: PlanMeta,\n  request: RowsRequest,\n  additionalFilter?: IdbRowFilter\n): LoweredRows {\n  // Omit a no-op closure so unfiltered reads keep a stable middleware cache key.\n  const filter =\n    request.where === undefined && additionalFilter === undefined\n      ? undefined\n      : rowFilter(catalog, request, additionalFilter);\n  const comparator = logical.direction === undefined ? buildRowComparator(request.orderBy, catalog.fields) : undefined;\n  const base = { meta, storeName: catalog.storeName };\n  const pagination = {\n    ...(request.skip === undefined ? {} : { skip: request.skip }),\n    ...(request.take === undefined ? {} : { take: request.take }),\n  };\n  let shapedByDriver = false;\n  let idbPlan: IdbPlanBody;\n  switch (logical.access.kind) {\n    case \"empty\":\n      idbPlan = { meta, kind: \"batch\", storeNames: [catalog.storeName], ops: [] };\n      break;\n    case \"full\":\n      idbPlan = {\n        ...base,\n        kind: \"cursor-scan\",\n        ...(filter === undefined ? {} : { filter }),\n        ...(comparator === undefined ? {} : { comparator }),\n        ...pagination,\n      };\n      shapedByDriver = true;\n      break;\n    case \"ranges\": {\n      const { source } = logical.access;\n      const ranges = [...logical.access.ranges];\n      if (logical.direction === \"prev\") ranges.reverse();\n      const single = ranges.length === 1;\n      const ops: IdbAtomicPlan[] = ranges.map((range) => {\n        if (range?.kind === \"only\" && source.indexName === undefined)\n          return { ...base, kind: \"key-get\", key: range.key };\n        const access = {\n          ...base,\n          ...(source.indexName === undefined ? {} : { indexName: source.indexName }),\n          ...(range === undefined ? {} : { range }),\n        };\n        if (!single && logical.direction !== undefined && request.take !== undefined) {\n          // Any row in the global page is within the first skip + take matches\n          // of its range. Bound each cursor, then paginate the combined rows.\n          return {\n            ...access,\n            kind: \"cursor-scan\",\n            direction: logical.direction,\n            ...(filter === undefined ? {} : { filter }),\n            take: (request.skip ?? 0) + request.take,\n          };\n        }\n        if (single && request.take !== undefined) {\n          shapedByDriver = true;\n          return {\n            ...access,\n            kind: \"cursor-scan\",\n            ...(filter === undefined ? {} : { filter }),\n            ...(logical.direction === undefined ? {} : { direction: logical.direction }),\n            ...(comparator === undefined ? {} : { comparator }),\n            ...pagination,\n          };\n        }\n        // getAll has no descending traversal; a cursor preserves planned order.\n        if (logical.direction === \"prev\")\n          return { ...access, kind: \"cursor-scan\", direction: \"prev\", ...(filter === undefined ? {} : { filter }) };\n        return { ...access, kind: \"get-all\" };\n      });\n      idbPlan = single ? ops[0]! : { meta, kind: \"batch\", storeNames: [catalog.storeName], ops };\n      break;\n    }\n  }\n  return {\n    idbPlan,\n    /** Normalize returned rows and apply filtering and shaping not already handled by the driver. */\n    finish(rows) {\n      // Keep the full-filter safety boundary for every access path. Cursor\n      // paths also filter before pagination, so their returned rows pass twice.\n      // Every row leaves here normalized, so the caller never sees an absent nullable field.\n      let result = rows.map(catalog.absentAsNull);\n      if (filter !== undefined) result = result.filter(filter);\n      if (!shapedByDriver) {\n        if (comparator !== undefined) result.sort(comparator);\n        const skip = request.skip ?? 0;\n        result = result.slice(skip, request.take === undefined ? undefined : skip + request.take);\n      }\n      return result;\n    },\n  };\n}\n\n/** One driver operation and the synchronous reduction of its result to a row count. */\nexport interface LoweredCount {\n  readonly idbPlan: IdbPlanBody;\n  finish(rows: Record<string, unknown>[]): number;\n}\n\n/** One driver operation and the synchronous reduction of its result to a yes or no. */\nexport interface LoweredExists {\n  readonly idbPlan: IdbPlanBody;\n  finish(rows: Record<string, unknown>[]): boolean;\n}\n\n/**\n * Lower a row count. An `exact` plan counts index entries and loads no rows.\n * The planner emits disjoint ranges on a non-multi-entry source, so each row\n * is counted once. Anything else counts the rows that pass the filter.\n * Pagination and `additionalFilter` always take the row path.\n */\nexport function lowerCount(\n  catalog: QueryCatalog,\n  logical: LogicalPlan,\n  meta: PlanMeta,\n  request: RowsRequest,\n  additionalFilter?: IdbRowFilter\n): LoweredCount {\n  const paginated = request.skip !== undefined || request.take !== undefined;\n  if (!logical.exact || paginated || additionalFilter !== undefined) {\n    const lowered = lowerRows(catalog, logical, meta, request, additionalFilter);\n    return { idbPlan: lowered.idbPlan, finish: (rows) => lowered.finish(rows).length };\n  }\n  return {\n    idbPlan: combine(\n      catalog,\n      meta,\n      accessOps(catalog, meta, logical, (target) => ({ ...target, kind: \"count\" }))\n    ),\n    finish: (rows) => rows.reduce((total, row) => total + (row[\"count\"] as number), 0),\n  };\n}\n\n/**\n * Lower an existence check. An `exact` plan reads one primary key per range\n * and loads no rows. Anything else stops each range at its first row that\n * passes the filter.\n */\nexport function lowerExists(\n  catalog: QueryCatalog,\n  logical: LogicalPlan,\n  meta: PlanMeta,\n  request: PlanRequest,\n  additionalFilter?: IdbRowFilter\n): LoweredExists {\n  if (logical.exact && additionalFilter === undefined) {\n    return {\n      idbPlan: combine(\n        catalog,\n        meta,\n        accessOps(catalog, meta, logical, (target) => ({ ...target, kind: \"keys\", take: 1 }))\n      ),\n      finish: (rows) => rows.length > 0,\n    };\n  }\n  const filter = rowFilter(catalog, request, additionalFilter);\n  return {\n    idbPlan: combine(\n      catalog,\n      meta,\n      accessOps(catalog, meta, logical, (target) => ({ ...target, kind: \"cursor-scan\", filter, take: 1 }))\n    ),\n    finish: (rows) => rows.some(filter),\n  };\n}\n\n/** Write inputs. `take` limits matches across all planned ranges. */\nexport interface WriteRequest extends PlanRequest {\n  readonly write: \"put-merged\" | \"delete\";\n  readonly patch?: Record<string, unknown>;\n}\n\n/** A cursor write, or a read that must finish before any keyed writes begin. */\nexport type LoweredWrite =\n  { readonly kind: \"scan\"; readonly idbPlan: IdbPlanBody } | { readonly kind: \"collect\"; readonly rows: LoweredRows };\n\n/**\n * Lower writes through the same access paths as reads. If the patch touches\n * the walked key, collect every range first so moved rows cannot enter a\n * later range or change the cursor's position. Multiple ranges with a limit\n * also collect first, because the limit applies to their combined matches.\n */\nexport function lowerWrite(\n  catalog: QueryCatalog,\n  logical: LogicalPlan,\n  meta: PlanMeta,\n  request: WriteRequest,\n  additionalFilter?: IdbRowFilter\n): LoweredWrite {\n  const { access } = logical;\n  const walkedFields = access.kind === \"ranges\" ? access.source.fields : catalog.primaryKey.fields;\n  const movesKey = request.write === \"put-merged\" && walkedFields.some((field) => field in (request.patch ?? {}));\n  const limitedRanges = access.kind === \"ranges\" && access.ranges.length > 1 && request.take !== undefined;\n  if (movesKey || limitedRanges) {\n    return { kind: \"collect\", rows: lowerRows(catalog, logical, meta, request, additionalFilter) };\n  }\n  const filter = rowFilter(catalog, request, additionalFilter);\n  return {\n    kind: \"scan\",\n    idbPlan: combine(\n      catalog,\n      meta,\n      accessOps(catalog, meta, logical, (target) => ({\n        ...target,\n        kind: \"scan-write\",\n        write: request.write,\n        filter,\n        ...(request.patch === undefined ? {} : { patch: request.patch }),\n        ...(request.take === undefined ? {} : { take: request.take }),\n      }))\n    ),\n  };\n}\n\n/** The store, index, and range assigned to one lowered operation. */\ninterface AccessTarget {\n  readonly meta: PlanMeta;\n  readonly storeName: string;\n  readonly indexName?: string;\n  readonly range?: IdbKeyRangeDescriptor;\n}\n\n/** One operation per planned range, in ascending key order. */\nfunction accessOps(\n  catalog: QueryCatalog,\n  meta: PlanMeta,\n  logical: LogicalPlan,\n  build: (target: AccessTarget) => IdbAtomicPlan\n): IdbAtomicPlan[] {\n  const { access } = logical;\n  const base = { meta, storeName: catalog.storeName };\n  switch (access.kind) {\n    case \"empty\":\n      return [];\n    case \"full\":\n      return [build(base)];\n    case \"ranges\": {\n      const { indexName } = access.source;\n      return access.ranges.map((range) =>\n        build({\n          ...base,\n          ...(indexName === undefined ? {} : { indexName }),\n          ...(range === undefined ? {} : { range }),\n        })\n      );\n    }\n  }\n}\n\nfunction combine(catalog: QueryCatalog, meta: PlanMeta, ops: IdbAtomicPlan[]): IdbPlanBody {\n  return ops.length === 1 ? ops[0]! : { meta, kind: \"batch\", storeNames: [catalog.storeName], ops };\n}\n","/**\n * Multi-store mutation scope for the IDB ORM.\n *\n * `withMutationScope` opens one IDB transaction spanning the named stores,\n * runs the callback with an `IdbTransactionScope` (raw driver-level execute),\n * then commits or rolls back depending on whether the callback throws.\n *\n * Pattern is a direct port of `withMutationScope` from\n * `sql-orm-client/mutation-executor.ts`, adapted for IDB's explicit\n * transaction scope API.\n *\n * @example\n * ```ts\n * await withMutationScope(runtime, [\"users\", \"posts\"], async (scope) => {\n *   const userRow = await scope.execute({ kind: \"put\", storeName: \"users\", ... });\n *   await scope.execute({ kind: \"put\", storeName: \"posts\", ... });\n * });\n * ```\n */\nimport type { IdbQueryExecutor } from \"./executor\";\nimport type { IdbTransactionScope } from \"@prisma-idb/driver-idb/runtime\";\n\n// ── Interface ─────────────────────────────────────────────────────────────────\n\n/**\n * Extends the basic {@link IdbQueryExecutor} with multi-store transaction\n * support. `IdbRuntime` satisfies this interface — `runtime.transaction()`\n * delegates to `driver.transaction()` which opens the IDB transaction.\n */\nexport interface IdbQueryExecutorWithTransaction extends IdbQueryExecutor {\n  /**\n   * Open a multi-store IDB transaction and return a scope object.\n   *\n   * The returned scope's `execute()` runs `IdbAtomicPlan`s directly inside\n   * the transaction — no new transaction is opened per call, and the\n   * middleware chain is bypassed. `commit()` resolves when `tx.oncomplete`\n   * fires; `rollback()` calls `tx.abort()`.\n   */\n  transaction(storeNames: string[], mode?: IDBTransactionMode): Promise<IdbTransactionScope>;\n}\n\n// ── withMutationScope ─────────────────────────────────────────────────────────\n\n/**\n * Run a callback inside a single multi-store IDB readwrite transaction.\n *\n * Opens the transaction, passes the `IdbTransactionScope` to `run`, then:\n * - On success: awaits `scope.commit()` (waits for `tx.oncomplete`).\n * - On error: calls `scope.rollback()` and rethrows.\n *\n * The callback receives the low-level scope, not the ORM accessor.\n * Use this for multi-store atomic writes that span several object stores.\n */\nexport async function withMutationScope<T>(\n  executor: IdbQueryExecutorWithTransaction,\n  storeNames: string[],\n  run: (scope: IdbTransactionScope) => Promise<T>\n): Promise<T> {\n  const tx = await executor.transaction(storeNames, \"readwrite\");\n  try {\n    const result = await run(tx);\n    await tx.commit();\n    return result;\n  } catch (err) {\n    tx.rollback();\n    throw err;\n  }\n}\n","/**\n * IDB relation mutator factory and type guards.\n *\n * Port of `sql-orm-client/relation-mutator.ts` — same pattern, IDB types only.\n * The mutator object is passed to user-supplied relation callbacks so they can\n * express nested writes in a type-safe, intent-revealing way.\n *\n * @example\n * ```ts\n * orm.users.create({\n *   id: \"u1\",\n *   name: \"Alice\",\n *   posts: (rel) => rel.create([{ id: \"p1\", title: \"Hello\" }]),\n * });\n * ```\n */\nimport type {\n  CreateInput,\n  IdbContract,\n  IdbRelationMutation,\n  IdbRelationMutator,\n  RelationMutationConnect,\n  RelationMutationCreate,\n  RelationMutationDisconnect,\n} from \"./types\";\n\n/** Build the relation descriptors consumed by the nested-write executor. */\nexport function createRelationMutator<TContract extends IdbContract, ModelName extends string>(): IdbRelationMutator<\n  TContract,\n  ModelName\n> {\n  return {\n    /** Normalize a single nested record or a list into one create descriptor. */\n    create(\n      data: CreateInput<TContract, ModelName> | readonly CreateInput<TContract, ModelName>[]\n    ): RelationMutationCreate<TContract, ModelName> {\n      const rows = Array.isArray(data) ? [...data] : [data];\n      return { kind: \"create\", data: rows as readonly CreateInput<TContract, ModelName>[] };\n    },\n\n    connect(criteria: Record<string, unknown> | readonly Record<string, unknown>[]): RelationMutationConnect {\n      const values = Array.isArray(criteria) ? [...criteria] : [criteria];\n      return { kind: \"connect\", criteria: values };\n    },\n\n    disconnect(criteria?: readonly Record<string, unknown>[]): RelationMutationDisconnect {\n      if (!criteria) return { kind: \"disconnect\" };\n      return { kind: \"disconnect\", criteria: [...criteria] };\n    },\n  };\n}\n\nexport function isRelationMutationDescriptor(value: unknown): value is IdbRelationMutation<IdbContract, string> {\n  if (!value || typeof value !== \"object\") return false;\n  const candidate = value as { kind?: unknown };\n  return candidate.kind === \"create\" || candidate.kind === \"connect\" || candidate.kind === \"disconnect\";\n}\n\nexport function isRelationMutationCallback(\n  value: unknown\n): value is (mutator: IdbRelationMutator<IdbContract, string>) => IdbRelationMutation<IdbContract, string> {\n  return typeof value === \"function\";\n}\n","/**\n * IDB nested-write executor.\n *\n * IDB adaptation of `sql-orm-client/mutation-executor.ts`. Key differences\n * from the SQL vendor:\n *\n * - No column/field mapping — IDB field names ARE the storage keys.\n * - `applyCreateDefaults`/`applyUpdateDefaults` (`mutation-defaults.ts`) fill\n *   in every generator id `contract.execution.mutations.defaults` declares\n *   (see `IdbMutationDefaultGeneratorId`) — IDB has no server-rendered\n *   defaults, so this always runs client-side, unlike SQL's storage-plane\n *   `ColumnDefault`.\n * - `insertSingleRow` → `scope.execute({ kind: \"add\", ... })`.\n * - Mutation lookups use the query planner and reapply the full filter.\n *   IDB allows reads inside a readwrite transaction; the transaction scope accepts\n *   all `IdbAtomicPlan` types including `cursor-scan`.\n * - Child-owned `connect` → `scope.execute({ kind: \"scan-write\", write: \"put-merged\", ... })`.\n *   IDB has no UPDATE SET WHERE, so we use the scan-write plan with a filter closure.\n * - `connect()` for parent-owned (N:1) relations throws if the referenced row is not\n *   found — this checks that the connected parent exists.\n * - Recursive nesting (nested writes inside nested writes) is not supported and throws.\n *\n * All multi-store writes are wrapped in a single `withMutationScope` call that opens\n * one IDB transaction spanning all required stores, per ADR 007.\n */\n\nimport type { PlanMeta } from \"@prisma/orm-framework/contract/types\";\nimport type { ContractReferenceRelation } from \"@prisma/orm-framework/contract/types\";\nimport { domainModelsAtDefaultNamespace } from \"@prisma/orm-framework/contract/types\";\nimport type { IdbAtomicPlan, IdbPlanBody, IdbRowFilter } from \"@prisma-idb/driver-idb/runtime\";\nimport { andExpr, fieldFilter, shorthandToFilterExpr } from \"@prisma-idb/adapter-idb/runtime\";\nimport type { IdbFilterExpr } from \"@prisma-idb/adapter-idb/runtime\";\nimport type { IdbReferentialAction } from \"@prisma-idb/target-idb/pack\";\nimport type { IdbQueryExecutor } from \"./executor\";\nimport { assertEnumValues } from \"./enum-validation\";\nimport { assertValidRecord } from \"./record-validation\";\nimport {\n  applyUpdateDefaults,\n  completeCreateRecord,\n  createMutationDefaultsCache,\n  type MutationDefaultsCache,\n} from \"./mutation-defaults\";\nimport { absentAsNull } from \"@prisma-idb/target-idb/runtime\";\nimport { buildCatalog } from \"./planner/catalog\";\nimport { preserveDecimalKeySpelling } from \"./decimal-identity\";\nimport { lowerExists, lowerRows, lowerWrite, type WriteRequest } from \"./planner/lower\";\nimport { planQuery } from \"./planner/plan\";\nimport { withMutationScope, type IdbQueryExecutorWithTransaction } from \"./mutation-scope\";\nimport { createRelationMutator, isRelationMutationCallback, isRelationMutationDescriptor } from \"./relation-mutator\";\nimport {\n  type IdbContract,\n  type IdbRelationMutation,\n  type IdbRelationMutator,\n  type MutationCreateInput,\n  type MutationUpdateInput,\n  extractKeyFromRow,\n  fieldValuesEqual,\n  getKeyPath,\n  getStoreName,\n  keyEquals,\n  keyToken,\n} from \"./types\";\nimport { keyPathFields } from \"@prisma-idb/target-idb/pack\";\nimport type { IdbTransactionScope } from \"@prisma-idb/driver-idb/runtime\";\n\n// ── Internal types ─────────────────────────────────────────────────────────────\n\n/** The store and join fields needed to execute a reference relation. */\ninterface RelationDefinition {\n  readonly relationName: string;\n  readonly relatedModelName: string;\n  readonly relatedStoreName: string;\n  readonly cardinality: string | undefined;\n  readonly localFields: readonly string[];\n  readonly targetFields: readonly string[];\n}\n\n/** A relation paired with the descriptor returned by its mutation callback. */\ninterface ParsedRelationMutation {\n  readonly relation: RelationDefinition;\n  readonly mutation: IdbRelationMutation<IdbContract, string>;\n}\n\n/** Scalar write data separated from relation mutation descriptors. */\ninterface ParsedMutationInput {\n  readonly scalarData: Record<string, unknown>;\n  readonly relationMutations: readonly ParsedRelationMutation[];\n}\n\n// ── Plan meta helpers ─────────────────────────────────────────────────────────\n\n/** Plan metadata for the raw plans the mutation executor issues itself, outside any accessor's grouping key. */\nexport function makePlanMeta(contract: IdbContract): PlanMeta {\n  return {\n    target: \"idb\",\n    storageHash: contract.storage.storageHash,\n    lane: \"idb-mutation-executor\",\n    annotations: { groupingKey: \"nested\" },\n  };\n}\n\n// ── Relation definition resolution (cached) ──────────────────────────────────\n\nconst relationDefsCache = new WeakMap<object, Map<string, RelationDefinition[]>>();\n\n/** Cache reference-relation metadata by contract identity and model. */\nfunction getRelationDefinitions(contract: IdbContract, modelName: string): RelationDefinition[] {\n  let perContract = relationDefsCache.get(contract);\n  if (!perContract) {\n    perContract = new Map();\n    relationDefsCache.set(contract, perContract);\n  }\n\n  const cached = perContract.get(modelName);\n  if (cached) return cached;\n\n  const model = domainModelsAtDefaultNamespace(contract.domain)[modelName];\n  if (!model) {\n    perContract.set(modelName, []);\n    return [];\n  }\n\n  const defs: RelationDefinition[] = [];\n  for (const [relationName, rawRelation] of Object.entries(model.relations)) {\n    if (!rawRelation || typeof rawRelation !== \"object\" || !(\"on\" in rawRelation)) continue;\n\n    const relation = rawRelation as ContractReferenceRelation;\n    // `relation.to` is a CrossReference `{ namespace, model }`.\n    const relatedModelName = relation.to.model;\n    const relatedStoreName = getStoreName(contract, relatedModelName);\n    defs.push({\n      relationName,\n      relatedModelName,\n      relatedStoreName,\n      cardinality: relation.cardinality,\n      localFields: relation.on.localFields,\n      targetFields: relation.on.targetFields,\n    });\n  }\n\n  perContract.set(modelName, defs);\n  return defs;\n}\n\n// ── Public helpers ────────────────────────────────────────────────────────────\n\n/**\n * Returns true if `data` contains at least one field that is both a known\n * relation name for `modelName` and a function (a mutation callback).\n */\nexport function hasNestedMutationCallbacks(\n  contract: IdbContract,\n  modelName: string,\n  data: Record<string, unknown>\n): boolean {\n  const relationNames = new Set(getRelationDefinitions(contract, modelName).map((r) => r.relationName));\n  for (const [fieldName, value] of Object.entries(data)) {\n    if (relationNames.has(fieldName) && isRelationMutationCallback(value)) return true;\n  }\n  return false;\n}\n\n/**\n * Guards that the executor supports multi-store transactions.\n * Throws a clear error if `transaction()` is not available — the user must\n * use IdbRuntime (createIdbRuntime / createAutoMigratingIdbClient) rather than\n * a plain IdbQueryExecutor stub.\n */\nexport function requireTransactionExecutor(executor: IdbQueryExecutor): IdbQueryExecutorWithTransaction {\n  if (typeof (executor as IdbQueryExecutorWithTransaction).transaction !== \"function\") {\n    throw new Error(\n      \"This operation requires an executor with transaction support (nested relation writes, \" +\n        \"FK-validated create/update, and referential-action delete all need it). \" +\n        \"Use IdbRuntime (createIdbRuntime or createAutoMigratingIdbClient) instead of a plain IdbQueryExecutor.\"\n    );\n  }\n  return executor as IdbQueryExecutorWithTransaction;\n}\n\n// ── Entry points ──────────────────────────────────────────────────────────────\n\n/** Create a parent and its nested related rows in one transaction. */\nexport async function executeNestedCreateMutation(options: {\n  executor: IdbQueryExecutorWithTransaction;\n  contract: IdbContract;\n  modelName: string;\n  data: MutationCreateInput<IdbContract, string>;\n}): Promise<Record<string, unknown>> {\n  const { executor, contract, modelName, data } = options;\n  const record = data as Record<string, unknown>;\n  const storeNames = collectStoreNames(contract, modelName, record, \"create\");\n  const defaultsCache = createMutationDefaultsCache();\n  return withMutationScope(executor, storeNames, (scope) =>\n    createGraph(scope, contract, modelName, record, defaultsCache)\n  );\n}\n\n/** Update the first filtered parent and its nested relations in one transaction. */\nexport async function executeNestedUpdateMutation(options: {\n  executor: IdbQueryExecutorWithTransaction;\n  contract: IdbContract;\n  modelName: string;\n  filters: readonly IdbFilterExpr[];\n  data: MutationUpdateInput<IdbContract, string>;\n}): Promise<Record<string, unknown> | null> {\n  const { executor, contract, modelName, filters, data } = options;\n  const record = data as Record<string, unknown>;\n  const storeNames = collectStoreNames(contract, modelName, record, \"update\");\n  const defaultsCache = createMutationDefaultsCache();\n  return withMutationScope(executor, storeNames, (scope) =>\n    updateFirstGraph(scope, contract, modelName, filters, record, defaultsCache)\n  );\n}\n\n// ── Store name collection ─────────────────────────────────────────────────────\n\n/**\n * Every store a nested write may touch: the model's own store, each related\n * store a relation callback writes to, and the parent stores that foreign-key\n * checks read, for the model and for each related model. An update also\n * declares the stores its `onUpdate` referential actions may touch.\n *\n * Parent stores are declared for every foreign key, not only the ones `data`\n * sets, because a nested write can set foreign keys through `connect()` or\n * through a default.\n */\nfunction collectStoreNames(\n  contract: IdbContract,\n  modelName: string,\n  data: Record<string, unknown>,\n  kind: \"create\" | \"update\"\n): string[] {\n  const stores = new Set([getStoreName(contract, modelName), ...fkParentStoreNames(contract, modelName)]);\n  const scalarData: Record<string, unknown> = {};\n  const relationNames = new Set<string>();\n  for (const def of getRelationDefinitions(contract, modelName)) {\n    relationNames.add(def.relationName);\n    if (def.relationName in data && isRelationMutationCallback(data[def.relationName])) {\n      stores.add(def.relatedStoreName);\n      for (const store of fkParentStoreNames(contract, def.relatedModelName)) stores.add(store);\n    }\n  }\n  if (kind === \"update\") {\n    for (const [field, value] of Object.entries(data)) {\n      if (!relationNames.has(field)) scalarData[field] = value;\n    }\n    const patch = applyUpdateDefaults(\n      contract.execution?.mutations.defaults,\n      getStoreName(contract, modelName),\n      scalarData,\n      createMutationDefaultsCache()\n    );\n    for (const store of collectOnUpdateEnforcementStoreNames(contract, modelName, patch).storeNames) stores.add(store);\n  }\n  return [...stores];\n}\n\n/** The stores of every parent `modelName` has a foreign key to. */\nfunction fkParentStoreNames(contract: IdbContract, modelName: string): string[] {\n  return getRelationDefinitions(contract, modelName)\n    .filter((def) => def.cardinality === \"N:1\")\n    .map((def) => def.relatedStoreName);\n}\n\n// ── Graph operations ──────────────────────────────────────────────────────────\n\n/** Resolve parent-owned references before inserting the parent, then write its children. */\nasync function createGraph(\n  scope: IdbTransactionScope,\n  contract: IdbContract,\n  modelName: string,\n  input: Record<string, unknown>,\n  defaultsCache: MutationDefaultsCache\n): Promise<Record<string, unknown>> {\n  const parsed = parseMutationInput(contract, modelName, input);\n  const { parentOwned, childOwned } = partitionByOwnership(parsed.relationMutations);\n\n  const scalarData = { ...parsed.scalarData };\n\n  for (const item of parentOwned) {\n    if (item.mutation.kind === \"disconnect\") {\n      throw new Error(\"disconnect() is only supported in update() nested mutations\");\n    }\n    await applyParentOwnedMutation(scope, contract, scalarData, item.relation, item.mutation, defaultsCache);\n  }\n\n  const parentRow = await insertSingleRow(scope, contract, modelName, scalarData, defaultsCache);\n\n  for (const item of childOwned) {\n    if (item.mutation.kind === \"disconnect\") {\n      throw new Error(\"disconnect() is only supported in update() nested mutations\");\n    }\n    await applyChildOwnedMutation(scope, contract, modelName, parentRow, item.relation, item.mutation, defaultsCache);\n  }\n\n  return parentRow;\n}\n\n/** Read the parent before resolving relation mutations and validating its scalar patch. */\nasync function updateFirstGraph(\n  scope: IdbTransactionScope,\n  contract: IdbContract,\n  modelName: string,\n  filters: readonly IdbFilterExpr[],\n  input: Record<string, unknown>,\n  defaultsCache: MutationDefaultsCache\n): Promise<Record<string, unknown> | null> {\n  const existingRow = await findFirstByFilters(scope, contract, modelName, filters);\n  if (!existingRow) return null;\n\n  const parsed = parseMutationInput(contract, modelName, input);\n  const { parentOwned, childOwned } = partitionByOwnership(parsed.relationMutations);\n\n  const scalarData = { ...parsed.scalarData };\n\n  for (const item of parentOwned) {\n    await applyParentOwnedMutation(scope, contract, scalarData, item.relation, item.mutation, defaultsCache);\n  }\n\n  let parentRow = existingRow;\n\n  if (Object.keys(scalarData).length > 0) {\n    const storeName = getStoreName(contract, modelName);\n    const keyPath = getKeyPath(contract, modelName);\n    const key = extractKeyFromRow(existingRow, keyPath);\n    const meta = makePlanMeta(contract);\n    const patch = applyUpdateDefaults(contract.execution?.mutations.defaults, storeName, scalarData, defaultsCache);\n    assertEnumValues(contract, modelName, patch);\n    assertValidRecord(contract, modelName, \"update\", patch);\n    await validateScalarFks(scope, contract, modelName, patch, existingRow);\n    await applyReferentialActionsForRowOnUpdate(scope, contract, modelName, existingRow, patch);\n    const rows = await scope.execute({ meta, kind: \"update\", storeName, key, patch });\n    const updated = rows[0];\n    if (updated) parentRow = absentAsNull(contract, modelName)(updated);\n  }\n\n  for (const item of childOwned) {\n    await applyChildOwnedMutation(scope, contract, modelName, parentRow, item.relation, item.mutation, defaultsCache);\n  }\n\n  return parentRow;\n}\n\n// ── Input parsing ─────────────────────────────────────────────────────────────\n\n/** Separate scalar values from validated relation callback results. */\nfunction parseMutationInput(\n  contract: IdbContract,\n  modelName: string,\n  input: Record<string, unknown>\n): ParsedMutationInput {\n  const scalarData: Record<string, unknown> = {};\n  const relationDefs = new Map(getRelationDefinitions(contract, modelName).map((r) => [r.relationName, r]));\n  const relationMutations: ParsedRelationMutation[] = [];\n\n  for (const [fieldName, value] of Object.entries(input)) {\n    const relation = relationDefs.get(fieldName);\n    if (!relation) {\n      scalarData[fieldName] = value;\n      continue;\n    }\n\n    if (!isRelationMutationCallback(value)) {\n      throw new Error(`Relation field \"${fieldName}\" on model \"${modelName}\" expects a mutator callback`);\n    }\n\n    const mutator = createRelationMutator<IdbContract, string>();\n    const mutation = value(mutator as IdbRelationMutator<IdbContract, string>);\n    if (!isRelationMutationDescriptor(mutation)) {\n      throw new Error(`Relation field \"${fieldName}\" on model \"${modelName}\" returned an invalid mutation descriptor`);\n    }\n\n    relationMutations.push({ relation, mutation });\n  }\n\n  return { scalarData, relationMutations };\n}\n\n// ── Ownership partitioning ────────────────────────────────────────────────────\n\n/** Separate relations whose foreign keys belong to the parent from those owned by children. */\nfunction partitionByOwnership(mutations: readonly ParsedRelationMutation[]): {\n  parentOwned: ParsedRelationMutation[];\n  childOwned: ParsedRelationMutation[];\n} {\n  const parentOwned: ParsedRelationMutation[] = [];\n  const childOwned: ParsedRelationMutation[] = [];\n\n  for (const item of mutations) {\n    if (item.relation.cardinality === \"N:1\") {\n      parentOwned.push(item);\n      continue;\n    }\n    if (item.relation.cardinality === \"M:N\") {\n      throw new Error(\"M:N nested mutations are not supported\");\n    }\n    childOwned.push(item);\n  }\n\n  return { parentOwned, childOwned };\n}\n\n// ── Parent-owned (N:1) mutations ──────────────────────────────────────────────\n\n/** Resolve a to-one mutation into scalar foreign-key values on the parent. */\nasync function applyParentOwnedMutation(\n  scope: IdbTransactionScope,\n  contract: IdbContract,\n  scalarData: Record<string, unknown>,\n  relation: RelationDefinition,\n  mutation: IdbRelationMutation<IdbContract, string>,\n  defaultsCache: MutationDefaultsCache\n): Promise<void> {\n  if (mutation.kind === \"disconnect\") {\n    for (const localField of relation.localFields) {\n      scalarData[localField] = null;\n    }\n    return;\n  }\n\n  if (mutation.kind === \"create\") {\n    const row = mutation.data[0] as Record<string, unknown> | undefined;\n    if (!row) {\n      throw new Error(`create() nested mutation for relation \"${relation.relationName}\" requires data`);\n    }\n    // Recursive nesting is not supported — the nested record must\n    // be a plain scalar create, not itself a nested mutation.\n    const relatedRow = await insertSingleRow(scope, contract, relation.relatedModelName, row, defaultsCache);\n    copyRelatedValuesToParent(relation, scalarData, relatedRow);\n    return;\n  }\n\n  // connect()\n  const criterion = mutation.criteria[0] as Record<string, unknown> | undefined;\n  if (!criterion) {\n    throw new Error(`connect() nested mutation for relation \"${relation.relationName}\" requires a criterion`);\n  }\n  const relatedRow = await findRowByCriterion(scope, contract, relation.relatedModelName, criterion);\n  if (!relatedRow) {\n    throw new Error(`connect() nested mutation for relation \"${relation.relationName}\" did not find a matching row`);\n  }\n  copyRelatedValuesToParent(relation, scalarData, relatedRow);\n}\n\n/** Copy each referenced value into the matching local foreign-key field. */\nfunction copyRelatedValuesToParent(\n  relation: RelationDefinition,\n  scalarData: Record<string, unknown>,\n  relatedRow: Record<string, unknown>\n): void {\n  // localFields = parent's FK fields; targetFields = related model's PK/unique fields\n  for (let i = 0; i < relation.localFields.length; i++) {\n    const localField = relation.localFields[i];\n    const targetField = relation.targetFields[i];\n    if (!localField || !targetField) continue;\n    scalarData[localField] = relatedRow[targetField];\n  }\n}\n\n// ── Child-owned (1:N / 1:1) mutations ────────────────────────────────────────\n\n/** Create, connect, or disconnect children using the persisted parent join values. */\nasync function applyChildOwnedMutation(\n  scope: IdbTransactionScope,\n  contract: IdbContract,\n  parentModelName: string,\n  parentRow: Record<string, unknown>,\n  relation: RelationDefinition,\n  mutation: IdbRelationMutation<IdbContract, string>,\n  defaultsCache: MutationDefaultsCache\n): Promise<void> {\n  // parentValues: childFkField → parentPkValue (e.g. \"authorId\" → \"u1\")\n  const parentValues = readParentColumnValues(parentModelName, relation, parentRow);\n\n  if (mutation.kind === \"create\") {\n    for (const childInput of mutation.data) {\n      const payload: Record<string, unknown> = { ...(childInput as Record<string, unknown>) };\n      for (const [childField, parentValue] of parentValues.entries()) {\n        payload[childField] = parentValue;\n      }\n      await insertSingleRow(scope, contract, relation.relatedModelName, payload, defaultsCache);\n    }\n    return;\n  }\n\n  if (mutation.kind === \"connect\") {\n    for (const criterion of mutation.criteria) {\n      const setValues: Record<string, unknown> = {};\n      for (const [childField, parentValue] of parentValues.entries()) {\n        setValues[childField] = parentValue;\n      }\n      const patch = applyUpdateDefaults(\n        contract.execution?.mutations.defaults,\n        relation.relatedStoreName,\n        setValues,\n        defaultsCache\n      );\n      const where = shorthandToFilterExpr(criterion as Record<string, unknown>);\n      // scan-write + put-merged: set the FK fields on every child row matching\n      // the criterion. No `take` cap — the vendor's relational connect\n      // (`executeUpdateCount`) connects all matching rows; for the normal\n      // unique-key criterion that is exactly one row anyway.\n      await writeMutationRows(scope, contract, relation.relatedModelName, {\n        write: \"put-merged\",\n        patch,\n        ...(where === undefined ? {} : { where }),\n      });\n    }\n    return;\n  }\n\n  // disconnect()\n  const setValues: Record<string, unknown> = {};\n  for (const childField of parentValues.keys()) {\n    setValues[childField] = null;\n  }\n\n  if (!mutation.criteria || mutation.criteria.length === 0) {\n    // Disconnect all children of this parent.\n    const patch = applyUpdateDefaults(\n      contract.execution?.mutations.defaults,\n      relation.relatedStoreName,\n      setValues,\n      defaultsCache\n    );\n    const parentJoinWhere = buildParentJoinWhere(parentValues);\n    await writeMutationRows(scope, contract, relation.relatedModelName, {\n      write: \"put-merged\",\n      patch,\n      where: parentJoinWhere,\n    });\n    return;\n  }\n\n  // Disconnect specific children matching each criterion AND the parent join.\n  for (const criterion of mutation.criteria) {\n    const patch = applyUpdateDefaults(\n      contract.execution?.mutations.defaults,\n      relation.relatedStoreName,\n      setValues,\n      defaultsCache\n    );\n    const criterionWhere = shorthandToFilterExpr(criterion as Record<string, unknown>);\n    const parentJoinWhere = buildParentJoinWhere(parentValues);\n    const where = criterionWhere === undefined ? parentJoinWhere : andExpr([parentJoinWhere, criterionWhere]);\n    await writeMutationRows(scope, contract, relation.relatedModelName, {\n      write: \"put-merged\",\n      patch,\n      where,\n    });\n  }\n}\n\n/** Resolve parent join values before writing children; missing values cannot form a relation. */\nfunction readParentColumnValues(\n  parentModelName: string,\n  relation: RelationDefinition,\n  parentRow: Record<string, unknown>\n): Map<string, unknown> {\n  const values = new Map<string, unknown>();\n  // For 1:N: localFields = parent PK fields; targetFields = child FK fields\n  for (let i = 0; i < relation.localFields.length; i++) {\n    const localField = relation.localFields[i];\n    const targetField = relation.targetFields[i];\n    if (!localField || !targetField) continue;\n    const parentValue = parentRow[localField];\n    if (parentValue === undefined) {\n      throw new Error(\n        `Nested mutation requires parent field \"${localField}\" to be present in \"${parentModelName}\" row`\n      );\n    }\n    // targetField is the child's FK column name; map it to the parent's value.\n    values.set(targetField, parentValue);\n  }\n  return values;\n}\n\n// ── Row operations ────────────────────────────────────────────────────────────\n\n/** Complete and validate a nested record, then insert it with foreign-key checks. */\nasync function insertSingleRow(\n  scope: IdbTransactionScope,\n  contract: IdbContract,\n  modelName: string,\n  data: Record<string, unknown>,\n  defaultsCache: MutationDefaultsCache\n): Promise<Record<string, unknown>> {\n  assertNoNestedCallbacks(modelName, data);\n  const storeName = getStoreName(contract, modelName);\n  const meta = makePlanMeta(contract);\n  const record = completeCreateRecord(contract, modelName, data, defaultsCache);\n  assertEnumValues(contract, modelName, record);\n  assertValidRecord(contract, modelName, \"create\", record);\n  await validateScalarFks(scope, contract, modelName, record);\n  const rows = await scope.execute({ meta, kind: \"add\", storeName, record });\n  return rows[0] ?? record;\n}\n\n/**\n * Recursive nesting (a relation callback inside an already-nested create) is\n * not supported. Without this guard the callback function would be\n * handed to `store.put(...)`, where IDB's structured-clone throws an opaque\n * `DataCloneError` (\"could not be cloned\") that gives the developer no hint\n * about the real cause. Surface a precise error instead.\n */\nfunction assertNoNestedCallbacks(modelName: string, data: Record<string, unknown>): void {\n  for (const [field, value] of Object.entries(data)) {\n    if (typeof value === \"function\") {\n      throw new Error(\n        `Recursive nested writes are not supported: field \"${field}\" on a nested \"${modelName}\" ` +\n          \"record is a relation callback. Only one level of relation nesting is supported — \" +\n          \"flatten the inner relation into a separate create/connect call.\"\n      );\n    }\n  }\n}\n\n/** Require a non-empty connect criterion and return its first matching row. */\nasync function findRowByCriterion(\n  scope: IdbTransactionScope,\n  contract: IdbContract,\n  modelName: string,\n  criterion: Record<string, unknown>\n): Promise<Record<string, unknown> | null> {\n  const expr = shorthandToFilterExpr(criterion);\n  if (!expr) {\n    throw new Error(`Nested connect for model \"${modelName}\" requires a non-empty criterion`);\n  }\n  return (await readMutationRows(scope, contract, modelName, expr, 1))[0] ?? null;\n}\n\n/** Find the first parent selected by the nested-update filters. */\nasync function findFirstByFilters(\n  scope: IdbTransactionScope,\n  contract: IdbContract,\n  modelName: string,\n  filters: readonly IdbFilterExpr[]\n): Promise<Record<string, unknown> | null> {\n  if (filters.length === 0) return null;\n  return (await readMutationRows(scope, contract, modelName, andExpr(filters), 1))[0] ?? null;\n}\n\n/** Execute lowered atomic operations without leaving the transaction's microtask chain. */\nexport async function executeMutationPlan(\n  scope: IdbTransactionScope,\n  plan: IdbPlanBody\n): Promise<Record<string, unknown>[]> {\n  const plans = plan.kind === \"batch\" ? plan.ops : [plan];\n  const rows: Record<string, unknown>[] = [];\n  for (const op of plans) rows.push(...(await scope.execute(op)));\n  return rows;\n}\n\n/** Read mutation preimages through the planner, then reapply the original filter. */\nexport async function readMutationRows(\n  scope: IdbTransactionScope,\n  contract: IdbContract,\n  modelName: string,\n  where: IdbFilterExpr | undefined,\n  take?: number\n): Promise<Record<string, unknown>[]> {\n  const catalog = buildCatalog(contract, getStoreName(contract, modelName), modelName);\n  const request = { ...(where === undefined ? {} : { where }), ...(take === undefined ? {} : { take }) };\n  const lowered = lowerRows(catalog, planQuery(catalog, request), makePlanMeta(contract), request);\n  return lowered.finish(await executeMutationPlan(scope, lowered.idbPlan));\n}\n\n/** Write planned matches, collecting preimages first when changing the walked index key. */\nasync function writeMutationRows(\n  scope: IdbTransactionScope,\n  contract: IdbContract,\n  modelName: string,\n  request: WriteRequest\n): Promise<Record<string, unknown>[]> {\n  if (request.write !== \"delete\") assertValidRecord(contract, modelName, \"update\", request.patch ?? {});\n  const catalog = buildCatalog(contract, getStoreName(contract, modelName), modelName);\n  const meta = makePlanMeta(contract);\n  const lowered = lowerWrite(catalog, planQuery(catalog, request), meta, request);\n  if (lowered.kind === \"scan\") return executeMutationPlan(scope, lowered.idbPlan);\n\n  // Materialize all ranges before writing: moving a key could otherwise make\n  // an already-written row enter a range we have not visited yet.\n  const oldRows = lowered.rows.finish(await executeMutationPlan(scope, lowered.rows.idbPlan));\n  const results: Record<string, unknown>[] = [];\n  for (const row of oldRows) {\n    const key = extractKeyFromRow(row, catalog.primaryKey.keyPath);\n    const rows = await scope.execute({\n      meta,\n      storeName: catalog.storeName,\n      ...(request.write === \"delete\" ? { kind: \"delete\", key } : { kind: \"update\", key, patch: request.patch ?? {} }),\n    });\n    results.push(...rows);\n  }\n  return results;\n}\n\nfunction buildParentJoinWhere(parentValues: Map<string, unknown>): IdbFilterExpr {\n  return andExpr([...parentValues].map(([field, value]) => fieldFilter(field, \"eq\", value)));\n}\n\n// ── Referential action helpers ────────────────────────────────────────────────\n\n/**\n * Which referential-action slot to read from `IdbRelationStorage`. Shared by\n * `onDelete` enforcement (delete/deleteAll/deleteCount) and `onUpdate`\n * enforcement (update/updateAll/updateCount/upsert) — both actions are\n * declared and resolved identically, just stored under a different key.\n */\ntype ReferentialActionKind = \"onDelete\" | \"onUpdate\";\n\n/** Read an explicitly declared referential action from model storage metadata. */\nfunction getStoredAction(\n  contract: IdbContract,\n  modelName: string,\n  relationName: string,\n  kind: ReferentialActionKind\n): IdbReferentialAction | undefined {\n  const model = domainModelsAtDefaultNamespace(contract.domain)[modelName];\n  const storage = model?.storage as\n    { relations?: Record<string, { onDelete?: string; onUpdate?: string }> } | undefined;\n  return storage?.relations?.[relationName]?.[kind] as IdbReferentialAction | undefined;\n}\n\nfunction sameFields(a: readonly string[], b: readonly string[]): boolean {\n  return a.length === b.length && a.every((field, index) => field === b[index]);\n}\n\n/**\n * Resolves the referential action for a child-enforcement relation: prefers\n * the action stored directly on this side, falls back to the same action\n * stored on the inverse (FK-owning) side of the relation, and finally to\n * `defaultAction` when neither side declares one.\n *\n * Both branches are live, for different authoring paths. PSL only ever\n * stores the action on the `N:1` (FK-owning) side — enforcement always walks\n * from the parent (`1:N`/non-owning-`1:1`) side, which PSL leaves bare, so\n * the fallback is what actually finds it. TS-DSL relation entries are\n * self-contained (no PSL-style pairing requirement) and typically declare\n * the action directly on the side this function is called for, so the direct\n * check is what fires there — see `contract-builder.ts`'s\n * `validateNoConflictingRelationActions`, which rejects declaring the same\n * action kind on both sides so this fallback never has to arbitrate a real\n * conflict.\n */\nfunction getReferentialActionForRelation(\n  contract: IdbContract,\n  modelName: string,\n  def: RelationDefinition,\n  kind: ReferentialActionKind\n): EnforcedReferentialAction {\n  return enforcedAction(findDeclaredAction(contract, modelName, def, kind));\n}\n\n/** Find an action on the enforcement side or on its matching inverse relation. */\nfunction findDeclaredAction(\n  contract: IdbContract,\n  modelName: string,\n  def: RelationDefinition,\n  kind: ReferentialActionKind\n): IdbReferentialAction | undefined {\n  const direct = getStoredAction(contract, modelName, def.relationName, kind);\n  if (direct !== undefined) return direct;\n\n  for (const inverse of getRelationDefinitions(contract, def.relatedModelName)) {\n    if (inverse.relatedModelName !== modelName) continue;\n    if (!sameFields(inverse.localFields, def.targetFields)) continue;\n    if (!sameFields(inverse.targetFields, def.localFields)) continue;\n\n    const inverseAction = getStoredAction(contract, def.relatedModelName, inverse.relationName, kind);\n    if (inverseAction !== undefined) return inverseAction;\n  }\n\n  return undefined;\n}\n\n/** A referential action after defaults are applied and `noAction` is resolved. */\ntype EnforcedReferentialAction = Exclude<IdbReferentialAction, \"noAction\">;\n\n/**\n * Applies the default and resolves `noAction`, matching what Postgres does\n * with the same schema, so a synced app behaves the same on both sides:\n *\n * - An undeclared action defaults to `restrict`, for `onDelete` and\n *   `onUpdate` alike. Prisma 8 emits no `ON DELETE`/`ON UPDATE` clause for an\n *   undeclared action, and the database default is `NO ACTION`.\n * - `noAction` behaves like `restrict`. In SQL, `NO ACTION` also rejects the\n *   change; it only defers the check to the end of the statement, which makes\n *   no difference here.\n */\nfunction enforcedAction(declared: IdbReferentialAction | undefined): EnforcedReferentialAction {\n  return declared === undefined || declared === \"noAction\" ? \"restrict\" : declared;\n}\n\n/** Identify relations that need child checks when this model changes. */\nfunction isChildEnforcementRelation(contract: IdbContract, modelName: string, def: RelationDefinition): boolean {\n  if (def.cardinality === \"1:N\") return true;\n  if (def.cardinality === \"1:1\") {\n    // Shared-PK 1:1: the non-owning side is the one whose *own* primary key\n    // IS the FK (localFields === the model's own keyPath, field-for-field,\n    // in order — a compound key must match the whole ordered field list, not\n    // just its first member).\n    const keyPath = getKeyPath(contract, modelName);\n    return sameFields(def.localFields, keyPathFields(keyPath));\n  }\n  return false;\n}\n\n// ── Existence lookups ─────────────────────────────────────────────────────────\n\n/**\n * `true` if any child row matches the relation against `parentRow`'s values —\n * the existence check behind `restrict`. A null value references no child.\n */\nasync function childExists(\n  scope: IdbTransactionScope,\n  contract: IdbContract,\n  meta: PlanMeta,\n  def: RelationDefinition,\n  parentRow: Record<string, unknown>\n): Promise<boolean> {\n  const values = def.localFields.map((field) => parentRow[field]);\n  if (values.some((value) => value === null || value === undefined)) return false;\n  return rowExists(scope, contract, meta, def.relatedModelName, def.targetFields, values);\n}\n\n/**\n * Does `modelName` have a row whose `fields` equal `values`, pairwise?\n * Compares values the way IndexedDB compares keys. `additionalFilter` narrows\n * the match in memory; it makes the check read rows instead of keys.\n */\nasync function rowExists(\n  scope: IdbTransactionScope,\n  contract: IdbContract,\n  meta: PlanMeta,\n  modelName: string,\n  fields: readonly string[],\n  values: readonly unknown[],\n  additionalFilter?: IdbRowFilter\n): Promise<boolean> {\n  const where = andExpr(fields.map((field, i) => fieldFilter(field, \"eq\", values[i])));\n  const catalog = buildCatalog(contract, getStoreName(contract, modelName), modelName);\n  const lowered = lowerExists(catalog, planQuery(catalog, { where }), meta, { where }, additionalFilter);\n  // The scope runs atomic plans only. Each `await` here resolves in a\n  // microtask, so the transaction stays open between the requests.\n  return lowered.finish(await executeMutationPlan(scope, lowered.idbPlan));\n}\n\n/**\n * Builds a filter matching a relation's children against one specific parent\n * row's values. Shared by `onDelete` cascade (`applyReferentialActionsForRow`)\n * and `onUpdate` cascade (`applyReferentialActionsForRowOnUpdate`).\n */\nfunction buildChildWhereFromRow(def: RelationDefinition, row: Record<string, unknown>): IdbFilterExpr {\n  return andExpr(def.targetFields.map((field, i) => fieldFilter(field, \"eq\", row[def.localFields[i]!])));\n}\n\n/** Reads a field's literal `@default(...)` value from `IdbModelStorage.fieldDefaults`, if declared. */\nfunction getFieldDefault(contract: IdbContract, modelName: string, fieldName: string): unknown {\n  const model = domainModelsAtDefaultNamespace(contract.domain)[modelName];\n  const storage = model?.storage as { fieldDefaults?: Record<string, unknown> } | undefined;\n  return storage?.fieldDefaults?.[fieldName];\n}\n\n/**\n * Builds the patch for a `setDefault` referential action: each of the\n * relation's `targetFields` (the child's FK fields) reset to its own\n * declared literal default — not the parent's. Throws when any target field\n * has no declared default; `setDefault` is only meaningful when every FK\n * field it resets has somewhere to reset to.\n */\nfunction buildSetDefaultPatch(contract: IdbContract, def: RelationDefinition): Record<string, unknown> {\n  const patch: Record<string, unknown> = {};\n  for (const targetField of def.targetFields) {\n    const value = getFieldDefault(contract, def.relatedModelName, targetField);\n    if (value === undefined) {\n      throw new Error(\n        `setDefault referential action on relation '${def.relationName}' requires field ` +\n          `'${def.relatedModelName}.${targetField}' to declare a literal @default(...) value — ` +\n          \"no default is registered for that field.\"\n      );\n    }\n    patch[targetField] = value;\n  }\n  return patch;\n}\n\n/**\n * Validates that a `setDefault` patch actually references a real row before\n * it's written — without this, `setDefault` would silently reintroduce the\n * exact dangling-FK problem the rest of this file exists to prevent. A real\n * SQL database only makes `SET DEFAULT` safe because its FK constraint\n * re-checks the new value transactionally at write time; IDB has no such\n * engine to delegate to, so this check is IDB's equivalent.\n *\n * Checks against `modelName`'s own store (the parent being deleted/updated)\n * using `def.localFields` — the relation's own semantics (\"child.targetField\n * references parent.localField\") mean that's exactly what a default value\n * written to the child's FK field must match. That store is always already\n * part of the transaction (it's the model literally being written), so no\n * store-list changes are needed to call this.\n *\n * A compound relation is checked as one tuple: a single parent row must\n * match every field's default.\n *\n * `excludeKey`, when given, excludes the parent row currently being\n * deleted/updated from the existence scan. That row is still physically\n * present in the store at this point (its own write/delete hasn't happened\n * yet — this check runs first, before the enforcement loop's caller applies\n * it), so without the exclusion, a default value equal to that row's *old*\n * `localField` value would false-positive: the scan would find the row about\n * to disappear (or change away from that value) and wrongly conclude the\n * default references a real row, when after the transaction nothing will.\n */\nasync function validateSetDefaultPatch(\n  scope: IdbTransactionScope,\n  contract: IdbContract,\n  modelName: string,\n  def: RelationDefinition,\n  patch: Record<string, unknown>,\n  excludeKey?: IDBValidKey\n): Promise<void> {\n  const values = def.targetFields.map((f) => patch[f]);\n  // A default of null leaves no reference to check.\n  if (values.some((v) => v === null || v === undefined)) return;\n\n  const meta = makePlanMeta(contract);\n  const exists = await parentExists(scope, contract, meta, modelName, def.localFields, values, excludeKey);\n  if (!exists) {\n    throw new Error(\n      `setDefault referential action on relation '${def.relationName}' would set ` +\n        `${def.relatedModelName} to ${describeTuple(def.targetFields, values)}, but no ${modelName} with ` +\n        `${describeTuple(def.localFields, values)} exists — the declared default does not reference a real row.`\n    );\n  }\n}\n\n// ── Update referential action enforcement ─────────────────────────────────────\n\n/**\n * Collects every store an `onUpdate`-enforced write to `modelName` might\n * touch: the model's own store, plus the related store of any 1:N/1:1-\n * parent-side relation whose `localFields` appear in the raw patch —\n * pessimistic (checks field *presence*, not whether the resolved value will\n * actually change, since the current row isn't read yet when this runs).\n * Once a `cascade` edge is entered, the walk continues transitively (mirrors\n * `collectDeleteStoreNames`'s cascade-only recursion), since a propagated\n * value change may itself need to cascade further.\n *\n * Returns `enforces: false` when no `onUpdate` enforcement can apply to this\n * write — callers use that to keep the existing fast blind-write path\n * instead of paying for a read-before-write. This is tracked as an explicit\n * flag rather than inferred from `storeNames.length > 1`: for a\n * self-referential relation, `def.relatedStoreName` equals `modelName`'s own\n * store (already the seed of the `Set`), so the store count alone can't tell\n * \"no enforcement\" apart from \"enforces, but only against this same store\".\n */\nexport function collectOnUpdateEnforcementStoreNames(\n  contract: IdbContract,\n  modelName: string,\n  data: Record<string, unknown>\n): { storeNames: string[]; enforces: boolean } {\n  const stores = new Set([getStoreName(contract, modelName)]);\n  const visitedModels = new Set<string>([modelName]);\n  let enforces = false;\n\n  for (const def of getRelationDefinitions(contract, modelName)) {\n    if (!isChildEnforcementRelation(contract, modelName, def)) continue;\n    if (!def.localFields.some((f) => f in data)) continue;\n    const action = getReferentialActionForRelation(contract, modelName, def, \"onUpdate\");\n    enforces = true;\n    stores.add(def.relatedStoreName);\n    if (action === \"cascade\") addOnUpdateCascadeStores(contract, def.relatedModelName, stores, visitedModels);\n  }\n\n  return { storeNames: [...stores], enforces };\n}\n\n/**\n * Enforces every `onUpdate` action declared on `modelName`'s child relations\n * against one specific `oldRow` about to be patched with `patch`. Only\n * relations whose `localFields` are both present in `patch` and differ from\n * `oldRow`'s current value are enforced — a patch that sets a field to its\n * existing value, or never touches a locally-referenced field, is a no-op\n * here. Children are matched against `oldRow`'s pre-change values.\n *\n * `cascade` propagates the new value(s) onto the matched children's FK\n * fields and recurses into each child's own `onUpdate` relations before\n * writing (the propagated change may itself need to cascade further) —\n * mirrors `applyReferentialActionsForRow`'s recursive shape, including the\n * `visited` row-level cycle guard (see that function's doc comment for the\n * fresh-per-top-level-row / shared-across-one-row's-descent contract).\n * `setNull`/`setDefault` are leaf actions: the child's FK field changes but\n * its own key doesn't, so nothing below it needs re-enforcement.\n *\n * Compound relations use values from the same `oldRow`/`patch`, so every\n * child is matched against the full pre-change tuple.\n */\nexport async function applyReferentialActionsForRowOnUpdate(\n  scope: IdbTransactionScope,\n  contract: IdbContract,\n  modelName: string,\n  oldRow: Record<string, unknown>,\n  patch: Record<string, unknown>,\n  visited: Set<string> = new Set()\n): Promise<void> {\n  const keyPath = getKeyPath(contract, modelName);\n  patch = preserveDecimalKeySpelling(contract, modelName, patch, extractKeyFromRow(oldRow, keyPath));\n  const rowKey = `${getStoreName(contract, modelName)}::${keyToken(extractKeyFromRow(oldRow, keyPath))}`;\n  if (visited.has(rowKey)) return;\n  visited.add(rowKey);\n\n  const meta = makePlanMeta(contract);\n  for (const def of getRelationDefinitions(contract, modelName)) {\n    if (!isChildEnforcementRelation(contract, modelName, def)) continue;\n    const changedFields = def.localFields.filter((f) => f in patch && !fieldValuesEqual(patch[f], oldRow[f]));\n    if (changedFields.length === 0) continue;\n\n    const action = getReferentialActionForRelation(contract, modelName, def, \"onUpdate\");\n\n    const childWhere = buildChildWhereFromRow(def, oldRow);\n\n    if (action === \"restrict\") {\n      if (await childExists(scope, contract, meta, def, oldRow)) {\n        throw new Error(\n          `Cannot update ${modelName} '${keyToken(extractKeyFromRow(oldRow, keyPath))}': changing field(s) ${changedFields.join(\", \")} ` +\n            `would orphan child records on relation '${def.relationName}'. ` +\n            \"Update or remove those children first, or declare onUpdate: Cascade, SetNull or SetDefault on the relation.\"\n        );\n      }\n      continue;\n    }\n\n    if (action === \"cascade\") {\n      const childPatch: Record<string, unknown> = {};\n      for (let i = 0; i < def.localFields.length; i++) {\n        const lf = def.localFields[i]!;\n        const tf = def.targetFields[i]!;\n        if (changedFields.includes(lf)) childPatch[tf] = patch[lf];\n      }\n      const children = await readMutationRows(scope, contract, def.relatedModelName, childWhere);\n      for (const child of children) {\n        await applyReferentialActionsForRowOnUpdate(scope, contract, def.relatedModelName, child, childPatch, visited);\n      }\n      await writeMutationRows(scope, contract, def.relatedModelName, {\n        write: \"put-merged\",\n        patch: childPatch,\n        where: childWhere,\n      });\n      continue;\n    }\n\n    if (action === \"setNull\") {\n      const childPatch: Record<string, unknown> = {};\n      for (const targetField of def.targetFields) childPatch[targetField] = null;\n      await writeMutationRows(scope, contract, def.relatedModelName, {\n        write: \"put-merged\",\n        patch: childPatch,\n        where: childWhere,\n      });\n      continue;\n    }\n\n    if (action === \"setDefault\") {\n      const childPatch = buildSetDefaultPatch(contract, def);\n      await validateSetDefaultPatch(scope, contract, modelName, def, childPatch, extractKeyFromRow(oldRow, keyPath));\n      await writeMutationRows(scope, contract, def.relatedModelName, {\n        write: \"put-merged\",\n        patch: childPatch,\n        where: childWhere,\n      });\n      continue;\n    }\n  }\n}\n\n// ── Scalar FK validation ──────────────────────────────────────────────────────\n\n/**\n * Returns true if `data` contains at least one non-null value for a localField\n * of a N:1 relation — indicating scalar FK fields that need existence validation.\n */\nexport function hasScalarFkFields(contract: IdbContract, modelName: string, data: Record<string, unknown>): boolean {\n  for (const def of getRelationDefinitions(contract, modelName)) {\n    if (def.cardinality !== \"N:1\") continue;\n    for (const localField of def.localFields) {\n      if (localField in data && data[localField] !== null && data[localField] !== undefined) return true;\n    }\n  }\n  return false;\n}\n\n/** Include parent stores for the non-null foreign keys supplied by this write. */\nexport function collectScalarFkStoreNames(\n  contract: IdbContract,\n  modelName: string,\n  data: Record<string, unknown>\n): string[] {\n  const stores = new Set([getStoreName(contract, modelName)]);\n  for (const def of getRelationDefinitions(contract, modelName)) {\n    if (def.cardinality !== \"N:1\") continue;\n    const hasFkField = def.localFields.some((f) => f in data && data[f] !== null && data[f] !== undefined);\n    if (hasFkField) stores.add(def.relatedStoreName);\n  }\n  return [...stores];\n}\n\n/**\n * Checks that every foreign key `data` sets points at an existing parent row,\n * inside the write's transaction.\n *\n * A compound foreign key is checked as one tuple: a single parent row must\n * match every field. Checking the fields one at a time could pass with each\n * value taken from a different parent. When `data` sets only some fields of a\n * compound key, the rest come from `existingRow`, the row being updated.\n * Callers must pass it in that case; see {@link fkCheckNeedsExistingRow}.\n *\n * A key with any `null` field isn't checked, like SQL's default `MATCH SIMPLE`.\n */\nexport async function validateScalarFks(\n  scope: IdbTransactionScope,\n  contract: IdbContract,\n  modelName: string,\n  data: Record<string, unknown>,\n  existingRow?: Record<string, unknown>\n): Promise<void> {\n  const meta = makePlanMeta(contract);\n  for (const def of getRelationDefinitions(contract, modelName)) {\n    if (def.cardinality !== \"N:1\") continue;\n    if (!def.localFields.some((f) => f in data)) continue;\n    const values = def.localFields.map((f) => (f in data ? data[f] : existingRow?.[f]));\n    if (values.some((v) => v === null || v === undefined)) continue;\n\n    const exists = await parentExists(scope, contract, meta, def.relatedModelName, def.targetFields, values);\n    if (!exists) {\n      throw new Error(\n        `FK violation on relation '${def.relationName}': no ${def.relatedModelName} with ${describeTuple(def.targetFields, values)}`\n      );\n    }\n  }\n}\n\n/**\n * `true` when `data` sets some, but not all, fields of a compound foreign\n * key. Checking it then needs the rest of the key from the row being\n * updated, so the update has to read each row before writing it.\n */\nfunction fkCheckNeedsExistingRow(contract: IdbContract, modelName: string, data: Record<string, unknown>): boolean {\n  return getRelationDefinitions(contract, modelName).some((def) => {\n    if (def.cardinality !== \"N:1\") return false;\n    const set = def.localFields.filter((f) => f in data).length;\n    return set > 0 && set < def.localFields.length;\n  });\n}\n\n/**\n * Does `parentModel` have a row whose `fields` equal `values`, pairwise?\n *\n * `excludeKey` leaves out one parent row, for checks that run while that row\n * is being deleted or changed.\n */\nasync function parentExists(\n  scope: IdbTransactionScope,\n  contract: IdbContract,\n  meta: PlanMeta,\n  parentModel: string,\n  fields: readonly string[],\n  values: readonly unknown[],\n  excludeKey?: IDBValidKey\n): Promise<boolean> {\n  const keyPath = getKeyPath(contract, parentModel);\n  const notExcluded =\n    excludeKey === undefined\n      ? undefined\n      : (row: Record<string, unknown>): boolean => !keyEquals(extractKeyFromRow(row, keyPath), excludeKey);\n  return rowExists(scope, contract, meta, parentModel, fields, values, notExcluded);\n}\n\n/** `id='u1'`, or `orgId='a', id='u1'` for a compound key. */\nfunction describeTuple(fields: readonly string[], values: readonly unknown[]): string {\n  return fields.map((f, i) => `${f}='${String(values[i])}'`).join(\", \");\n}\n\n/** Create one completed record and check its foreign keys in the same transaction. */\nexport async function executeScalarCreateWithFkValidation(options: {\n  executor: IdbQueryExecutorWithTransaction;\n  contract: IdbContract;\n  modelName: string;\n  data: Record<string, unknown>;\n}): Promise<Record<string, unknown>> {\n  const { executor, contract, modelName, data } = options;\n  // Apply defaults first, so the transaction declares the parent store of a\n  // foreign key that a default fills in. `insertSingleRow` checks the result.\n  const defaultsCache = createMutationDefaultsCache();\n  const record = completeCreateRecord(contract, modelName, data, defaultsCache);\n  const storeNames = collectScalarFkStoreNames(contract, modelName, record);\n  return withMutationScope(executor, storeNames, (scope) =>\n    insertSingleRow(scope, contract, modelName, record, defaultsCache)\n  );\n}\n\n/**\n * `createAll()` for rows that set foreign keys: checks every row's foreign\n * keys and inserts it, all in one transaction, so one bad row writes nothing.\n * The batch shares one defaults cache, like the plain `createAll()` path.\n */\nexport async function executeScalarCreateAllWithFkValidation(options: {\n  executor: IdbQueryExecutorWithTransaction;\n  contract: IdbContract;\n  modelName: string;\n  data: readonly Record<string, unknown>[];\n}): Promise<Record<string, unknown>[]> {\n  const { executor, contract, modelName, data } = options;\n  const defaultsCache = createMutationDefaultsCache();\n  const records = data.map((row) => completeCreateRecord(contract, modelName, row, defaultsCache));\n  const storeNames = [...new Set(records.flatMap((row) => collectScalarFkStoreNames(contract, modelName, row)))];\n  return withMutationScope(executor, storeNames, async (scope) => {\n    const inserted: Record<string, unknown>[] = [];\n    for (const record of records) {\n      inserted.push(await insertSingleRow(scope, contract, modelName, record, defaultsCache));\n    }\n    return inserted;\n  });\n}\n\n/**\n * Adds the stores an `onUpdate` cascade reaches from `modelName`: every child\n * relation's store, walking further through `cascade` edges only.\n */\nfunction addOnUpdateCascadeStores(\n  contract: IdbContract,\n  modelName: string,\n  stores: Set<string>,\n  visitedModels: Set<string>\n): void {\n  if (visitedModels.has(modelName)) return;\n  visitedModels.add(modelName);\n  for (const def of getRelationDefinitions(contract, modelName)) {\n    if (!isChildEnforcementRelation(contract, modelName, def)) continue;\n    stores.add(def.relatedStoreName);\n    if (getReferentialActionForRelation(contract, modelName, def, \"onUpdate\") === \"cascade\") {\n      addOnUpdateCascadeStores(contract, def.relatedModelName, stores, visitedModels);\n    }\n  }\n}\n\n/**\n * Every store an `onUpdate` enforcement on `modelName` could touch, whichever\n * fields the write sets. Use it to open a transaction before the write's\n * fields are known.\n */\nexport function collectOnUpdateClosureStoreNames(contract: IdbContract, modelName: string): string[] {\n  const stores = new Set([getStoreName(contract, modelName)]);\n  addOnUpdateCascadeStores(contract, modelName, stores, new Set());\n  return [...stores];\n}\n\n/**\n * Combines FK-existence store scope (this model's own N:1 relations) with\n * `onUpdate` enforcement store scope (this model's child relations) for a\n * single write. Returns the union alongside whether `onUpdate` enforcement\n * actually applies, including self-relations that touch only this model's\n * own store. Callers use that flag to choose between the existing\n * fast blind-write path and the read-before-write enforcement path.\n */\nfunction collectUpdateStoreNames(\n  contract: IdbContract,\n  modelName: string,\n  data: Record<string, unknown>\n): { storeNames: string[]; enforcesOnUpdate: boolean } {\n  const fkStoreNames = collectScalarFkStoreNames(contract, modelName, data);\n  const { storeNames: onUpdateStoreNames, enforces } = collectOnUpdateEnforcementStoreNames(contract, modelName, data);\n  return {\n    storeNames: [...new Set([...fkStoreNames, ...onUpdateStoreNames])],\n    enforcesOnUpdate: enforces,\n  };\n}\n\n/** The executor, contract, filters, and scalar patch for a validated update. */\ninterface ScalarUpdateOptions {\n  readonly executor: IdbQueryExecutorWithTransaction;\n  readonly contract: IdbContract;\n  readonly modelName: string;\n  readonly filters: readonly IdbFilterExpr[];\n  readonly data: Record<string, unknown>;\n}\n\n/** Updates the first matching row with FK validation and referential actions. */\nexport async function executeScalarUpdateWithFkValidation(\n  options: ScalarUpdateOptions\n): Promise<Record<string, unknown> | null> {\n  const rows = await executeScalarUpdates(options, 1);\n  return rows[0] ?? null;\n}\n\n/**\n * Bulk counterpart to {@link executeScalarUpdateWithFkValidation}: same FK\n * validation and `onUpdate` enforcement, but applies the patch to every row\n * the filter matches (no `take: 1`) and returns all of them.\n *\n * The transaction scope lets the sync interceptor observe the affected rows\n * and write one outbox event per row in the same transaction. A bulk write's\n * affected keys are only known after it runs, so tracking cannot happen by\n * extending the plan before execution.\n */\nexport async function executeBulkUpdateWithFkValidation(\n  options: ScalarUpdateOptions\n): Promise<Record<string, unknown>[]> {\n  return executeScalarUpdates(options);\n}\n\n/** Shares validation and atomic writes; only single-row updates limit the scan. */\nasync function executeScalarUpdates(options: ScalarUpdateOptions, take?: 1): Promise<Record<string, unknown>[]> {\n  const { executor, contract, modelName, filters, data } = options;\n  const storeName = getStoreName(contract, modelName);\n  // Apply defaults first, so the checks and the store list see every field\n  // the write sets, including one an `onUpdate` default fills in.\n  const patch = applyUpdateDefaults(\n    contract.execution?.mutations.defaults,\n    storeName,\n    data,\n    createMutationDefaultsCache()\n  );\n  assertEnumValues(contract, modelName, patch);\n  assertValidRecord(contract, modelName, \"update\", patch);\n  const { storeNames, enforcesOnUpdate } = collectUpdateStoreNames(contract, modelName, patch);\n  const needsRowForFks = fkCheckNeedsExistingRow(contract, modelName, patch);\n  const updatedRows = await withMutationScope(executor, storeNames, async (scope) => {\n    if (!needsRowForFks) await validateScalarFks(scope, contract, modelName, patch);\n    const meta = makePlanMeta(contract);\n    const where = filters.length === 0 ? undefined : andExpr(filters);\n    if (!enforcesOnUpdate && !needsRowForFks) {\n      return writeMutationRows(scope, contract, modelName, {\n        write: \"put-merged\",\n        patch,\n        ...(take === undefined ? {} : { take }),\n        ...(where === undefined ? {} : { where }),\n      });\n    }\n\n    // Enforcement needs the preimage for changed referenced fields and for\n    // compound foreign keys whose other fields are absent from the patch.\n    const oldRows = await readMutationRows(scope, contract, modelName, where, take);\n    const keyPath = getKeyPath(contract, modelName);\n    const results: Record<string, unknown>[] = [];\n    for (const oldRow of oldRows) {\n      if (needsRowForFks) await validateScalarFks(scope, contract, modelName, patch, oldRow);\n      if (enforcesOnUpdate) await applyReferentialActionsForRowOnUpdate(scope, contract, modelName, oldRow, patch);\n      const key = extractKeyFromRow(oldRow, keyPath);\n      const rows = await scope.execute({ meta, kind: \"update\", storeName, key, patch } as IdbAtomicPlan);\n      const updated = rows[0];\n      if (updated) results.push(updated);\n    }\n    return results;\n  });\n  // The rows come straight from the store, so a field added after they were written is absent.\n  return updatedRows.map(absentAsNull(contract, modelName));\n}\n\n// ── Delete referential action enforcement ─────────────────────────────────────\n\n/**\n * Returns true if the model has at least one child relation (1:N or parent-side\n * 1:1). Every such relation has an `onDelete` action to enforce: `noAction`\n * behaves like `restrict`, which is also the default.\n */\nexport function hasEnforceableChildRelations(contract: IdbContract, modelName: string): boolean {\n  return getRelationDefinitions(contract, modelName).some((def) =>\n    isChildEnforcementRelation(contract, modelName, def)\n  );\n}\n\n/** The store of `modelName` plus the store of every model it has a relation to, in either direction. */\nexport function collectRelatedStoreNames(contract: IdbContract, modelName: string): string[] {\n  const stores = new Set([getStoreName(contract, modelName)]);\n  for (const def of getRelationDefinitions(contract, modelName)) stores.add(def.relatedStoreName);\n  return [...stores];\n}\n\n/**\n * Transitively walks the `onDelete` cascade graph from `modelName`, collecting\n * every store a recursive delete might touch. `cascade` edges are walked\n * further (a cascaded child's own children may themselves cascade);\n * `restrict`/`setNull`/`setDefault` edges still need their store added (each\n * is read or written once) but don't recurse further, since none of them\n * delete the child row. Guarded by a model-level visited set — required\n * because IDB must declare every store a transaction might touch before it\n * opens, so this static walk must terminate even on a self-referential model\n * or a cycle of mutually-cascading models.\n */\nexport function collectDeleteStoreNames(contract: IdbContract, modelName: string): string[] {\n  const stores = new Set<string>();\n  const visitedModels = new Set<string>();\n\n  /** Collect cascade stores once per model so cyclic relations cannot recurse indefinitely. */\n  function walk(mName: string): void {\n    if (visitedModels.has(mName)) return;\n    visitedModels.add(mName);\n    stores.add(getStoreName(contract, mName));\n    for (const def of getRelationDefinitions(contract, mName)) {\n      if (!isChildEnforcementRelation(contract, mName, def)) continue;\n      const action = getReferentialActionForRelation(contract, mName, def, \"onDelete\");\n      stores.add(def.relatedStoreName);\n      if (action === \"cascade\") walk(def.relatedModelName);\n    }\n  }\n\n  walk(modelName);\n  return [...stores];\n}\n\n/**\n * Enforces every `onDelete` action declared on `modelName`'s child relations\n * against one specific `row` about to be deleted. `cascade` recurses into\n * each matched child's own `onDelete` relations *before* deleting it — so a\n * multi-hop chain (`User --cascade--> Post --cascade--> Comment`) is fully\n * torn down, and a `restrict` several hops deep still aborts the whole\n * transaction (recursing before deleting means the delete never happens if a\n * deeper hop throws). `setNull`/`setDefault` are leaf actions: the child row\n * survives, so recursion never continues past them.\n *\n * `visited` (keyed by `storeName::key`) guards against row-level cycles — two\n * specific rows whose FKs point at each other through a self-referential or\n * mutually-cascading relation graph. Callers should leave it at its default\n * (a fresh `Set` per top-level call) so independent rows deleted in the same\n * `deleteAll()` batch don't cross-suppress each other's cascades; it's only\n * ever passed explicitly by this function's own recursive calls, to keep one\n * shared guard across a single row's full recursive descent.\n */\nexport async function applyReferentialActionsForRow(\n  scope: IdbTransactionScope,\n  contract: IdbContract,\n  modelName: string,\n  row: Record<string, unknown>,\n  visited: Set<string> = new Set()\n): Promise<void> {\n  const keyPath = getKeyPath(contract, modelName);\n  const rowKey = `${getStoreName(contract, modelName)}::${keyToken(extractKeyFromRow(row, keyPath))}`;\n  if (visited.has(rowKey)) return;\n  visited.add(rowKey);\n\n  const meta = makePlanMeta(contract);\n  for (const def of getRelationDefinitions(contract, modelName)) {\n    if (!isChildEnforcementRelation(contract, modelName, def)) continue;\n    const action = getReferentialActionForRelation(contract, modelName, def, \"onDelete\");\n\n    const childWhere = buildChildWhereFromRow(def, row);\n\n    if (action === \"restrict\") {\n      if (await childExists(scope, contract, meta, def, row)) {\n        throw new Error(\n          `Cannot delete ${modelName} '${keyToken(extractKeyFromRow(row, keyPath))}': child records exist on relation '${def.relationName}'. ` +\n            \"Delete those children first, or declare onDelete: Cascade, SetNull or SetDefault on the relation.\"\n        );\n      }\n      continue;\n    }\n\n    if (action === \"cascade\") {\n      const childKeyPath = getKeyPath(contract, def.relatedModelName);\n      const children = await readMutationRows(scope, contract, def.relatedModelName, childWhere);\n      for (const child of children) {\n        await applyReferentialActionsForRow(scope, contract, def.relatedModelName, child, visited);\n        await scope.execute({\n          meta,\n          kind: \"delete\",\n          storeName: def.relatedStoreName,\n          key: extractKeyFromRow(child, childKeyPath),\n        } as IdbAtomicPlan);\n      }\n      continue;\n    }\n\n    if (action === \"setNull\") {\n      const patch: Record<string, unknown> = {};\n      for (const targetField of def.targetFields) patch[targetField] = null;\n      await writeMutationRows(scope, contract, def.relatedModelName, {\n        write: \"put-merged\",\n        patch,\n        where: childWhere,\n      });\n      continue;\n    }\n\n    if (action === \"setDefault\") {\n      const patch = buildSetDefaultPatch(contract, def);\n      await validateSetDefaultPatch(scope, contract, modelName, def, patch, extractKeyFromRow(row, keyPath));\n      await writeMutationRows(scope, contract, def.relatedModelName, {\n        write: \"put-merged\",\n        patch,\n        where: childWhere,\n      });\n      continue;\n    }\n  }\n}\n\n/** Load a keyed row, apply its child actions, and delete it in one transaction. */\nexport async function executeDeleteWithReferentialActions(options: {\n  executor: IdbQueryExecutorWithTransaction;\n  contract: IdbContract;\n  modelName: string;\n  key: IDBValidKey;\n}): Promise<void> {\n  const { executor, contract, modelName, key } = options;\n  const storeNames = collectDeleteStoreNames(contract, modelName);\n  await withMutationScope(executor, storeNames, async (scope) => {\n    const storeName = getStoreName(contract, modelName);\n    const meta = makePlanMeta(contract);\n    const keyPath = getKeyPath(contract, modelName);\n    const fields = keyPathFields(keyPath);\n    const values = typeof keyPath === \"string\" ? [key] : (key as IDBValidKey[]);\n    const where = andExpr(fields.map((field, i) => fieldFilter(field, \"eq\", values[i])));\n    const rows = await readMutationRows(scope, contract, modelName, where, 1);\n    const row = rows[0];\n    if (!row) return [];\n    await applyReferentialActionsForRow(scope, contract, modelName, row);\n    await scope.execute({ meta, kind: \"delete\", storeName, key } as IdbAtomicPlan);\n    return [];\n  });\n}\n\n/** Delete filtered rows with all child actions inside the same transaction. */\nexport async function executeDeleteAllWithReferentialActions(options: {\n  executor: IdbQueryExecutorWithTransaction;\n  contract: IdbContract;\n  modelName: string;\n  where?: IdbFilterExpr;\n}): Promise<Record<string, unknown>[]> {\n  const { executor, contract, modelName, where } = options;\n  const storeNames = collectDeleteStoreNames(contract, modelName);\n  return withMutationScope(executor, storeNames, async (scope) => {\n    const storeName = getStoreName(contract, modelName);\n    const meta = makePlanMeta(contract);\n    const keyPath = getKeyPath(contract, modelName);\n    if (!hasEnforceableChildRelations(contract, modelName)) {\n      const deleted = await writeMutationRows(scope, contract, modelName, {\n        write: \"delete\",\n        ...(where === undefined ? {} : { where }),\n      });\n      return deleted.map(absentAsNull(contract, modelName));\n    }\n    const rows = await readMutationRows(scope, contract, modelName, where);\n    for (const row of rows) {\n      await applyReferentialActionsForRow(scope, contract, modelName, row);\n      const key = extractKeyFromRow(row, keyPath);\n      await scope.execute({ meta, kind: \"delete\", storeName, key } as IdbAtomicPlan);\n    }\n    return rows;\n  });\n}\n"],"mappings":"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"}