@aventara/prisma7-adapter 0.1.0-pilot.0

package/dist/prisma-client.interface.d.ts

@@ -0,0 +1,48 @@
+import type { PrismaIsolationLevel } from "./provider/provider-profile.js";
+/**
+ * T-1 — the minimal structural shape the adapter actually uses, rather than
+ * the full generated client type. This is the seam that keeps the adapter
+ * compilable with no generated client in scope and testable with a recording
+ * double.
+ *
+ * **Why there is no `[model: string]` index signature here, though T-1
+ * describes the host as "an index of model delegates plus `$transaction`":**
+ * a generated `PrismaClient` is a *class*, and TypeScript grants an implicit
+ * index signature only to object-literal type aliases. Observed on 2026-09-23
+ * with the real generated client and `tsc -p tsconfig.typecheck.json`:
+ *
+ *   error TS2322: Type 'PrismaClient' is not assignable to type 'HostWithIndex'.
+ *     Index signature for type 'string' is missing in type
+ *     'PrismaClient<never, GlobalOmitConfig | undefined, DefaultArgs>'.
+ *
+ * The same probe with the index signature removed compiled clean. So the
+ * public constraint declares only `$transaction`, and the delegate index is
+ * reached through `prismaDelegates()` below — one named seam, in one place,
+ * instead of a constraint no real client can satisfy.
+ */
+/** Adapter-owned transaction options; never Aventara public configuration (D-806). */
+export type PrismaTransactionOptions = {
+    /** Prisma's own default is 2000 ms **[PKG, `runtime/client.d.ts`]**. */
+    readonly maxWait?: number;
+    /** Prisma's own default is 5000 ms **[PKG, `runtime/client.d.ts`]**. */
+    readonly timeout?: number;
+    readonly isolationLevel?: PrismaIsolationLevel;
+};
+/** One Prisma model delegate, as far as the adapter is concerned. */
+export type PrismaDelegate = Readonly<Record<string, unknown>>;
+/**
+ * The host the adapter is handed. `$transaction` is declared in its callback
+ * form only: the array overload is never reached (C-803, spec §14.5).
+ */
+export interface PrismaDelegateHost {
+    $transaction<T>(work: (transactional: PrismaDelegateHost) => Promise<T>, options?: PrismaTransactionOptions): Promise<T>;
+}
+/** The delegate index view of a host. */
+export type PrismaDelegateIndex = Readonly<Record<string, PrismaDelegate | undefined>>;
+/**
+ * The single place the structural gap between a generated client (a class,
+ * with no index signature) and a delegate index is crossed. Every delegate
+ * lookup in the adapter goes through here, so there is exactly one assertion
+ * to audit rather than one per call site.
+ */
+export declare function prismaDelegates(client: PrismaDelegateHost): PrismaDelegateIndex;

package/dist/prisma-client.interface.js

@@ -0,0 +1,9 @@
+/**
+ * The single place the structural gap between a generated client (a class,
+ * with no index signature) and a delegate index is crossed. Every delegate
+ * lookup in the adapter goes through here, so there is exactly one assertion
+ * to audit rather than one per call site.
+ */
+export function prismaDelegates(client) {
+    return client;
+}

package/dist/prisma.adapter.d.ts

