@aventara/prisma7-adapter 0.1.0-pilot.3 → 0.1.0-pilot.4

package/dist/generate/prisma.generate.d.ts

@@ -5,63 +5,15 @@ import type { PrismaProvider } from "../provider/provider-profile.js";
 import type { PrismaEntityAbsence } from "./existence.gate.js";
 import { type PrismaCli } from "./prisma-cli.resolver.js";
 import type { PrismaReaderExemption } from "./reader-crosscheck.js";
-/**
- * Nothing under `execution/`, and nothing in `discovery/artifact.loader.ts`,
- * imports it; the package's build `exclude` keeps `src/generate/**` out of `dist`
- * entirely, so a deployed application never carries `typescript`, a PSL reader or
- * a child process.
- *
- * **The order is fixed, and each step earns its place:**
- *
- * 1. **The pinned `prisma` major**. PSL's grammar and the generated client's shape
- *    are version-bound; a major this reader has never seen must stop the build
- *    rather than produce a wrong `AdapterModel` from a grammar nobody read.
- * 2. **`@prisma/client/runtime/client` resolves**. This one is first among equals,
- *    because its failure is *silent*: every generated file opens `// @ts-nocheck`,
- *    so with the runtime unresolvable a TypeScript program over the generated tree
- *    reports **zero** diagnostics while `FieldRef` degrades to its uninstantiated
- *    form and `JsonValue` stops being a union — flipping a types-derived
- *    nullability from `true` to `false` with nothing anywhere to say so
- *    **[RUN8]**. The guard is therefore a module *resolution*, never a diagnostic
- *    count: a diagnostic count is exactly the instrument that reads clean in this
- *    failure.
- * 3. **`prisma generate`**, run by this step itself. The two sources must describe
- *    one instant; a client generated by some earlier command may describe an older
- *    schema, and nothing downstream could tell.
- * 4. **Both sources read in that same run** — PSL for the semantic model, the 🟢
- *    generated types for the capability surface and for existence.
- * 5. **The structural checks, in that order.** The existence gate first, because
- *    it decides *which* entities exist and a cross-check of an entity nobody
- *    admitted is noise; then the reader-versus-reader cross-check
- *    (`reader-crosscheck.ts`), which answers the reverse direction the gate hands
- *    it and every other fact both sources carry. Its findings stop the step; its
- *    two documented exemptions are reported and carried out on the result.
- * 6. **Emit** one TypeScript module.
- *
- * **The two readers fail differently, and the step keeps them different.** A PSL
- * `unhandled` entry means *I located a token I do not model*: there is a
- * construct, a spelling and a site to report, so they are aggregated and reported
- * together. A types-reader failure means *I cannot read the surface at all*: there
- * is nothing to record, so it throws. Inventing an `unhandled` vocabulary for the
- * type surface would be a second parallel representation of "something went wrong"
- * for no gain.
- */
-/** The `prisma` major this reader's grammar was written against. */
+/** The Prisma major this package generates for. */
 export declare const PINNED_PRISMA_MAJOR = 7;
