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

package/dist/discovery/capability.deriver.js

@@ -1,56 +1,7 @@
 import { PRISMA_EDGE_ARGUMENTS, PRISMA_FILTER_OPERATORS, PRISMA_REDUCERS, PRISMA_RELATION_DIRECTIVES, PRISMA_RELATION_FILTERS, PRISMA_SCALAR_DIRECTIVES, } from "./vocabulary.dictionary.js";
-/**
- * T-6 — field capabilities, derived from the generated client's own types.
- *
- * # The input is narrower than T-6 writes it, and the narrowing IS the invariant
- *
- * T-6 spells `ScalarCapabilityInput` as `{ field, surface, mapping, profile }`.
- * This module accepts `surface` alone, and that is deliberate: dictionary
- * invariant 6 says a capability is read from the client's own types and never
- * tabulated from a provider row, and the strongest available mechanism for that is
- * to make the provider **unrepresentable** rather than merely unread. A
- * `PrismaProviderProfile` in this input is a `provider` member one keystroke from
- * a branch; with no such member, `if (provider === …)` is a compile error, and the
- * three per-engine differences this pass exists to prove — `mode`, `JsonFilter`'s
- * ordering operators, and the `path` / `in` / `notIn` operand shapes — have to come
- * from the surface because nothing else is in scope.
- *
- * Dropping `field` has the same effect on C-812: a lifecycle trait cannot grant a
- * capability if no lifecycle trait can be passed. `mapping` went with them because
- * nothing here reads an Aventara scalar identity to answer a capability question.
- *
- * **This is a deviation from T-6 and is reported as one.** It predicted that the
- * `path` question — omit, or translate, where the operand is a JSONPath string —
- * would need `mapping` back. **Task 7 settled it and did not:** see
- * {@link translatable}. The answer is read off the recorded operand shape, which
- * is already on the surface; the Aventara scalar identity would have been a
- * second, weaker source for the same fact. `mapping` stays out.
- *
- * # Order is canonical, not incidental
- *
- * Every list is emitted in **core's own union declaration order**, held below as a
- * closed ordered array. Prisma's declaration order is an input, not a semantic
- * fact, and C-843 wants two generate runs byte-identical; ordering by the Aventara
- * union makes the output independent of how a generator happens to write a member
- * list, while keeping the array reviewable against `contracts/capability.ts`.
- *
- * # Absent and empty are different answers
- *
- * `create: []` / `update: []` mean **writable with no directive** — plain
- * assignment, which is what `set` alone is. An absent `create` / `update` means
- * **not writable**, and core enforces exactly that: `validateScalarMutation`
- * answers `V1006` *"is not writable during <stage>"* when the member is
- * `undefined` **[CORE, operations/operation-validator-core.ts]**. So the two must
- * not be conflated, and the surface's `null` (the client exposes no entry for this
- * column at this stage) is the only thing that produces the absent form.
- */
-/** A Prisma spelling that no dictionary table recognises: a build stop, never a drop. */
 export class PrismaCapabilityDerivationError extends Error {
     name = "PrismaCapabilityDerivationError";
 }