@@ -0,0 +1,55 @@
+import type { Adapter } from "@aventara/core";
+import type { PrismaAdapterModel, PrismaDiscoveryArtifact } from "./discovery/discovery-artifact.interface.js";
+import type { PrismaDelegateHost, PrismaTransactionOptions } from "./prisma-client.interface.js";
+import { type PrismaDriver, type PrismaProvider } from "./provider/provider-profile.js";
+/**
+ * T-1 — the adapter's only public entry point, and the composition root.
+ *
+ * `TClient` stays generic so a caller's generated client type flows through
+ * without this package naming it: `client` is the one and only place a Prisma
+ * type enters the public surface, and it enters as the caller's own parameter
+ * (C-802).
+ */
+export type PrismaAdapterOptions<TClient extends PrismaDelegateHost, M extends PrismaAdapterModel = PrismaAdapterModel> = {
+    /** Application-owned, already-constructed client (spec §18.2). */
+    readonly client: TClient;
+    /**
+     * The generate-time discovery artifact this adapter loads and checks
+     * (D-802, T-3.2).
+     *
+     * This is the one and only inference site for `M`: the emitted artifact
+     * module's `model` is a literal type, and `PrismaDiscoveryArtifact<M>`
+     * expands to a bare `model: M` property so the compiler reads that literal
+     * off the argument. Route `M` through a conditional or a mapped type here
+     * and it stops inferring, falls back to its default with **no compile
+     * error**, and every narrowing downstream of the model quietly widens to
+     * `string` — the trap core hit at S2 with `Cfg`.
+     */
+    readonly discovery: PrismaDiscoveryArtifact<M>;
+    /** Declared, never sniffed from client internals (D-804). */
+    readonly provider: PrismaProvider;
+    readonly driver: PrismaDriver;
+    /** Adapter-owned, never Aventara public configuration (D-806). */
+    readonly transactionOptions?: PrismaTransactionOptions;
+};
+/**
+ * The installed client's version, resolved by the caller.
+ *
+ * `@prisma/client` is a *peer* dependency, so the version that matters is the
+ * one installed beside the application, not beside this package. The caller
+ * supplies it; `createPrismaAdapter` does not go looking, which is also what
+ * keeps the construction path free of Prisma tooling.
+ */
+export type PrismaAdapterConstruction<TClient extends PrismaDelegateHost, M extends PrismaAdapterModel = PrismaAdapterModel> = PrismaAdapterOptions<TClient, M> & {
+    readonly installedPrismaVersion?: string;
+};
+/**
+ * Construction is `async` because core's `Adapter.model` is a settled fact read
+ * synchronously at framework construction, while *verifying* the artifact is
+ * asynchronous: `computeModelHash` digests through `globalThis.crypto.subtle`,
+ * which is a promise-returning API. The artifact itself is already a value in
+ * hand (`options.discovery`); only its verification has to
+ * await, so it happens here, once, before an adapter exists — every fence is
+ * the same fence, moved from the first `discover()` call to construction.
+ */
+export declare function createPrismaAdapter<TClient extends PrismaDelegateHost, M extends PrismaAdapterModel = PrismaAdapterModel>(options: PrismaAdapterConstruction<TClient, M>): Promise<Adapter<M>>;

package/dist/prisma.adapter.js