+/** Thrown when the generate step refuses; the message says why and what to change. */
 export declare class PrismaGenerateStepError extends Error {
     readonly name = "PrismaGenerateStepError";
 }
 /**
- * What composition produces: the three halves the artifact carries.
- *
- * They are composed together and emitted apart. The `model` is core's — hashed
- * and Contract-bound — while `translation` is the adapter's Prisma addressing and
- * `referentialActions` is what the schema's resolved `@relation(onDelete:)` and
- * `@relation(onUpdate:)` arguments say. Neither of the latter two is part of the
- * model, so both stay out of the hash: a `@@unique(name:)` rename must not move
- * the Contract identity, and core has no referential-action vocabulary for a
- * Contract to carry. All three come from one pass over one field list, so they
- * cannot disagree about which identifiers or which edges exist.
+ * What composition produces: the model, Prisma addressing, referential actions
+ * and create requirements the artifact carries.
  */
 export type PrismaComposedArtifact = {
     readonly model: PrismaAdapterModel;
@@ -69,27 +21,15 @@ export type PrismaComposedArtifact = {
     readonly referentialActions: PrismaReferentialActionTable;
     readonly createRequirements: PrismaCreateRequirementTable;
 };
-/**
- * Composition of the two readers' facts into the artifact's two halves.
- *
- * It is a parameter rather than a call, because composition is
- * `discovery/model.discoverer.ts`'s and this step's job is order and refusal over
- * external effects. The step hands over only what it has verified: both readers'
- * output, and the resource names the existence gate admitted.
- */
+/** Composes the schema's and the generated client's facts into the artifact's contents. */
 export type PrismaModelComposer = (input: {
     readonly facts: PrismaSchemaFacts;
     readonly surface: PrismaCapabilitySurface;
     readonly admitted: readonly string[];
 }) => PrismaComposedArtifact;
 /**
- * The step's external world, in one record.
- *
- * Every member is an effect this package does not own — a child process, a
- * version on disk, a module resolution, a file write — which is why they are
- * injectable: the step's contract is the *order* it performs them in and the
- * points at which it refuses, and neither is observable when the effects are
- * unobservable. {@link createPrismaGenerateToolchain} is the real one.
+ * The generate step's external effects: running Prisma, reading files and
+ * writing the artifact. Replace it only to change how those effects happen.
  */
 export type PrismaGenerateToolchain = {
     readonly installedPrismaVersion: () => Promise<string>;
@@ -99,10 +39,10 @@ export type PrismaGenerateToolchain = {
     readonly readSurface: (clientDirectory: string) => PrismaCapabilitySurface;
     readonly writeArtifact: (file: string, source: string) => Promise<void>;
 };
+/** What {@link runPrismaGenerateStep} needs. */
 export type PrismaGenerateRequest = {
     /** The `schema.prisma` file, or a Prisma 7 schema folder. */
     readonly schema: string;
-    /** The generator's `output` directory: the 🟢 files' root. */
     readonly clientDirectory: string;
     readonly provider: PrismaProvider;
     /** Where the emitted TypeScript artifact module is written. */
@@ -110,25 +50,17 @@ export type PrismaGenerateRequest = {
     readonly composeModel: PrismaModelComposer;
     readonly toolchain?: PrismaGenerateToolchain;
 };
+/** What {@link runPrismaGenerateStep} produced. */
 export type PrismaGenerateResult = {
     readonly artifactFile: string;
     /** The emitted module's exact bytes. */
     readonly source: string;
     readonly modelHash: string;
-    /** Resource names the 🟢 types admitted, in PSL declaration order. */
     readonly admitted: readonly string[];
     /** PSL-only entities the schema itself explained away. */
     readonly excluded: readonly PrismaEntityAbsence[];
-    /**
-     * Carried out rather than swallowed, so a caller can print them and a spec can
-     * assert them by name and reason.
-     */
     readonly exemptions: readonly PrismaReaderExemption[];
 };
-/**
- * Looked up from this package — where an optional peer is linked — and then from
- * the project the step runs in.
- */
 export declare function resolveInstalledPrismaCli(): PrismaCli;
 /**
  * The version fence's input: the version of the Prisma CLI this step runs, which
@@ -137,12 +69,11 @@ export declare function resolveInstalledPrismaCli(): PrismaCli;
  * load time against the artifact — see `discovery/artifact.loader.ts`.)
  */
 export declare function readInstalledPrismaVersion(): Promise<string>;
-/**
- * Asked as a module resolution, never as a diagnostic count, and asked from a file
- * path *inside* `clientDirectory` because resolution walks `node_modules` upward
- * from the importer. The directory need not exist yet: resolution is a path
- * question, which is what lets this fence run before `prisma generate`.
- */
 export declare function clientRuntimeResolves(clientDirectory: string): boolean;
+/** The toolchain the generate step uses by default: the installed Prisma CLI and TypeScript. */
 export declare function createPrismaGenerateToolchain(): PrismaGenerateToolchain;
+/**
+ * Runs `prisma generate`, reads the schema and the generated client, checks they
+ * agree, and writes the discovery artifact.
+ */
 export declare function runPrismaGenerateStep(request: PrismaGenerateRequest): Promise<PrismaGenerateResult>;

package/dist/generate/reader-crosscheck.d.ts

@@ -1,86 +1,8 @@
 import type { PrismaCapabilitySurface } from "../discovery/capability-surface.interface.js";
 import type { PrismaIdentifierMapping } from "../discovery/identifier.mapper.js";
 import type { PrismaSchemaFacts, PrismaSchemaModel } from "../discovery/schema-facts.interface.js";
-/**
- * # It is a self-test of the two readers, not a check on the developer
- *
- * That framing decides every case in this module. A finding here does not mean
- * *your schema is wrong*; it means **one of this adapter's two readers is wrong**,
- * or the client it read was generated from a different schema than the one PSL was
- * read from. The remedy is never "edit the schema" — it is regenerate, or fix a
- * reader.
- *
- * It follows that the check can only see facts **both** sources carry. That is not
- * a gap to be closed by trying harder; it is arithmetic. The honest limit is
- * measured below.
- *
- * # What it cannot see, measured rather than described
- *
- * | edit | sqlite | postgres | |
- * --------------------------------------------------- | ------ | -------- | |
- * `@default(uuid())` → `@default(cuid())` | 0 | 0 | | `@default(now())` →
- * `@default(dbgenerated("…"))` | 0 | 0 | | `@default(BRONZE)` → `@default(GOLD)` |
- * 0 | 0 | | `@relation("Mentorship")` → `@relation("Coaching")` | 0 | 0 |
- *
- * Every one of them changes what the database does. None of them is visible to a
- * cross-check, because none of them reaches the 🟢 surface at all: a `@default`
- * argument's *content* and a relation's *name* are PSL-exclusive (the name appears
- * nowhere on the generated surface, which is why `field.mapper.ts` pairs edges
- * from PSL alone). A fifth class is the mirror image: which filter operators a
- * `<Kind>Filter` exposes is 🟢-exclusive, so a reader that under-reads one is
- * equally invisible — seeded as the sixth edit in
- * `__fixtures__/diverged-surface.ts` and caught by nothing.
- *
- * **So this module is not a schema-drift detector and must not be trusted as
- * one.** Staleness — a developer who edits `schema.prisma` and does not re-run the
- * generate step — is prevented by the step *running `prisma generate` itself*, so
- * that both sources describe one instant. What survives that ruling catches a
- * different failure again: `modelHash` proves the artifact is internally intact
- * and the `prismaVersion` major fence catches a client that moved underneath it.
- * Neither notices a schema that moved, and neither does this.
- *
- * # Two exemptions, and both are explanations rather than allowances
- *
- * A freshly generated pair is not silent, and the two cases where it speaks are
- * *understood*:
- *
- * 1. **`json-null-is-a-value`** — the one disagreement a pristine pair produces on
- *    both engines. JSON null is a *value*, so `JsonFilterBase` writes `| null`
- *    operands (`array_starts_with`, `array_ends_with`, and `array_contains` on
- *    PostgreSQL) on a column PSL declares **required**. A plausible "the operands
- *    mention null, therefore the column is nullable" rule is right for every other
- *    scalar and wrong for every `Json` one, which is why nullability comes from
- *    PSL's `?` and nothing else and why this one is exempted by PSL *type* rather
- *    than waved through.
- *
- * Each exemption is **recorded with its reason**, not dropped. A spec can then
- * assert both by name and by reason, so an unexplained third disagreement fails
- * rather than hiding behind "the pair is clean".
- *
- * # What belongs to other modules, and is deliberately not restated here
- *
- * - **A PSL-declared entity the 🟢 types do not expose** is the EXISTENCE GATE's
- *   answer: it decides admission and whether the absence is explained. This module
- *   answers only the reverse direction — a type-exclusive resource or field —
- *   which the gate's own header hands to it.
- * - **A `FieldRef` token that disagrees with the written PSL type** is
- *   `field.mapper.ts`'s, where it *throws*: the two readers describing one field
- *   two ways is not a schema a Contract can be compiled from. Restating the rule
- *   here would be two owners for one fact.
- * - **A create-optional marker with no PSL cause** is `field.mapper.ts`'s
- *   `crossCheckCreateOptional`, run by `model.discoverer.ts` where the field
- *   projections already exist. It needs the projected lifecycle, which this module
- *   does not compute.
- */
 /** A disagreement about a fact both sources carry: one of the readers is wrong. */
-export type PrismaReaderFindingKind = 
-/** The 🟢 types expose a resource PSL does not declare. */
-"resource-exclusive-to-types"
-/** The 🟢 types expose a field PSL does not declare on that model. */
- | "field-exclusive-to-types"
-/** PSL's `?` and the operands the 🟢 filter admits disagree. */
- | "nullability"
- | "identifier-key"
+export type PrismaReaderFindingKind = "resource-exclusive-to-types" | "field-exclusive-to-types" | "nullability" | "identifier-key"
 /** An enum is exposed and not declared, declared and not exposed, or its members differ. */
  | "enum";
 export type PrismaReaderFinding = {
@@ -94,10 +16,11 @@ export type PrismaReaderFinding = {
 };
 /** A disagreement that is understood, and therefore not a finding. */
 export type PrismaReaderExemptionKind = "json-null-is-a-value" | "nullable-participant-key";
+/** A known, expected difference between the schema and the generated client. */
 export type PrismaReaderExemption = {
     readonly kind: PrismaReaderExemptionKind;
     readonly entity: string;
-    /** Why the two sources may differ here. Recorded so a spec can assert the reason. */
+    /** Why the two may differ here. */
     readonly reason: string;
 };
 export type PrismaReaderCrossCheck = {
@@ -110,14 +33,6 @@ export type PrismaIdentifierKeyFinding = {
     readonly key: string;
     readonly reason: string;
 };
-/**
- * Exported because it has **two callers that must check one rule**: the generate
- * step, through {@link crossCheckReaders}, and `identifier.mapper.spec.ts`, whose
- * own cases were written against a local copy while this file did not exist. The
- * explanation is re-derived **from PSL**, never taken on the mapping's word —
- * otherwise a mapper that invented a nullable participant would clear its own
- * exemption.
- */
 export declare function crossCheckIdentifierKeys(declared: PrismaSchemaModel, mapping: PrismaIdentifierMapping, uniqueKeys: readonly string[]): readonly PrismaIdentifierKeyFinding[];
 /**
  * The whole cross-check: a pure function of the two readers' output.

package/dist/generate/reader-crosscheck.js

@@ -61,7 +61,7 @@ export function crossCheckReaders(facts, surface) {
         findings.push({
             kind: "resource-exclusive-to-types",
             entity: name,
-            message: `the generated 🟢 types expose a model \`${name}\` that \`schema.prisma\` does not declare. The two readers describe one instant, so this is a stale generated client or a reader defect — the schema cannot have said it.`,
+            message: `the generated client's types expose a model \`${name}\` that \`schema.prisma\` does not declare. The two readers describe one instant, so this is a stale generated client or a reader defect — the schema cannot have said it.`,
         });
     }
     for (const model of facts.models) {
@@ -80,7 +80,7 @@ export function crossCheckReaders(facts, surface) {
             findings.push({
                 kind: "field-exclusive-to-types",
                 entity: `${model.name}.${field}`,
-                message: `the generated 🟢 types expose \`${model.name}.${field}\` and \`schema.prisma\` declares no such member. A rename seen by only one of the two readers looks exactly like this.`,
+                message: `the generated client's types expose \`${model.name}.${field}\` and \`schema.prisma\` declares no such member. A rename seen by only one of the two readers looks exactly like this.`,
             });
         }
         for (const field of model.fields) {
@@ -109,7 +109,7 @@ export function crossCheckReaders(facts, surface) {
             findings.push({
                 kind: "nullability",
                 entity: `${model.name}.${field.name}`,
-                message: `\`${model.name}.${field.name}\` is ${field.optional ? "optional" : "required"} in \`schema.prisma\` and the generated 🟢 filter ${typesSayNullable ? `admits \`null\` on [${nullAdmitting.join(", ")}]` : "admits `null` nowhere"}. PSL's \`?\` is the only source of nullability, so the model is built from it either way — this says one of the two readers, or the client, is from a different schema.`,
+                message: `\`${model.name}.${field.name}\` is ${field.optional ? "optional" : "required"} in \`schema.prisma\` and the generated client's filter type ${typesSayNullable ? `admits \`null\` on [${nullAdmitting.join(", ")}]` : "admits `null` nowhere"}. PSL's \`?\` is the only source of nullability, so the model is built from it either way — this says one of the two readers, or the client, is from a different schema.`,
             });
         }
         const mapping = mapPrismaIdentifiers(model);
@@ -139,7 +139,7 @@ export function crossCheckReaders(facts, surface) {
         findings.push({
             kind: "enum",
             entity: name,
-            message: `the generated 🟢 \`enums.ts\` exposes \`${name}\` and \`schema.prisma\` declares no such enum.`,
+            message: `the generated client's \`enums.ts\` exposes \`${name}\` and \`schema.prisma\` declares no such enum.`,
         });
     }
     for (const declared of facts.enums) {

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

@@ -1,38 +1,18 @@
 import type { PrismaIsolationLevel } from "./provider/provider-profile.js";
-/**
- * This is the seam that keeps the adapter compilable with no generated client in
- * scope and testable with a recording double.
- *
- * 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. */
+/** Prisma interactive-transaction options. */
 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. */
+/** One Prisma model delegate, such as `prisma.user`. */
 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.
- */
+/** The Prisma client shape the adapter accepts. */
 export interface PrismaDelegateHost {
+    /** Prisma's interactive `$transaction`. */
     $transaction<T>(work: (transactional: PrismaDelegateHost) => Promise<T>, options?: PrismaTransactionOptions): Promise<T>;
 }
-/** The delegate index view of a host. */
+/** A Prisma client's model delegates, by name. */
 export type PrismaDelegateIndex = Readonly<Record<string, PrismaDelegate | undefined>>;
 /**
  * The single place the structural gap between a generated client (a class,

package/dist/prisma.adapter.d.ts

@@ -2,26 +2,17 @@ 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";
-/**
- * `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.
- */
+/** Options for {@link createPrismaAdapter}. */
 export type PrismaAdapterOptions<TClient extends PrismaDelegateHost, M extends PrismaAdapterModel = PrismaAdapterModel> = {
-    /** Application-owned, already-constructed client. */
+    /** Your constructed Prisma client. */
     readonly client: TClient;
-    /**
-     * The generate-time discovery artifact this adapter loads and checks.
-     *
-     * 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.
-     */
+    /** The `discovery` export of the generated discovery artifact. */
     readonly discovery: PrismaDiscoveryArtifact<M>;
-    /** Declared, never sniffed from client internals. */
+    /** The database provider the client was generated for. */
     readonly provider: PrismaProvider;
+    /** The Prisma driver adapter the client is constructed with. */
     readonly driver: PrismaDriver;
-    /** Adapter-owned, never Aventara public configuration. */
+    /** Options passed to every Prisma interactive transaction. */
     readonly transactionOptions?: PrismaTransactionOptions;
 };
 /**
@@ -36,12 +27,20 @@ export type PrismaAdapterConstruction<TClient extends PrismaDelegateHost, M exte
     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.
+ * Creates the Aventara adapter for a Prisma 7 client, after checking the
+ * discovery artifact against the installed Prisma version and against itself.
+ *
+ * @example
+ * ```ts
+ * const adapter = await createPrismaAdapter({
+ *   client: prisma,
+ *   discovery,
+ *   provider: "postgresql",
+ *   driver: "@prisma/adapter-pg",
+ * });
+ * ```
+ *
+ * @throws `PrismaDiscoveryArtifactError` when the artifact is stale, corrupt or
+ * was generated for another Prisma major; its message says how to regenerate it.
  */
 export declare function createPrismaAdapter<TClient extends PrismaDelegateHost, M extends PrismaAdapterModel = PrismaAdapterModel>(options: PrismaAdapterConstruction<TClient, M>): Promise<Adapter<M>>;

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

@@ -1,28 +1,20 @@
 import type { TransactionCapability } from "@aventara/core";
-/**
- * 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.
- */
 export declare const PRISMA_PROVIDERS: readonly ["sqlite", "postgresql"];
+/** The database providers this package supports. */
 export type PrismaProvider = (typeof PRISMA_PROVIDERS)[number];
-/**
- * The closed driver set.
- */
+/** The closed driver set. */
 export declare const PRISMA_DRIVERS: readonly ["@prisma/adapter-better-sqlite3", "@prisma/adapter-pg", "@prisma/adapter-d1"];
+/** The Prisma driver adapters this package supports. */
 export type PrismaDriver = (typeof PRISMA_DRIVERS)[number];
-/** The five levels `Prisma.IsolationLevel` admits **[PKG, `runtime/client.d.ts`]**. */
+/** The isolation levels Prisma's `$transaction` accepts. */
 export type PrismaIsolationLevel = "ReadUncommitted" | "ReadCommitted" | "RepeatableRead" | "Snapshot" | "Serializable";
-/** The caller's explicit declaration; never sniffed from client internals. */
 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.
+ * What a provider and driver pair supports: transactions and isolation
+ * levels.
  */
 export type PrismaProviderProfile = {
     readonly provider: PrismaProvider;

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

@@ -1,42 +1,4 @@
 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.
- *
- * 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.
- * - 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.
  *

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

@@ -1,48 +1,5 @@
 import { type AdapterModel, type OperationIdentity } from "@aventara/core";
 import type { PrismaIdentifierAddress } from "../discovery/discovery-artifact.interface.js";
-/**
- * # Pure, and the tables are the module
- *
- * No client, no database, no provider name.
- *
- * - {@link SCALAR_DIRECTIVE_TOKENS} over `ScalarMutationDirective`;
- * - {@link RELATION_DIRECTIVE_EMISSIONS} over `RelationMutationDirective`;
- *
- * This module's emission site is {@link emitValue}, which is now a call rather
- * than a copy.
- *
- * 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. 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.
- * A directive quietly dropped here would surface as a write that silently did less
- * than it was asked to.
- *
- * `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";
@@ -60,12 +17,9 @@ 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."*
+     * (`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.
      */
     readonly identifiers: Readonly<Record<string, readonly PrismaIdentifierAddress[]>>;
 };
@@ -81,8 +35,8 @@ export type MutationTranslation = {
     readonly data: unknown;
 };
 /**
- * Translates one validated Aventara mutation `data` into the Prisma write argument
- * for the named operation and stage.
+ * 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