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

package/dist/discovery/field.mapper.d.ts

@@ -4,70 +4,59 @@ import type { PrismaAdapterModel, PrismaReferentialAction } from "./discovery-ar
 import type { PrismaSchemaField, PrismaSchemaUnknown } from "./schema-facts.interface.js";
 import { type PrismaDiscoveryDiagnostic, type PrismaEvidence } from "./vocabulary.dictionary.js";
 /**
- * Task 4 — one PSL field, answered as an `AdapterScalarField` or an
- * `AdapterRelationField` (C-808, C-811, C-813).
- *
  * # Nullability comes from PSL, and the required `Json` column is why
  *
- * `nullable` is `PrismaSchemaField.optional` — PSL's `?` — and **nothing else**
- * (T-3.1 invariant 4). The type surface cannot answer the question, and the
- * damage is not hypothetical: `$MetricPayload.scalars.sJson` resolves to
- * `null | string | number | false | true | JsonObject | JsonArray` while PSL says
- * `sJson Json`, required, because JSON null is a *value*. The reader's own facts
- * point the same wrong way — `JsonFilterBase.array_contains` admits `| null` and
- * `equals` admits `JsonNullValueFilter` on that same required column — so a
- * plausible "the operands mention null, therefore the column is nullable" rule
- * is wrong for **every** `Json` field while being right everywhere else. That is
- * the whole reason this rule is stated as a rule rather than left to taste.
+ * `nullable` is `PrismaSchemaField.optional` — PSL's `?` — and **nothing else**.
+ * The type surface cannot answer the question, and the damage is not hypothetical:
+ * `$MetricPayload.scalars.sJson` resolves to `null | string | number | false |
+ * true | JsonObject | JsonArray` while PSL says `sJson Json`, required, because
+ * JSON null is a *value*. The reader's own facts point the same wrong way —
+ * `JsonFilterBase.array_contains` admits `| null` and `equals` admits
+ * `JsonNullValueFilter` on that same required column — so a plausible "the
+ * operands mention null, therefore the column is nullable" rule is wrong for
+ * **every** `Json` field while being right everywhere else. That is the whole
+ * reason this rule is stated as a rule rather than left to taste.
  *
  * # The create-optional marker is a cross-check, never a source
  *
  * {@link crossCheckCreateOptional} is a separate function that *consumes* this
- * projection, and the data flows one way only: the marker never reaches
- * {@link projectPrismaField}. `<M>UncheckedCreateInput`'s `?` is **one bit over
- * several causes** — `@default(uuid())`, `@default(BRONZE)`, `@default(now())`,
- * `@updatedAt`, plain nullability, and a scalar list, which needs no value
- * because the empty list is one — and nothing on the 🟢 surface tells them
- * apart. Deriving a trait *from* the marker would invert the check into the bug
- * it exists to catch: it would make the two readers agree by construction and
- * detect nothing.
+ * projection, and the data flows one way only: the marker never reaches {@link
+ * projectPrismaField}. `<M>UncheckedCreateInput`'s `?` is **one bit over several
+ * causes** — `@default(uuid())`, `@default(BRONZE)`, `@default(now())`,
+ * `@updatedAt`, plain nullability, and a scalar list, which needs no value because
+ * the empty list is one — and nothing on the 🟢 surface tells them apart. Deriving
+ * a trait *from* the marker would invert the check into the bug it exists to
+ * catch: it would make the two readers agree by construction and detect nothing.
  *
  * # `@default` is matched, never parsed
  *
  * {@link matchPrismaDefault} walks `PRISMA_DEFAULT_TABLE` over the raw argument
- * text the PSL reader carried across unchanged. B1 deferred this matcher to this
- * task deliberately: the dictionary owns the data, and the lookup belongs where
- * a red test can drive it.
- *
- * The matcher adds **one** discriminant the dictionary's table does not state,
- * and it is a shape test rather than a parse: an argument that begins with an
- * identifier followed by `(` is a *generator form*, and anything else is a
- * *static value*. Both are `DEFAULTED`; only an unrecognised generator form
- * records an unknown. Without that split, `tier Tier @default(BRONZE)` — a field
- * of the Phase 8 schemas — would record an unknown and fail the generate step,
- * while C-811's own acceptance criteria say `@default("x")` is `["DEFAULTED"]`
- * with nothing recorded. The test never reads *inside* the argument, so
+ * text the PSL reader carried across unchanged.
+ *
+ * The matcher adds **one** discriminant the dictionary's table does not state, and
+ * it is a shape test rather than a parse: an argument that begins with an
+ * identifier followed by `(` is a *generator form*, and anything else is a *static
+ * value*. Both are `DEFAULTED`; only an unrecognised generator form records an
+ * unknown. The test never reads *inside* the argument, so
  * `dbgenerated("gen_random_uuid()")` remains a key and `"a, b // not a comment"`
  * remains opaque text.
  *
  * # A relation carries four members, and the FK is not one of them
  *
- * `target`, `cardinality`, `nullable`, and (from Task 6) `capabilities`. The
- * `@relation(fields: […], references: […])` scalars are read, used to identify
- * the FK column and check it against the edge's own optionality, and then
- * **discarded** (C-813). `@relation`'s *name* is not an Aventara concept either,
- * and its referential actions are not core's yet, so both travel beside the
- * projection as {@link PrismaRelationEdge} rather than inside it: pairing is
- * discovery-internal, and it is **PSL-only** — the name
- * appears nowhere on the 🟢 surface, so from the types alone `Author` has two
- * `Author` edges with nothing to pair them.
+ * `target`, `cardinality`, `nullable`, and `capabilities`. The `@relation(fields:
+ * […], references: […])` scalars are read, used to identify the FK column and
+ * check it against the edge's own optionality, and then **discarded**.
+ * `@relation`'s *name* is not an Aventara concept either, and its referential
+ * actions are not core's yet, so both travel beside the projection as {@link
+ * PrismaRelationEdge} rather than inside it: pairing is discovery-internal, and it
+ * is **PSL-only** — the name appears nowhere on the 🟢 surface, so from the types
+ * alone `Author` has two `Author` edges with nothing to pair them.
  *
  * # Two failure vocabularies, kept apart
  *
- * A **diagnostic** is about the schema: PSL declares a column the 🟢 types do
- * not expose (C-808's existence gate, whose fatality the generate step decides),
- * or a Prisma type name in no table. A **throw** is about the readers: the two
- * sources disagree about a fact they both state, which no schema can cause and
+ * A **diagnostic** is about the schema: PSL declares a column the 🟢 types do not
+ * expose, or a Prisma type name in no table. A **throw** is about the readers: the
+ * two sources disagree about a fact they both state, which no schema can cause and
  * no diagnostic vocabulary describes. The types reader draws the same line.
  */
 /** A reader-versus-reader disagreement: not a schema problem, and not recoverable. */