@@ -0,0 +1,105 @@
+import { loadDiscoveryArtifact } from "./discovery/artifact.loader.js";
+import { createPrismaOperationExecutor } from "./execution/operation.executor.js";
+import { createPrismaTransactionExecutor } from "./execution/transaction.executor.js";
+import { resolveProviderProfile, } from "./provider/provider-profile.js";
+/**
+ * Each Prisma referential action as core's word for it (F-806). Keyed by the
+ * closed {@link PrismaReferentialAction} union with `satisfies`, so a sixth
+ * Prisma action is a compile error here rather than an edge core never follows,
+ * and valued by core's own union, so a word core does not have is one too. The
+ * mapping is one to one (the architect's five words, 2026-10-04): `no-action`
+ * stays `noAction` although, measured on both engines (Phase 9 S0, U4), it is not
+ * `DEFERRABLE` and answers one delete exactly as `restrict` does; `set-default`
+ * stays `setDefault` although, like `setNull`, it keeps the rows.
+ */
+const DELETE_EFFECTS = {
+    cascade: "cascade",
+    restrict: "restrict",
+    "no-action": "noAction",
+    "set-null": "setNull",
+    "set-default": "setDefault",
+};
+/**
+ * The artifact's referential actions, translated into core's vocabulary.
+ *
+ * The direction is carried over unchanged, because it is the same sentence on
+ * both sides of the seam: an edge listed under Resource `R` says **deleting a
+ * `target` row does `onDelete` to rows of `R`**. Only owning edges exist in the
+ * artifact, and `onUpdate` is not carried: core plans the delete closure only.
+ */
+function translateReferentialActions(table) {
+    return Object.fromEntries(Object.entries(table).map(([resource, { owningEdges }]) => [
+        resource,
+        owningEdges.map((edge) => ({
+            field: edge.field,
+            target: edge.target,
+            onDelete: DELETE_EFFECTS[edge.onDelete],
+        })),
+    ]));
+}
+/**
+ * Construction is `async` because core's `Adapter.model` is a settled fact read
+ * synchronously at framework construction, while *verifying* the artifact is
+ * asynchronous: `computeModelHash` digests through `globalThis.crypto.subtle`,
+ * which is a promise-returning API. The artifact itself is already a value in
+ * hand (`options.discovery`); only its verification has to
+ * await, so it happens here, once, before an adapter exists — every fence is
+ * the same fence, moved from the first `discover()` call to construction.
+ */
+export async function createPrismaAdapter(options) {
+    const profile = resolveProviderProfile({
+        provider: options.provider,
+        driver: options.driver,
+    });
+    // The loader is a *verifier*, and its return is deliberately discarded. It
+    // takes `unknown` because it guards the runtime boundary, so its answer is
+    // the general `PrismaAdapterModel`; the literal `M` is already in hand on
+    // `options.discovery.model`, which is the very object the loader would have
+    // handed back. Reading it from the argument keeps the literal without a
+    // cast, and keeps the loader honest about validating untrusted input.
+    await loadDiscoveryArtifact({
+        artifact: options.discovery,
+        installedPrismaVersion: options.installedPrismaVersion ?? options.discovery.prismaVersion,
+    });
+    const model = options.discovery.model;
+    // Read once, like the model: a settled fact of the constructed adapter.
+    const referentialActions = translateReferentialActions(options.discovery.referentialActions);
+    // Task 10: `execute` is real. The executor is built once, at construction, and
+    // closes over the client, the discovered model and the generate-time
+    // translation table — the three facts every call needs and none of which can
+    // change afterwards.
+    //
+    // `translation` is widened by one deliberate cast. `PrismaTranslationTable<M>`
+    // is a mapped type over `M`'s own resource keys, which is exactly what makes a
+    // missing Resource a compile error at the generate step; a mapped type over a
+    // literal union carries no index signature, so the executor — which looks a
+    // Resource up by a name core validated — takes the widened view. The narrow
+    // type has already done its work by the time this line runs.
+    const { execute } = createPrismaOperationExecutor({
+        client: options.client,
+        model: options.discovery.model,
+        translation: options.discovery.translation,
+        scope: "root",
+        ...(options.transactionOptions === undefined
+            ? {}
+            : { transactionOptions: options.transactionOptions }),
+    });
+    // DA-12: `transaction` is mounted exactly when the declared driver supports
+    // an interactive one. For `@prisma/adapter-d1` the profile says `"none"`
+    // [PKG], so core never calls it and the `_transactions` route is never
+    // mounted. The declaration is Task 10's (D-805) and the body is Task 11's:
+    // one interactive transaction per plan, with the transaction-scoped executor
+    // as the only thing the callback hands core (C-803, C-804).
+    if (profile.transactions === "none") {
+        return { model, referentialActions, execute };
+    }
+    const transaction = createPrismaTransactionExecutor({
+        client: options.client,
+        model: options.discovery.model,
+        translation: options.discovery.translation,
+        ...(options.transactionOptions === undefined
+            ? {}
+            : { transactionOptions: options.transactionOptions }),
+    });
+    return { model, referentialActions, execute, transaction };
+}

package/dist/provider/provider-profile.d.ts

