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

package/dist/discovery/vocabulary.dictionary.js

@@ -1,17 +1,3 @@
-/**
- * T-3.1's table, row for row, so a reader can audit one against the other.
- *
- * **`format?` diverges from T-3.1's table deliberately, and the plan row is the
- * one that is wrong.** T-3.1 says `format?` is `CFG` — "PSL's `@db.*` is a hint
- * only … policy, not discovery". Spec §6.1 says the opposite in as many words:
- * UUID "is a string scalar plus passive format metadata **when the adapter can
- * prove the format**", §18.3's discovery mapping reads "scalar type → stable
- * framework scalar + optional format", C-809 restates both, T-5 restates them
- * again, and `AdapterScalarField.format?` exists **[CORE]** — a member with no
- * producer if discovery never emits one. 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 const VOCABULARY = [
     {
         fact: 'kind: "scalar" / "relation"',
@@ -61,7 +47,7 @@ export const VOCABULARY = [
     {
         fact: "enum values",
         sources: ["PSL"],
-        rule: "Declaration order is semantic (§19.2) and is never sorted; cross-checked against `enums.ts`.",
+        rule: "Declaration order is semantic and is never sorted; cross-checked against `enums.ts`.",
     },
     {
         fact: "field & operation capabilities",
@@ -76,7 +62,7 @@ export const VOCABULARY = [
     {
         fact: "transactions",
         sources: ["DRIVER"],
-        rule: "F-801 — the configured driver adapter, not the provider name.",
+        rule: "The configured driver adapter, not the provider name.",
     },
     {
         fact: "COMPUTED_* / VIRTUAL",
@@ -84,15 +70,6 @@ export const VOCABULARY = [
         rule: "Outside `AdapterLifecycleTrait` by construction [CORE]; the adapter cannot emit them.",
     },
 ];
-/**
- * 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 (C-809).
- *
- * **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`).
- */
 export const PRISMA_SCALAR_TABLE = {
     String: { scalar: "string" },
     Boolean: { scalar: "boolean" },
@@ -104,48 +81,9 @@ export const PRISMA_SCALAR_TABLE = {
     Bytes: { scalar: "bytes" },
     Json: { scalar: "json" },
 };
-/**
- * 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]**.
- *
- * `@default(uuid())` does **not** clear it, which is where T-5's wording is
- * narrowed: on a `String` column with no `@db.Uuid` the column is `text`, only
- * *generated* values are UUIDs, and a client may legally supply any string. 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 const PRISMA_NATIVE_FORMATS = {
     "@db.Uuid": "uuid",
 };
-/**
- * T-3.1's `@default` table.
- *
- * **`traits` is the whole trait set, where T-3.1's table lists only the trait the
- * *argument* adds.** The two are consistent, not contradictory: `DEFAULTED` comes
- * from `@default`'s **presence** (C-808: "`@default` → `DEFAULTED` and, when
- * generator-owned, `GENERATED_ON_CREATE`"), and C-811's acceptance criteria spell
- * the full sets out — `@default(autoincrement())` → `["DEFAULTED",
- * "GENERATED_ON_CREATE"]`, `@default("x")` → `["DEFAULTED"]`. 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 (Task 4),
- * where it can be driven red; this pass owns the data only.
- */
 export const PRISMA_DEFAULT_TABLE = [
     {
         match: { literal: "uuid()" },
@@ -193,51 +131,12 @@ export const PRISMA_DEFAULT_TABLE = [
         evidence: "RUN8",
     },
     {
-        // Mongo; unreachable for the SQL providers Phase 8 supports.
         match: { pattern: /^auto\(\)$/ },
         traits: ["DEFAULTED", "GENERATED_ON_CREATE"],
         evidence: "UNVERIFIED",
     },
 ];
-/**
- * Any other text — `"BRONZE"`, `"x"`, `sequence()`, `nanoid()`, a spelling added
- * after 7.10.0. The value is still `DEFAULTED`, because `@default` is present;
- * the *unknown* is what fails the generate step, so an unrecognised generator
- * function is a build stop rather than a column Aventara quietly thinks the
- * client must supply.
- */
 export const PRISMA_UNMATCHED_DEFAULT_TRAITS = ["DEFAULTED"];
-/* ------------------------------------------------------------------ *
- * Prisma → Aventara renames (invariant 2)                            *
- * ------------------------------------------------------------------ */
-/**
- * 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 (2026-10-02, T-6).** 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.
- * A key absent from a table is a different thing entirely, and the deriver that
- * reads these refuses rather than dropping it silently, because a silently dropped
- * capability key is how C-855's failure mode begins.
- *
- * C-837's relation *translator* table — which Prisma argument each directive emits
- * — is still Task 9's. 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.
- */
 export const PRISMA_FILTER_OPERATORS = {
     equals: "equals",
     not: "not",
@@ -263,15 +162,6 @@ export const PRISMA_FILTER_OPERATORS = {
     array_starts_with: "arrayStartsWith",
     array_ends_with: "arrayEndsWith",
 };
-/**
- * `[Nullable]ScalarRelationFilter` and `ListRelationFilter` keys.
- *
- * `is` and `isNot` both answer `match`: §18.5 has one to-one matching capability
- * and no `is`/`isNot` wrapper, so the two Prisma keys collapse into it. `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.
- */
 export const PRISMA_RELATION_FILTERS = {
     is: "match",
     isNot: "match",
@@ -279,15 +169,6 @@ export const PRISMA_RELATION_FILTERS = {
     every: "every",
     none: "none",
 };
-/**
- * `<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]**. `unset` is carried although neither Phase 8 engine emits it — it is
- * Mongo's, and a key the dictionary recognises and never advertises is better than
- * one that makes the deriver throw the day a third provider is added.
- */
 export const PRISMA_SCALAR_DIRECTIVES = {
     set: null,
     increment: "$increment",
@@ -297,14 +178,6 @@ export const PRISMA_SCALAR_DIRECTIVES = {
     push: "$push",
     unset: "$unset",
 };
-/**
- * `<M>Update<edge>Without<M>NestedInput` / `<M>Create<edge>…NestedInput` keys.
- *
- * `createMany`, `updateMany` and `deleteMany` are `null`: they are nested BULK
- * writes, and `RelationMutationDirective` models per-row intent only **[CORE]**.
- * Aventara expresses the same effect by addressing the target Resource, so
- * advertising them would promise an argument no directive could carry.
- */
 export const PRISMA_RELATION_DIRECTIVES = {
     create: "$create",
     connect: "$connect",
@@ -318,15 +191,6 @@ export const PRISMA_RELATION_DIRECTIVES = {
     updateMany: null,
     deleteMany: null,
 };
-/**
- * `<M>$<edge>Args` keys, valued in `PaginationCapability`.
- *
- * `null` means the argument is read for something else, or for nothing:
- * `orderBy` answers `order`, `where` answers the `nested` filter capability,
- * `select`/`omit`/`include` answer projection, and `distinct` is a Prisma concept
- * Aventara has no word for. The table is total over the keys both clients write,
- * so a new edge argument at 7.11 is an unrecognised key rather than a silent drop.
- */
 export const PRISMA_EDGE_ARGUMENTS = {
     take: "limit",
     skip: "offset",
@@ -338,7 +202,6 @@ export const PRISMA_EDGE_ARGUMENTS = {
     include: null,
     where: null,
 };
-/** `_count` on `<M>Include` / `<M>CountOutputType`. */
 export const PRISMA_REDUCERS = {
     _count: "$count",
 };
@@ -346,19 +209,6 @@ const BOTH_ENGINES = [
     "@prisma/adapter-better-sqlite3",
     "@prisma/adapter-pg",
 ];
-/**
- * Task 1's observations, inlined with the engines they were made on
- * **[RUN8, `src/environment.spec.ts`]**. 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]` (§12): a plausible value shape is not an
- * observed one, and this table exists precisely so that nobody has to guess which
- * is which.
- */
 export const OBSERVED_VALUE_SHAPES = [
     {
         prismaType: "Decimal",

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

@@ -1,25 +1,19 @@
 import { FrameworkError, type OperationErrorCode, type OperationIdentity } from "@aventara/core";
 import { type PrismaConstraintSubject } from "./prisma-error.reader.js";
 /**
- * T-10 — error normalization: one closed table from `@prisma/client` 7.x
- * P-codes to Aventara outcomes, and nothing else.
- *
- * ## Version bound (C-846)
- *
  * 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.
+ * 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:
+ * 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
@@ -58,6 +52,11 @@ import { type PrismaConstraintSubject } from "./prisma-error.reader.js";
  *                    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" }
@@ -71,83 +70,62 @@ import { type PrismaConstraintSubject } from "./prisma-error.reader.js";
  *
  * ## Two inherited claims that the measurement refutes
  *
- * 1. **`meta.errorIdentifier` does not exist.** D-811 and the error-code map
- *    both state that P2025's cases are told apart by
- *    `meta.errorIdentifier` (`MISSING_RECORD` / `MISSING_RELATED_RECORD` /
- *    `INCOMPLETE_CONNECT_INPUT`), and both marked it unverified at the meta
- *    level. 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. That is structural, which is what ADR 0006 requires — the
- *    alternative, `meta.operation`, is English prose.
- * 2. **`meta.target` is never emitted.** RC-9's open question is answered:
- *    the v7 docs are stale (see `PrismaErrorFacts.legacyTarget`).
- *
- * 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.
- *
- * ## RC-8 is decided, and this measurement is what decided it
- *
- * 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 (RC-8, D-831). The architect assented
- * (2026-10-02) to the discrimination this measurement showed to be available:
- * `A2008` now means the **constraint** case alone, a write conflict or
- * deadlock answers **`A2013 CONCURRENT_MODIFICATION`**, and the lost-row race
- * answers **`A2014 STALE_SELECTION`** from the emulator's own seam. The
- * observed surface each decision rests on is this:
+ * 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 |
- *
- * So all three are separable **without reading any message text**, which is
- * what ADR 0006 requires and what C-821 warns `P2028` cannot offer, and that
- * is why the discrimination is implemented by P-code and by call site alone.
+ * |---|---|---|---| | 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.
- *
- * ## F-608 / D-816 — what was observed about non-`Error` throws
+ * **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`. So the primitive-throw ambiguity
- * F-608 describes did not arise for the only real adapter that exists, and
- * the general fix (boxing primitive Adapter throws at core's seam) has no
- * demonstrated urgency. That observation, not a guess, is what Task 14 (§14a)
- * judges the row on. The adapter half is discharged here:
- * `prismaOutcomeFailure` returns a `FrameworkError`, so every failure this
- * module originates is an `Error` subclass, enforced by a spec.
- *
- * ## F-723 — why nothing leaks today
- *
- * A deliberate `FrameworkError`'s top-level `cause.message` is forwarded
- * verbatim; that channel is still open and is Phase 13's. What keeps it from
- * leaking is this module's own rule (C-819): the cause is framework text, and
- * the reader never reads `message` at all, so there is no provider string in
- * scope to forward. If that rule is ever relaxed, the leak is immediate —
- * which is the input Phase 13 should receive.
+ * 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. T-10, verbatim. */
+/** The three answers a Prisma failure can get. */
 export type PrismaErrorClassification = {
     readonly kind: "absence";
 } | {
@@ -157,19 +135,14 @@ export type PrismaErrorClassification = {
     readonly kind: "unclassified";
 };
 /**
- * When a code is a `null` result rather than a failure (D-811).
- *
- * `variants` is read literally from D-811: Prisma's `update`/`delete` throw
- * P2025 when the selector matches nothing, and core's outcome mapper turns a
- * returned `null` into `A2003 NOT_FOUND` for exactly those two variants, so
- * the adapter hands back `null` instead of inventing 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.
+ * 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}`[];
@@ -177,14 +150,14 @@ type PrismaAbsenceRule = {
 };
 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 (C-838).
+     * 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.
      */
     readonly outcome: OperationErrorCode;
     readonly absence?: PrismaAbsenceRule;
 };
-/** One closed table, scoped to `@prisma/client` 7.x (C-846). */
+/** 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
@@ -192,53 +165,30 @@ export type PrismaErrorTable = Readonly<Record<string, PrismaErrorRule>>;
  */
 export declare const PRISMA_ERROR_TABLE_MAJOR = "7";
 /**
- * Every code here was induced above. Codes that 7.10.0 *can* raise but that
- * no statement here produced — `P2000`, `P2011`, `P2014`, `P2017`, `P2020`,
- * `P2023`, `P2010`, `P2028`, `P2029`, `P2030`, `P2036`, `P2037`, `P2039`,
- * `P1008`, `P1017`, `P1018` — are **deliberately absent**: an unmeasured
- * rule is a guess, and D-812's answer for anything unrecognised is to leave
- * it to core's `AdapterBoundary`, which reports `A3001 ADAPTER_ERROR` with
- * core's own text and sends the raw error to diagnostics. Adding a row
- * later is additive and costs nothing; shipping a wrong one is not
- * recoverable.
+ * Every code here was induced above. Adding a row later is additive and costs
+ * nothing; shipping a wrong one is not recoverable.
  */
 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. The
- * operation is needed because D-811's answer depends on the variant the
- * caller asked for, which is framework knowledge and not in the error.
+ * `error` is `unknown` and stays `unknown`: the reader is the only thing that
+ * touches it, and the rules see nothing but measured facts.
  */
 export declare function classifyPrismaError(error: unknown, operation: Pick<OperationIdentity, "family" | "variant">): PrismaErrorClassification;
 /**
  * The deliberate failure an `outcome` classification stands for.
  *
- * It is a `FrameworkError`, so every failure this adapter originates is an
- * `Error` subclass — D-816's adapter half, which needs no core change.
- *
- * The cause carries framework text and nothing else: no issues, and that is
- * now the **rule** rather than an absence (C-839, ADR 0008 decision 4). A
- * conflict is not a Framework Validation Layer failure, ADR 0008 decision 1
- * makes a V-code *determine* the A-code, and `validationCode` rolls up to only
- * `A2001`/`A2002`/`A2004`/`A2007`/`A2009` — so a conflict V-code would have no
- * legal rollup, which is why `A2008`, `A2013` and `A2014` pair with none and
- * carry `cause.issues` absent. And no provider text, because a deliberate
- * outcome's top-level `cause.message` is forwarded verbatim (C-819, F-723).
- * Nothing read off the Prisma error reaches this value.
+ * 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.
  */
 export declare function prismaOutcomeFailure(code: OperationErrorCode): FrameworkError;
 /**
- * What RC-8 will discriminate on, recorded rather than re-measured.
- *
- * **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. It is the measurement that answered §14c — whether the three
- * situations once collapsed into `A2008` are *structurally* separable, which
- * they are — and it remains the record of what a diagnostics sink could
- * usefully be told.
+ * **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;

package/dist/errors/error.normalizer.js

@@ -1,44 +1,12 @@
 import { FrameworkError, } from "@aventara/core";
 import { readPrismaError, } from "./prisma-error.reader.js";
-/**
- * The installed-major this table is written against. The spec asserts the
- * installed `@prisma/client` agrees.
- */
 export const PRISMA_ERROR_TABLE_MAJOR = "7";
-/**
- * Every code here was induced above. Codes that 7.10.0 *can* raise but that
- * no statement here produced — `P2000`, `P2011`, `P2014`, `P2017`, `P2020`,
- * `P2023`, `P2010`, `P2028`, `P2029`, `P2030`, `P2036`, `P2037`, `P2039`,
- * `P1008`, `P1017`, `P1018` — are **deliberately absent**: an unmeasured
- * rule is a guess, and D-812's answer for anything unrecognised is to leave
- * it to core's `AdapterBoundary`, which reports `A3001 ADAPTER_ERROR` with
- * core's own text and sends the raw error to diagnostics. Adding a row
- * later is additive and costs nothing; shipping a wrong one is not
- * recoverable.
- */
 export const PRISMA_ERROR_TABLE = {
-    // Uniqueness conflict — caller-actionable state conflict, HTTP 409 (D-810, C-820).
     P2002: { outcome: "A2008" },
-    // Foreign-key violation — an invalid reference is the same class of
-    // conflict, and D-810 maps it to the same code. These two are what
-    // `A2008` now means, and the whole of it: re-running either request
-    // unchanged fails the same way, which is what separates them from
-    // `A2013`/`A2014`.
     P2003: { outcome: "A2008" },
-    // Write conflict or deadlock: another operation reached the same state
-    // first, so nothing this one asked for was applied. Both arrive as P2034
-    // and are not separable at this seam, so they share one outcome. Prisma
-    // performs no automatic retry and this adapter adds none (C-822, D-809,
-    // F-705): a retried plan would re-run developer callbacks whose side
-    // effects are not rollback-safe. A retry is the caller's to make.
+    P2014: { outcome: "A2008" },
     P2034: { outcome: "A2013" },
-    // The required connected records were not found: measured only with a
-    // relation reference in `meta`, and always about the arguments.
     P2018: { outcome: "A2004" },
-    // Depends on records that were required but not found. A caller error
-    // about the arguments by default; a `null` result on the two strict
-    // unique variants, and only when the missing record is the one the call
-    // selected rather than a relation target (D-811).
     P2025: {
         outcome: "A2004",
         absence: {
@@ -47,38 +15,17 @@ export const PRISMA_ERROR_TABLE = {
         },
     },
 };
-/** Framework-owned text, one line per code it may emit. */
 const OUTCOME_MESSAGES = {
-    // `A2008` now means the constraint case alone, and its text is
-    // UNCHANGED on purpose. §13.2's narrowed meaning — "would violate a
-    // uniqueness or reference constraint the Resource declares" — is
-    // documentation, NOT a legal wire message: C-819's measured sweeps ban
-    // `constraint`, `Unique` and `UNIQUE` from a provider-originated
-    // envelope, because those are the provider's own words for this very
-    // failure. Narrowing the code's meaning does not license naming the
-    // constraint to the caller, and this line is what keeps the two apart.
     A2008: "The operation conflicts with the current state of the resource.",
     A2013: "Another operation modified the same state concurrently, so this operation was not applied and nothing was written.",
     A2004: "The operation's arguments referenced a record that does not exist.",
 };
-/**
- * `"root-record"`: the failure is about the record the call selected, not
- * about a relation target. Measured discriminant, not message text.
- */
 function matchesAbsenceSubject(subject, facts) {
     switch (subject) {
         case "root-record":
             return facts.relation === undefined;
     }
 }
-/**
- * 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. The
- * operation is needed because D-811's answer depends on the variant the
- * caller asked for, which is framework knowledge and not in the error.
- */
 export function classifyPrismaError(error, operation) {
     const facts = readPrismaError(error);
     if (facts.code === undefined) {
@@ -100,22 +47,6 @@ export function classifyPrismaError(error, operation) {
         ? { kind: "absence" }
         : { kind: "outcome", code: rule.outcome };
 }
-/**
- * The deliberate failure an `outcome` classification stands for.
- *
- * It is a `FrameworkError`, so every failure this adapter originates is an
- * `Error` subclass — D-816's adapter half, which needs no core change.
- *
- * The cause carries framework text and nothing else: no issues, and that is
- * now the **rule** rather than an absence (C-839, ADR 0008 decision 4). A
- * conflict is not a Framework Validation Layer failure, ADR 0008 decision 1
- * makes a V-code *determine* the A-code, and `validationCode` rolls up to only
- * `A2001`/`A2002`/`A2004`/`A2007`/`A2009` — so a conflict V-code would have no
- * legal rollup, which is why `A2008`, `A2013` and `A2014` pair with none and
- * carry `cause.issues` absent. And no provider text, because a deliberate
- * outcome's top-level `cause.message` is forwarded verbatim (C-819, F-723).
- * Nothing read off the Prisma error reaches this value.
- */
 export function prismaOutcomeFailure(code) {
     return new FrameworkError(code, {
         message: OUTCOME_MESSAGES[code] ?? "The operation could not be completed.",