-/* ------------------------------------------------------------------ *
- * Canonical orders — core's own union declaration order [CORE]        *
- * ------------------------------------------------------------------ */
 const FILTER_OPERATOR_ORDER = [
     "equals",
     "not",
@@ -107,9 +58,6 @@ const PAGINATION_ORDER = [
     "offset",
     "cursor",
 ];
-/* ------------------------------------------------------------------ *
- * Scalars                                                            *
- * ------------------------------------------------------------------ */
 export function deriveScalarCapabilities(input) {
     const { surface } = input;
     const operands = deriveScalarFilterOperands(input);
@@ -117,34 +65,14 @@ export function deriveScalarCapabilities(input) {
         .map((key) => look(PRISMA_FILTER_OPERATORS, key, "a scalar filter operator"))
         .filter((operator) => translatable(operator, operands)));
     return {
-        // The column is in `$<M>Payload.scalars`, which is the set the client
-        // actually returns — the existence gate's own evidence (T-3.1 invariant 3).
         select: true,
         ...(filter.length > 0 ? { filter } : {}),
         order: surface.orderable,
-        // C-836: only where `SortOrderInput` is admitted for THIS field. Absent, not
-        // `false`, elsewhere — core reads `orderNulls !== true` either way, and an
-        // absent member keeps the canonical form free of negative facts.
         ...(surface.nullsOrderable ? { orderNulls: true } : {}),
         ...directives("create", surface.createOperations),
         ...directives("update", surface.updateOperations),
     };
 }
-/**
- * The Prisma operand for each ADVERTISED operator, keyed by the Aventara name.
- *
- * T-6's three signatures return core types unchanged, and `ScalarFieldCapabilities`
- * has nowhere to put an operand shape — yet the shape is exactly where two engines
- * differ on keys they both carry (`JsonFilter.path` is `string[]` on one and
- * `string` on the other; `in`/`notIn` admit `List<Kind>FieldRefInput` on one only).
- * A deriver that answered operator NAMES alone would report the two engines
- * identical where they are not, so the shape is carried beside the capability
- * rather than discarded.
- *
- * Keyed by the Aventara operator so Task 7 reads a shape without re-running the
- * rename — and so a provider branch has nothing to be for (§Open question,
- * "How the `path` filter operator is emitted per provider").
- */
 export function deriveScalarFilterOperands(input) {
     const operands = {};
     for (const operator of FILTER_OPERATOR_ORDER) {
@@ -157,41 +85,12 @@ export function deriveScalarFilterOperands(input) {
     }
     return operands;
 }
-/**
- * Whether an advertised operator's OPERAND can be honoured — Task 7's half of
- * §9.2's rule that *"JSON path/content operators are exposed only where provider
- * behavior can be mapped reliably"*.
- *
- * Exactly one operator reaches this test today, and it is the one the plan left
- * open (§12, "How the `path` filter operator is emitted per provider"):
- * `JsonFilterBase.path` is `string[]` on one engine and a JSONPath `string` on
- * the other, measured 2026-10-02 at 7.10.0 — and the engines enforce it at
- * RUNTIME, not only in the types:
- *
- * - PostgreSQL: *"Argument `path`: Invalid value provided. Expected String[], provided String."*
- * - SQLite: *"Argument `path`: Invalid value provided. Expected String, provided (String)."*
- *
- * So one canonical Aventara operand cannot be carried to both, and the choice is
- * §9.2's other ending: **the operator is not advertised where the operand is the
- * JSONPath string**. Translating instead would mean synthesizing a JSONPath from
- * a segment list — an escaping and array-index dialect nobody has measured — and
- * a translation that is wrong on `{"a.b": …}` is the silent behaviour change
- * C-855 exists to prevent. Omission is expressible in
- * `ScalarFieldCapabilities.filter` exactly as it stands, so nothing escalates to
- * core.
- *
- * The decision is read off the recorded operand SHAPE and nothing else. No
- * `provider` is in scope here, by construction (see this module's header), and no
- * Aventara scalar identity is needed either: T-6's `mapping` would be a second,
- * weaker source for a fact the operand already states.
- */
 function translatable(operator, operands) {
     if (operator !== "path") {
         return true;
     }
     return admitsStringList(operands.path);
 }
-/** Whether a written operand type admits a list of strings. */
 function admitsStringList(written) {
     if (written === undefined) {
         return false;
@@ -203,7 +102,6 @@ function admitsStringList(written) {
 }
 function directives(stage, operations) {
     if (operations === null) {
-        // The client exposes no entry for this column at this stage: not writable.
         return {};
     }
     return {
@@ -212,35 +110,6 @@ function directives(stage, operations) {
             .filter((directive) => directive !== null)),
     };
 }
-/* ------------------------------------------------------------------ *
- * Relations                                                          *
- * ------------------------------------------------------------------ */
-/* ------------------------------------------------------------------ *
- * The scope arms — the narrowest encoding that is still honest         *
- * ------------------------------------------------------------------ */
-/**
- * The projection answer for one member: the **unqualified** arm where the
- * capability holds in every scope, the qualified arm only where it is genuinely
- * narrower, and `false` where it holds nowhere.
- *
- * # Why the full list is never emitted
- *
- * `RelationProjectionCapability` is a union, and a list naming every
- * `ProjectionScope` says exactly what `true` says. Emitting it would put one
- * semantic fact into two encodings — one fact with two hashes, which is C-843 and
- * `AGENT.md`'s one-source-of-truth rule, and the ground on which the architect
- * rejected the flat-or-per-variant option. So the degenerate list is not produced
- * here at all. S4's canonicalizing collapse is the safety net for a *different*
- * producer; this one does not need it.
- *
- * # Non-emptiness
- *
- * `ProjectionScopes` is a non-empty tuple, so "holds nowhere" cannot be spelled as
- * `[]`. It is `false` — *the capability is absent*, which is the answer this module
- * already gave before any scope existed and the answer `absent ≠ empty` requires.
- * Every array below is a literal with a written member, so the tuple's lower bound
- * is discharged by construction rather than by an assertion.
- */
 function projectableIn(unrestricted, bulk) {
     if (unrestricted && bulk) {
         return true;
@@ -253,25 +122,9 @@ function projectableIn(unrestricted, bulk) {
     }
     return false;
 }
-/**
- * The reducer answer: the bare reducer list where the reducers hold in every
- * projection scope, the scoped form where they are narrower.
- *
- * The reducer list and the scope list stay separate facts, so `[]` keeps meaning
- * what it means and the scope says only where the reducers may be asked for.
- */
 function reducersIn(reducers, bulk) {
     return bulk ? reducers : { reducers, scopes: ["record"] };
 }
-/**
- * The write answer for one stage, on the same rule: the bare directive list where
- * the stage holds in every write scope, the scoped form where it is narrower.
- *
- * The directive list is carried through rather than replaced, because `[]` already
- * means *"writable with no directive"* and an absent member means *"not writable
- * during this stage"* — two live answers core distinguishes (`V1006`), and a scope
- * qualifier must not collapse them into a third.
- */
 function writableIn(directives, bulk) {
     return bulk ? directives : { directives, scopes: ["nested"] };
 }
@@ -282,12 +135,8 @@ export function deriveRelationCapabilities(input) {
         look(PRISMA_EDGE_ARGUMENTS, argument, "an edge argument");
     }
     const filter = canonical(RELATION_FILTER_ORDER, [
-        // The edge's own `where` argument is what core calls `nested`: filtering the
-        // RETURNED edge **[CORE, operations/operation-validator-core.ts]**.
         ...(edgeArguments.has("where") ? ["nested"] : []),
         ...surface.filters.map((key) => look(PRISMA_RELATION_FILTERS, key, "a relation filter")),
-        // A null absence predicate needs a nullable edge; `[Nullable]ScalarRelationFilter`
-        // carries the same two keys either way, so nullability is the discriminant.
         ...(surface.nullable ? ["null"] : []),
     ]);
     const pagination = canonical(PAGINATION_ORDER, surface.pagination
@@ -298,10 +147,6 @@ export function deriveRelationCapabilities(input) {
         .map((key) => look(PRISMA_RELATION_DIRECTIVES, key, "a relation mutation directive"))
         .filter((directive) => directive !== null));
     return {
-        // The edge's own `select` / `include` arguments answer the UNRESTRICTED
-        // position; the surface's `bulkSelect` / `bulkInclude` answer the bulk one.
-        // Both are presence reads: see `PrismaRelationSurface.bulkSelect` for why the
-        // foreign-key rule is the explanation and not the mechanism.
         select: projectableIn(edgeArguments.has("select"), surface.bulkSelect),
         include: projectableIn(edgeArguments.has("include"), surface.bulkInclude),
         ...(filter.length > 0 ? { filter } : {}),
@@ -310,40 +155,16 @@ export function deriveRelationCapabilities(input) {
         ...(reducers.length > 0
             ? { reducers: reducersIn(reducers, surface.bulkReducers) }
             : {}),
-        // C-818, now EXPRESSIBLE rather than recorded as a conflict: the bulk create
-        // input carries no entry for this edge, so the create stage is advertised at
-        // the `nested` scope and nowhere else. Composition no longer has to choose
-        // between the two create variants' answers, and nothing is advertised to
-        // `create.many` that Prisma has no key for.
-        //
-        // C-855: each stage is still derived from ITS OWN nested input. The
-        // create-stage input admits `create` / `connectOrCreate` / `createMany` /
-        // `connect` and nothing more, so reusing the update-stage list here advertised
-        // five directives per to-many edge — and two per to-one edge — that Prisma
-        // rejects outright and `mutation.translator.ts` therefore refuses.
         create: writableIn(directives(surface.createMutations), surface.bulkCreatable),
         update: writableIn(directives(surface.updateMutations), surface.bulkUpdatable),
     };
 }
-/* ------------------------------------------------------------------ *
- * The two shared mechanics                                           *
- * ------------------------------------------------------------------ */
-/**
- * A dictionary lookup that refuses rather than returning `undefined`.
- *
- * A Prisma key no table recognises is a vocabulary gap — a 7.11 spelling, a
- * provider feature nobody measured — and dropping one silently is precisely
- * C-855's failure mode seen from the discovery side: a capability that quietly
- * does not exist. The dictionary's `null` is the deliberate "no Aventara word"
- * answer and passes through.
- */
 function look(table, key, what) {
     if (!(key in table)) {
         throw new PrismaCapabilityDerivationError(`the generated types offer "${key}" as ${what} and the dictionary has no row for it`);
     }
     return table[key];
 }
-/** The members present, in the canonical order, deduplicated. */
 function canonical(order, present) {
     const seen = new Set(present);
     return order.filter((member) => seen.has(member));

package/dist/discovery/client-shape.verifier.d.ts

@@ -0,0 +1,13 @@
+import type { PrismaClientShape } from "./discovery-artifact.interface.js";
+/**
+ * What differs between the client the artifact recorded and the one in hand, as
+ * short phrases — empty when they agree.
+ */
+export declare function describeClientDrift(recorded: PrismaClientShape, client: unknown): readonly string[];
+/**
+ * Throws when the client in hand is not the one the artifact was generated
+ * against — one sentence, naming what differs and `aventara:prepare`.
+ *
+ * @throws PrismaDiscoveryArtifactError
+ */
+export declare function assertClientMatchesArtifact(recorded: PrismaClientShape, client: unknown): void;

package/dist/discovery/client-shape.verifier.js

@@ -0,0 +1,93 @@
+import { delegateKeyOf } from "../execution/operation.executor.js";
+import { PrismaDiscoveryArtifactError } from "./artifact.loader.js";
+const SHOWN = 3;
+function readMember(value, key) {
+    if ((typeof value !== "object" && typeof value !== "function") ||
+        value === null) {
+        return undefined;
+    }
+    try {
+        return value[key];
+    }
+    catch {
+        return undefined;
+    }
+}
+function ownKeys(value) {
+    if (typeof value !== "object" || value === null) {
+        return [];
+    }
+    try {
+        return Reflect.ownKeys(value).filter((key) => typeof key === "string");
+    }
+    catch {
+        return [];
+    }
+}
+function delegateModelName(candidate) {
+    const name = readMember(candidate, "$name");
+    return typeof name === "string" &&
+        typeof readMember(candidate, "findMany") === "function"
+        ? name
+        : undefined;
+}
+function observedModels(client) {
+    const models = new Set();
+    for (const key of ownKeys(client)) {
+        if (key.startsWith("$") || key.startsWith("_") || key === "constructor") {
+            continue;
+        }
+        const name = delegateModelName(readMember(client, key));
+        if (name !== undefined) {
+            models.add(name);
+        }
+    }
+    return models;
+}
+export function describeClientDrift(recorded, client) {
+    const drift = [];
+    const live = observedModels(client);
+    const recognised = Object.keys(recorded).filter((model) => delegateModelName(readMember(client, delegateKeyOf(model))) === model);
+    if (live.size === 0 && recognised.length === 0) {
+        return [];
+    }
+    if (live.size > 0) {
+        for (const model of [...live].sort()) {
+            if (!Object.hasOwn(recorded, model)) {
+                drift.push(`model \`${model}\` is in the client and not in the artifact`);
+            }
+        }
+    }
+    for (const model of Object.keys(recorded).sort()) {
+        const delegate = readMember(client, delegateKeyOf(model));
+        if (delegateModelName(delegate) !== model) {
+            drift.push(`model \`${model}\` is in the artifact and not in the client`);
+            continue;
+        }
+        const fields = new Set(ownKeys(readMember(delegate, "fields")));
+        if (fields.size === 0) {
+            continue;
+        }
+        const expected = new Set(recorded[model]);
+        for (const field of [...fields].sort()) {
+            if (!expected.has(field)) {
+                drift.push(`field \`${model}.${field}\` is in the client and not in the artifact`);
+            }
+        }
+        for (const field of [...expected].sort()) {
+            if (!fields.has(field)) {
+                drift.push(`field \`${model}.${field}\` is in the artifact and not in the client`);
+            }
+        }
+    }
+    return drift;
+}
+export function assertClientMatchesArtifact(recorded, client) {
+    const drift = describeClientDrift(recorded, client);
+    if (drift.length === 0) {
+        return;
+    }
+    const shown = drift.slice(0, SHOWN).join("; ");
+    const more = drift.length > SHOWN ? `; and ${drift.length - SHOWN} more` : "";
+    throw new PrismaDiscoveryArtifactError(`The Prisma client has changed since the discovery artifact was generated (${shown}${more}):`, "run `npm run aventara:prepare` (the adapter's `aventara-prisma7-generate`) to regenerate it, then restart.");
+}

package/dist/discovery/discovery-artifact.interface.d.ts

@@ -1,14 +1,8 @@
-import type { AdapterResource, EnumDefinition, ScalarRegistry, TransactionCapability } from "@aventara/core";
+import type { Adapter, AdapterResource, EnumDefinition, ScalarRegistry, TransactionCapability } from "@aventara/core";
 import type { PrismaProvider } from "../provider/provider-profile.js";
 /**
- * T-4 — the discovery output, produced and never redefined.
- *
  * A plain `type`, not `interface … extends`: `AdapterModel.resources` is
  * self-typed `AdapterResource<this>`, and a nominal `extends` hits TS2430.
- * Phase 8 adds no member.
- *
- * (§9 of the plan names no owning file for this alias. It lives here because
- * this is the Task 2 file that needs it — the artifact is what carries it.)
  */
 export type PrismaAdapterModel = {
     readonly scalars: ScalarRegistry;
@@ -152,33 +146,54 @@ export type PrismaResourceReferentialActions = {
  * part of the model. Putting it inside would push referential-action vocabulary
  * into the compiled Contract and the ClientContract, where core has no word for
  * it, and would move the Contract identity of every schema that has a relation.
- *
- * Phase 8 owns the half that makes the facts exist and readable; the core seam
- * that plans a cascade from them is Phase 9's (S10): `createPrismaAdapter`
- * translates this table into core's words and states it as the adapter's
- * `referentialActions`, and core builds the closure from that.
  */
 export type PrismaReferentialActionTable<M extends PrismaAdapterModel = PrismaAdapterModel> = {
     readonly [R in keyof M["resources"]]: PrismaResourceReferentialActions;
 };
 /**
- * T-3.2 — what the generate step emits and the adapter loads.
- *
- * **ADR 0009 (Accepted) overrides the plan here: the artifact is one TypeScript
- * module, not JSON.** `resolveJsonModule` widens `"string"` to `string`, so a
- * JSON artifact would force a second emitted declaration purely to carry the
- * literals, and two emissions from one source can drift. One module written
- * `as const satisfies AdapterModel` makes value and type the same literal, and
- * makes drift unrepresentable rather than merely detectable.
- *
- * It is still passive, serializable, introspectable, hashable and free of
- * runtime callbacks (C-841): a `.ts` module whose only expression is a frozen
- * object literal is JSON that carries its own type.
- *
- * `M` is the reason this type is generic at all. The emitted module's `model`
- * is a literal type; if this alias pinned `model` to the general
- * {@link PrismaAdapterModel}, every resource key and field key would be erased
- * to `string` on the way to `createPrismaAdapter`, `EffectiveFieldKey` would
+ * What the generated Prisma client exposed when the artifact was generated: each
+ * model it has a delegate for, keyed by the model's name, and that model's field
+ * references (`prisma.<model>.fields`) in code-unit order.
+ *
+ * It is the artifact's record of the client it was read from, and the runtime
+ * reads the same two facts off the client it is handed — the delegates the client
+ * carries, and each one's public `fields`. When they disagree, the schema changed
+ * and the client was regenerated without the artifact, and the adapter refuses to
+ * start rather than serve a model that no longer matches. Prisma excludes
+ * `Unsupported(…)` and `@ignore`d fields and `@@ignore`d models from both the
+ * generated types and the runtime client, so the two readings agree by
+ * construction on an unchanged schema.
+ *
+ * Beside the model and outside `modelHash`, like the translation table: it
+ * describes the provider client, not the semantic model.
+ */
+export type PrismaClientShape = Readonly<Record<string, readonly string[]>>;
+/**
+ * What a create of each Resource cannot do without, already in core's words
+ * (`Adapter["createRequirements"]`): a column the client must write, or a
+ * required relation that may instead be written through the scalar fields that
+ * hold its reference — and the relation's other end, through which a nested
+ * create supplies it.
+ *
+ * Read at generate time from the generated client's create inputs — the
+ * question marks on `<M>UncheckedCreateInput` and `<M>CreateInput` — and from the
+ * schema's `@relation(fields: …)` pairing. Beside the model and outside
+ * `modelHash`: a requirement is a fact about the store, not about the semantic
+ * model, and the Contract carries no foreign-key detail.
+ */
+export type PrismaCreateRequirementTable = NonNullable<Adapter["createRequirements"]>;
+/**
+ * One module written `as const satisfies AdapterModel` makes value and type the
+ * same literal, and makes drift unrepresentable rather than merely detectable.
+ *
+ * It is still passive, serializable, introspectable, hashable and free of runtime
+ * callbacks: a `.ts` module whose only expression is a frozen object literal is
+ * JSON that carries its own type.
+ *
+ * `M` is the reason this type is generic at all. The emitted module's `model` is a
+ * literal type; if this alias pinned `model` to the general {@link
+ * PrismaAdapterModel}, every resource key and field key would be erased to
+ * `string` on the way to `createPrismaAdapter`, `EffectiveFieldKey` would
  * degenerate, and core's whole config-typing workstream would buy nothing —
  * silently, with no compile error anywhere. `model: M` is a bare property
  * position, which is what makes `M` actually infer at the call site;
@@ -188,7 +203,7 @@ export type PrismaReferentialActionTable<M extends PrismaAdapterModel = PrismaAd
  * "some Prisma adapter model".
  */
 export type PrismaDiscoveryArtifact<M extends PrismaAdapterModel = PrismaAdapterModel> = {
-    /** e.g. `"7.10.0"`; only the major is fenced (C-846). */
+    /** e.g. `"7.10.0"`; only the major is fenced. */
     readonly prismaVersion: string;
     readonly provider: PrismaProvider;
     /** `sha256:<hex>` of the canonicalized `model` below — and of nothing else. */
@@ -207,4 +222,14 @@ export type PrismaDiscoveryArtifact<M extends PrismaAdapterModel = PrismaAdapter
      * `R` says **deleting a `target` row does `onDelete` to rows of `R`**.
      */
     readonly referentialActions: PrismaReferentialActionTable<M>;
+    /**
+     * The client this artifact was generated against, beside the model and
+     * outside `modelHash`: see {@link PrismaClientShape}.
+     */
+    readonly client: PrismaClientShape;
+    /**
+     * The create requirements, beside the model and outside `modelHash`: see
+     * {@link PrismaCreateRequirementTable}.
+     */
+    readonly createRequirements: PrismaCreateRequirementTable;
 };

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

@@ -2,20 +2,13 @@ import type { EnumDefinition } from "@aventara/core";
 import type { PrismaSchemaEnum } from "./schema-facts.interface.js";
 import type { PrismaDiscoveryDiagnostic } from "./vocabulary.dictionary.js";
 /**
- * PSL enums → `EnumDefinition` **[CORE]**, and the one line of C-810.
- *
  * # Declaration order is semantic, so nothing here sorts
  *
- * §19.2 puts enum declaration order among the arrays whose order survives
- * canonicalization and enters the Contract hash. `definition.values` is therefore
- * PSL's order, copied — the types are a **cross-check**, not the source, exactly
- * as T-3.1's `enum values` row says.
- *
  * # What a cross-check failure means
  *
  * `enums.ts` and `schema.prisma` were read in the same instant by the same
- * generate step (D-802). If they disagree, one of them is stale, and the answer
- * is `diverged` — a build stop — rather than a preference for either. The message
+ * generate step. If they disagree, one of them is stale, and the answer is
+ * `diverged` — a build stop — rather than a preference for either. The message
  * prints both orders because "the enum diverged" without them costs the reader a
  * second investigation.
  *
@@ -24,8 +17,8 @@ import type { PrismaDiscoveryDiagnostic } from "./vocabulary.dictionary.js";
  * PSL's reader discards it as bucket 2 (a database name, which Aventara has no
  * word for), and the generated `enums.ts` writes the member name on *both* sides
  * of a mapped member — `GAMMA: 'GAMMA'`, not `GAMMA: 'g'` **[RUN8 — 2026-09-28,
- * prisma 7.10.0]**. So the cross-check compares Aventara identities on both
- * sides, and the mapper has nothing to resurrect.
+ * prisma 7.10.0]**. So the cross-check compares Aventara identities on both sides,
+ * and the mapper has nothing to resurrect.
  */
 export type EnumMappingInput = {
     /** PSL — the source of the values and their order. */
@@ -45,9 +38,8 @@ export type EnumMappingOutcome = {
     readonly diagnostic: PrismaDiscoveryDiagnostic;
 };
 /**
- * C-810 made concrete: an enum-backed column projects to a **ScalarField** whose
- * type ref takes the `enum` arm. The `kind` is a literal `"scalar"`, so a third
- * structural kind cannot be introduced here without the type changing.
+ * The `kind` is a literal `"scalar"`, so a third structural kind cannot be
+ * introduced here without the type changing.
  */
 export type EnumBackedColumn = {
     readonly kind: "scalar";

package/dist/discovery/enum.mapper.js

@@ -16,14 +16,13 @@ export function mapPrismaEnum(input) {
             outcome: "diverged",
             diagnostic: {
                 code: "enum-diverged",
-                message: `enum \`${declared.name}\` reads [${declaredOrder}] in ${declared.site.file} and [${exposedOrder}] in the generated \`enums.ts\`. Declaration order is semantic (§19.2) and enters the Contract hash, so this is a stale generated client, not a cosmetic difference.`,
+                message: `enum \`${declared.name}\` reads [${declaredOrder}] in ${declared.site.file} and [${exposedOrder}] in the generated \`enums.ts\`. Declaration order is semantic and enters the Contract hash, so this is a stale generated client, not a cosmetic difference.`,
             },
         };
     }
     return {
         outcome: "enum",
         name: declared.name,
-        // PSL's order, copied. Never sorted, never taken from the cross-check.
         definition: { values: [...declared.values] },
     };
 }