@@ -0,0 +1,53 @@
+import type { TransactionCapability } from "@aventara/core";
+/**
+ * T-2 / D-824 — the one closed table of provider and driver facts, carrying
+ * **only** the facts no reader can supply.
+ *
+ * What is deliberately absent: `supportsScalarLists`, `supportsOrderNulls`,
+ * `supportsCreateManyAndReturn` and `supportsUpdateManyAndReturn` are
+ * *discovered* from the generated client's own types at generate time and
+ * recorded in `PrismaDiscoveryArtifact` (T-3, T-3.2); `supportsEmulatedFirst
+ * Variants` is *derived* — it is exactly `transactions !== "none"` — and is
+ * computed where the §8.3 gate lives. A stored copy of either class would be a
+ * second source of truth, which is dictionary invariant 6.
+ *
+ * Nothing here is inferred at runtime, because nothing here is derived at
+ * runtime at all.
+ */
+/**
+ * The two engines Phase 8 runs — a value, so the bin's `--provider` check and
+ * the manifest's declaration drift guard (`declaration-drift.gate.spec.ts`)
+ * read the same list the type is derived from.
+ */
+export declare const PRISMA_PROVIDERS: readonly ["sqlite", "postgresql"];
+export type PrismaProvider = (typeof PRISMA_PROVIDERS)[number];
+/**
+ * The closed driver set. Neon-HTTP and PlanetScale-HTTP are **absent**, not
+ * `false`: their interactive-transaction support is genuinely UNVERIFIED for
+ * Prisma 7 (C-825 — no adapter package is installed, neither driver is in
+ * Phase 8's engine split, and all three v7 driver-adapter documentation pages
+ * returned HTTP 404), and an entry with no evidence is a guess.
+ */
+export declare const PRISMA_DRIVERS: readonly ["@prisma/adapter-better-sqlite3", "@prisma/adapter-pg", "@prisma/adapter-d1"];
+export type PrismaDriver = (typeof PRISMA_DRIVERS)[number];
+/** The five levels `Prisma.IsolationLevel` admits **[PKG, `runtime/client.d.ts`]**. */
+export type PrismaIsolationLevel = "ReadUncommitted" | "ReadCommitted" | "RepeatableRead" | "Snapshot" | "Serializable";
+/** The caller's explicit declaration; never sniffed from client internals (D-804). */
+export type PrismaProviderDeclaration = {
+    readonly provider: PrismaProvider;
+    readonly driver: PrismaDriver;
+};
+/**
+ * The resolved profile. Three members, and three only — see the type comment
+ * above for what is discovered or derived instead.
+ */
+export type PrismaProviderProfile = {
+    readonly provider: PrismaProvider;
+    readonly transactions: TransactionCapability;
+    readonly isolationLevels: readonly PrismaIsolationLevel[];
+};
+/**
+ * Resolves the profile for a declaration. Pure, total over the closed sets,
+ * and the only place provider truth is read.
+ */
+export declare function resolveProviderProfile(declaration: PrismaProviderDeclaration): PrismaProviderProfile;

package/dist/provider/provider-profile.js