@@ -75,9 +64,8 @@ export declare class PrismaFieldProjectionError extends Error {
     readonly name = "PrismaFieldProjectionError";
 }
 /**
- * The projection minus `capabilities`, which is Task 6's and is derived from the
- * capability surface rather than from PSL. `Omit` rather than a restatement, so
- * the composed field is the core type by construction.
+ * `Omit` rather than a restatement, so the composed field is the core type by
+ * construction.
  */
 export type ProjectedScalarField = Omit<AdapterScalarField<PrismaAdapterModel>, "capabilities">;
 export type ProjectedRelationField = Omit<AdapterRelationField<PrismaAdapterModel>, "capabilities">;
@@ -87,20 +75,18 @@ export type ProjectedRelationField = Omit<AdapterRelationField<PrismaAdapterMode
  *
  * # Why the actions ride here and not on `AdapterRelationField`
  *
- * `AdapterRelationField` is core's type and its members are C-813's (`target`,
- * `cardinality`, `nullable`, `capabilities`). Wiring a referential action into
- * the Contract is a core change and belongs to the task that owns core's
- * transaction planner, not to discovery. Until then the fact lives where
- * discovery can state it truthfully.
+ * Wiring a referential action into the Contract is a core change and belongs to
+ * the task that owns core's transaction planner, not to discovery. Until then the
+ * fact lives where discovery can state it truthfully.
  *
  * # The lookup is inverted, and the edge is shaped so a consumer need not invert
  *
  * `onDelete` is declared on the CHILD — `Kid.parent @relation(…, onDelete:
- * Cascade)` — and fires when the PARENT is deleted. So an edge reads:
- * **deleting a `target` does `onDelete` to rows of `resource`.** A consumer
- * asking "what does deleting `X` remove?" filters `target === X && onDelete ===
- * "cascade"` and reads off `resource`; it does not have to re-derive which side
- * of a pair declared what.
+ * Cascade)` — and fires when the PARENT is deleted. So an edge reads: **deleting a
+ * `target` does `onDelete` to rows of `resource`.** A consumer asking "what does
+ * deleting `X` remove?" filters `target === X && onDelete === "cascade"` and reads
+ * off `resource`; it does not have to re-derive which side of a pair declared
+ * what.
  *
  * `null` on both members means this edge is not the owning side (it declares no
  * `fields:`), so the actions are on its partner — never that no action applies.
@@ -129,7 +115,7 @@ export type FieldProjectionInput = {
     readonly field: PrismaSchemaField;
     /** The model's other fields: the only way to identify an FK scalar by name. */
     readonly siblings: readonly PrismaSchemaField[];
-    /** TYPE — what this client exposes. The existence gate (C-808). */
+    /** TYPE — what this client exposes. The existence gate. */
     readonly surface: PrismaResourceSurface;
     /** TYPE — `enums.ts`, which is what makes an enum name an enum name. */
     readonly enums: Readonly<Record<string, readonly string[]>>;
@@ -140,7 +126,7 @@ export type FieldProjection = {
     readonly outcome: "scalar";
     readonly name: string;
     readonly field: ProjectedScalarField;
-    /** Recorded unknowns; a non-empty list FAILS the generate step (T-3.1 invariant 5). */
+    /** Recorded unknowns; a non-empty list FAILS the generate step. */
     readonly unknowns: readonly PrismaSchemaUnknown[];
 } | {
     readonly outcome: "relation";
@@ -173,8 +159,8 @@ export type PrismaDefaultOutcome =
     readonly traits: readonly AdapterLifecycleTrait[];
 };
 /**
- * T-3.1's `@default` table, looked up — never evaluated. The argument arrives as
- * opaque text precisely so that this function can be a lookup.
+ * The argument arrives as opaque text precisely so that this function can be a
+ * lookup.
  */
 export declare function matchPrismaDefault(argument: string): PrismaDefaultOutcome;
 /** Why a field is legitimately optional in `<M>UncheckedCreateInput`. */

package/dist/discovery/field.mapper.js

@@ -2,74 +2,6 @@ import { LIFECYCLE_TRAITS, } from "@aventara/core";
 import { projectEnumBackedColumn } from "./enum.mapper.js";
 import { mapPrismaScalarField } from "./scalar.mapper.js";
 import { PRISMA_DEFAULT_TABLE, PRISMA_UNMATCHED_DEFAULT_TRAITS, } from "./vocabulary.dictionary.js";
-/**
- * Task 4 — one PSL field, answered as an `AdapterScalarField` or an
- * `AdapterRelationField` (C-808, C-811, C-813).
- *
- * # Nullability comes from PSL, and the required `Json` column is why
- *
- * `nullable` is `PrismaSchemaField.optional` — PSL's `?` — and **nothing else**
- * (T-3.1 invariant 4). The type surface cannot answer the question, and the
- * damage is not hypothetical: `$MetricPayload.scalars.sJson` resolves to
- * `null | string | number | false | true | JsonObject | JsonArray` while PSL says
- * `sJson Json`, required, because JSON null is a *value*. The reader's own facts
- * point the same wrong way — `JsonFilterBase.array_contains` admits `| null` and
- * `equals` admits `JsonNullValueFilter` on that same required column — so a
- * plausible "the operands mention null, therefore the column is nullable" rule
- * is wrong for **every** `Json` field while being right everywhere else. That is
- * the whole reason this rule is stated as a rule rather than left to taste.
- *
- * # The create-optional marker is a cross-check, never a source
- *
- * {@link crossCheckCreateOptional} is a separate function that *consumes* this
- * projection, and the data flows one way only: the marker never reaches
- * {@link projectPrismaField}. `<M>UncheckedCreateInput`'s `?` is **one bit over
- * several causes** — `@default(uuid())`, `@default(BRONZE)`, `@default(now())`,
- * `@updatedAt`, plain nullability, and a scalar list, which needs no value
- * because the empty list is one — and nothing on the 🟢 surface tells them
- * apart. Deriving a trait *from* the marker would invert the check into the bug
- * it exists to catch: it would make the two readers agree by construction and
- * detect nothing.
- *
- * # `@default` is matched, never parsed
- *
- * {@link matchPrismaDefault} walks `PRISMA_DEFAULT_TABLE` over the raw argument
- * text the PSL reader carried across unchanged. B1 deferred this matcher to this
- * task deliberately: the dictionary owns the data, and the lookup belongs where
- * a red test can drive it.
- *
- * The matcher adds **one** discriminant the dictionary's table does not state,
- * and it is a shape test rather than a parse: an argument that begins with an
- * identifier followed by `(` is a *generator form*, and anything else is a
- * *static value*. Both are `DEFAULTED`; only an unrecognised generator form
- * records an unknown. Without that split, `tier Tier @default(BRONZE)` — a field
- * of the Phase 8 schemas — would record an unknown and fail the generate step,
- * while C-811's own acceptance criteria say `@default("x")` is `["DEFAULTED"]`
- * with nothing recorded. The test never reads *inside* the argument, so
- * `dbgenerated("gen_random_uuid()")` remains a key and `"a, b // not a comment"`
- * remains opaque text.
- *
- * # A relation carries four members, and the FK is not one of them
- *
- * `target`, `cardinality`, `nullable`, and (from Task 6) `capabilities`. The
- * `@relation(fields: […], references: […])` scalars are read, used to identify
- * the FK column and check it against the edge's own optionality, and then
- * **discarded** (C-813). `@relation`'s *name* is not an Aventara concept either,
- * and its referential actions are not core's yet, so both travel beside the
- * projection as {@link PrismaRelationEdge} rather than inside it: pairing is
- * discovery-internal, and it is **PSL-only** — the name
- * appears nowhere on the 🟢 surface, so from the types alone `Author` has two
- * `Author` edges with nothing to pair them.
- *
- * # Two failure vocabularies, kept apart
- *
- * A **diagnostic** is about the schema: PSL declares a column the 🟢 types do
- * not expose (C-808's existence gate, whose fatality the generate step decides),
- * or a Prisma type name in no table. A **throw** is about the readers: the two
- * sources disagree about a fact they both state, which no schema can cause and
- * no diagnostic vocabulary describes. The types reader draws the same line.
- */
-/** A reader-versus-reader disagreement: not a schema problem, and not recoverable. */
 export class PrismaFieldProjectionError extends Error {
     name = "PrismaFieldProjectionError";
 }
@@ -78,16 +10,10 @@ export function projectPrismaField(input) {
         ? projectRelationField(input)
         : projectScalarField(input);
 }
-/* ------------------------------------------------------------------ *
- * Scalars                                                            *
- * ------------------------------------------------------------------ */
 function projectScalarField(input) {
     const { resource, field, surface, enums } = input;
     const mapped = mapPrismaScalarField({ resource, field, surface, enums });
     if (mapped.outcome === "excluded" || mapped.outcome === "unmapped") {
-        // The existence gate and the unmapped-type diagnostic are the scalar
-        // mapper's own answers, forwarded whole: restating them here would be a
-        // second wording of one decision.
         return mapped;
     }
     const exposed = surface.scalarFields[field.name];
@@ -107,7 +33,6 @@ function projectScalarField(input) {
             kind: "scalar",
             type,
             ...(format === undefined ? {} : { format }),
-            // PSL's `?`, and nothing else (T-3.1 invariant 4).
             nullable: field.optional,
             list: field.list,
             lifecycle: lifecycle.traits,
@@ -115,15 +40,6 @@ function projectScalarField(input) {
         unknowns: lifecycle.unknowns,
     };
 }
-/**
- * The `FieldRef` token against the written PSL type.
- *
- * **A token carries its list suffix** — `Post.tags` reads as `String[]`, not
- * `String` — so the suffix is split off before the names are compared and is
- * then the TYPE half of `list`. Comparing the raw token to the PSL type name
- * would make every list field look like a type mismatch, and a provider-drop
- * check built on that would fire on a field that is present.
- */
 function assertTokenAgrees(resource, field, token) {
     const listed = token.endsWith("[]");
     const base = listed ? token.slice(0, -2) : token;
@@ -134,23 +50,10 @@ function assertTokenAgrees(resource, field, token) {
         throw new PrismaFieldProjectionError(`${resource}.${field.name} is ${field.list ? "a list" : "not a list"} in schema.prisma and the 🟢 types carry the FieldRef token \`${token}\`, which says the opposite.`);
     }
 }
