@aventara/prisma7-adapter 0.1.0-pilot.1 → 0.1.0-pilot.2

package/dist/translation/mutation.translator.js

@@ -1,88 +1,9 @@
 import { advertisedDirectives, } from "@aventara/core";
 import { addressIdentifier } from "./identifier.addressing.js";
 import { emitScalarValue } from "./scalar.conversion.js";
-/**
- * T-7's mutation half — one validated Aventara `data` in, one Prisma write
- * argument out.
- *
- * # Pure, and the tables are the module
- *
- * No client, no database, no provider name. Three tables carry everything this
- * module knows, each one TOTAL over a core union by `satisfies`, so a member
- * added to core with no row here is a compile error rather than a silently
- * dropped argument (C-855's emission half, C-837's translator table — the one
- * `vocabulary.dictionary.ts` explicitly left to this task):
- *
- * - {@link SCALAR_DIRECTIVE_TOKENS} over `ScalarMutationDirective`;
- * - {@link RELATION_DIRECTIVE_EMISSIONS} over `RelationMutationDirective`;
- * - {@link MUTATION_DATA_SITES} over every standard operation key, which is
- *   C-818's enforcement point.
- *
- * C-834's own table is NOT one of them any more: the scalar value conversion was
- * born here, and `where.translator.ts` and `execution/result.shaper.ts` need the
- * same answers, so it moved to `scalar.conversion.ts` and all three read it
- * (Task 10's `identifier.addressing.ts` is the precedent). This module's
- * emission site is {@link emitValue}, which is now a call rather than a copy.
- *
- * Phase 7's `RELATION_MUTATION_RECORD_SITES` is the pattern
- * (`packages/core/src/runtime/mutation-planner.ts`): `as const satisfies
- * Readonly<Record<Union, …>>` keeps every cell a literal while making the union
- * coverage a compile-time obligation. Two of core's passes are already keyed
- * that way; this is the third, and the only one that names Prisma.
- *
- * # Refusing is part of honouring (the `where.translator.ts` stance)
- *
- * The adapter assumes validated input (C-845). It still refuses to EMIT a
- * directive the discovered model does not advertise for that field and stage,
- * and refuses one for which Prisma's nested input at that stage and cardinality
- * has no key at all. Both refusals are C-855 seen from the emission side: an
- * argument is honoured or it is not sent. A directive quietly dropped here would
- * surface as a write that silently did less than it was asked to.
- *
- * # C-818 cannot reach the Contract, so it is enforced here
- *
- * `RelationFieldCapabilities` is one record per field with a single `create`
- * member **[CORE, adapters/adapter-field.ts]**, so "relation create directives
- * for `create.one` and none for `create.many`" is unrepresentable in the model;
- * `model.discoverer.ts` composes the permissive `create.one` answer and says so.
- * The restriction therefore lives in {@link MUTATION_DATA_SITES}, which is keyed
- * by the operation the data belongs to. Measured at 7.10.0 on both engines
- * (2026-10-02), a nested relation key in a bulk write is a hard failure, not a
- * no-op:
- *
- * - `post.createMany({ data: [{ title, author: { connect: … } }] })` →
- *   *"Argument `authorId` is missing."*
- * - `post.updateMany({ where, data: { category: { connect: … } } })` →
- *   *"Unknown argument `category`. Available options are marked with ?."*
- *
- * # Nothing in the caller's arguments is touched
- *
- * Every object and array returned is new. The input is read, never written: a
- * translator that mutated its argument would corrupt the second attempt of a
- * retried operation, which is the one place the bug would not show up in a
- * single-shot test.
- */
-/** A mutation the model, the stage or the active operation does not license. */
 export class PrismaMutationTranslationError extends Error {
     name = "PrismaMutationTranslationError";
 }
