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

package/dist/generate/prisma.generate.js

@@ -11,70 +11,11 @@ import { readDeclaredSupport } from "./declared-support.reader.js";
 import { applyExistenceGate } from "./existence.gate.js";
 import { resolvePrismaCli } from "./prisma-cli.resolver.js";
 import { crossCheckReaders, describeReaderFindings, } from "./reader-crosscheck.js";
-/**
- * Task 3 — the adapter's **generate step**: a devDependency-only executable and
- * the only module that runs `prisma` or spawns a process. Nothing under
- * `execution/`, and nothing in `discovery/artifact.loader.ts`, imports it; the
- * package's build `exclude` keeps `src/generate/**` out of `dist` entirely, so
- * a deployed application never carries `typescript`, a PSL reader or a child
- * process.
- *
- * **The order is fixed, and each step earns its place:**
- *
- * 1. **The pinned `prisma` major** (C-846). PSL's grammar and the generated
- *    client's shape are version-bound; a major this reader has never seen must
- *    stop the build rather than produce a wrong `AdapterModel` from a grammar
- *    nobody read.
- * 2. **`@prisma/client/runtime/client` resolves** (§1.2 item 16). This one is
- *    first among equals, because its failure is *silent*: every generated file
- *    opens `// @ts-nocheck`, so with the runtime unresolvable a TypeScript
- *    program over the generated tree reports **zero** diagnostics while
- *    `FieldRef` degrades to its uninstantiated form and `JsonValue` stops being
- *    a union — flipping a types-derived nullability from `true` to `false` with
- *    nothing anywhere to say so **[RUN8]**. The guard is therefore a module
- *    *resolution*, never a diagnostic count: a diagnostic count is exactly the
- *    instrument that reads clean in this failure.
- * 3. **`prisma generate`**, run by this step itself. The two sources must
- *    describe one instant; a client generated by some earlier command may
- *    describe an older schema, and nothing downstream could tell.
- * 4. **Both sources read in that same run** — PSL for the semantic model, the
- *    🟢 generated types for the capability surface and for existence.
- * 5. **The structural checks, in that order.** The existence gate first (T-3.1
- *    invariant 3), because it decides *which* entities exist and a cross-check
- *    of an entity nobody admitted is noise; then the reader-versus-reader
- *    cross-check (`reader-crosscheck.ts`), which answers the reverse direction
- *    the gate hands it and every other fact both sources carry. Its findings
- *    stop the step; its two documented exemptions are reported and carried out
- *    on the result.
- * 6. **Emit** one TypeScript module (ADR 0009).
- *
- * The plan's §9 sketch puts the runtime check *after* `prisma generate`; the
- * order above is the brief's, and it is the better one — module resolution
- * walks `node_modules` upward from the client directory and does not need the
- * directory populated, so nothing is gained by generating output first that the
- * step is about to refuse to read.
- *
- * **The two readers fail differently, and the step keeps them different.** A
- * PSL `unhandled` entry means *I located a token I do not model*: there is a
- * construct, a spelling and a site to report, so they are aggregated and
- * reported together. A types-reader failure means *I cannot read the surface at
- * all*: there is nothing to record, so it throws. Inventing an `unhandled`
- * vocabulary for the type surface would be a second parallel representation of
- * "something went wrong" for no gain.
- */
-/** The `prisma` major this reader's grammar was written against (C-846). */
 export const PINNED_PRISMA_MAJOR = 7;
 export class PrismaGenerateStepError extends Error {
     name = "PrismaGenerateStepError";
 }
 const run = promisify(execFile);
