@aventara/prisma7-adapter 0.1.0-pilot.3 → 1.0.0-rc.0

package/dist/discovery/types.reader.d.ts

@@ -2,19 +2,11 @@ import ts from "typescript";
 import type { PrismaCapabilitySurface } from "./capability-surface.interface.js";
 export type PrismaTypesReadResult = {
     readonly surface: PrismaCapabilitySurface;
-    /**
-     * Every file under the client directory the reader actually opened. Reported
-     * rather than assumed: the 🛑 files are absent by refusal, not by luck, and a
-     * caller — or a spec — can assert the file **set** and not only the output.
-     */
+    /** Every file under the client directory the reader actually opened. */
     readonly filesRead: readonly string[];
 };
 export declare class PrismaTypesReaderError extends Error {
     readonly name = "PrismaTypesReaderError";
 }
-/**
- * The reader's one checker question, exported because it is the distinction the
- * whole reader rests on and therefore has to be testable on its own.
- */
 export declare function readWrittenTypeArguments(checker: ts.TypeChecker, reference: ts.TypeReferenceNode): readonly string[];
 export declare function readPrismaCapabilitySurface(clientDirectory: string): PrismaTypesReadResult;

package/dist/discovery/types.reader.js

@@ -21,7 +21,7 @@ export function readPrismaCapabilitySurface(clientDirectory) {
     const root = path.resolve(clientDirectory);
     const publicFiles = listPublicFiles(root);
     if (publicFiles.length === 0) {
-        throw new PrismaTypesReaderError(`no generated 🟢 file was found under ${root}`);
+        throw new PrismaTypesReaderError(`no generated Prisma client file was found under ${root}`);
     }
     const filesRead = new Set();
     const host = createPublicOnlyHost(root, filesRead);
@@ -63,11 +63,11 @@ function createPublicOnlyHost(root, filesRead) {
             return undefined;
         }
         if (isPrivatePath(root, resolved)) {
-            throw new PrismaTypesReaderError(`the types reader asked for ${path.relative(root, resolved)}, which is a 🛑 file`);
+            throw new PrismaTypesReaderError(`the types reader asked for ${path.relative(root, resolved)}, which is an internal file of the generated client that must not be imported`);
         }
         const text = readFileSync(resolved, "utf8");
         if (text.includes(RED_BANNER) || !text.includes(GREEN_BANNER)) {
-            throw new PrismaTypesReaderError(`${path.relative(root, resolved)} does not carry the 🟢 banner`);
+            throw new PrismaTypesReaderError(`${path.relative(root, resolved)} does not carry Prisma's "${GREEN_BANNER}" banner`);
         }
         filesRead.add(resolved);
         return text;
@@ -128,7 +128,7 @@ function projectionMembers(index, name) {
         ? written.typeArguments?.[0]
         : written;
     if (literal === undefined || !ts.isTypeLiteralNode(literal)) {
-        throw new PrismaTypesReaderError(`${name} is declared by the 🟢 types and is not a written object type, so its projection members cannot be read`);
+        throw new PrismaTypesReaderError(`${name} is declared by the generated client's types and is not a written object type, so its projection members cannot be read`);
     }
     return new Set(memberNames(literal.members.filter(ts.isPropertySignature)));
 }
@@ -197,10 +197,20 @@ function keysOfReferenced(index, node, accept) {
     }
     const members = membersOf(index, referencedName(reference));
     if (members === null) {
-        throw new PrismaTypesReaderError(`${referencedName(reference)} is referenced by the 🟢 types but declared nowhere in them`);
+        throw new PrismaTypesReaderError(`${referencedName(reference)} is referenced by the generated client's types but declared nowhere in them`);
     }
     return memberNames(members);
 }