@@ -0,0 +1,91 @@
+/**
+ * T-2 / D-824 — the one closed table of provider and driver facts, carrying
+ * **only** the facts no reader can supply.
+ *
+ * What is deliberately absent: `supportsScalarLists`, `supportsOrderNulls`,
+ * `supportsCreateManyAndReturn` and `supportsUpdateManyAndReturn` are
+ * *discovered* from the generated client's own types at generate time and
+ * recorded in `PrismaDiscoveryArtifact` (T-3, T-3.2); `supportsEmulatedFirst
+ * Variants` is *derived* — it is exactly `transactions !== "none"` — and is
+ * computed where the §8.3 gate lives. A stored copy of either class would be a
+ * second source of truth, which is dictionary invariant 6.
+ *
+ * Nothing here is inferred at runtime, because nothing here is derived at
+ * runtime at all.
+ */
+/**
+ * The two engines Phase 8 runs — a value, so the bin's `--provider` check and
+ * the manifest's declaration drift guard (`declaration-drift.gate.spec.ts`)
+ * read the same list the type is derived from.
+ */
+export const PRISMA_PROVIDERS = ["sqlite", "postgresql"];
+/**
+ * The closed driver set. Neon-HTTP and PlanetScale-HTTP are **absent**, not
+ * `false`: their interactive-transaction support is genuinely UNVERIFIED for
+ * Prisma 7 (C-825 — no adapter package is installed, neither driver is in
+ * Phase 8's engine split, and all three v7 driver-adapter documentation pages
+ * returned HTTP 404), and an entry with no evidence is a guess.
+ */
+export const PRISMA_DRIVERS = [
+    "@prisma/adapter-better-sqlite3",
+    "@prisma/adapter-pg",
+    "@prisma/adapter-d1",
+];
+/**
+ * `transactions` is a **DRIVER** fact, and each row carries its evidence.
+ *
+ * - `@prisma/adapter-d1` → `"none"` **[PKG]**: `runtime/client.js` of
+ *   `@prisma/client` 7.10.0 branches on
+ *   `this._engineConfig.adapter?.adapterName === "@prisma/adapter-d1"` and
+ *   throws `"Cloudflare D1 does not support interactive transactions. …"`.
+ *   Read from the installed package on 2026-09-23 (C-824, F-703).
+ * - `@prisma/adapter-better-sqlite3` and `@prisma/adapter-pg` →
+ *   `"interactive"` **[RUN8]**: observed, not assumed. D-805 conditions this
+ *   value on an interactive transaction having been *proved to run* on each
+ *   driver, and `src/provider/interactive-transaction.spec.ts` runs one — a
+ *   write and a read issued through the callback's `tx`, with the write
+ *   visible afterwards — on both. Produced by
+ *   `AVENTARA_TEST_POSTGRES_URL=postgresql://aventara:aventara_dev@127.0.0.1:5432/aventara
+ *    npx vitest run --config ../../vitest.config.mts --root .
+ *    src/provider/interactive-transaction.spec.ts --reporter=verbose`
+ *   from `packages/prisma7-adapter`, which is what the relative `--config` path
+ *   and `--root .` are relative to. Run on 2026-09-23 against `@prisma/client`
+ *   7.10.0, Node v24.20.0, SQLite through better-sqlite3 12.11.1 and
+ *   PostgreSQL 18.6: 4 passed, and 2 of those 4 skip when the URL is absent, so
+ *   the PostgreSQL half is not a silent pass. Re-run as written on 2026-10-02
+ *   after the config's `.mts` rename (`aba66a2`): 4 passed, and 2 passed with
+ *   2 skipped without the URL.
+ */
+const DRIVER_TRANSACTIONS = {
+    "@prisma/adapter-better-sqlite3": "interactive",
+    "@prisma/adapter-pg": "interactive",
+    "@prisma/adapter-d1": "none",
+};
+/**
+ * `isolationLevels` is a **PROVIDER** fact **[DOC7]**, fetched 2026-09-23 from
+ * the version-pinned `prisma.io/docs/orm/v7/…/queries/transactions` page:
+ * PostgreSQL supports ReadUncommitted, ReadCommitted, RepeatableRead and
+ * Serializable; SQLite supports Serializable only. `Snapshot` is a SQL Server
+ * level and belongs to neither Phase 8 engine, so it appears in the level
+ * union (it is one of the five Prisma admits) and in no row.
+ */
+const PROVIDER_ISOLATION_LEVELS = {
+    sqlite: ["Serializable"],
+    postgresql: [
+        "ReadUncommitted",
+        "ReadCommitted",
+        "RepeatableRead",
+        "Serializable",
+    ],
+};
+/**
+ * Resolves the profile for a declaration. Pure, total over the closed sets,
+ * and the only place provider truth is read.
+ */
+export function resolveProviderProfile(declaration) {
+    return {
+        provider: declaration.provider,
+        transactions: DRIVER_TRANSACTIONS[declaration.driver],
+        isolationLevels: PROVIDER_ISOLATION_LEVELS[declaration.provider],
+    };
+}

package/dist/translation/identifier.addressing.d.ts