-/* ------------------------------------------------------------------ *
- * Lifecycle (C-811)                                                  *
- * ------------------------------------------------------------------ */
-/**
- * The three adapter traits in core's own declaration order, so a trait list has
- * one canonical order and it is not this module's invention. Order is semantic:
- * it enters the Contract hash.
- */
 const ADAPTER_TRAIT_ORDER = LIFECYCLE_TRAITS.filter((trait) => trait === "DEFAULTED" ||
     trait === "GENERATED_ON_CREATE" ||
     trait === "GENERATED_ON_UPDATE");
-/** An argument that begins with an identifier and an open paren: a generator form. */
 const GENERATOR_FORM = /^[A-Za-z_][A-Za-z0-9_]*\(/;
-/**
- * T-3.1's `@default` table, looked up — never evaluated. The argument arrives as
- * opaque text precisely so that this function can be a lookup.
- */
 export function matchPrismaDefault(argument) {
     for (const row of PRISMA_DEFAULT_TABLE) {
         const matched = "literal" in row.match
@@ -176,10 +79,6 @@ function projectLifecycle(resource, field) {
             present.add(trait);
         }
         if (outcome.form === "unrecognised-generator") {
-            // Recorded as the same `PrismaSchemaUnknown` the PSL reader records, so
-            // it fails the generate step by construction rather than through a second
-            // rule written for it. An unrecognised generator function is a build stop,
-            // not a column Aventara quietly decides the client must supply.
             unknowns.push({
                 kind: "attribute-argument",
                 spelling: "@default",
@@ -197,16 +96,6 @@ function projectLifecycle(resource, field) {
         unknowns,
     };
 }
-/**
- * TYPE's only contribution to lifecycle: a check, run in one direction.
- *
- * Every field the 🟢 `<M>UncheckedCreateInput` marks optional must carry a PSL
- * cause. A field the types mark optional with no cause means **one of the two
- * readers is wrong** — that is the entire signal, and it is why the marker is
- * never read as a trait. Names the types mark that this model does not project
- * as a scalar (relation edges) are skipped rather than reported: their
- * optionality is structural.
- */
 export function crossCheckCreateOptional(input) {
     const byName = new Map(input.fields.map((field) => [field.name, field]));
     const explained = [];
@@ -228,11 +117,7 @@ export function crossCheckCreateOptional(input) {
     return { explained, unexplained, messages };
 }
 function causeOf(projected) {
-    // Lifecycle first, in core's order, so a field with both a default and a
-    // nullable column reports the stronger cause.
     const trait = ADAPTER_TRAIT_ORDER.filter((candidate) => projected.lifecycle.includes(candidate));
-    // `GENERATED_ON_CREATE` outranks the `DEFAULTED` that always accompanies it:
-    // it is the more specific reason the client may omit the value.
     const strongest = trait.includes("GENERATED_ON_CREATE")
         ? "GENERATED_ON_CREATE"
         : trait[0];
@@ -244,9 +129,6 @@ function causeOf(projected) {
     }
     return projected.list ? "list" : null;
 }
-/* ------------------------------------------------------------------ *
- * Relations (C-813)                                                  *
- * ------------------------------------------------------------------ */
 function projectRelationField(input) {
     const { resource, field, siblings, surface } = input;
     const column = `${resource}.${field.name}`;
@@ -261,11 +143,7 @@ function projectRelationField(input) {
         };
     }
     const cardinality = field.list ? "many" : "one";
-    // A to-many edge is a collection, and an absent collection is an empty one:
-    // never nullable. A to-one edge is nullable exactly where PSL wrote `?`.
     const nullable = cardinality === "many" ? false : field.optional;
-    // TYPE is the cross-check, from `$<M>Payload.objects`: `mentor:
-    // $AuthorPayload | null`, `mentees: $AuthorPayload[]`.
     if (exposed.many !== field.list) {
         throw new PrismaFieldProjectionError(`${column} is ${field.list ? "a list" : "a single edge"} in schema.prisma and the 🟢 payload says the opposite.`);
     }
@@ -279,8 +157,6 @@ function projectRelationField(input) {
     return {
         outcome: "relation",
         name: field.name,
-        // Four members. No target field schema, no FK, no join-table name, no
-        // owning-side metadata (C-813).
         field: {
             kind: "relation",
             target: field.type,
@@ -293,31 +169,11 @@ function projectRelationField(input) {
             target: field.type,
             cardinality,
             relationName: field.relation?.name ?? null,
-            // Carried, not projected: the action changes what a delete DOES, so it
-            // is evidence a transaction planner needs, and it is not a member of
-            // `AdapterRelationField` (see the edge's own doc).
             onDelete: field.relation?.onDelete ?? null,
             onUpdate: field.relation?.onUpdate ?? null,
         },
     };
 }
-/**
- * The FK, read and then discarded.
- *
- * `fields: […]` is used for exactly two things, both of them checks: each named
- * scalar must be a column this model declares, and an **optional FK forces an
- * optional edge**. PSL enforces the second itself — `prisma validate` 7.10.0
- * answers *"The relation field `author` uses the scalar fields authorId. At
- * least one of those fields is optional. Hence the relation field must be
- * optional as well."* — so a violation can only come from a reader defect.
- *
- * The converse does **not** hold, and assuming it would be wrong: `mentor
- * Author? @relation(fields: [mentorId])` with `mentorId String` **required** is
- * valid PSL at 7.10.0 and its client still types `mentor: $AuthorPayload |
- * null`. So the FK is not the source of nullability — the edge's own `?` is.
- *
- * Nothing about the FK enters the projection.
- */
 function assertForeignKeyAgrees(column, field, siblings, nullable) {
     for (const name of field.relation?.fields ?? []) {
         const scalar = siblings.find((sibling) => sibling.name === name);
@@ -329,21 +185,6 @@ function assertForeignKeyAgrees(column, field, siblings, nullable) {
         }
     }
 }
-/**
- * Pairs each edge with its back-reference, which **only PSL can do**.
- *
- * An explicit `@relation("Name")` is the pairing evidence, and for the two
- * `Author` → `Author` edges it is the *only* evidence: the name appears nowhere
- * on the 🟢 surface, so from the types alone there are two self-edges and
- * nothing to say they are one relation.
- *
- * Unnamed edges are paired by the unordered model pair, which is unambiguous
- * because PSL requires a name as soon as two relations connect the same two
- * models. Where an unordered pair still has more than two edges, they are left
- * unpaired rather than guessed: the implicit name Prisma would compute lives in
- * the 🛑 runtime data model, and re-deriving it here would be this module
- * reimplementing the generator.
- */
 export function pairPrismaRelationEdges(edges) {
     const groups = new Map();
     for (const edge of edges) {
@@ -375,8 +216,6 @@ export function pairPrismaRelationEdges(edges) {
         }
         pairs.push(sortKey(first) <= sortKey(second) ? [first, second] : [second, first]);
     }
-    // Sorted by the first edge, so the answer's order is a property of the model
-    // and not of how the groups happened to be keyed.
     return {
         pairs: [...pairs].sort((left, right) => sortKey(left[0]).localeCompare(sortKey(right[0]))),
         unpaired,

package/dist/discovery/identifier.mapper.d.ts

@@ -1,8 +1,6 @@
 import type { PrismaIdentifierAddress } from "./discovery-artifact.interface.js";
 import type { PrismaSchemaBlockIdentifier, PrismaSchemaModel } from "./schema-facts.interface.js";
 /**
- * PSL uniqueness → `AdapterIdentifier` tuples **[CORE]**: C-814 and C-815.
- *
  * # Why identity comes from PSL
  *
  * Because the generated types cannot state it. Measured on 2026-09-28 against
@@ -13,100 +11,70 @@ import type { PrismaSchemaBlockIdentifier, PrismaSchemaModel } from "./schema-fa
  * model Epsilon { code String @id      name String }
  * ```
  *
- * `models/Delta.ts` and `models/Epsilon.ts` are **byte-identical** — equal
- * md5 after a case-insensitive `Delta|delta → MODEL|model` substitution and
- * after removing one 4-line `StringFieldUpdateOperationsInput` block, which is
- * the generator's first-file-wins dedup of a shared input type and lands in
- * whichever model file sorts first. Both declare their `AtLeast` key set as
- * `}, "code">` on the same line. A grep for `primaryKey|isId|isUnique` over
- * the 🟢 files of that client and of **both** Phase 8 clients is empty — not
- * only over the 🟢 files: over the whole generated tree, `internal/`
- * included.
+ * `models/Delta.ts` and `models/Epsilon.ts` are **byte-identical** — equal md5
+ * after a case-insensitive `Delta|delta → MODEL|model` substitution and after
+ * removing one 4-line `StringFieldUpdateOperationsInput` block, which is the
+ * generator's first-file-wins dedup of a shared input type and lands in whichever
+ * model file sorts first. Both declare their `AtLeast` key set as `}, "code">` on
+ * the same line.
  *
- * So `@id` and `@unique` are the same fact to TYPE, and a compound `@@id` is
- * the same fact as a compound `@@unique`. PSL is the only source that
- * distinguishes them.
+ * So `@id` and `@unique` are the same fact to TYPE, and a compound `@@id` is the
+ * same fact as a compound `@@unique`. PSL is the only source that distinguishes
+ * them.
  *
  * # Why that negative costs the model nothing
  *
  * `AdapterResource.identifiers` is `readonly AdapterIdentifier<TFields>[]`
  * **[CORE]** — an **unmarked set** of non-empty scalar field tuples with no
  * primary/secondary distinction. Aventara never asks which identifier is the
- * primary key, so a source that cannot tell `@id` from `@unique` withholds
- * nothing this mapper needs.
+ * primary key, so a source that cannot tell `@id` from `@unique` withholds nothing
+ * this mapper needs.
  *
  * # The types are a cross-check, and a one-sided one
  *
- * `PrismaResourceSurface.uniqueKeys` — `AtLeast<…, K>`'s key union — is
- * checked two-directionally and never read as a source (C-814): every
- * identifier's **stored** key must appear among the keys, and every key with no
- * identifier behind it must be explained by C-815 and by nothing else. Stored,
- * not re-derived: matching a key computed as `members.join("_")` is what used to
- * refuse a schema carrying `@@unique(…, name: "X")`, whose surface key is `X`.
- * Equality is unsatisfiable by construction, because C-815 omits a criterion
- * the generator still emits a key for. Measured: `Author` has three keys
- * (`"id" | "email" | "tenantId_handle"`, identical on both engines) and two
- * identifiers.
- *
- * What the two directions do **not** catch is this mapper keeping a criterion
- * C-815 rejects: an extra identifier only removes a key from the explained
- * set, so both directions still pass. Measured on 2026-09-28 — a build of this
- * mapper without the C-815 branch passes the cross-check on all eight
- * model/engine pairs. The cross-check guards the two readers against each
- * other; C-815 is pinned by its own cases.
+ * Stored, not re-derived: matching a key computed as `members.join("_")` is what
+ * used to refuse a schema carrying `@@unique(…, name: "X")`, whose surface key is
+ * `X`. Measured: `Author` has three keys (`"id" | "email" | "tenantId_handle"`,
+ * identical on both engines) and two identifiers.
  *
  * Its key **ORDERING is not used at all**. It appears to list the primary key
- * first, but that is an undocumented generator artifact, it is ordering inside
- * a union — which TypeScript does not preserve semantically — and it
- * degenerates completely when a model has exactly one unique criterion, the
- * common case. Nothing here may start depending on it.
+ * first, but that is an undocumented generator artifact, it is ordering inside a
+ * union — which TypeScript does not preserve semantically — and it degenerates
+ * completely when a model has exactly one unique criterion, the common case.
+ * Nothing here may start depending on it.
  *
  * # Nothing here sorts
  *
  * Member order is the attribute's list as written, never the field declaration
- * order (`@@unique([y, x])` is `["y", "x"]` even where `x` is declared first),
- * and the identifiers themselves come out in PSL's own order: field-level
- * criteria in field declaration order, then `@@id`, then `@@unique` as
- * written. Order enters the Contract hash (§19.2), so a deterministic order
- * derived from PSL is the point, not a convenience.
+ * order (`@@unique([y, x])` is `["y", "x"]` even where `x` is declared first), and
+ * the identifiers themselves come out in PSL's own order: field-level criteria in
+ * field declaration order, then `@@id`, then `@@unique` as written. Order enters
+ * the Contract hash, so a deterministic order derived from PSL is the point, not a
+ * convenience.
  */
 /** Which PSL spelling a criterion came from. Reported, and never used to rank one. */
 export type PrismaIdentifierSource = "@id" | "@unique" | "@@id" | "@@unique";
-/** One uniqueness criterion as PSL states it, before C-815 is applied. */
 export type PrismaUniquenessCriterion = {
     readonly source: PrismaIdentifierSource;
     /** Member order as written in the attribute's list. Never sorted. */
     readonly members: readonly string[];
     /**
-     * The Prisma addressing key for this criterion — {@link prismaUniqueInputKey}
-     * over the PSL facts, computed once here.
-     *
-     * Carried by the OMISSIONS too, and not only by the usable identifiers,
-     * because the TYPE cross-check's second direction matches an `AtLeast` key
-     * against the omission that explains it: a named criterion C-815 rejects is
-     * keyed by its name on the generated surface, so an omission without its key
-     * would leave that key unexplained and fail a schema Prisma accepts.
+     * The Prisma addressing key for this criterion — {@link prismaUniqueInputKey} over
+     * the PSL facts, computed once here.
      */
     readonly key: string;
 };
 /**
  * A criterion that is NOT a usable identifier, recorded with its reason.
  *
- * Recorded rather than dropped for two independent reasons: C-814 requires the
- * omission to be reported, and the TYPE cross-check needs it — the generator
- * emits an `AtLeast` key for a criterion C-815 rejects, and an unrecorded
- * omission would leave that key unexplained and indistinguishable from a
- * reader bug.
- *
- * A discriminated union, because the arms carry different evidence: which
- * members are nullable is not the same fact as which members are not scalar
- * columns at all.
+ * A discriminated union, because the arms carry different evidence: which members
+ * are nullable is not the same fact as which members are not scalar columns at
+ * all.
  *
- * These are not `PrismaDiscoveryDiagnostic`s. A diagnostic carries prose for
- * an engineer; the cross-check needs the member names as data.
+ * These are not `PrismaDiscoveryDiagnostic`s. A diagnostic carries prose for an
+ * engineer; the cross-check needs the member names as data.
  */
 export type PrismaIdentifierOmission = PrismaUniquenessCriterion & ({
-    /** C-815: SQL uniqueness does not constrain NULLs. */
     readonly reason: "nullable-participant";
     readonly nullableMembers: readonly string[];
 } | {
@@ -151,20 +119,13 @@ export type PrismaIdentifierMapping = {
  * `WhereUniqueInput` accepts, and the key the generated `AtLeast<…, K>` union
  * lists.
  *
- * Computed **once**, here, at generate time — the architect's decision on
- * 2026-09-29: *"store it, less processing and less room for drifting."* Runtime
- * matches the stored key and never re-derives it.
- *
  * The rule, measured at 7.10.0 (regenerated 2026-09-29 over five models):
  *
- * | criterion                          | key       | wraps |
- * | ---------------------------------- | --------- | ----- |
- * | `id String @id` / `@unique`        | `id`      | no    |
- * | `@@unique([b, a])`                 | `b_a`     | yes   |
- * | `@@id([a, b])`                     | `a_b`     | yes   |
- * | `@@unique([b, a], name: "altKey")` | `altKey`  | yes   |
- * | `@@id([a, b], name: "pk")`         | `pk`      | yes   |
- * | any of the above, `map: "…"`       | unchanged | —     |
+ * | criterion | key | wraps | | ---------------------------------- | --------- |
+ * ----- | | `id String @id` / `@unique` | `id` | no | | `@@unique([b, a])` | `b_a`
+ * | yes | | `@@id([a, b])` | `a_b` | yes | | `@@unique([b, a], name: "altKey")` |
+ * `altKey` | yes | | `@@id([a, b], name: "pk")` | `pk` | yes | | any of the above,
+ * `map: "…"` | unchanged | — |
  *
  * Two of those rows are why this is a function of the PSL facts and not of the
  * members alone. A custom `name:` **replaces** the positional alias rather than
@@ -174,8 +135,8 @@ export type PrismaIdentifierMapping = {
  * 2026-09-29; `map:` stays invisible and stays discarded).
  *
  * What this key is **not** is part of the identifier. `AdapterIdentifier` is a
- * tuple of field names with nowhere to put a name (C-814), and this key lives in
- * the artifact's translation table beside the model, never in it.
+ * tuple of field names with nowhere to put a name, and this key lives in the
+ * artifact's translation table beside the model, never in it.
  */
 export declare function prismaUniqueInputKey(uniqueness: PrismaSchemaBlockIdentifier): string;
 /**