-/* ------------------------------------------------------------------ *
- * C-837 — the scalar directive table                                  *
- * ------------------------------------------------------------------ */
-/**
- * The Prisma operand key for each of core's scalar mutation directives.
- *
- * The inverse of discovery's `PRISMA_SCALAR_DIRECTIVES` rename table, written
- * here rather than imported from it for the reason `where.translator.ts` gives:
- * that table is generate-time and `vocabulary.dictionary.ts` is excluded from
- * the published build, while this module is runtime. `mutation.translator.spec.ts`
- * round-trips every emitted token back through the dictionary, so the two cannot
- * drift.
- *
- * Prisma's `set` has no row because it is not a directive: plain assignment is
- * how core spells it, and the bare value is what this module emits — wrapping it
- * in `{ set: … }` would add a token the request never carried.
- */
 const SCALAR_DIRECTIVE_TOKENS = {
     $increment: "increment",
     $decrement: "decrement",
@@ -91,53 +12,6 @@ const SCALAR_DIRECTIVE_TOKENS = {
     $push: "push",
     $unset: "unset",
 };
-/**
- * §18.5's normalization table, forward: one Aventara directive → one Prisma
- * nested-write key and operand, per stage and cardinality.
- *
- * Total over `RelationMutationDirective`, so a ninth directive fails to compile
- * — the same obligation core's two tables carry. Every cell below was read off
- * the generated types and then RUN on both engines (2026-10-02); the three that
- * matter are not key-for-key renames and would each have been wrong the obvious
- * way.
- *
- * **To-many `$update` emits `updateMany`, not `update`.** Core validates a
- * to-many `$update` entry's `where` with `validateWhere` — a GENERAL filter, not
- * a unique selector **[CORE, operations/operation-validator-core.ts]** — and
- * §18.5 says so in as many words: *"Prisma nested update/updateMany normalize to
- * $update (general where → update every relation match)"*. Prisma's nested
- * `update` takes `<T>UpdateWithWhereUnique…Input`, which refuses a general
- * filter: *"Argument `where` of type PostWhereUniqueInput needs at least one of
- * `id` arguments."* `updateMany` takes `{ where: <T>ScalarWhereInput, data }`,
- * which is the shape core actually hands over.
- *
- * **To-many `$delete` emits `deleteMany`, for the same reason**, and its operand
- * is the where UNWRAPPED: `deleteMany?: PostScalarWhereInput`. The singular
- * `delete` is a `<T>WhereUniqueInput[]` and refuses the entry: *"Argument
- * `delete`: Invalid value provided. Expected PostWhereUniqueInput[], provided
- * Object."*
- *
- * **A `<T>ScalarWhereInput` carries scalars only**, so the two bulk forms refuse
- * a relation predicate rather than emit one Prisma will reject: *"Unknown
- * argument `category`. Did you mean `categoryId`?"* — and `updateMany`'s `data`
- * is an `UpdateMany` input, so it admits no nested relation write either:
- * *"Unknown argument `category`."*
- *
- * **The create stage admits four directives, not eight.**
- * `<T>Create…NestedInput` carries `create`, `connectOrCreate`, `createMany` and
- * `connect` and nothing else, on both cardinalities — *"Unknown argument
- * `disconnect`. Did you mean `connect`?"*, *"Unknown argument `set`."* A to-one
- * edge has no `set` at EITHER stage: *"Unknown argument `set`. Did you mean
- * `upsert`?"* The `create: null` cells are therefore measured facts.
- *
- * They were also where discovery over-advertised: `PrismaRelationSurface` carried
- * ONE mutation list, read off the UPDATE-stage nested input and reused for both
- * stages, so the model offered `$set`/`$disconnect`/`$update`/`$delete`/`$upsert`
- * at the create stage, which Prisma has no key for. This table refused them
- * loudly — which is C-855's whole point — and the deriver now reads each stage
- * from its own nested input (`createMutations` / `updateMutations`), so the
- * Contract no longer advertises what these cells refuse.
- */
 const RELATION_DIRECTIVE_EMISSIONS = {
     $create: {
         create: {
@@ -202,22 +76,6 @@ const RELATION_DIRECTIVE_EMISSIONS = {
         },
     },
 };
-/**
- * Every standard operation, and the mutation data it carries — `null` for the
- * ten that carry none.
- *
- * Total over the whole operation set rather than over the mutating subset, so a
- * variant added to `ResourceOperations` fails to compile here instead of
- * reaching the `forbidden`/`nested` question by default. The read and delete
- * families are `null` for the same reason the dictionary spells a missing
- * Aventara word `null`: *"no data"* is an answer, and an absent row is not.
- *
- * `create.many`, `create.count`, `update.many` and `update.count` are the
- * `forbidden` four: they become `createMany`/`updateMany`, whose inputs carry
- * scalars and foreign keys only. `update.first` is `nested` because the variant
- * is emulated as a read followed by a singular `update` (T-7.1), and that write
- * step is an `<M>UpdateInput`.
- */
 const MUTATION_DATA_SITES = {
     "find.first": null,
     "find.unique": null,
@@ -236,14 +94,6 @@ const MUTATION_DATA_SITES = {
     "delete.count": null,
     "upsert.unique": { stages: ["create", "update"], relations: "nested" },
 };
-/**
- * Translates one validated Aventara mutation `data` into the Prisma write
- * argument for the named operation and stage.
- *
- * @throws {PrismaMutationTranslationError} rather than emitting a directive the
- * model does not advertise, one Prisma has no key for at this stage and
- * cardinality, or a nested relation write inside a bulk argument (C-818).
- */
 export function translateMutationData(input, dependencies) {
     const key = `${input.operation.family}.${input.operation.variant}`;
     if (!isOperationKey(key)) {
@@ -281,9 +131,7 @@ function translateRecord(pass, resourceKey, data, stage, path) {
             continue;
         }
         if (pass.relations === "forbidden") {
-            // C-818, and the only place it can be enforced: the Contract cannot say
-            // which variant this data belongs to.
-            throw new PrismaMutationTranslationError(`${path}.${key}: a bulk write carries no nested relation directive; Prisma's createMany/updateMany inputs admit scalars and foreign keys only (C-818)`);
+            throw new PrismaMutationTranslationError(`${path}.${key}: a bulk write carries no nested relation directive; Prisma's createMany/updateMany inputs admit scalars and foreign keys only`);
         }
         emitted[key] = translateRelationWrite(pass, field, value, stage, `${path}.${key}`);
     }
@@ -296,9 +144,6 @@ function translateScalarWrite(pass, field, value, stage, path) {
     }
     const directives = directiveKeysOf(value, path);
     if (directives === undefined) {
-        // Core's own rule: a value that is not a directive object IS plain
-        // assignment, and Prisma spells that the same way. Wrapping it in
-        // `{ set: … }` would emit a token the request never carried.
         return emitValue(pass, field, value, path);
     }
     const operand = {};
@@ -313,16 +158,6 @@ function translateScalarWrite(pass, field, value, stage, path) {
     }
     return operand;
 }
-/**
- * The directive keys of a scalar write, or `undefined` when the value is a
- * value.
- *
- * The discriminant is the `$` prefix, which is core's own
- * (`validateScalarMutation` rejects a mixed object with `V1001` *"Scalar
- * mutation action objects may contain only $-prefixed directive keys"*). It is
- * mirrored rather than improved on: a `json` column's value is a plain object
- * too, and any second discriminant would disagree with core's on some input.
- */
 function directiveKeysOf(value, path) {
     if (!isRecord(value)) {
         return undefined;
@@ -337,13 +172,6 @@ function directiveKeysOf(value, path) {
     }
     return directives;
 }
-/**
- * C-834's emission site: one Aventara runtime value, one Prisma operand.
- *
- * The conversion itself belongs to `scalar.conversion.ts`, which owns both
- * directions for every scalar; this module owns only *where* a value sits in a
- * write argument.
- */
 function emitValue(pass, field, value, path) {
     return emitScalarValue(pass.model, field, value, path);
 }
@@ -374,11 +202,6 @@ function translateRelationWrite(pass, field, value, stage, path) {
     }
     return emitted;
 }
-/**
- * One directive's operand, with its ARITY preserved: core admits a single entry
- * or an array on a to-many edge, Prisma admits both, and collapsing or
- * expanding one would change the shape the request carried.
- */
 function emitRelationOperand(pass, target, cardinality, form, operand, path) {
     if (cardinality === "many" && Array.isArray(operand)) {
         return operand.map((entry, index) => emitRelationEntry(pass, target, form, entry, `${path}[${index}]`));
@@ -418,8 +241,6 @@ function emitRelationEntry(pass, target, form, entry, path) {
                 throw new PrismaMutationTranslationError(`${path}: a to-one $delete is true or an optional where object`);
             }
             if (!Object.hasOwn(entry, "where")) {
-                // `{}` is "delete the related row", which Prisma spells `true`. The
-                // empty object is not a Prisma where: `delete: {}` would match nothing.
                 return true;
             }
             return pass.dependencies.translateWhere(target, entry.where, `${path}.where`);
@@ -436,14 +257,11 @@ function emitRelationEntry(pass, target, form, entry, path) {
             const { where, data } = requireMembers(entry, ["where", "data"], path);
             return {
                 where: scalarWhere(pass, target, where, `${path}.where`),
-                // `<T>UpdateManyWithWhere…Input.data` is an UpdateMany input: scalars
-                // and foreign keys only, exactly as a top-level `updateMany`.
                 data: translateRecord(bulk(pass), target, data, "update", `${path}.data`),
             };
         }
         case "to-many-delete-many": {
             const { where } = requireMembers(entry, ["where"], path);
-            // `deleteMany` takes the scalar where itself, not `{ where }`.
             return scalarWhere(pass, target, where, `${path}.where`);
         }
         case "to-many-upsert": {
@@ -464,27 +282,14 @@ function bulk(pass) {
         ? pass
         : { ...pass, relations: "forbidden" };
 }
-/** A to-one `$update`/`$upsert` `where` is optional, and absent is not `undefined`. */
 function optionalWhere(pass, target, entry, path) {
     if (!isRecord(entry) || !Object.hasOwn(entry, "where")) {
         return {};
     }
-    // Prisma's to-one `update`/`upsert` `where` is a general `<T>WhereInput`, so
-    // core's flat unique selector needs no addressing here — it is already a valid
-    // filter. Measured on both engines (2026-10-02).
     return {
         where: pass.dependencies.translateWhere(target, entry.where, `${path}.where`),
     };
 }
-/**
- * A `<T>ScalarWhereInput`: the nested bulk forms' filter, which carries scalar
- * columns only.
- *
- * Core's `validateWhere` admits a relation predicate here, so this is a real
- * narrowing and it refuses rather than emits: Prisma answers *"Unknown argument
- * `category`. Did you mean `categoryId`?"* on both engines. Reported as a
- * C-855 gap in the advertised surface rather than silently dropped.
- */
 function scalarWhere(pass, target, where, path) {
     requireScalarPredicate(pass, target, where, path);
     return pass.dependencies.translateWhere(target, where, path);
@@ -513,15 +318,6 @@ function requireScalarPredicate(pass, target, where, path) {
         }
     }
 }
-/**
- * Core's FLAT unique selector → Prisma's `<T>WhereUniqueInput`, for a NESTED
- * `connect`/`disconnect`/`set`/`update`/`upsert` target.
- *
- * The addressing rule itself lives in `identifier.addressing.ts`, which Task 10
- * extracted when the top-level where-unique made it the third copy. What stays
- * here is this site's two decisions: the match is **exact**, and each member's
- * value goes out through C-834's scalar emission (`scalar.conversion.ts`).
- */
 function addressUnique(pass, target, selector, path) {
     if (!isRecord(selector)) {
         throw new PrismaMutationTranslationError(`${path} must be a unique identifier object`);
@@ -534,10 +330,6 @@ function addressUnique(pass, target, selector, path) {
     if (addresses === undefined) {
         throw new PrismaMutationTranslationError(`${path}: Resource "${target}" has no Prisma addressing in the translation table`);
     }
-    // `"exact"`: core's unique selector carries one identifier and nothing else,
-    // so a spare key means it is not that identifier. Each member goes out through
-    // C-834's scalar emission, which is why the conversion is passed in rather
-    // than the table imported by the addressing module.
     const addressed = addressIdentifier({
         addresses,
         values: selector,

package/dist/translation/operation.translator.d.ts

@@ -2,14 +2,10 @@ import type { AdapterModel, AdapterOperation } from "@aventara/core";
 import type { PrismaResourceTranslation } from "../discovery/discovery-artifact.interface.js";
 import { type PrismaProjectionPlan } from "./projection.translator.js";
 /**
- * T-7 — **one validated Aventara operation → one provider call description**,
- * and the module that makes the whole sixteen-variant grammar assertable as pure
- * data with no database in sight.
- *
  * Splitting translation from execution is the plan's single largest testability
- * decision (T-7): everything below is a pure function of the discovered model,
- * the generate-time translation table and the arguments core validated. The
- * database is needed only for the *other* half, `execution/operation.executor.ts`.
+ * decision: everything below is a pure function of the discovered model, the
+ * generate-time translation table and the arguments core validated. The database
+ * is needed only for the *other* half, `execution/operation.executor.ts`.
  *
  * # The dispatch table is the module
  *
@@ -21,43 +17,32 @@ import { type PrismaProjectionPlan } from "./projection.translator.js";
  *
  * # The negative half of the table is the load-bearing half
  *
- * {@link PrismaAction} deliberately **excludes** `findUniqueOrThrow` and
- * `findFirstOrThrow` (RC-2: core's outcome mapper owns the absence decision, and
- * an `OrThrow` call would move it into the adapter), `groupBy` and `aggregate`
- * (spec §18.5), and **every raw action** — the `findRaw`/`aggregateRaw` model
- * actions and the client's own raw methods — which C-853 forbids outright and
- * permanently. Aventara is not an ORM and reaches the database only through the
- * adapter's ORM; a raw statement would forfeit the ORM's own injection
- * protection and oblige Aventara to build its own. Because the exclusion lives in
- * the *type*, a raw call is not representable in a {@link PrismaExecutionPlan} at
- * all: the rule is enforced by the compiler, not by a reviewer's memory.
+ * Aventara is not an ORM and reaches the database only through the adapter's ORM;
+ * a raw statement would forfeit the ORM's own injection protection and oblige
+ * Aventara to build its own. Because the exclusion lives in the *type*, a raw call
+ * is not representable in a {@link PrismaExecutionPlan} at all: the rule is
+ * enforced by the compiler, not by a reviewer's memory.
  * `operation.translator.spec.ts` asserts the same thing from the value side, as
  * the belt to that type's braces.
  *
  * # `delete.many` is a hole in the table, and the hole is the decision
  *
- * 7.10.0 has no `deleteManyAndReturn` **[PKG]**, and the architect ruled the
- * variant **omitted rather than emulated** (C-829, D-826). `operations.deriver.ts`
- * therefore never advertises it, so core rejects the request with `A2002
- * UNKNOWN_OPERATION` before any adapter call. The table still carries the key —
- * it is total over core's grammar — with an `"unavailable"` entry, so the
- * omission is a fact a reader can find rather than an absence they have to infer.
+ * `operations.deriver.ts` therefore never advertises it, so core rejects the
+ * request with `A2002 UNKNOWN_OPERATION` before any adapter call. The table still
+ * carries the key — it is total over core's grammar — with an `"unavailable"`
+ * entry, so the omission is a fact a reader can find rather than an absence they
+ * have to infer.
  *
  * # First-style variants, and the write route
  *
- * `update.first` and `delete.first` are **framework-manufactured** (D-828): a
- * cross-ORM survey found the four-part shape — general filter, ordering decides
- * "first", effect limited to one row, the affected row is returned, all in one
- * call — essentially absent across ORM design, and Prisma 7.10.0 has no
+ * `update.first` and `delete.first` are **framework-manufactured**: a cross-ORM
+ * survey found the four-part shape — general filter, ordering decides "first",
+ * effect limited to one row, the affected row is returned, all in one call —
+ * essentially absent across ORM design, and Prisma 7.10.0 has no
  * `updateFirst`/`deleteFirst` **[PKG]**. So the plan is an ordinary read then
  * write, and its two steps are {@link PrismaExecutionPlan}'s `"emulated"` arm.
  *
- * **The write route is Route A — select-first + unique mutation — and Task 10
- * measured it rather than inheriting it.** T-7.1.1 recorded two routes and §14e
- * reserved the choice; §1.0 forbids an implementation task from blocking on an
- * owner decision, so Task 10 ran both against the real 7.10.0 client on **both**
- * engines. Every row came out for Route A, and two of them came out *against*
- * Route B:
+ * Every row came out for Route A, and two of them came out *against* Route B:
  *
  * ```text
  * measured 2026-10-02, @prisma/client 7.10.0, SQLite + PostgreSQL 18, identical
@@ -76,13 +61,8 @@ import { type PrismaProjectionPlan } from "./projection.translator.js";
  * B  deleteMany({ where: { id, AND: […] } })                    -> { count: 1 } — carries no row at all
  * ```
  *
- * So Route A is the mechanism spec §8.3's own worked example names, it satisfies
- * §8.2's return contract for **every** projection core can plan, and it needs no
- * pre-write projection read and no identifier strip. Route B cannot serve a
- * caller projection that reaches a to-many relation or `$count` at all, and its
- * `delete.first` must read before it writes. The route is **one entry** in the
- * table below — {@link FIRST_VARIANT_WRITE_ROUTE} — which is the seam D-801/§9
- * put here precisely so §14e's ratification (or reversal) is one edit.
+ * Route B cannot serve a caller projection that reaches a to-many relation or
+ * `$count` at all, and its `delete.first` must read before it writes.
  *
  * # The write step of an emulated plan is a template, and says so
  *
@@ -90,17 +70,15 @@ import { type PrismaProjectionPlan } from "./projection.translator.js";
  * step is **not**, by construction: its `where` carries the caller's re-asserted
  * predicate under `AND` and the identifier is added by
  * `execution/first-variant.emulator.ts` from the row the read returned. That is
- * what "emulated" means — the second statement is not knowable until the first
- * has run — and it is why the emulator, not this module, issues it.
- *
- * # Nothing is emitted that the framework did not send (C-855, D-830)
+ * what "emulated" means — the second statement is not knowable until the first has
+ * run — and it is why the emulator, not this module, issues it.
  *
  * Every key below is added only when the corresponding Aventara argument is
  * **present**. An absent argument and an `undefined` one are different arguments
  * to a provider, so `"take" in args` is never made true by accident. An argument
  * this module does not recognise raises rather than being dropped: an argument
- * that typechecks and is silently ignored is worse than an absent one, because
- * the absent one fails loudly at the caller (D-830's MikroORM evidence).
+ * that typechecks and is silently ignored is worse than an absent one, because the
+ * absent one fails loudly at the caller.
  */
 /** The `ModelAction` subset this adapter uses. See the header for the exclusions. */
 export type PrismaAction = "findUnique" | "findFirst" | "findMany" | "count" | "create" | "createMany" | "createManyAndReturn" | "update" | "updateMany" | "updateManyAndReturn" | "delete" | "deleteMany" | "upsert";
@@ -115,7 +93,7 @@ export type PrismaCall = {
     readonly action: PrismaAction;
     readonly args: Readonly<Record<string, unknown>>;
 };
-/** A variant is either one call, or an emulated sequence (§8.3, D-807). */
+/** A variant is either one call, or an emulated sequence. */
 export type PrismaExecutionPlan = {
     readonly kind: "single";
     readonly call: PrismaCall;
@@ -125,11 +103,11 @@ export type PrismaExecutionPlan = {
     readonly atomicity: "outer-tx" | "own-tx";
 };
 /**
- * What the variant owes its caller, and therefore which shaper runs (T-8).
+ * What the variant owes its caller, and therefore which shaper runs.
  *
- * It is a property of the *variant*, not of the provider answer, so it belongs
- * in the dispatch table beside the action rather than in a second table the
- * executor would have to keep in step.
+ * It is a property of the *variant*, not of the provider answer, so it belongs in
+ * the dispatch table beside the action rather than in a second table the executor
+ * would have to keep in step.
  */
 export type PrismaResultKind = "row" | "rows" | "count";
 export type PrismaVariantDispatch = {
@@ -145,7 +123,7 @@ export type PrismaVariantDispatch = {
     readonly kind: "unavailable";
     readonly reason: string;
 };
-/** The sixteen-variant dispatch table (T-7, §18.4), total over core's grammar. */
+/** The sixteen-variant dispatch table, total over core's grammar. */
 export declare const PRISMA_VARIANT_DISPATCH: {
     readonly "find.first": {
         readonly kind: "single";
@@ -216,7 +194,7 @@ export declare const PRISMA_VARIANT_DISPATCH: {
     };
     readonly "delete.many": {
         readonly kind: "unavailable";
-        readonly reason: "@prisma/client 7.10.0 has no deleteManyAndReturn, so delete.many is omitted rather than emulated (C-829, D-826); delete.count deletes a filtered set";
+        readonly reason: "@prisma/client 7.10.0 has no deleteManyAndReturn, so delete.many is omitted rather than emulated; delete.count deletes a filtered set";
     };
     readonly "delete.count": {
         readonly kind: "single";
@@ -237,13 +215,8 @@ export declare class PrismaOperationTranslationError extends Error {
  * The translation of one operation: the plan, plus the projection plan the result
  * shaper needs.
  *
- * T-7 names only `PrismaExecutionPlan`, and that is not enough on its own:
- * `AdapterOperation` carries no read plan **[CORE]**, so Task 8's
- * {@link PrismaProjectionPlan} — the reconstruction of where every `$count`
- * envelope sits — is produced *here*, while translating the projection, and
- * cannot be recovered from the emitted Prisma arguments afterwards (Prisma's
- * `_count` is a sibling key, not a position). Returning it beside the plan is
- * what keeps `result.shaper.ts` free of a second, drifting reconstruction.
+ * Returning it beside the plan is what keeps `result.shaper.ts` free of a second,
+ * drifting reconstruction.
  */
 export type PrismaOperationTranslation = {
     readonly plan: PrismaExecutionPlan;
@@ -251,9 +224,9 @@ export type PrismaOperationTranslation = {
     /**
      * The caller's `where`, translated, or `undefined` when they sent none.
      *
-     * Recorded for the emulator, which re-asserts it on the write (C-856, D-829).
-     * It is the same value the read step carries, by identity, so the two halves
-     * of the manufacture cannot assert different predicates.
+     * Recorded for the emulator, which re-asserts it on the write. It is the same
+     * value the read step carries, by identity, so the two halves of the manufacture
+     * cannot assert different predicates.
      */
     readonly predicate: Readonly<Record<string, unknown>> | undefined;
 };

package/dist/translation/operation.translator.js

@@ -3,32 +3,16 @@ import { translateMutationData } from "./mutation.translator.js";
 import { translateOrderBy, translatePagination, } from "./order-pagination.translator.js";
 import { translateProjection, } from "./projection.translator.js";
 import { translateWhere } from "./where.translator.js";
-/**
- * The chosen first-variant write route, in one place (§14e, T-7.1.1).
- *
- * Route A: the read selects the identifier, and the write is Prisma's own
- * `update`/`delete` narrowed to that identifier with the caller's predicate
- * re-asserted. Both are projection-carrying — their result maps through
- * `GetFindResult`, the same helper `findFirst` uses **[PKG,
- * `runtime/client.d.ts:1352`, `:1356`, `:1144`]** — and Task 10 measured both on
- * both engines (see the header). Switching to Route B is an edit to these two
- * cells and to `first-variant.emulator.ts`'s lost-row detection, and nothing else.
- */
 const FIRST_VARIANT_WRITE_ROUTE = {
     update: "update",
     delete: "delete",
 };
-/** The sixteen-variant dispatch table (T-7, §18.4), total over core's grammar. */
 export const PRISMA_VARIANT_DISPATCH = {
     "find.first": { kind: "single", action: "findFirst", result: "row" },
-    // RC-2: `findUnique` and a returned `null`, never `findUniqueOrThrow` — core's
-    // `OUTCOME_TABLE` owns the absence decision and maps the `null` to `A2003`.
     "find.unique": { kind: "single", action: "findUnique", result: "row" },
     "find.many": { kind: "single", action: "findMany", result: "rows" },
     "find.count": { kind: "single", action: "count", result: "count" },
     "create.one": { kind: "single", action: "create", result: "row" },
-    // C-817: the row-returning bulk write is what `create.many` owes its caller;
-    // `createMany` answers `{ count }` and is `create.count`'s call instead.
     "create.many": {
         kind: "single",
         action: "createManyAndReturn",
@@ -57,22 +41,14 @@ export const PRISMA_VARIANT_DISPATCH = {
     "delete.unique": { kind: "single", action: "delete", result: "row" },
     "delete.many": {
         kind: "unavailable",
-        reason: "@prisma/client 7.10.0 has no deleteManyAndReturn, so delete.many is omitted rather than emulated (C-829, D-826); delete.count deletes a filtered set",
+        reason: "@prisma/client 7.10.0 has no deleteManyAndReturn, so delete.many is omitted rather than emulated; delete.count deletes a filtered set",
     },
     "delete.count": { kind: "single", action: "deleteMany", result: "count" },
     "upsert.unique": { kind: "single", action: "upsert", result: "row" },
 };
-/** An operation the adapter will not translate. */
 export class PrismaOperationTranslationError extends Error {
     name = "PrismaOperationTranslationError";
 }
-/**
- * Translates one validated Aventara operation.
- *
- * @throws {PrismaOperationTranslationError} for a variant the adapter advertises
- * no call for, an argument it does not recognise, or a unique selector that
- * addresses no row — never a silently narrowed or widened call.
- */
 export function translateOperation(input) {
     const key = `${input.operation.family}.${input.operation.variant}`;
     const dispatch = Object.hasOwn(PRISMA_VARIANT_DISPATCH, key)
@@ -125,9 +101,6 @@ export function translateOperation(input) {
                     args: {
                         ...(predicate === undefined ? {} : { where: predicate }),
                         ...orderByArgument(context),
-                        // The read selects the identifier and nothing else: under Route A
-                        // the WRITE carries the caller's projection, so reading it twice
-                        // would be a statement the contract does not need.
                         select: identifierSelect(context),
                     },
                 },
@@ -135,8 +108,6 @@ export function translateOperation(input) {
                     model: context.resource,
                     action: dispatch.write,
                     args: {
-                        // A template: the identifier is added by the emulator from the row
-                        // the read returned. `AND` carries the re-assertion (C-856, D-829).
                         ...(predicate === undefined ? {} : { where: { AND: predicate } }),
                         ...(context.operation.family === "update"
                             ? { data: mutationData(context, "update", "data") }
@@ -151,12 +122,6 @@ export function translateOperation(input) {
         predicate,
     };
 }
-/**
- * The four variants whose `where` is core's FLAT unique selector rather than a
- * general predicate, read from core's own rule: `hasGeneralRootWhere` is false
- * for exactly `find.unique`, `update.unique`, `delete.unique` and `upsert.unique`
- * **[CORE, operations/operation-validator.ts]**.
- */
 function isUniqueSelectorVariant(key) {
     return (key === "find.unique" ||
         key === "update.unique" ||
@@ -224,7 +189,6 @@ function singleCallArguments(context, key, predicate, projectionArgs) {
             throw new PrismaOperationTranslationError(`"${key}" has a dispatch entry and no argument shape, which is a translator defect`);
     }
 }
-/** Core's flat unique selector → `<M>WhereUniqueInput`, at the top level. */
 function uniqueWhere(context) {
     const selector = context.args.where;
     if (!isRecord(selector)) {
@@ -234,10 +198,6 @@ function uniqueWhere(context) {
         addresses: identifiersOf(context, context.resource),
         values: selector,
         match: "exact",
-        // A unique selector's values are scalars core has already normalized. The
-        // one conversion C-834 names — a core `Decimal`, which Prisma refuses — is
-        // NOT applied here, and that is a recorded gap rather than an omission: see
-        // `operation.executor.ts`'s header.
         emit: (_member, value) => value,
     });
     if (addressed === undefined) {
@@ -245,7 +205,6 @@ function uniqueWhere(context) {
     }
     return addressed.where;
 }
-/** The identifier the first-style read selects: the first recorded criterion. */
 function identifierSelect(context) {
     const [address] = identifiersOf(context, context.resource);
     if (address === undefined) {
@@ -293,7 +252,6 @@ function mutationData(context, stage, argument) {
         data: context.args[argument],
     }, mutationDependencies(context));
 }
-/** `create.many`/`create.count` carry an ARRAY of records **[CORE]**. */
 function bulkMutationData(context, key, stage) {
     const data = context.args.data;
     if (!Array.isArray(data)) {
@@ -317,14 +275,6 @@ function mutationDependencies(context) {
         ])),
     };
 }
-/**
- * Task 7's vocabulary, as the projection translator's one dependency.
- *
- * The nested arguments are translated against the **target** Resource, which the
- * projection path names: `projection.translator.ts` owns where a relation sits
- * and this closure owns what its arguments mean, which is the seam that keeps the
- * `_count` filter the *same* translated `where` the relation read uses.
- */
 function relationArgumentTranslator(context) {
     return (args, { path }) => {
         const target = resolveRelationTarget(context, path);