+function deleteManyTakesScalarWhere(index, node) {
+    const input = findReference(node, (n) => n.endsWith("NestedInput"));
+    if (input === null) {
+        return false;
+    }
+    const deleteMany = (membersOf(index, referencedName(input)) ?? []).find((member) => memberName(member) === "deleteMany");
+    return (deleteMany !== undefined &&
+        findReference(deleteMany.type, (n) => n.endsWith("ScalarWhereInput")) !==
+            null);
+}
 function readEnums(program, root) {
     const source = program.getSourceFile(path.join(root, "enums.ts"));
     if (source === undefined) {
@@ -325,7 +335,7 @@ function readMutationOperations(index, model, stage, field, member) {
     }
     const members = membersOf(index, referencedName(reference));
     if (members === null) {
-        throw new PrismaTypesReaderError(`${referencedName(reference)} is referenced by ${model}Unchecked${stage}Input.${field} and declared nowhere in the 🟢 types`);
+        throw new PrismaTypesReaderError(`${referencedName(reference)} is referenced by ${model}Unchecked${stage}Input.${field} and declared nowhere in the generated client's types`);
     }
     return memberNames(members);
 }
@@ -371,7 +381,7 @@ function readRelationFields(checker, index, payload, where, create, update, incl
         }
         const targetMembers = membersOf(index, referencedName(targetPayload));
         if (targetMembers === null) {
-            throw new PrismaTypesReaderError(`${referencedName(targetPayload)} is declared nowhere in the 🟢 types`);
+            throw new PrismaTypesReaderError(`${referencedName(targetPayload)} is declared nowhere in the generated client's types`);
         }
         const edge = findReference(include.get(name)?.type, (n) => n.endsWith("Args"));
         const edgeArguments = edge === null
@@ -386,6 +396,7 @@ function readRelationFields(checker, index, payload, where, create, update, incl
             createRequired: create.get(name) !== undefined &&
                 create.get(name)?.questionToken === undefined,
             updateMutations: keysOfReferenced(index, update.get(name)?.type, (n) => n.endsWith("NestedInput")),
+            scalarNestedWriteFilter: deleteManyTakesScalarWhere(index, update.get(name)?.type),
             edgeArguments,
             pagination: edgeArguments.filter((argument) => !NON_PAGINATION_EDGE_ARGUMENTS.has(argument)),
             orderable: orderBy.has(name),

package/dist/discovery/vocabulary.dictionary.d.ts

@@ -1,66 +1,14 @@
-import type { AdapterLifecycleTrait, BuiltInScalar, PaginationCapability, RelationFilterCapability, RelationMutationDirective, ScalarFilterOperator, ScalarFormat, ScalarMutationDirective } from "@aventara/core";
-/**
- * # It is data, not conditionals
- *
- * # Every entry names its source class (invariant 1)
- *
- * `VOCABULARY` carries one row per Aventara fact with its source code — `PSL`,
- * `TYPE`, `RUN`, `DRIVER` or `CFG`. `VocabularyEntry.sources` is a **non-empty**
- * tuple, so "an entry with no source" is a compile error rather than a silent
- * default.
- *
- * # `@default` is matched, never parsed (invariant 5)
- *
- * `PRISMA_DEFAULT_TABLE` is looked up with the raw text the PSL reader carried
- * across unchanged. `dbgenerated("gen_random_uuid()")` is a **key**, not an
- * expression: the day this module evaluates one, the reader behind it has become a
- * parser and needs a different decision. An unmatched form falls back to
- * `PRISMA_UNMATCHED_DEFAULT_TRAITS` **plus** a recorded unknown that fails the
- * generate step — never an inferred trait.
- *
- * `@db.*` is matched the same way, by its **exact written spelling**
- * (`PRISMA_NATIVE_FORMATS`). `@db.Decimal(10, 2)` matches no key and therefore
- * proves no format, which is the right answer arrived at without splitting an
- * argument list.
- *
- * # This dictionary proposes no `CONTEXT.md` term
- *
- * It is adapter-internal data, not framework vocabulary. Its job is the opposite:
- * no Prisma term reaches `AdapterModel` (invariant 2) — `AtLeast`,
- * `WhereUniqueInput`, `FieldRef`, `@@map`, `take`/`skip` all die here.
- */
-/**
- * `PSL` — `schema.prisma` · `TYPE` — the 🟢 generated types ·
- * `RUN` — observed runtime behaviour · `DRIVER` — the configured Prisma driver
- * adapter · `CFG` — framework configuration, which is policy and not discovery.
- */
+import type { BuiltInScalar, PaginationCapability, RelationFilterCapability, RelationMutationDirective, ScalarFilterOperator, ScalarFormat, ScalarMutationDirective } from "@aventara/core";
+import type { AdapterLifecycleTrait } from "@aventara/core/internal";
 export type VocabularySource = "PSL" | "TYPE" | "RUN" | "DRIVER" | "CFG";
 export type VocabularyEntry = {
     readonly fact: string;
-    /** Non-empty by construction: invariant 1 is enforced by the type, not by a comment. */
     readonly sources: readonly [VocabularySource, ...VocabularySource[]];
     readonly rule: string;
 };
-/**
- * So the source is `PSL` **and** `CFG`: discovery emits what the provider's own
- * column type proves, configuration owns everything else. `scalar.mapper.ts`'s
- * header carries the full argument.
- */
 export declare const VOCABULARY: readonly VocabularyEntry[];
-/**
- * The closed set of ways a mapper refuses. It is dictionary data because a
- * refusal is the dictionary's own answer: a construct it has no word for.
- */
-export type PrismaDiscoveryDiagnosticCode = 
-/** A Prisma type name in neither PRISMA_SCALAR_TABLE nor `enums.ts`. */
-"unmapped-prisma-type"
-/**
- * PSL declares it, the 🟢 types do not expose it: omitted, with the reason said
- * out loud.
- */
- | "not-exposed"
-/** PSL and `enums.ts` disagree about an enum's members or their order. */
- | "enum-diverged";
+/** The closed set of ways a mapper refuses. */
+export type PrismaDiscoveryDiagnosticCode = "unmapped-prisma-type" | "not-exposed" | "enum-diverged";
 export type PrismaDiscoveryDiagnostic = {
     readonly code: PrismaDiscoveryDiagnosticCode;
     /** Written for the engineer who has to fix the schema, naming the entity it is about. */
@@ -71,39 +19,13 @@ export type PrismaScalarMapping = {
     readonly format?: ScalarFormat;
 };
 export type PrismaScalarTable = Readonly<Record<string, PrismaScalarMapping>>;
-/**
- * Total and 1:1 over `BUILT_IN_SCALARS` **[CORE]**. There is no default arm: a
- * Prisma type name absent from this table is a diagnostic, not a guess.
- *
- * **No row carries a `format`**, and that is the point: a format is a property of
- * a *column*, not of a Prisma *type name*. `String` alone proves nothing, so the
- * one thing that can prove something — the native column type — is a separate
- * lookup (`PRISMA_NATIVE_FORMATS`).
- */
+/** Total and 1:1 over `BUILT_IN_SCALARS` **[CORE]**. */
 export declare const PRISMA_SCALAR_TABLE: PrismaScalarTable;
 /**
  * The only `@db.*` spellings that **prove** a format, matched by exact written
  * spelling and never parsed.
- *
- * The bar for a row here is not "the name suggests a format". It is: **the column
- * type itself rejects the values `format` would later reject.** `format` is
- * enforced, not decorative — `normalizeScalarFieldValue` turns `format: "uuid"`
- * into a `V1003` rejection of request input **[CORE,
- * `runtime/scalar-runtime.ts`]** — so a row that is merely probable would have
- * Aventara refuse writes the database accepts.
- *
- * `@db.Uuid` clears that bar: PostgreSQL's `uuid` column rejects `'not-a-uuid'`
- * (`ERROR: invalid input syntax for type uuid`) where a `text` column takes it
- * **[RUN8 — 2026-09-28, `aventara-postgres`, postgres:18]**.
- *
- * That intent belongs in `FrameworkScalarFieldConfig.format` **[CORE]**, which the
- * Contract compiler already applies over the adapter's value.
- *
- * `@db.Decimal(10, 2)` and `@db.VarChar(255)` are absent because they prove no
- * *format*; they carry precision and width, which Aventara has no word for.
  */
 export declare const PRISMA_NATIVE_FORMATS: Readonly<Record<string, ScalarFormat>>;
-/** Whether a row was exercised against 7.10.0 or is carried forward unproven. */
 export type PrismaEvidence = "RUN8" | "UNVERIFIED";
 export type PrismaDefaultRow = {
     /**
@@ -119,13 +41,6 @@ export type PrismaDefaultRow = {
     readonly traits: readonly AdapterLifecycleTrait[];
     readonly evidence: PrismaEvidence;
 };
-/**
- * This table states the answer rather than half of it, so no consumer has to
- * remember to add the other half.
- *
- * The lookup that walks this table lives with the lifecycle projection, where it
- * can be driven red; this pass owns the data only.
- */
 export declare const PRISMA_DEFAULT_TABLE: readonly PrismaDefaultRow[];
 /**
  * Any other text — `"BRONZE"`, `"x"`, `sequence()`, `nanoid()`, a spelling added
@@ -138,42 +53,12 @@ export declare const PRISMA_UNMATCHED_DEFAULT_TRAITS: readonly AdapterLifecycleT
 /**
  * The dictionary's other half: the point at which Prisma's spelling stops and
  * Aventara's begins.
- *
- * **One untyped `PRISMA_RENAMES` became six typed tables.** The single
- * `Record<string, string>` could not make a mistake a compile error: a rename to a
- * word core does not have, or a Prisma key nobody decided about, both typechecked.
- * Each table below is keyed on the Prisma spelling and valued in the ONE Aventara
- * vocabulary that spelling can land in, so `"arrayContains"` misspelt fails to
- * compile. The table had no consumer, so nothing was broken by splitting it.
- *
- * `null` is a value, not an omission: it means **recognised, and Aventara has no
- * word for it** — the nested bulk writes, `distinct`, Prisma's `set` assignment.
- *
- * This is the vocabulary half only.
- */
-/**
- * `<Kind>Filter` / `<Kind>NullableFilter` / `Json[Nullable]Filter` keys.
- *
- * Total and 1:1 over `ScalarFilterOperator` **[CORE]** at 7.10.0, measured over
- * both generated clients: 23 Prisma keys, 23 Aventara operators, no survivor on
- * either side.
  */
+/** `<Kind>Filter` / `<Kind>NullableFilter` / `Json[Nullable]Filter` keys. */
 export declare const PRISMA_FILTER_OPERATORS: Readonly<Record<string, ScalarFilterOperator>>;
-/**
- * `[Nullable]ScalarRelationFilter` and `ListRelationFilter` keys.
- *
- * `nested` and `null` are **not** keys of any filter input — they are read off the
- * edge's own `where` argument and off the edge's nullability — so they are absent
- * here by construction rather than by omission.
- */
+/** `[Nullable]ScalarRelationFilter` and `ListRelationFilter` keys. */
 export declare const PRISMA_RELATION_FILTERS: Readonly<Record<string, RelationFilterCapability>>;
-/**
- * `<Kind>FieldUpdateOperationsInput` and `<M><Stage><field>Input` keys.
- *
- * `set` is `null` because plain assignment is not a directive in Aventara: the
- * value is written directly, and `ScalarMutationDirective` has no `$set`
- * **[CORE]**.
- */
+/** `<Kind>FieldUpdateOperationsInput` and `<M><Stage><field>Input` keys. */
 export declare const PRISMA_SCALAR_DIRECTIVES: Readonly<Record<string, ScalarMutationDirective | null>>;
 /**
  * `<M>Update<edge>Without<M>NestedInput` / `<M>Create<edge>…NestedInput` keys.
@@ -205,15 +90,4 @@ export type ObservedValueShape = {
     readonly engines: readonly string[];
     readonly evidence: PrismaEvidence;
 };
-/**
- * Identical through both driver adapters, so the representation is not
- * driver-dependent *between these two engines* — which is a narrower claim than
- * "not driver-dependent", and the narrower one is what was measured.
- *
- * A row is `RUN8` only where a read-back value was actually asserted. `String`,
- * `Boolean`, `Int` and `Float` were written into a row and never read back under
- * assertion, so they stay `[UNVERIFIED]`: a plausible value shape is not an
- * observed one, and this table exists precisely so that nobody has to guess which
- * is which.
- */
 export declare const OBSERVED_VALUE_SHAPES: readonly ObservedValueShape[];

package/dist/discovery/vocabulary.dictionary.js

@@ -7,7 +7,7 @@ export const VOCABULARY = [
     {
         fact: "nullable",
         sources: ["PSL"],
-        rule: "Never TYPE (invariant 4): `JsonValue` contains `null` because JSON null is a value, so a types-derived nullable is wrong for every Json field.",
+        rule: "Never TYPE: `JsonValue` contains `null` because JSON null is a value, so a types-derived nullable is wrong for every Json field.",
     },
     {
         fact: "list",
@@ -32,7 +32,7 @@ export const VOCABULARY = [
     {
         fact: "relation pairing",
         sources: ["PSL"],
-        rule: '`@relation("Mentorship")` on both sides is the only pairing evidence; the name appears nowhere on the 🟢 surface.',
+        rule: '`@relation("Mentorship")` on both sides is the only pairing evidence; the name appears nowhere in the generated client.',
     },
     {
         fact: "lifecycle traits",

package/dist/errors/error.normalizer.d.ts

@@ -1,130 +1,5 @@
 import { FrameworkError, type OperationErrorCode, type OperationIdentity } from "@aventara/core";
 import { type PrismaConstraintSubject } from "./prisma-error.reader.js";
-/**
- * The table's keys are P-codes, which are **7.x's** error surface. Prisma 8
- * replaced them with dotted `NAMESPACE.SUBCODE` codes, so a Prisma 8 adapter
- * re-maps this module rather than patching it. `error.normalizer.spec.ts` reads
- * `@prisma/client`'s own `package.json` and fails if the installed major is not
- * `7`, so the bound is enforced rather than described.
- *
- * ## Every code in the table was induced, not inherited
- *
- * Nothing here rests on documentation. Each rule was produced by throwing a real
- * statement at a real engine on this repository's own schema, on
- * `@prisma/adapter-better-sqlite3` and `@prisma/adapter-pg`, both 7.10.0. The
- * measured payloads, inlined because the source measurement lives outside the
- * repository:
- *
- * ```text
- * P2002  author.create duplicate @unique email
- *   sqlite  meta = { driverAdapterError: { name: "DriverAdapterError", cause: {
- *             originalCode: "SQLITE_CONSTRAINT_UNIQUE",
- *             originalMessage: "UNIQUE constraint failed: Author.email",
- *             kind: "UniqueConstraintViolation",
- *             constraint: { fields: ["email"] }, table: "Author" } },
- *           modelName: "Author" }
- *   pg      meta = { driverAdapterError: { name: "DriverAdapterError", cause: {
- *             originalCode: "23505",
- *             originalMessage: "duplicate key value violates unique constraint \"Author_email_key\"",
- *             kind: "UniqueConstraintViolation",
- *             constraint: { index: "Author_email_key" }, table: "Author" } },
- *           modelName: "Author" }
- *
- * P2002  author.create violating @@unique([tenantId, handle])
- *   sqlite  constraint: { fields: ["tenantId", "handle"] }
- *   pg      constraint: { index: "Author_tenantId_handle_key" }
- *
- * P2003  post.create with an authorId that does not exist
- *   sqlite  meta = { modelName: "Post", driverAdapterError: { cause: {
- *             originalCode: "SQLITE_CONSTRAINT_FOREIGNKEY",
- *             originalMessage: "FOREIGN KEY constraint failed",
- *             kind: "ForeignKeyConstraintViolation",
- *             constraint: { foreignKey: {} } } } }
- *   pg      constraint: { index: "Post_authorId_fkey" }, originalCode "23503"
- *
- * P2025  author.update / author.delete on a missing unique selector
- *   both    meta = { modelName: "Author", operation: "an update" }
- *   both    meta = { modelName: "Author", operation: "a delete" }
- *
- * P2025  nested connect whose target does not exist (create, update, upsert)
- *   both    meta = { modelName: "Post", model: "Author",
- *                    relation: "AuthorToPost", relationType: "one-to-many",
- *                    operation: "a nested connect",
- *                    neededFor: "inline the relation on 'Post' record(s)" }
- *
- * P2014  author.update with posts.set [] (or posts.disconnect) while a post
- *        still requires that author
- *   both    meta = { modelName: "Author", relation: "AuthorToPost",
- *                    modelA: "Post", modelB: "Author" }
- *
- * P2018  author.update with posts.connect to a missing post
- *   sqlite  meta = { modelName: "Author", expectedRows: 1,
- *                    relation: "AuthorToPost", relationType: "one-to-many" }
- *
- * P2034  two SERIALIZABLE transactions, both reading then both writing
- *   pg      meta = { modelName: "Author", driverAdapterError: { cause: {
- *             originalCode: "40001",
- *             originalMessage: "could not serialize access due to concurrent update",
- *             kind: "TransactionWriteConflict" } } }
- * ```
- *
- * ## Two inherited claims that the measurement refutes
- *
- * 1. It is **absent from every payload above**; the identifiers are internal rule
- *    names, not a `meta` key. What 7.10.0 actually emits is two different *key
- *    sets*, and the discriminant is the presence of `meta.relation` (with
- *    `meta.model`): present → the failure is about a relation reference; absent →
- *    the record the call selected was not there.
- *
- * Also unobserved: the `{}` meta that `expectNonEmpty` was expected to carry.
- * `findUniqueOrThrow` and `findFirstOrThrow` both report `{ modelName, operation:
- * "a query" }`, so no empty-meta P2025 was produced by any statement tried here.
- * Either arm classifies identically under the rule above (no `relation` → root
- * record), so the rule is safe either way, but the shape itself stays unverified.
- *
- * Three distinct situations used to answer the one `A2008 CONFLICT`. Coarse but
- * correct, so nothing provisional ever reached the wire and the discriminant was
- * purely additive. The observed surface each decision rests on is this:
- *
- * | Situation | Code | `meta` keys observed | Structurally separable? |
- * |---|---|---|---| | Uniqueness violation | `P2002` | `modelName`,
- * `driverAdapterError` | **Yes** — distinct P-code; `cause.kind` is
- * `"UniqueConstraintViolation"`; `cause.constraint` is `{fields}` (SQLite) or
- * `{index}` (PostgreSQL) | | Write conflict / deadlock | `P2034` | `modelName`,
- * `driverAdapterError` | **Yes** from a constraint violation — distinct P-code;
- * `cause.kind` is `"TransactionWriteConflict"`; **no** `constraint` at all. **No**
- * from each other: `cause.originalCode` is `40001` for a write conflict and
- * `40P01` for a deadlock, and that field is provider-owned and never crosses the
- * boundary | | Lost-row race | *none* | *none* | **Yes, trivially** — there is no
- * provider error behind it: it is a zero-row count in a sequence the framework
- * manufactured, and it is raised in `execution/first-variant.emulator.ts`, never
- * here |
- *
- * The two provider-backed ones differ by P-code; `driverAdapterError.cause.kind`
- * is a second, independent witness.
- *
- * **A write conflict and a deadlock share `A2013` deliberately.** Both arrive as
- * `P2034` with identical `meta` keys, differing only in a provider-owned
- * `originalCode` (`40001` versus `40P01`) that never crosses the boundary. They
- * are not separable at this seam, so one outcome is the only honest answer;
- * splitting them later would need a discriminant that does not exist.
- * `describePrismaConflict` is the recorded surface, and `PrismaConstraintSubject`
- * records that the two engines do not agree on *which* identifier they can name —
- * a uniqueness discriminant that promised the caller the constraint's name would
- * be unsatisfiable on SQLite.
- *
- * **No Prisma path observed here threw a non-`Error`.** Every induced failure
- * arrived as a `PrismaClientKnownRequestError`, which extends `Error` (`error
- * instanceof Error` was asserted true for all of them), and the one non-Prisma
- * failure the engines produced — `better-sqlite3` refusing a missing directory —
- * was a `TypeError`. The adapter half is discharged here: `prismaOutcomeFailure`
- * returns a `FrameworkError`, so every failure this module originates is an
- * `Error` subclass, enforced by a spec.
- *
- * What keeps it from leaking is this module's own rule: the cause is framework
- * text, and the reader never reads `message` at all, so there is no provider
- * string in scope to forward.
- */
 /** The three answers a Prisma failure can get. */
 export type PrismaErrorClassification = {
     readonly kind: "absence";
@@ -134,62 +9,24 @@ export type PrismaErrorClassification = {
 } | {
     readonly kind: "unclassified";
 };
-/**
- * When a code is a `null` result rather than a failure.
- *
- * `subject` is the measured `meta` shape that may be forgiven. The same P2025
- * reaches `update.unique` for a second reason — a nested `connect` whose target is
- * missing — and that one is a caller error about the *arguments*, not an absent
- * record. `"root-record"` means `meta` carries no relation reference; the
- * single-member union says that is the one shape measured, and leaves room for a
- * second if one is ever observed.
- */
 type PrismaAbsenceRule = {
     readonly variants: readonly `${string}.${string}`[];
     readonly subject: "root-record";
 };
 type PrismaErrorRule = {
-    /**
-     * The outcome this code answers. Typed as core's own `OperationErrorCode`, so the
-     * adapter cannot widen the code space — a code the table does not contain has no
-     * rule at all.
-     */
+    /** The outcome this code answers. */
     readonly outcome: OperationErrorCode;
     readonly absence?: PrismaAbsenceRule;
 };
-/** One closed table, scoped to `@prisma/client` 7.x. */
 export type PrismaErrorTable = Readonly<Record<string, PrismaErrorRule>>;
-/**
- * The installed-major this table is written against. The spec asserts the
- * installed `@prisma/client` agrees.
- */
+/** The installed-major this table is written against. */
 export declare const PRISMA_ERROR_TABLE_MAJOR = "7";
-/**
- * Every code here was induced above. Adding a row later is additive and costs
- * nothing; shipping a wrong one is not recoverable.
- */
+/** Every code here was induced above. */
 export declare const PRISMA_ERROR_TABLE: PrismaErrorTable;
-/**
- * Classifies one failed Prisma call.
- *
- * `error` is `unknown` and stays `unknown`: the reader is the only thing that
- * touches it, and the rules see nothing but measured facts.
- */
+/** Classifies one failed Prisma call. */
 export declare function classifyPrismaError(error: unknown, operation: Pick<OperationIdentity, "family" | "variant">): PrismaErrorClassification;
-/**
- * The deliberate failure an `outcome` classification stands for.
- *
- * The cause carries framework text and nothing else: no issues, and that is now
- * the **rule** rather than an absence. And no provider text, because a deliberate
- * outcome's top-level `cause.message` is forwarded verbatim. Nothing read off the
- * Prisma error reaches this value.
- */
+/** The deliberate failure an `outcome` classification stands for. */
 export declare function prismaOutcomeFailure(code: OperationErrorCode): FrameworkError;
-/**
- * **Server-side only.** Every field is provider-owned, so this value never reaches
- * a `cause` — which is why it is a separate function and not a field on
- * `PrismaErrorClassification`: nothing can carry it onto the wire by accident.
- */
 export type PrismaConflictSubject = {
     readonly code: string;
     readonly model: string | undefined;

package/dist/errors/prisma-error.reader.d.ts

@@ -1,72 +1,3 @@
-/**
- * The total read of one hostile value.
- *
- * Everything on the failure path arrives as `unknown`. `@prisma/client` 7.10.0
- * raises `PrismaClientKnownRequestError`, whose `meta` is typed `Record<string,
- * unknown>` and is **not** a discriminated union, so a reader that trusts the type
- * would be reading a shape nobody promised. Worse, the value need not come from
- * Prisma at all: a developer callback, a driver, or a proxy can hand the adapter
- * anything.
- *
- * So this module reads structurally and defensively, under two rules it never
- * relaxes — the same totality discipline as core's diagnostics reporter, which
- * also observes values it cannot vouch for:
- *
- * 1. **No accessor is ever invoked.** Every read goes through
- *    `Object.getOwnPropertyDescriptor` and takes `descriptor.value`. An accessor
- *    descriptor yields `undefined` and its getter is never called, so a
- *    booby-trapped property cannot run code, mutate state, or throw from inside
- *    the adapter's failure path.
- * 2. **Nothing escapes.** Every reflective call is guarded, because a Proxy may
- *    throw from its `getOwnPropertyDescriptor` or `ownKeys` trap, and a reader
- *    that throws while classifying a failure would replace a legible outcome with
- *    an illegible one.
- *
- * Reading only *own* properties is deliberate rather than incidental: 7.10.0
- * carries `code` and `meta` as own data properties (observed own keys:
- * `["code","meta","clientVersion","name"]`), so the own read is sufficient for
- * every real error, and a `code` that exists only as an inherited accessor is
- * precisely the case rule 1 refuses to touch.
- *
- * ## What this module does NOT read
- *
- * `message` is never read. At 7.10.0 a `PrismaClientKnownRequestError` message is
- * not a sentence — it is a rendered call site. Measured verbatim on this
- * repository's own schema:
- *
- * ```text
- * Invalid `client.author.create()` invocation in
- * /home/.../packages/prisma7-adapter/src/errors/__probe__.spec.ts:50:18
- *
- *   49 await capture("P2002 duplicate email", () =>
- * → 50 	client.author.create(
- * Unique constraint failed on the fields: (`email`)
- * ```
- *
- * That single string carries an absolute file path, a source excerpt and the
- * violated constraint. The cheapest guarantee is not to read the message at all,
- * so the leak has no source; the raw error still reaches core's diagnostics sink,
- * which is server-side and may carry it.
- *
- * Everything below is scoped to `@prisma/client` **7.x**. Prisma 8 replaced
- * P-codes with dotted `NAMESPACE.SUBCODE` codes, which makes a Prisma 8 adapter a
- * re-map of this module rather than a patch to it.
- */
-/**
- * The violated constraint as 7.10.0's driver adapters actually report it, at
- * `meta.driverAdapterError.cause.constraint`.
- *
- * The arms are **provider-shaped, measured on both engines**, not guessed:
- *
- * | Engine | Unique (P2002) | Foreign key (P2003) |
- * |-----------------------------------|-------------------------------|-------------------------|
- * | `@prisma/adapter-better-sqlite3` | `{ fields: ["email"] }` | `{ foreignKey: {}
- * }` | | `@prisma/adapter-pg` | `{ index: "Author_email_key" }` | `{ index:
- * "Post_authorId_fkey" }` |
- *
- * It is therefore **not a string**, and the two engines do not agree on which
- * identifier they can name — SQLite names columns, PostgreSQL names the index.
- */
 export type PrismaConstraintSubject = {
     readonly kind: "fields";
     readonly fields: readonly string[];
@@ -78,23 +9,9 @@ export type PrismaConstraintSubject = {
 } | {
     readonly kind: "unreadable";
 };
-/**
- * Everything the normalizer is allowed to know about one failed call.
- *
- * Narrow and flat on purpose: a classification rule reads these fields and
- * nothing else, so no rule can reach back into the raw value and no rule
- * can depend on a shape this module has not measured.
- */
+/** Everything the normalizer is allowed to know about one failed call. */
 export type PrismaErrorFacts = {
-    /**
-     * The P-code, when it is an own string property. A missing or non-string `code`
-     * leaves this `undefined`, which the table answers as `unclassified` — never as a
-     * guess.
-     */
     readonly code: string | undefined;
-    /**
-     * The own, enumerable key names of `meta`, in the order 7.10.0 wrote them.
-     */
     readonly metaKeys: readonly string[];
     /** `meta.modelName` — the Prisma model the failure occurred on. */
     readonly modelName: string | undefined;
@@ -107,15 +24,6 @@ export type PrismaErrorFacts = {
     readonly relatedModel: string | undefined;
     /** `meta.driverAdapterError.cause.constraint`, read structurally. */
     readonly constraint: PrismaConstraintSubject | undefined;
-    /**
-     * `meta.target` — **read so that it is measured, depended on by nothing**.
-     *
-     * It was induced on both engines here and **`target` was absent from every
-     * payload** — P2002 (single and compound unique), P2003, P2025 (three shapes),
-     * P2018 and P2034, on SQLite and on PostgreSQL. The docs are stale; the installed
-     * package governs. This field exists so the next reader sees that measured, and
-     * does not "fix" the code to match the documentation.
-     */
     readonly legacyTarget: readonly string[] | undefined;
 };
 /**

package/dist/execution/first-variant.emulator.d.ts

@@ -2,41 +2,18 @@ import { FrameworkError } from "@aventara/core";
 import type { PrismaIdentifierAddress } from "../discovery/discovery-artifact.interface.js";
 import type { PrismaCall } from "../translation/operation.translator.js";
 /**
- * The lost-row conflict: the read selected a row and the re-asserted write matched
- * none, so **nothing was written** and a retry may succeed.
- *
- * `A2014 STALE_SELECTION`, and this is the only place that names it.
+ * The lost-row conflict: the read selected a row and the re-asserted write
+ * matched none, so **nothing was written** and a retry may succeed.
  */
 export declare function lostRowConflict(): FrameworkError;
-/**
- * Issues one of the emulation's two statements.
- */
+/** Issues one of the emulation's two statements. */
 export type FirstVariantIssuer = (call: PrismaCall, step: "read" | "write") => Promise<unknown>;
-/**
- * How the emulation's two statements are issued, and against which client.
- *
- * An earlier draft of this module took the two separately — a `unit` that opened a
- * transaction and an `issue` already bound to a client — and the standalone case
- * then opened a transaction whose two statements ran on the **root** client,
- * outside it: the emulation would have looked atomic and been nothing of the kind,
- * and no assertion about the issued `where` would have noticed. Making the unit
- * the thing that hands out the issuer removes the gap rather than documenting it.
- *
- * This module therefore never sees a Prisma client, a provider name or a
- * transaction; it sees one issuer, already in the right unit.
- */
+/** How the emulation's two statements are issued, and against which client. */
 export type FirstVariantEmulation = {
-    /** The translated plan's two steps: the read, then the write template. */
     readonly steps: readonly PrismaCall[];
     /** The Resource's recorded Prisma addressing, for the write's identifier. */
     readonly identifiers: readonly PrismaIdentifierAddress[];
-    /**
-     * Opens the one adapter-internal unit and runs `work` inside it.
-     *
-     * Standalone this opens an interactive transaction and the issuer it yields is
-     * scoped to it; inside a plan it runs `work` against the outer transaction client,
-     * so the emulated steps roll back **with** the plan rather than independently.
-     */
+    /** Opens the one adapter-internal unit and runs `work` inside it. */
     readonly inUnit: <T>(work: (issue: FirstVariantIssuer) => Promise<T>) => Promise<T>;
 };
 /** A plan that is not the two-step shape this module manufactures. */