@prisma-idb/client-idb 0.10.0 → 0.12.0

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

@@ -1 +0,0 @@
-{"version":3,"file":"mutation-executor-CD5n_kKT.mjs","names":["_exhaustive"],"sources":["../src/core/types.ts","../src/core/enum-validation.ts","../src/core/mutation-defaults.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 (v0.12.0 domain plane) ───────────────────────────────\n\n/**\n * Extract the model map from a contract by traversing the domain namespace.\n *\n * 0.14.0: `Contract` dropped the 2nd `TModels` type parameter; models are now\n * accessed via `domain.namespaces[ns].models`. For a single-namespace contract\n * (the only IDB case) 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\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\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 * `contract.models[ModelName].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 — see ADR-tracked decision in\n * Phase 9.1), which requires order, unlike `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-key models keep today's scalar shape (e.g. `string`) — no\n * change for the common case, and untyped/loosely-typed contracts (no\n * emitted type maps — `ModelKeyPathOrdered` resolves to `never`) fall\n * through to the exact same `IDBValidKey` fallback `KeyType` always used\n * before compound keys existed. 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.table`). */\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 * Input shape for `create()`: the full input row with an `autoIncrement`\n * primary key made optional (see {@link OptionalKeyPathField}), and every\n * field with an `onCreate` execution default — including a `uuid()`/`cuid()`\n * key — also made optional. Any other key field stays required.\n */\nexport type CreateInput<TContract, ModelName extends string> = Omit<\n  ResolvedInputRow<TContract, ModelName>,\n  OptionalKeyPathField<TContract, ModelName> | FieldsWithCreateDefault<TContract, ModelName>\n> &\n  Partial<\n    Pick<\n      ResolvedInputRow<TContract, ModelName>,\n      KeyPathField<TContract, ModelName> | DefaultedInputField<TContract, ModelName>\n    >\n  >;\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()` (Phase 6.5), 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/**\n * Partial update shape for `update()`, `updateAll()`, `updateCount()`, and the\n * `update` arm of `upsert()`. All fields are optional — only provided fields\n * are shallow-merged onto the existing record.\n */\nexport type PatchInput<TContract, ModelName extends string> = Partial<DefaultModelRow<TContract, ModelName>>;\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 * All scalar fields are optional (shallow merge); relation fields accept\n * `connect` or `disconnect` callbacks.\n */\nexport type MutationUpdateInput<TContract, ModelName extends string> = PatchInput<TContract, ModelName> &\n  RelationMutationFields<TContract, ModelName>;\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`. 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 * Build a field → indexName lookup for every single-field, non-multi-entry\n * index on `storeName`. Top-level scans use this map to find indexed equality\n * conditions in combined filter expressions. Compound and multi-entry indexes\n * cannot serve these single-field point lookups.\n */\nexport function buildFieldToIndexMap(contract: IdbContract, storeName: string): Record<string, string> {\n  const storeDef = contract.storage.stores[storeName];\n  const result: Record<string, string> = {};\n  if (storeDef?.indexes === undefined) return result;\n  for (const [indexName, indexDef] of Object.entries(storeDef.indexes)) {\n    if (typeof indexDef.keyPath === \"string\" && indexDef.multiEntry !== true) {\n      result[indexDef.keyPath] = indexName;\n    }\n  }\n  return result;\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","/**\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\ntype EnumFieldRule = {\n  readonly enumName: string;\n  readonly values: ReadonlySet<unknown>;\n  readonly nullable: boolean;\n  readonly many: boolean;\n};\n\ntype ModelEnumRules = ReadonlyMap<string, EnumFieldRule>;\n\nconst rulesByContract = new WeakMap<IdbContract, Map<string, ModelEnumRules>>();\n\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: field.many === true,\n  };\n}\n\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\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.\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 (!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","/**\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\";\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\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\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.table !== storeName || !d.onCreate) continue;\n    if (result[d.ref.column] !== undefined) continue;\n    if (result === data) result = { ...data };\n    result[d.ref.column] = resolveGeneratedValue(d.onCreate, cache);\n  }\n  return result;\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.table !== storeName || !d.onUpdate) continue;\n    if (result[d.ref.column] !== undefined) continue;\n    if (result === patch) result = { ...patch };\n    result[d.ref.column] = resolveGeneratedValue(d.onUpdate, cache);\n  }\n  return result;\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\nexport function createRelationMutator<TContract extends IdbContract, ModelName extends string>(): IdbRelationMutator<\n  TContract,\n  ModelName\n> {\n  return {\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 * - `findRowByCriterion` / `findFirstByFilters` → `scope.execute({ kind: \"cursor-scan\", ... })`.\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 is Phase 6.4's implicit FK validation for the connect case.\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, IdbCursorScanPlan } from \"@prisma-idb/driver-idb/runtime\";\nimport { evaluateFilter, 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 {\n  applyCreateDefaults,\n  applyUpdateDefaults,\n  createMutationDefaultsCache,\n  type MutationDefaultsCache,\n} from \"./mutation-defaults\";\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  isValidIdbKey,\n  keyEquals,\n  keyToken,\n} from \"./types\";\nimport { keyPathFields, type IdbKeyPath } from \"@prisma-idb/target-idb/pack\";\nimport type { IdbTransactionScope } from \"@prisma-idb/driver-idb/runtime\";\n\n// ── Internal types ─────────────────────────────────────────────────────────────\n\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\ninterface ParsedRelationMutation {\n  readonly relation: RelationDefinition;\n  readonly mutation: IdbRelationMutation<IdbContract, string>;\n}\n\ninterface ParsedMutationInput {\n  readonly scalarData: Record<string, unknown>;\n  readonly relationMutations: readonly ParsedRelationMutation[];\n}\n\n// ── Plan meta helpers ─────────────────────────────────────────────────────────\n\nfunction 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\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\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\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\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\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    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 = 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\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\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\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 in Phase 6.4 — 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\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\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 filter = buildCriterionFilter(criterion as Record<string, unknown>);\n      const meta = makePlanMeta(contract);\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. (PLAN Issue #24.)\n      await scope.execute({\n        meta,\n        kind: \"scan-write\",\n        storeName: relation.relatedStoreName,\n        write: \"put-merged\",\n        patch,\n        filter,\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  const meta = makePlanMeta(contract);\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 parentJoinFilter = buildParentJoinFilter(parentValues);\n    await scope.execute({\n      meta,\n      kind: \"scan-write\",\n      storeName: relation.relatedStoreName,\n      write: \"put-merged\",\n      patch,\n      filter: parentJoinFilter,\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 criterionFilter = buildCriterionFilter(criterion as Record<string, unknown>);\n    const parentJoinFilter = buildParentJoinFilter(parentValues);\n    const combinedFilter = (row: Record<string, unknown>): boolean => parentJoinFilter(row) && criterionFilter(row);\n    await scope.execute({\n      meta,\n      kind: \"scan-write\",\n      storeName: relation.relatedStoreName,\n      write: \"put-merged\",\n      patch,\n      filter: combinedFilter,\n    });\n  }\n}\n\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\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 = applyCreateDefaults(contract.execution?.mutations.defaults, storeName, data, defaultsCache);\n  assertEnumValues(contract, modelName, 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 in Phase 6.4. 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. (PLAN Issue #22.)\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\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  const filter = (row: Record<string, unknown>): boolean => evaluateFilter(expr, row);\n  return scanOneRow(scope, contract, modelName, filter);\n}\n\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  const combined = filters.length === 1 ? filters[0]! : { kind: \"and\" as const, exprs: filters };\n  const filter = (row: Record<string, unknown>): boolean => evaluateFilter(combined, row);\n  return scanOneRow(scope, contract, modelName, filter);\n}\n\nasync function scanOneRow(\n  scope: IdbTransactionScope,\n  contract: IdbContract,\n  modelName: string,\n  filter: (row: Record<string, unknown>) => boolean\n): Promise<Record<string, unknown> | null> {\n  const storeName = getStoreName(contract, modelName);\n  const meta = makePlanMeta(contract);\n  const plan: IdbCursorScanPlan = { meta, kind: \"cursor-scan\", storeName, filter, take: 1 };\n  const rows = await scope.execute(plan as IdbAtomicPlan);\n  return rows[0] ?? null;\n}\n\n// ── Filter helpers ────────────────────────────────────────────────────────────\n\nfunction buildCriterionFilter(criterion: Record<string, unknown>): (row: Record<string, unknown>) => boolean {\n  const expr = shorthandToFilterExpr(criterion);\n  if (!expr) return () => true;\n  return (row) => evaluateFilter(expr, row);\n}\n\nfunction buildParentJoinFilter(parentValues: Map<string, unknown>): (row: Record<string, unknown>) => boolean {\n  const pairs = [...parentValues.entries()];\n  return (row: Record<string, unknown>): boolean =>\n    pairs.every(([childField, parentValue]) => fieldValuesEqual(row[childField], parentValue));\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\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\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\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// ── Key-only existence lookups ────────────────────────────────────────────────\n\n/**\n * An `IDBKeyRange` for the lookup \"does `modelName` have a row whose `field`\n * equals `value`?\" — but ONLY when `field` is that model's own single-field\n * primary key (so the answer is a pure key lookup that needs no row value)\n * and `value` is a legal IDB key. `null` otherwise, and the caller keeps its\n * value-materializing `cursor-scan`.\n *\n * Deliberately `null` for a compound primary key even if `field` is one of its\n * members (one member can't pin the whole key), and for any non-key field\n * (that needs an index-resolution step — Phase 10.5's shared primitive, not\n * this helper's job). `IDBKeyRange.only` throws `DataError` on invalid keys\n * (`null`, `NaN`, booleans, …), hence the guard.\n */\nfunction pkEqualityRange(contract: IdbContract, modelName: string, field: string, value: unknown): IDBKeyRange | null {\n  if (typeof IDBKeyRange === \"undefined\") return null;\n  const keyPath = getKeyPath(contract, modelName);\n  if (typeof keyPath !== \"string\" || keyPath !== field) return null;\n  if (!isValidIdbKey(value)) return null;\n  return IDBKeyRange.only(value);\n}\n\n/**\n * Resolves to the first primary key in `storeName` within `range`, or\n * `undefined` — one `getKey` request, no row deserialized.\n */\nasync function firstKeyInRange(\n  scope: IdbTransactionScope,\n  meta: PlanMeta,\n  storeName: string,\n  range: IDBKeyRange\n): Promise<IDBValidKey | undefined> {\n  const rows = await scope.execute({ meta, kind: \"keys\", storeName, range, take: 1 } as IdbAtomicPlan);\n  return rows[0]?.[\"key\"] as IDBValidKey | undefined;\n}\n\n/**\n * `true` if any child row matches the relation against `parentRow`'s values —\n * the existence check behind `restrict`. Key-only when the relation's single\n * child field is the child model's own primary key (a shared-PK 1:1); a\n * value-materializing `cursor-scan` (`take: 1`) otherwise.\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  if (def.targetFields.length === 1) {\n    const range = pkEqualityRange(contract, def.relatedModelName, def.targetFields[0]!, parentRow[def.localFields[0]!]);\n    if (range !== null) return (await firstKeyInRange(scope, meta, def.relatedStoreName, range)) !== undefined;\n  }\n  const found = await scope.execute({\n    meta,\n    kind: \"cursor-scan\",\n    storeName: def.relatedStoreName,\n    filter: buildChildFilterFromRow(def, parentRow),\n    take: 1,\n  } as IdbAtomicPlan);\n  return found.length > 0;\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 buildChildFilterFromRow(\n  def: RelationDefinition,\n  row: Record<string, unknown>\n): (child: Record<string, unknown>) => boolean {\n  const pairs = def.localFields.map((lf, i) => ({ childField: def.targetFields[i]!, parentValue: row[lf] }));\n  return (child: Record<string, unknown>): boolean =>\n    pairs.every(({ childField, parentValue }) => fieldValuesEqual(child[childField], parentValue));\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>();\n  let enforces = false;\n\n  function walkCascadeChain(mName: string): void {\n    if (visitedModels.has(mName)) return;\n    visitedModels.add(mName);\n    for (const def of getRelationDefinitions(contract, mName)) {\n      if (!isChildEnforcementRelation(contract, mName, def)) continue;\n      const action = getReferentialActionForRelation(contract, mName, def, \"onUpdate\");\n      stores.add(def.relatedStoreName);\n      if (action === \"cascade\") walkCascadeChain(def.relatedModelName);\n    }\n  }\n\n  visitedModels.add(modelName);\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\") walkCascadeChain(def.relatedModelName);\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  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 childFilter = buildChildFilterFromRow(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 scope.execute({\n        meta,\n        kind: \"cursor-scan\",\n        storeName: def.relatedStoreName,\n        filter: childFilter,\n      } as IdbAtomicPlan);\n      for (const child of children) {\n        await applyReferentialActionsForRowOnUpdate(scope, contract, def.relatedModelName, child, childPatch, visited);\n      }\n      await scope.execute({\n        meta,\n        kind: \"scan-write\",\n        storeName: def.relatedStoreName,\n        write: \"put-merged\",\n        patch: childPatch,\n        filter: childFilter,\n      } as IdbAtomicPlan);\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 scope.execute({\n        meta,\n        kind: \"scan-write\",\n        storeName: def.relatedStoreName,\n        write: \"put-merged\",\n        patch: childPatch,\n        filter: childFilter,\n      } as IdbAtomicPlan);\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 scope.execute({\n        meta,\n        kind: \"scan-write\",\n        storeName: def.relatedStoreName,\n        write: \"put-merged\",\n        patch: childPatch,\n        filter: childFilter,\n      } as IdbAtomicPlan);\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\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 * When `fields` are exactly the parent's primary key (in any order), this is\n * one key-only lookup. Otherwise it scans the parent store, comparing values\n * the way IndexedDB compares keys. `excludeKey` leaves out one parent row,\n * for checks that run while that row 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 storeName = getStoreName(contract, parentModel);\n  const keyPath = getKeyPath(contract, parentModel);\n  const range = primaryKeyRange(keyPath, fields, values);\n  if (range !== null) {\n    // A primary key matches at most one row.\n    const foundKey = await firstKeyInRange(scope, meta, storeName, range);\n    return foundKey !== undefined && (excludeKey === undefined || !keyEquals(foundKey, excludeKey));\n  }\n  const filter = (row: Record<string, unknown>): boolean =>\n    fields.every((f, i) => fieldValuesEqual(row[f], values[i])) &&\n    (excludeKey === undefined || !keyEquals(extractKeyFromRow(row, keyPath), excludeKey));\n  const found = await scope.execute({ meta, kind: \"cursor-scan\", storeName, filter, take: 1 } as IdbAtomicPlan);\n  return found.length > 0;\n}\n\n/**\n * An `IDBKeyRange` for \"the row whose primary key is `values`\", when `fields`\n * are exactly the key's fields (in any order) and every value is a valid\n * IndexedDB key. `null` otherwise, and the caller scans instead.\n */\nfunction primaryKeyRange(\n  keyPath: IdbKeyPath,\n  fields: readonly string[],\n  values: readonly unknown[]\n): IDBKeyRange | null {\n  if (typeof IDBKeyRange === \"undefined\") return null;\n  const keyFields = keyPathFields(keyPath);\n  if (keyFields.length !== fields.length || !keyFields.every((f) => fields.includes(f))) return null;\n  const ordered = keyFields.map((f) => values[fields.indexOf(f)]);\n  if (!ordered.every((v) => isValidIdbKey(v))) return null;\n  return IDBKeyRange.only(typeof keyPath === \"string\" ? (ordered[0] as IDBValidKey) : (ordered as IDBValidKey[]));\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\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 = applyCreateDefaults(\n    contract.execution?.mutations.defaults,\n    getStoreName(contract, modelName),\n    data,\n    defaultsCache\n  );\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 storeName = getStoreName(contract, modelName);\n  const records = data.map((row) =>\n    applyCreateDefaults(contract.execution?.mutations.defaults, storeName, row, defaultsCache)\n  );\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 * 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\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  const { storeNames, enforcesOnUpdate } = collectUpdateStoreNames(contract, modelName, patch);\n  const needsRowForFks = fkCheckNeedsExistingRow(contract, modelName, patch);\n  return withMutationScope(executor, storeNames, async (scope) => {\n    if (!needsRowForFks) await validateScalarFks(scope, contract, modelName, patch);\n    const meta = makePlanMeta(contract);\n    const combined =\n      filters.length === 0 ? undefined : filters.length === 1 ? filters[0]! : { kind: \"and\" as const, exprs: filters };\n    const filter =\n      combined !== undefined ? (row: Record<string, unknown>): boolean => evaluateFilter(combined, row) : undefined;\n\n    if (!enforcesOnUpdate && !needsRowForFks) {\n      return scope.execute({\n        meta,\n        kind: \"scan-write\",\n        storeName,\n        write: \"put-merged\",\n        patch,\n        ...(take !== undefined ? { take } : {}),\n        ...(filter !== undefined ? { filter } : {}),\n      } as IdbAtomicPlan);\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 scope.execute({\n      meta,\n      kind: \"cursor-scan\",\n      storeName,\n      ...(take !== undefined ? { take } : {}),\n      ...(filter !== undefined ? { filter } : {}),\n    } as IdbAtomicPlan);\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}\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/**\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  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 childFilter = buildChildFilterFromRow(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 scope.execute({\n        meta,\n        kind: \"cursor-scan\",\n        storeName: def.relatedStoreName,\n        filter: childFilter,\n      } as IdbAtomicPlan);\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 scope.execute({\n        meta,\n        kind: \"scan-write\",\n        storeName: def.relatedStoreName,\n        write: \"put-merged\",\n        patch,\n        filter: childFilter,\n      } as IdbAtomicPlan);\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 scope.execute({\n        meta,\n        kind: \"scan-write\",\n        storeName: def.relatedStoreName,\n        write: \"put-merged\",\n        patch,\n        filter: childFilter,\n      } as IdbAtomicPlan);\n      continue;\n    }\n  }\n}\n\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 rows = await scope.execute({ meta, kind: \"key-get\", storeName, key } as IdbAtomicPlan);\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\nexport async function executeDeleteAllWithReferentialActions(options: {\n  executor: IdbQueryExecutorWithTransaction;\n  contract: IdbContract;\n  modelName: string;\n  filter?: (row: Record<string, unknown>) => boolean;\n}): Promise<Record<string, unknown>[]> {\n  const { executor, contract, modelName, filter } = 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    const rows = await scope.execute({\n      meta,\n      kind: \"cursor-scan\",\n      storeName,\n      ...(filter !== undefined ? { filter } : {}),\n    } as IdbAtomicPlan);\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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"}