@@ -0,0 +1,80 @@
+import type { PrismaIdentifierAddress } from "../discovery/discovery-artifact.interface.js";
+/**
+ * The one owner of **core's flat identifier → Prisma's addressed
+ * `<M>WhereUniqueInput`**.
+ *
+ * # Why this module exists at all
+ *
+ * The rule is three facts, every one of them measured at 7.10.0 and recorded in
+ * {@link PrismaIdentifierAddress}: the generate-time `key` is matched and never
+ * re-derived (`members.join("_")` is wrong for every `name:`-renamed criterion),
+ * a key wraps its members iff `members.length > 1`, and the identifier chosen is
+ * the first recorded criterion the caller's values complete.
+ *
+ * Task 9 flagged that the rule had landed twice — `addressCursor` in
+ * `order-pagination.translator.ts` and `addressUnique` in
+ * `mutation.translator.ts` — and Task 10 needed it a third time, for the
+ * top-level where-unique of `find.unique`, `update.unique`, `delete.unique` and
+ * `upsert.unique`. Three copies of a measured rule is three places a later
+ * maintainer can fix two of, so the rule moved here and the three call sites
+ * became three *configurations* of it.
+ *
+ * # What the call sites still own, and why that is not a leak
+ *
+ * Two things differ between them and neither can be collapsed:
+ *
+ * - **How complete the values must be.** A unique selector is `"exact"`: core's
+ *   selector carries one identifier and nothing else, so a selector with a spare
+ *   key is not that identifier. A cursor is `"subset"`: `validateCursor` requires
+ *   the cursor's keys to equal the *active ordered scalar fields*, which include
+ *   a complete identifier **plus** every other ordered key, so the identifier is
+ *   a proper subset of what arrives.
+ * - **How a member's value is emitted.** `mutation.translator.ts` runs each
+ *   member through C-834's outbound scalar conversion (a core `Decimal` must
+ *   leave as a base-10 string); a cursor's values are already Prisma-shaped.
+ *   Passing the conversion in as `emit` keeps the scalar table in the module that
+ *   owns it rather than importing it here.
+ *
+ * # No spec file of its own, deliberately
+ *
+ * Every branch is exercised through its three callers' specs —
+ * `order-pagination.translator.spec.ts` (subset, compound wrapping, the
+ * "addresses no row" refusal), `mutation.translator.spec.ts` (exact, renamed
+ * keys, Decimal members) and `operation.translator.spec.ts` (exact, at the top
+ * level). A fourth spec restating them would test this module's three lines
+ * twice and the measured facts not at all.
+ */
+/**
+ * How completely the supplied values must cover a criterion.
+ *
+ * `"exact"` — the values are exactly one identifier: every member present and no
+ * other key. `"subset"` — the values may carry more keys than the criterion's
+ * members, and the criterion matches when all of its members are present.
+ */
+export type PrismaIdentifierMatch = "exact" | "subset";
+/** One member's value, on the way out to Prisma. */
+export type PrismaIdentifierMemberEmitter = (member: string, value: unknown) => unknown;
+export type PrismaIdentifierAddressing = {
+    /** The recorded criterion that matched. */
+    readonly address: PrismaIdentifierAddress;
+    /**
+     * The `<M>WhereUniqueInput` fragment: `{ [key]: value }` for a single-column
+     * criterion, `{ [key]: { …members } }` for a compound one.
+     */
+    readonly where: Readonly<Record<string, unknown>>;
+};
+export type PrismaIdentifierAddressingInput = {
+    /** The Resource's criteria, in discovery order — the first match wins. */
+    readonly addresses: readonly PrismaIdentifierAddress[];
+    readonly values: Readonly<Record<string, unknown>>;
+    readonly match: PrismaIdentifierMatch;
+    readonly emit: PrismaIdentifierMemberEmitter;
+};
+/**
+ * Addresses one row by the first recorded criterion the values complete.
+ *
+ * @returns the addressing, or `undefined` when no criterion is complete — which
+ * is a caller-specific refusal (each call site raises its own error type with
+ * its own path), never a silently unaddressed write.
+ */
+export declare function addressIdentifier(input: PrismaIdentifierAddressingInput): PrismaIdentifierAddressing | undefined;