-/**
- * The Prisma CLI this step runs, chosen as D11 states (`prisma-cli.resolver.ts`):
- * `@prisma/prisma7`'s `prisma7` when it is installed, else `prisma` when its
- * version is in the adapter's declared range, else a refusal naming both. Looked
- * up from this package — where an optional peer is linked — and then from the
- * project the step runs in.
- */
 export function resolveInstalledPrismaCli() {
     const resolution = resolvePrismaCli({
         searchFrom: [import.meta.url, path.join(process.cwd(), "package.json")],
@@ -85,26 +26,10 @@ export function resolveInstalledPrismaCli() {
     }
     return resolution.cli;
 }
-/**
- * The version fence's input: the version of the Prisma CLI this step runs, which
- * is the tool that produces the client and the grammar the PSL reader was
- * written against. (`@prisma/client`'s version is a different fact, fenced at
- * load time against the artifact — see `discovery/artifact.loader.ts`.)
- */
 export async function readInstalledPrismaVersion() {
     return resolveInstalledPrismaCli().version;
 }
-/**
- * D4 — the types reader and the runtime-resolution fence use TypeScript's
- * classic compiler API. TypeScript 7 has none (plan B3: `createProgram` and
- * `resolveModuleName` are absent; the package exports its version and nothing
- * else), and before this check the step died on it with a `TypeError` stack.
- * Asked of the API itself rather than of the version, because the API is what
- * the step needs.
- */
 function assertClassicCompilerApi() {
-    // Three members, not `Partial<typeof ts>`: a mapped type over the whole
-    // compiler namespace costs thousands of instantiations to ask three questions.
     const compiler = ts;
     if (typeof compiler?.createProgram === "function" &&
         typeof compiler.resolveModuleName === "function") {
@@ -112,15 +37,6 @@ function assertClassicCompilerApi() {
     }
     throw new PrismaGenerateStepError(`the installed \`typescript\` ${compiler?.version ?? "(no version)"} has no classic compiler API (\`createProgram\`), which this step reads the generated client's types with; install \`typescript\` in this adapter's declared range ${readDeclaredSupport().typescript}.`);
 }
-/**
- * Whether `@prisma/client/runtime/client` resolves from inside the generated
- * tree — the single question §1.2 item 16 turns on.
- *
- * Asked as a module resolution, never as a diagnostic count, and asked from a
- * file path *inside* `clientDirectory` because resolution walks `node_modules`
- * upward from the importer. The directory need not exist yet: resolution is a
- * path question, which is what lets this fence run before `prisma generate`.
- */
 export function clientRuntimeResolves(clientDirectory) {
     const containing = path.join(path.resolve(clientDirectory), "models", "_.ts");
     const resolved = ts.resolveModuleName("@prisma/client/runtime/client", containing, {
@@ -132,8 +48,6 @@ export function clientRuntimeResolves(clientDirectory) {
 }
 export function createPrismaGenerateToolchain() {
     assertClassicCompilerApi();
-    // Resolved once per toolchain, so the version the fence reads and the CLI the
-    // step runs cannot be two different installs.
     let cli;
     const prismaCli = () => {
         cli ??= resolveInstalledPrismaCli();
@@ -143,10 +57,6 @@ export function createPrismaGenerateToolchain() {
         installedPrismaVersion: async () => prismaCli().version,
         clientRuntimeResolves,
         runPrismaGenerate: async (schema) => {
-            // The CLI is the one resolved beside THIS package (or the project), run
-            // by path with this `node`: invoking whatever `prisma` is on PATH, or at
-            // a workspace root, can be a different install — or produce no output at
-            // all, which looks exactly like success.
             await run(process.execPath, [
                 prismaCli().entry,
                 "generate",
@@ -159,21 +69,6 @@ export function createPrismaGenerateToolchain() {
         writeArtifact: writeArtifactAtomically,
     };
 }
-/**
- * Writes the artifact so that no reader can ever open a partial file.
- *
- * Other packages' tests import the artifact while this package's `test` script
- * regenerates it, and turbo runs the two in parallel. `writeFile` truncates in
- * place, so a concurrent `import` could read an empty module — measured: the
- * client's pilot fixture failed with ``Cannot read properties of undefined
- * (reading 'enums')``. Two rules close it:
- *
- * - **unchanged bytes are not written** — generation is deterministic, so the
- *   common re-run touches nothing (and keeps the file's mtime for incremental
- *   tooling);
- * - **changed bytes land by `rename`** from a sibling temporary file, which POSIX
- *   makes atomic within one directory: a reader sees the old file or the new one.
- */
 async function writeArtifactAtomically(file, source) {
     const current = await readFile(file, "utf8").catch(() => undefined);
     if (current === source) {
@@ -197,10 +92,10 @@ function majorOf(version) {
 function assertPinnedMajor(version) {
     const major = majorOf(version);
     if (major === undefined) {
-        throw new PrismaGenerateStepError(`the installed \`prisma\` reports \`${version}\`, which is not a major.minor.patch version, so its major cannot be fenced against the pinned major ${PINNED_PRISMA_MAJOR} (C-846).`);
+        throw new PrismaGenerateStepError(`the installed \`prisma\` reports \`${version}\`, which is not a major.minor.patch version, so its major cannot be fenced against the pinned major ${PINNED_PRISMA_MAJOR}.`);
     }
     if (major !== PINNED_PRISMA_MAJOR) {
-        throw new PrismaGenerateStepError(`the installed \`prisma\` is major ${major} and this adapter's readers are written against pinned major ${PINNED_PRISMA_MAJOR} (C-846). PSL's grammar and the generated client's shape are version-bound, so a new major stops the build here rather than producing an AdapterModel from a grammar nobody has read.`);
+        throw new PrismaGenerateStepError(`the installed \`prisma\` is major ${major} and this adapter's readers are written against pinned major ${PINNED_PRISMA_MAJOR}. PSL's grammar and the generated client's shape are version-bound, so a new major stops the build here rather than producing an AdapterModel from a grammar nobody has read.`);
     }
 }
 function assertClientRuntimeResolves(toolchain, clientDirectory) {
@@ -220,22 +115,12 @@ function assertNothingUnhandled(facts) {
 }
 export async function runPrismaGenerateStep(request) {
     const toolchain = request.toolchain ?? createPrismaGenerateToolchain();
-    // 1. The version fence, before anything is run or read. The version is read
-    // ONCE and carried to the emit: a second read could answer differently, and
-    // an artifact stamped with a version the fence never saw is exactly the
-    // artifact the fence exists to prevent.
     const prismaVersion = await toolchain.installedPrismaVersion();
     assertPinnedMajor(prismaVersion);
-    // 2. The silent one.
     assertClientRuntimeResolves(toolchain, request.clientDirectory);
-    // 3. This step generates the client it is about to read.
     await toolchain.runPrismaGenerate(request.schema);
-    // 4. Both sources, in that same run.
     const facts = await toolchain.readSchema(request.schema);
     assertNothingUnhandled(facts);
-    // The types reader's failure mode is a throw with nothing to record, so it
-    // is re-raised as this step's own error with the cause preserved rather than
-    // aggregated into a vocabulary invented for it.
     let surface;
     try {
         surface = toolchain.readSurface(request.clientDirectory);
@@ -243,17 +128,12 @@ export async function runPrismaGenerateStep(request) {
     catch (cause) {
         throw new PrismaGenerateStepError(`the capability surface at ${request.clientDirectory} could not be read: ${cause instanceof Error ? cause.message : String(cause)}`, { cause });
     }
-    // 5. The structural checks. The gate decides existence; the cross-check then
-    // compares every fact both readers carry. A finding means one of the two
-    // READERS is wrong, never that the schema is — so the step stops rather than
-    // emitting a model it cannot justify.
     const { admitted, excluded } = applyExistenceGate(facts, surface);
     const { findings, exemptions } = crossCheckReaders(facts, surface);
     if (findings.length > 0) {
         throw new PrismaGenerateStepError(describeReaderFindings(findings));
     }
-    // 6. Emit.
-    const { model, translation, referentialActions } = request.composeModel({
+    const { model, translation, referentialActions, createRequirements } = request.composeModel({
         facts,
         surface,
         admitted,
@@ -264,6 +144,8 @@ export async function runPrismaGenerateStep(request) {
         model,
         translation,
         referentialActions,
+        client: clientShapeOf(surface),
+        createRequirements,
     });
     await toolchain.writeArtifact(request.artifactFile, source);
     const modelHash = await computeModelHash(model);
@@ -276,3 +158,11 @@ export async function runPrismaGenerateStep(request) {
         exemptions,
     };
 }
+function clientShapeOf(surface) {
+    return Object.fromEntries(Object.keys(surface.resources)
+        .sort()
+        .map((model) => [
+        model,
+        Object.keys(surface.resources[model]?.scalarFields ?? {}).sort(),
+    ]));
+}

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

@@ -2,73 +2,56 @@ import type { PrismaCapabilitySurface } from "../discovery/capability-surface.in
 import type { PrismaIdentifierMapping } from "../discovery/identifier.mapper.js";
 import type { PrismaSchemaFacts, PrismaSchemaModel } from "../discovery/schema-facts.interface.js";
 /**
- * Task 6 — the **reader-versus-reader cross-check**: PSL's facts against the 🟢
- * generated types' facts, at the one instant the generate step reads both.
- *
  * # It is a self-test of the two readers, not a check on the developer
  *
  * That framing decides every case in this module. A finding here does not mean
- * *your schema is wrong*; it means **one of this adapter's two readers is
- * wrong**, or the client it read was generated from a different schema than the
- * one PSL was read from. The remedy is never "edit the schema" — it is
- * regenerate, or fix a reader.
+ * *your schema is wrong*; it means **one of this adapter's two readers is wrong**,
+ * or the client it read was generated from a different schema than the one PSL was
+ * read from. The remedy is never "edit the schema" — it is regenerate, or fix a
+ * reader.
  *
- * It follows that the check can only see facts **both** sources carry. That is
- * not a gap to be closed by trying harder; it is arithmetic. The honest limit is
+ * It follows that the check can only see facts **both** sources carry. That is not
+ * a gap to be closed by trying harder; it is arithmetic. The honest limit is
  * measured below.
  *
  * # What it cannot see, measured rather than described
  *
- * **Re-measured 2026-10-02 on BOTH Phase 8 engines (prisma 7.10.0), by
- * `reader-crosscheck.spec.ts`'s "what the cross-check cannot see, by arithmetic"
- * case.** Four *real semantic* schema edits, each applied to the schema text
- * alone with the generated client left where it was, produce **zero findings
- * between them — eight measurements, eight zeros**:
- *
- * | edit                                                | sqlite | postgres |
- * | --------------------------------------------------- | ------ | -------- |
- * | `@default(uuid())` → `@default(cuid())`             | 0      | 0        |
- * | `@default(now())` → `@default(dbgenerated("…"))`    | 0      | 0        |
- * | `@default(BRONZE)` → `@default(GOLD)`               | 0      | 0        |
- * | `@relation("Mentorship")` → `@relation("Coaching")` | 0      | 0        |
+ * | edit | sqlite | postgres | |
+ * --------------------------------------------------- | ------ | -------- | |
+ * `@default(uuid())` → `@default(cuid())` | 0 | 0 | | `@default(now())` →
+ * `@default(dbgenerated("…"))` | 0 | 0 | | `@default(BRONZE)` → `@default(GOLD)` |
+ * 0 | 0 | | `@relation("Mentorship")` → `@relation("Coaching")` | 0 | 0 |
  *
  * Every one of them changes what the database does. None of them is visible to a
  * cross-check, because none of them reaches the 🟢 surface at all: a `@default`
- * argument's *content* and a relation's *name* are PSL-exclusive (the name
- * appears nowhere on the generated surface, which is why `field.mapper.ts` pairs
- * edges from PSL alone). A fifth class is the mirror image: which filter
- * operators a `<Kind>Filter` exposes is 🟢-exclusive, so a reader that
- * under-reads one is equally invisible — seeded as the sixth edit in
+ * argument's *content* and a relation's *name* are PSL-exclusive (the name appears
+ * nowhere on the generated surface, which is why `field.mapper.ts` pairs edges
+ * from PSL alone). A fifth class is the mirror image: which filter operators a
+ * `<Kind>Filter` exposes is 🟢-exclusive, so a reader that under-reads one is
+ * equally invisible — seeded as the sixth edit in
  * `__fixtures__/diverged-surface.ts` and caught by nothing.
  *
  * **So this module is not a schema-drift detector and must not be trusted as
- * one.** Staleness — a developer who edits `schema.prisma` and does not re-run
- * the generate step — is prevented by the step *running `prisma generate`
- * itself*, so that both sources describe one instant (T-3.2, the architect's
- * 2026-09-27 ruling). What survives that ruling catches a different failure
- * again: `modelHash` proves the artifact is internally intact and the
- * `prismaVersion` major fence catches a client that moved underneath it. Neither
- * notices a schema that moved, and neither does this.
+ * one.** Staleness — a developer who edits `schema.prisma` and does not re-run the
+ * generate step — is prevented by the step *running `prisma generate` itself*, so
+ * that both sources describe one instant. What survives that ruling catches a
+ * different failure again: `modelHash` proves the artifact is internally intact
+ * and the `prismaVersion` major fence catches a client that moved underneath it.
+ * Neither notices a schema that moved, and neither does this.
  *
  * # Two exemptions, and both are explanations rather than allowances
  *
  * A freshly generated pair is not silent, and the two cases where it speaks are
  * *understood*:
  *
- * 1. **`json-null-is-a-value`** — the one disagreement a pristine pair produces
- *    on both engines. JSON null is a *value*, so `JsonFilterBase` writes `|
- *    null` operands (`array_starts_with`, `array_ends_with`, and
- *    `array_contains` on PostgreSQL) on a column PSL declares **required**. A
- *    plausible "the operands mention null, therefore the column is nullable"
- *    rule is right for every other scalar and wrong for every `Json` one, which
- *    is why nullability comes from PSL's `?` and nothing else (T-3.1 invariant
- *    4) and why this one is exempted by PSL *type* rather than waved through.
- * 2. **`nullable-participant-key`** — `Author`'s `tenantId_handle` `AtLeast` key
- *    has no identifier behind it, because C-815 omits a tuple with a nullable
- *    participant (`handle String?`) while the generator still emits a key for
- *    it. C-814's rule is therefore a **subset relation with one closed
- *    explanation, never an equality**: equality is unsatisfiable by
- *    construction.
+ * 1. **`json-null-is-a-value`** — the one disagreement a pristine pair produces on
+ *    both engines. JSON null is a *value*, so `JsonFilterBase` writes `| null`
+ *    operands (`array_starts_with`, `array_ends_with`, and `array_contains` on
+ *    PostgreSQL) on a column PSL declares **required**. A plausible "the operands
+ *    mention null, therefore the column is nullable" rule is right for every other
+ *    scalar and wrong for every `Json` one, which is why nullability comes from
+ *    PSL's `?` and nothing else and why this one is exempted by PSL *type* rather
+ *    than waved through.
  *
  * Each exemption is **recorded with its reason**, not dropped. A spec can then
  * assert both by name and by reason, so an unexplained third disagreement fails
@@ -77,17 +60,17 @@ import type { PrismaSchemaFacts, PrismaSchemaModel } from "../discovery/schema-f
  * # What belongs to other modules, and is deliberately not restated here
  *
  * - **A PSL-declared entity the 🟢 types do not expose** is the EXISTENCE GATE's
- *   answer (`existence.gate.ts`, C-808): it decides admission and whether the
- *   absence is explained. This module answers only the reverse direction — a
- *   type-exclusive resource or field — which the gate's own header hands to it.
+ *   answer: it decides admission and whether the absence is explained. This module
+ *   answers only the reverse direction — a type-exclusive resource or field —
+ *   which the gate's own header hands to it.
  * - **A `FieldRef` token that disagrees with the written PSL type** is
  *   `field.mapper.ts`'s, where it *throws*: the two readers describing one field
  *   two ways is not a schema a Contract can be compiled from. Restating the rule
  *   here would be two owners for one fact.
  * - **A create-optional marker with no PSL cause** is `field.mapper.ts`'s
  *   `crossCheckCreateOptional`, run by `model.discoverer.ts` where the field
- *   projections already exist. It needs the projected lifecycle, which this
- *   module does not compute.
+ *   projections already exist. It needs the projected lifecycle, which this module
+ *   does not compute.
  */
 /** A disagreement about a fact both sources carry: one of the readers is wrong. */
 export type PrismaReaderFindingKind = 
@@ -97,7 +80,6 @@ export type PrismaReaderFindingKind =
  | "field-exclusive-to-types"
 /** PSL's `?` and the operands the 🟢 filter admits disagree. */
  | "nullability"
-/** C-814's subset rule is broken in one of its two directions. */
  | "identifier-key"
 /** An enum is exposed and not declared, declared and not exposed, or its members differ. */
  | "enum";
@@ -105,10 +87,7 @@ export type PrismaReaderFinding = {
     readonly kind: PrismaReaderFindingKind;
     /**
      * What the finding is about: `Model`, `Model.field`, `Enum`, or
-     * `Model:whereUniqueKey`. The **colon** marks an addressing key rather than a
-     * field path, because a `@@unique(name:)` key may be spelled like a column and
-     * reading one as the other is how C-814's cross-check once refused a schema
-     * Prisma accepts.
+     * `Model:whereUniqueKey`.
      */
     readonly entity: string;
     readonly message: string;
@@ -127,14 +106,11 @@ export type PrismaReaderCrossCheck = {
     /** Reported, never fatal. */
     readonly exemptions: readonly PrismaReaderExemption[];
 };
-/** One direction of C-814's subset rule, as a finding a spec can match on. */
 export type PrismaIdentifierKeyFinding = {
     readonly key: string;
     readonly reason: string;
 };
 /**
- * C-814's two directions, in one total function.
- *
  * Exported because it has **two callers that must check one rule**: the generate
  * step, through {@link crossCheckReaders}, and `identifier.mapper.spec.ts`, whose
  * own cases were written against a local copy while this file did not exist. The

package/dist/generate/reader-crosscheck.js

@@ -2,29 +2,17 @@ import { mapPrismaEnum } from "../discovery/enum.mapper.js";
 import { mapPrismaIdentifiers } from "../discovery/identifier.mapper.js";
 const JSON_EXEMPTION_REASON = "`Json` admits JSON null as a VALUE, so the generated `JsonFilterBase` writes `| null` operands " +
     "(`array_starts_with`, `array_ends_with`, and `array_contains` on PostgreSQL) on a column PSL " +
-    "declares required. Nullability therefore comes from PSL's `?` and nothing else (T-3.1 invariant 4).";
+    "declares required. Nullability therefore comes from PSL's `?` and nothing else.";
 function nullableParticipantReason(key, nullableMembers) {
-    return (`C-815 omits the uniqueness criterion behind \`${key}\` because [${nullableMembers.join(", ")}] ` +
+    return (`The model omits the uniqueness criterion behind \`${key}\` because [${nullableMembers.join(", ")}] ` +
         "is nullable and SQL uniqueness does not constrain NULLs, while the generator still emits an " +
-        "`AtLeast` key for it. C-814's rule is a subset relation with this one closed explanation, " +
+        "`AtLeast` key for it. The rule is a subset relation with this one closed explanation, " +
         "never an equality: equality is unsatisfiable by construction.");
 }
-/**
- * C-814's two directions, in one total function.
- *
- * Exported because it has **two callers that must check one rule**: the generate
- * step, through {@link crossCheckReaders}, and `identifier.mapper.spec.ts`, whose
- * own cases were written against a local copy while this file did not exist. The
- * explanation is re-derived **from PSL**, never taken on the mapping's word —
- * otherwise a mapper that invented a nullable participant would clear its own
- * exemption.
- */
 export function crossCheckIdentifierKeys(declared, mapping, uniqueKeys) {
     const findings = [];
     const nullableInPsl = new Set(declared.fields.filter((f) => f.optional).map((f) => f.name));
     const identifierKeys = mapping.identifiers.map((address) => address.key);
-    // (a) An identifier the types do not key means the PSL reader invented a
-    //     constraint.
     for (const key of identifierKeys) {
         if (!uniqueKeys.includes(key)) {
             findings.push({
@@ -33,8 +21,6 @@ export function crossCheckIdentifierKeys(declared, mapping, uniqueKeys) {
             });
         }
     }
-    // (b) A key with no identifier must be explained by C-815's nullable
-    //     participant and by nothing else.
     for (const key of uniqueKeys) {
         if (identifierKeys.includes(key)) {
             continue;
@@ -50,7 +36,7 @@ export function crossCheckIdentifierKeys(declared, mapping, uniqueKeys) {
         if (omission.reason !== "nullable-participant") {
             findings.push({
                 key,
-                reason: `omitted as ${omission.reason}, which C-815 does not license`,
+                reason: `omitted as ${omission.reason}, which no nullable participant explains`,
             });
             continue;
         }
@@ -64,14 +50,6 @@ export function crossCheckIdentifierKeys(declared, mapping, uniqueKeys) {
     }
     return findings;
 }
-/**
- * The whole cross-check: a pure function of the two readers' output.
- *
- * The order is a property of the model and not of how the readers happened to
- * build their records: resources in PSL declaration order, and within one
- * resource the type-exclusive fields, then nullability in PSL field order, then
- * the identifier keys; enums last.
- */
 export function crossCheckReaders(facts, surface) {
     const findings = [];
     const exemptions = [];
@@ -89,8 +67,6 @@ export function crossCheckReaders(facts, surface) {
     for (const model of facts.models) {
         const exposed = surface.resources[model.name];
         if (exposed === undefined) {
-            // A PSL-declared model the types do not expose is the existence gate's
-            // answer, with its own explained/unexplained split. Not restated here.
             continue;
         }
         const declaredFields = new Set(model.fields.map((f) => f.name));
@@ -110,16 +86,8 @@ export function crossCheckReaders(facts, surface) {
         for (const field of model.fields) {
             const scalar = exposed.scalarFields[field.name];
             if (scalar === undefined) {
-                // A relation edge's nullability is checked by `field.mapper.ts`, which
-                // has the payload's own `nullable` and throws on a disagreement.
                 continue;
             }
-            // A scalar LIST is out of scope, and the exclusion is a scoping decision
-            // rather than a measurement: `StringNullableListFilter.equals` is
-            // `string[] | null` on a `String[]` column PSL declares required
-            // (`Post.tags` on PostgreSQL), because the `null` there is about the
-            // absence of the whole list and not about an element. The rule below is a
-            // per-column nullability signal only where the column holds one value.
             if (field.list) {
                 continue;
             }
@@ -149,7 +117,7 @@ export function crossCheckReaders(facts, surface) {
             findings.push({
                 kind: "identifier-key",
                 entity: `${model.name}:${finding.key}`,
-                message: `\`${model.name}\`'s \`WhereUniqueInput\` key \`${finding.key}\` is ${finding.reason} (C-814).`,
+                message: `\`${model.name}\`'s \`WhereUniqueInput\` key \`${finding.key}\` is ${finding.reason}.`,
             });
         }
         for (const omission of mapping.omitted) {
@@ -175,9 +143,6 @@ export function crossCheckReaders(facts, surface) {
         });
     }
     for (const declared of facts.enums) {
-        // The member comparison is the ENUM MAPPER's own rule, invoked rather than
-        // restated: declaration order is semantic (§19.2) and enters the Contract
-        // hash, so "diverged" is the same judgement in both callers.
         const mapped = mapPrismaEnum({
             declared,
             exposed: surface.enums[declared.name],
@@ -193,7 +158,6 @@ export function crossCheckReaders(facts, surface) {
     }
     return { findings, exemptions };
 }
-/** The sentence the generate step refuses with. Built here, so one wording exists. */
 export function describeReaderFindings(findings) {
     return [
         "the two discovery readers disagree about facts they both carry, which means one of THEM is wrong — not the schema:",

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

@@ -1,26 +1,21 @@
 import type { PrismaIsolationLevel } from "./provider/provider-profile.js";
 /**
- * T-1 — the minimal structural shape the adapter actually uses, rather than
- * the full generated client type. This is the seam that keeps the adapter
- * compilable with no generated client in scope and testable with a recording
- * double.
+ * This is the seam that keeps the adapter compilable with no generated client in
+ * scope and testable with a recording double.
  *
- * **Why there is no `[model: string]` index signature here, though T-1
- * describes the host as "an index of model delegates plus `$transaction`":**
- * a generated `PrismaClient` is a *class*, and TypeScript grants an implicit
- * index signature only to object-literal type aliases. Observed on 2026-09-23
- * with the real generated client and `tsc -p tsconfig.typecheck.json`:
+ * Observed on 2026-09-23 with the real generated client and `tsc -p
+ * tsconfig.typecheck.json`:
  *
- *   error TS2322: Type 'PrismaClient' is not assignable to type 'HostWithIndex'.
- *     Index signature for type 'string' is missing in type
- *     'PrismaClient<never, GlobalOmitConfig | undefined, DefaultArgs>'.
+ * error TS2322: Type 'PrismaClient' is not assignable to type 'HostWithIndex'.
+ * Index signature for type 'string' is missing in type 'PrismaClient<never,
+ * GlobalOmitConfig | undefined, DefaultArgs>'.
  *
- * The same probe with the index signature removed compiled clean. So the
- * public constraint declares only `$transaction`, and the delegate index is
- * reached through `prismaDelegates()` below — one named seam, in one place,
- * instead of a constraint no real client can satisfy.
+ * The same probe with the index signature removed compiled clean. So the public
+ * constraint declares only `$transaction`, and the delegate index is reached
+ * through `prismaDelegates()` below — one named seam, in one place, instead of a
+ * constraint no real client can satisfy.
  */
-/** Adapter-owned transaction options; never Aventara public configuration (D-806). */
+/** Adapter-owned transaction options; never Aventara public configuration. */
 export type PrismaTransactionOptions = {
     /** Prisma's own default is 2000 ms **[PKG, `runtime/client.d.ts`]**. */
     readonly maxWait?: number;
@@ -31,8 +26,8 @@ export type PrismaTransactionOptions = {
 /** One Prisma model delegate, as far as the adapter is concerned. */
 export type PrismaDelegate = Readonly<Record<string, unknown>>;
 /**
- * The host the adapter is handed. `$transaction` is declared in its callback
- * form only: the array overload is never reached (C-803, spec §14.5).
+ * The host the adapter is handed. `$transaction` is declared in its callback form
+ * only: the array overload is never reached.
  */
 export interface PrismaDelegateHost {
     $transaction<T>(work: (transactional: PrismaDelegateHost) => Promise<T>, options?: PrismaTransactionOptions): Promise<T>;

package/dist/prisma-client.interface.js

@@ -1,9 +1,3 @@
-/**
- * The single place the structural gap between a generated client (a class,
- * with no index signature) and a delegate index is crossed. Every delegate
- * lookup in the adapter goes through here, so there is exactly one assertion
- * to audit rather than one per call site.
- */
 export function prismaDelegates(client) {
     return client;
 }

package/dist/prisma.adapter.d.ts

@@ -3,33 +3,25 @@ import type { PrismaAdapterModel, PrismaDiscoveryArtifact } from "./discovery/di
 import type { PrismaDelegateHost, PrismaTransactionOptions } from "./prisma-client.interface.js";
 import { type PrismaDriver, type PrismaProvider } from "./provider/provider-profile.js";
 /**
- * T-1 — the adapter's only public entry point, and the composition root.
- *
  * `TClient` stays generic so a caller's generated client type flows through
- * without this package naming it: `client` is the one and only place a Prisma
- * type enters the public surface, and it enters as the caller's own parameter
- * (C-802).
+ * without this package naming it: `client` is the one and only place a Prisma type
+ * enters the public surface, and it enters as the caller's own parameter.
  */
 export type PrismaAdapterOptions<TClient extends PrismaDelegateHost, M extends PrismaAdapterModel = PrismaAdapterModel> = {
-    /** Application-owned, already-constructed client (spec §18.2). */
+    /** Application-owned, already-constructed client. */
     readonly client: TClient;
     /**
-     * The generate-time discovery artifact this adapter loads and checks
-     * (D-802, T-3.2).
+     * The generate-time discovery artifact this adapter loads and checks.
      *
-     * This is the one and only inference site for `M`: the emitted artifact
-     * module's `model` is a literal type, and `PrismaDiscoveryArtifact<M>`
-     * expands to a bare `model: M` property so the compiler reads that literal
-     * off the argument. Route `M` through a conditional or a mapped type here
-     * and it stops inferring, falls back to its default with **no compile
-     * error**, and every narrowing downstream of the model quietly widens to
-     * `string` — the trap core hit at S2 with `Cfg`.
+     * This is the one and only inference site for `M`: the emitted artifact module's
+     * `model` is a literal type, and `PrismaDiscoveryArtifact<M>` expands to a bare
+     * `model: M` property so the compiler reads that literal off the argument.
      */
     readonly discovery: PrismaDiscoveryArtifact<M>;
-    /** Declared, never sniffed from client internals (D-804). */
+    /** Declared, never sniffed from client internals. */
     readonly provider: PrismaProvider;
     readonly driver: PrismaDriver;
-    /** Adapter-owned, never Aventara public configuration (D-806). */
+    /** Adapter-owned, never Aventara public configuration. */
     readonly transactionOptions?: PrismaTransactionOptions;
 };
 /**