package/dist/translation/identifier.addressing.js

@@ -0,0 +1,30 @@
+/**
+ * Addresses one row by the first recorded criterion the values complete.
+ *
+ * @returns the addressing, or `undefined` when no criterion is complete — which
+ * is a caller-specific refusal (each call site raises its own error type with
+ * its own path), never a silently unaddressed write.
+ */
+export function addressIdentifier(input) {
+    const keyCount = Object.keys(input.values).length;
+    for (const address of input.addresses) {
+        if (input.match === "exact" && address.members.length !== keyCount) {
+            continue;
+        }
+        if (!address.members.every((member) => Object.hasOwn(input.values, member))) {
+            continue;
+        }
+        const members = address.members.map((member) => [member, input.emit(member, input.values[member])]);
+        const [single] = members;
+        // A single-column criterion does NOT wrap, and a compound one does. The
+        // difference is `members.length`, read off the recorded criterion rather
+        // than guessed from the shape of the value.
+        return {
+            address,
+            where: members.length === 1 && single !== undefined
+                ? { [address.key]: single[1] }
+                : { [address.key]: Object.fromEntries(members) },
+        };
+    }
+    return undefined;
+}

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

@@ -0,0 +1,115 @@
+import { type AdapterModel, type OperationIdentity } from "@aventara/core";
+import type { PrismaIdentifierAddress } from "../discovery/discovery-artifact.interface.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 declare class PrismaMutationTranslationError extends Error {
+    readonly name = "PrismaMutationTranslationError";
+}
+/**
+ * A Prisma write argument, as plain data: `<M>CreateInput`, `<M>UpdateInput`,
+ * `<M>CreateManyInput` or `<M>UpdateManyMutationInput` depending on the
+ * operation the translation was asked for.
+ */
+export type PrismaMutationData = Readonly<Record<string, unknown>>;
+/** The two write stages core distinguishes. */
+export type PrismaWriteStage = "create" | "update";
+/**
+ * Task 7's `where` translator, injected rather than imported so this module
+ * stays a pure function of its inputs and the filter grammar keeps one owner
+ * (the same shape `projection.translator.ts` uses for the same reason).
+ */
+export type PrismaNestedWhereTranslator = (resource: string, where: unknown, path: string) => Readonly<Record<string, unknown>>;
+export type PrismaMutationDependencies = {
+    readonly translateWhere: PrismaNestedWhereTranslator;
+    /**
+     * Prisma addressing per Resource, from the generate-time translation table
+     * (`PrismaDiscoveryArtifact.translation`). Required, because a nested
+     * `connect` is a `<T>WhereUniqueInput` and core's unique selector is FLAT: a
+     * compound identifier must be wrapped under its recorded key. Measured on
+     * both engines (2026-10-02) — the flat form is refused outright:
+     * *"Argument `connect`: Invalid value provided. Expected
+     * MetricWhereUniqueInput[], provided Object."*
+     */
+    readonly identifiers: Readonly<Record<string, readonly PrismaIdentifierAddress[]>>;
+};
+export type MutationTranslation = {
+    /** The discovered model: field kinds, cardinalities, targets and capabilities. */
+    readonly model: AdapterModel;
+    /** The Aventara Resource key the data is written against. */
+    readonly resource: string;
+    /** The operation whose argument this data becomes; it decides C-818 admission. */
+    readonly operation: OperationIdentity;
+    /** Which of that operation's write stages this data is (`upsert.unique` has two). */
+    readonly stage: PrismaWriteStage;
+    /** A validated Aventara `CreateDataInput` / `UpdateDataInput`, as plain data. */
+    readonly data: unknown;
+};
+/**
+ * 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 declare function translateMutationData(input: MutationTranslation, dependencies: PrismaMutationDependencies): PrismaMutationData;