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

package/dist/discovery/types.reader.js

@@ -1,72 +1,9 @@
 import { readdirSync, readFileSync, statSync } from "node:fs";
 import path from "node:path";
 import ts from "typescript";
-/**
- * T-3, source **TYPE** — the reader over the generated client's 🟢 public types.
- *
- * # Rule one: the 🟢 files only
- *
- * The files whose banner reads *"🟢 You can import this file directly"* are the
- * only input. At 7.10.0 that is **9 per generated client** — `browser.ts`,
- * `client.ts`, `commonInputTypes.ts`, `enums.ts`, `models.ts` and one
- * `models/<M>.ts` per model — against **3** marked *"🛑 Under no circumstances
- * should you import this file directly! 🛑"*, all three under `internal/`. Across
- * the two Phase 8 clients: 18 and 6, re-counted on 2026-09-27 rather than
- * inherited.
- *
- * The 🛑 files are excluded **by path**, before anything is opened, because
- * classifying them by their banner would require opening them. The compiler host
- * below refuses a read under `internal/` outright instead of quietly skipping it,
- * and every 🟢 file it opens is checked to carry the 🟢 banner.
- *
- * # Rule two: the written type arguments, never the instantiated reference
- *
- * Token-shaped facts come from the **written syntax** — a
- * `TypeReferenceNode`'s `typeArguments` — resolved one node at a time with
- * `getTypeFromTypeNode`.
- *
- * The shorthand "from the AST rather than from the checker" is
- * self-contradictory, since `getTypeFromTypeNode` **is** a `ts.TypeChecker`
- * method. What matters is *which* checker question is asked. On a string-literal
- * type argument, `getTypeFromTypeNode` answers from that node's own syntax and
- * does not depend on `@prisma/client/runtime/client` resolving. Asking for the
- * type *at* the reference (`getTypeAtLocation` on `FieldRef<"M0", 'String'>`)
- * silently answers with the uninstantiated form when the runtime is unresolvable
- * — and `// @ts-nocheck`, which the generator writes into every file, means a
- * program over a broken install reports **zero** diagnostics while doing it
- * (§1.2 item 16). This reader asks the first question only.
- *
- * This program is deliberately built with `noResolve` and `noLib`, so the
- * broken-install condition is not merely survived, it is **the normal case**:
- * nothing outside the 🟢 files is ever resolved, and the reader still answers.
- *
- * # What this reader does not do
- *
- * It states no provider conditionality of its own. `filterOperands` carries each
- * operator's operand **as written** precisely so no later module has to branch on
- * `provider` to learn a fact the types already state (T-3.1 invariant 6).
- *
- * It also does not decide anything: `resources` is the existence gate's evidence,
- * not the gate. A PSL-only entity is a generate-time error, and the generate step
- * owns that error.
- *
- * # Rule three: a scope is a presence question, never a rule reproduced
- *
- * The bulk-returning projection ceiling and the flat-bulk write stage are read the
- * same way everything else here is read — **is the member in the type?** —
- * against `<M>Select{Create,Update}ManyAndReturn`, their `Include` counterparts and
- * the two bulk write inputs. The *explanation* for which relations survive is
- * foreign-key ownership rather than cardinality; reproducing that explanation as a
- * rule would be a tabulated provider fact (D-802, §18.4) that goes wrong the first
- * time Prisma admits a different set. See `PrismaRelationSurface.bulkSelect`.
- */
-/** The banner that marks a file as public. */
 const GREEN_BANNER = "You can import this file directly";
-/** The banner that marks a file as private. Never expected to be read. */
 const RED_BANNER = "Under no circumstances should you import this file directly";
-/** The generated tree's private directory, excluded by path. */
 const PRIVATE_DIRECTORY = "internal";
-/** Edge-argument keys that other surface fields already own, so pagination is the residual. */
 const NON_PAGINATION_EDGE_ARGUMENTS = new Set([
     "select",
     "omit",
@@ -77,14 +14,6 @@ const MANY_WRITE_OPERATION = /^(?:create|update|delete)Many(?:AndReturn)?$/;
 export class PrismaTypesReaderError extends Error {
     name = "PrismaTypesReaderError";
 }
-/**
- * The reader's one checker question, exported because it is the distinction the
- * whole reader rests on and therefore has to be testable on its own.
- *
- * Returns each written type argument's type as the checker renders it, so
- * `FieldRef<"M0", 'String'>` answers `['"M0"', '"String"']` — including when
- * `FieldRef` itself does not resolve.
- */
 export function readWrittenTypeArguments(checker, reference) {
     return (reference.typeArguments ?? []).map((argument) => checker.typeToString(checker.getTypeFromTypeNode(argument)));
 }
@@ -98,9 +27,6 @@ export function readPrismaCapabilitySurface(clientDirectory) {
     const host = createPublicOnlyHost(root, filesRead);
     const program = ts.createProgram({
         rootNames: publicFiles,
-        // `noResolve` and `noLib` are the point, not an optimisation: nothing
-        // outside the 🟢 files can be pulled in, so the reader's answers cannot
-        // depend on a resolvable `@prisma/client/runtime/client`.
         options: {
             noResolve: true,
             noLib: true,
@@ -119,9 +45,6 @@ export function readPrismaCapabilitySurface(clientDirectory) {
         filesRead: [...filesRead],
     };
 }
-/* ------------------------------------------------------------------ *
- * Input: the 🟢 files, and a host that refuses the 🛑 ones            *
- * ------------------------------------------------------------------ */
 function listPublicFiles(root) {
     return readdirSync(root, { recursive: true, withFileTypes: true })
         .filter((entry) => entry.isFile() &&
@@ -137,8 +60,6 @@ function createPublicOnlyHost(root, filesRead) {
     const readPublicFile = (fileName) => {
         const resolved = path.resolve(fileName);
         if (!resolved.startsWith(root + path.sep)) {
-            // Nothing outside the generated tree is served, so a stray specifier
-            // fails loudly rather than widening the input.
             return undefined;
         }
         if (isPrivatePath(root, resolved)) {
@@ -164,12 +85,6 @@ function createPublicOnlyHost(root, filesRead) {
         getCanonicalFileName: (fileName) => fileName,
         useCaseSensitiveFileNames: () => true,
         getNewLine: () => "\n",
-        // Existence is the file system's answer, and only for what this host would
-        // serve: a public `.ts` file under the root. TypeScript 6 probes
-        // `package.json` files under the root even with `noResolve` (plan B4); a
-        // host that answered `true` for any path there sent it to `readFile`, which
-        // threw `ENOENT`. TypeScript 5.9 never asked, so the old answer was never
-        // tested.
         fileExists: (fileName) => {
             const resolved = path.resolve(fileName);
             return (resolved.startsWith(root + path.sep) &&
@@ -196,30 +111,10 @@ function indexDeclarations(program, publicFiles) {
     }
     return index;
 }
-/** The two bulk-returning write calls, in the spelling the generated type names use. */
 const BULK_RETURNING_WRITES = ["CreateManyAndReturn", "UpdateManyAndReturn"];
-/**
- * Whether every one of the declared member sets lists `member`.
- *
- * **Zero sets answer `false`.** `Array.prototype.every` is vacuously true on an
- * empty array, and taking that answer would advertise a scope on a client that
- * declares no bulk-returning projection type at all — over-advertisement by
- * arithmetic, which is C-855's failure mode arriving through a language default.
- */
 function admittedByEvery(sets, member) {
     return sets.length > 0 && sets.every((names) => names.has(member));
 }
-/**
- * The member names of a projection type, read off the **written** object literal.
- *
- * Two shapes carry one meaning at 7.10.0 and both have to be read: `<M>Select…` is
- * written `GetSelect<{ … }, ExtArgs["result"]["m"]>`, so its members live in the
- * first written type argument, while `<M>Include…` is written as a plain object
- * type. `null` means the client declares no such type — the honest answer for a
- * generator that emits no `*AndReturn` projection, and not the same as a type that
- * is declared and empty (`UserIncludeCreateManyAndReturn` is literally `{}` in
- * this repository, which is a measured `false` per edge rather than an absence).
- */
 function projectionMembers(index, name) {
     const declaration = index.get(name);
     if (declaration === undefined) {
@@ -251,7 +146,6 @@ function readBulkSurface(index, model) {
         ]),
     };
 }
-/** The members of a named declaration, following Prisma's one `…Base` indirection. */
 function membersOf(index, name) {
     const declaration = index.get(name);
     if (declaration === undefined) {
@@ -263,8 +157,6 @@ function membersOf(index, name) {
     if (ts.isTypeLiteralNode(declaration.type)) {
         return declaration.type.members.filter(ts.isPropertySignature);
     }
-    // `JsonFilter` is a conditional over `JsonFilterBase`, which is where the
-    // operators are actually written. One documented indirection, not a search.
     return membersOf(index, `${name}Base`);
 }
 function memberName(member) {
@@ -275,13 +167,11 @@ function memberName(member) {
 function memberNames(members) {
     return members.map(memberName);
 }
-/** The rightmost identifier of a type reference's name: `Prisma.StringFilter` → `StringFilter`. */
 function referencedName(reference) {
     return ts.isQualifiedName(reference.typeName)
         ? reference.typeName.right.text
         : reference.typeName.text;
 }
-/** The first type reference, at any depth, whose name satisfies `accept`. */
 function findReference(node, accept) {
     if (node === undefined) {
         return null;
@@ -311,9 +201,6 @@ function keysOfReferenced(index, node, accept) {
     }
     return memberNames(members);
 }
-/* ------------------------------------------------------------------ *
- * Enums                                                              *
- * ------------------------------------------------------------------ */
 function readEnums(program, root) {
     const source = program.getSourceFile(path.join(root, "enums.ts"));
     if (source === undefined) {
@@ -332,8 +219,6 @@ function readEnums(program, root) {
                 !ts.isIdentifier(declaration.name)) {
                 continue;
             }
-            // Property order is the member order. `as const` is what makes it an
-            // enum projection rather than a mutable object.
             enums[declaration.name.text] = initializer.expression.properties
                 .filter(ts.isPropertyAssignment)
                 .map((property) => ts.isIdentifier(property.name) || ts.isStringLiteral(property.name)
@@ -343,9 +228,6 @@ function readEnums(program, root) {
     }
     return enums;
 }
-/* ------------------------------------------------------------------ *
- * Resources                                                          *
- * ------------------------------------------------------------------ */
 function readResources(checker, index) {
     const resources = {};
     for (const name of [...index.keys()].sort()) {
@@ -367,14 +249,8 @@ function readResource(checker, index, model) {
         throw new PrismaTypesReaderError(`$${model}Payload's own name literal is ${declaredName}`);
     }
     const where = membersOf(index, `${model}WhereInput`) ?? [];
-    // The CHECKED create/update inputs, because the unchecked halves carry no
-    // relation edge at all — the foreign-key scalar stands in for it there. Both
-    // stages are read, separately: see `PrismaRelationSurface.createMutations`.
     const create = membersOf(index, `${model}CreateInput`) ?? [];
     const update = membersOf(index, `${model}UpdateInput`) ?? [];
-    // The UNCHECKED inputs, because they are what the delegate accepts: `data` is
-    // `XOR<<M>UpdateInput, <M>UncheckedUpdateInput>`, and only the unchecked half
-    // carries the foreign-key scalars and the generated identifiers.
     const uncheckedCreate = membersOf(index, `${model}UncheckedCreateInput`) ?? [];
     const uncheckedUpdate = membersOf(index, `${model}UncheckedUpdateInput`) ?? [];
     const orderBy = membersOf(index, `${model}OrderByWithRelationInput`) ?? [];
@@ -390,7 +266,6 @@ function readResource(checker, index, model) {
         manyWriteArguments: readManyWriteArguments(index, model, operations),
     };
 }
-/** The payload's own `name: "M"` literal — the only authority on a relation's target. */
 function payloadName(checker, payload) {
     const member = payload.find((m) => memberName(m) === "name");
     if (member?.type === undefined) {
@@ -401,8 +276,6 @@ function payloadName(checker, payload) {
 function readScalarFields(checker, index, model, payload, where, uncheckedCreate, uncheckedUpdate, orderBy) {
     const tokens = readFieldRefTokens(checker, index, model);
     const declared = payload.find((m) => memberName(m) === "scalars");
-    // `scalars` is written as `GetPayloadResult<{ … }, …>`; the first written type
-    // argument is the object, and that is read, not the instantiated result.
     const written = declared?.type;
     const literal = written !== undefined && ts.isTypeReferenceNode(written)
         ? written.typeArguments?.[0]
@@ -430,14 +303,9 @@ function readScalarFields(checker, index, model, payload, where, uncheckedCreate
             filters: memberNames(filterMembers),
             filterOperands: Object.fromEntries(filterMembers.map((member) => [
                 memberName(member),
-                // As WRITTEN. Two engines carry `path` with different operands, and
-                // a name set cannot express that (T-3.1 invariant 6).
                 member.type?.getText() ?? "",
             ])),
             createOperations: readMutationOperations(index, model, "Create", name, uncheckedCreate.get(name)),
-            // The question mark, read from the member the line above read its
-            // directives from — one member, two facts, so they cannot disagree about
-            // whether the column is creatable at all.
             createOptional: uncheckedCreate.get(name)?.questionToken !== undefined,
             updateOperations: readMutationOperations(index, model, "Update", name, uncheckedUpdate.get(name)),
             orderable: order !== undefined,
@@ -446,23 +314,6 @@ function readScalarFields(checker, index, model, payload, where, uncheckedCreate
     }
     return fields;
 }
-/**
- * One mutation input entry, read as the keys of the `…Input` it references.
- *
- * Two reference spellings carry operations and no others do:
- * `<Kind>FieldUpdateOperationsInput` (`set`, and the four arithmetic directives on
- * the numeric kinds) and `<M><Stage><field>Input` (a scalar list's own `set` and
- * `push`). Everything else is a plain value — `Json`'s
- * `JsonNullValueInput | InputJsonValue`, and every create-stage scalar — and
- * answers `[]`.
- *
- * `undefined` in, `null` out: the client exposes no entry for this column at this
- * stage, which is the ONLY evidence of a column that cannot be written. Matching
- * the two spellings by name rather than taking the first `…Input` reference is
- * load-bearing: `JsonNullValueInput` is an `…Input` whose members are null
- * sentinels, and reading those as operations would advertise `DbNull` as a
- * mutation directive.
- */
 function readMutationOperations(index, model, stage, field, member) {
     if (member === undefined) {
         return null;
@@ -478,7 +329,6 @@ function readMutationOperations(index, model, stage, field, member) {
     }
     return memberNames(members);
 }
-/** `<M>FieldRefs` → field name to scalar token, read from the written type arguments. */
 function readFieldRefTokens(checker, index, model) {
     const members = membersOf(index, `${model}FieldRefs`);
     if (members === null) {
@@ -523,42 +373,23 @@ function readRelationFields(checker, index, payload, where, create, update, incl
         if (targetMembers === null) {
             throw new PrismaTypesReaderError(`${referencedName(targetPayload)} is declared nowhere in the 🟢 types`);
         }
-        // `<M>Include`'s entry for this edge names the edge's own argument type, and
-        // there are TWO spellings at 7.10.0 — measured 2026-10-02, because matching
-        // only the `$` one silently gave every REQUIRED to-one edge an empty argument
-        // list: a nullable to-one and a to-many name `<M>$<edge>Args`, while a
-        // required to-one names the target's `<T>DefaultArgs`. The difference is real
-        // and semantic — `<T>DefaultArgs` carries no `where`, so a required to-one
-        // genuinely admits no nested filtering of the returned edge — but
-        // `select`/`omit`/`include` are on both, so both have to be read.
         const edge = findReference(include.get(name)?.type, (n) => n.endsWith("Args"));
         const edgeArguments = edge === null
             ? []
             : memberNames(membersOf(index, referencedName(edge)) ?? []);
         fields[name] = {
-            // The TARGET payload's own `name` literal, not the alias's spelling.
             target: payloadName(checker, targetMembers),
             many,
             nullable,
             filters: keysOfReferenced(index, where.get(name)?.type, (n) => n.endsWith("RelationFilter")),
-            // The two stages name their nested inputs differently — the create-stage
-            // one is `<T>CreateNested{One,Many}Without<M>Input`, which does NOT end in
-            // `NestedInput` — and that is why each predicate is written out rather
-            // than one being reused: the stage is identified by the input the client
-            // itself references at that stage, not by a tabulated key set.
             createMutations: keysOfReferenced(index, create.get(name)?.type, (n) => CREATE_NESTED_INPUT.test(n)),
+            createRequired: create.get(name) !== undefined &&
+                create.get(name)?.questionToken === undefined,
             updateMutations: keysOfReferenced(index, update.get(name)?.type, (n) => n.endsWith("NestedInput")),
             edgeArguments,
-            // Pagination is the residual of the edge's own args: what neither
-            // projection nor predicate already owns. A to-one edge leaves nothing.
             pagination: edgeArguments.filter((argument) => !NON_PAGINATION_EDGE_ARGUMENTS.has(argument)),
             orderable: orderBy.has(name),
             reducers: counted.has(name) ? ["_count"] : [],
-            // PRESENCE in the four `*AndReturn` projection types and the two bulk
-            // write inputs. No foreign key is looked at and no cardinality is
-            // consulted: `many` sits three lines up and is deliberately not read here
-            // — a to-one that does not own its FK is absent from these types, and that
-            // is a fact about the types, not a rule this reader reproduces.
             bulkSelect: admittedByEvery(bulk.select, name),
             bulkInclude: admittedByEvery(bulk.include, name),
             bulkReducers: admittedByEvery([...bulk.select, ...bulk.include], "_count"),
@@ -568,11 +399,6 @@ function readRelationFields(checker, index, payload, where, create, update, incl
     }
     return fields;
 }
-/**
- * The create-stage nested-write input's name, as 7.10.0 writes it:
- * `<T>CreateNested{One,Many}Without<M>Input`. The update-stage spellings all end
- * in `NestedInput`, so the two never collide.
- */
 const CREATE_NESTED_INPUT = /CreateNested(?:One|Many)Without.*Input$/;
 function readUniqueKeys(checker, index, model) {
     const declaration = index.get(`${model}WhereUniqueInput`);
@@ -587,7 +413,6 @@ function readUniqueKeys(checker, index, model) {
     const nodes = ts.isUnionTypeNode(keys) ? keys.types : [keys];
     return nodes.map((node) => unquote(checker.typeToString(checker.getTypeFromTypeNode(node))));
 }
-/** `<M>Delegate`'s own methods, in declaration order. */
 function readOperations(index, model) {
     const declaration = index.get(`${model}Delegate`);
     if (declaration === undefined || !ts.isInterfaceDeclaration(declaration)) {

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

@@ -1,16 +1,7 @@
 import type { AdapterLifecycleTrait, BuiltInScalar, PaginationCapability, RelationFilterCapability, RelationMutationDirective, ScalarFilterOperator, ScalarFormat, ScalarMutationDirective } from "@aventara/core";
 /**
- * T-3.1 — the vocabulary dictionary: where PSL, the 🟢 generated types and the
- * observed runtime meet Aventara's own words.
- *
  * # It is data, not conditionals
  *
- * Every table below is a value a reader can hold beside T-3.1's table and check
- * row by row. Nothing here branches on a provider, a field name or a schema: a
- * module that learns a fact by asking `if (provider === "sqlite")` is tabulating
- * what the sources already state, which is the cover-up C-854 forbids
- * (T-3.1 invariant 6).
- *
  * # Every entry names its source class (invariant 1)
  *
  * `VOCABULARY` carries one row per Aventara fact with its source code — `PSL`,
@@ -22,8 +13,8 @@ import type { AdapterLifecycleTrait, BuiltInScalar, PaginationCapability, Relati
  *
  * `PRISMA_DEFAULT_TABLE` is looked up with the raw text the PSL reader carried
  * across unchanged. `dbgenerated("gen_random_uuid()")` is a **key**, not an
- * expression: the day this module evaluates one, the reader behind it has become
- * a parser and needs a different decision (T-3). An unmatched form falls back to
+ * expression: the day this module evaluates one, the reader behind it has become a
+ * parser and needs a different decision. An unmatched form falls back to
  * `PRISMA_UNMATCHED_DEFAULT_TRAITS` **plus** a recorded unknown that fails the
  * generate step — never an inferred trait.
  *
@@ -45,25 +36,15 @@ import type { AdapterLifecycleTrait, BuiltInScalar, PaginationCapability, Relati
  */
 export type VocabularySource = "PSL" | "TYPE" | "RUN" | "DRIVER" | "CFG";
 export type VocabularyEntry = {
-    /** The Aventara fact, spelled as T-3.1's left column spells it. */
     readonly fact: string;
     /** Non-empty by construction: invariant 1 is enforced by the type, not by a comment. */
     readonly sources: readonly [VocabularySource, ...VocabularySource[]];
     readonly rule: string;
 };
 /**
- * T-3.1's table, row for row, so a reader can audit one against the other.
- *
- * **`format?` diverges from T-3.1's table deliberately, and the plan row is the
- * one that is wrong.** T-3.1 says `format?` is `CFG` — "PSL's `@db.*` is a hint
- * only … policy, not discovery". Spec §6.1 says the opposite in as many words:
- * UUID "is a string scalar plus passive format metadata **when the adapter can
- * prove the format**", §18.3's discovery mapping reads "scalar type → stable
- * framework scalar + optional format", C-809 restates both, T-5 restates them
- * again, and `AdapterScalarField.format?` exists **[CORE]** — a member with no
- * producer if discovery never emits one. So the source is `PSL` **and** `CFG`:
- * discovery emits what the provider's own column type proves, configuration owns
- * everything else. `scalar.mapper.ts`'s header carries the full argument.
+ * So the source is `PSL` **and** `CFG`: discovery emits what the provider's own
+ * column type proves, configuration owns everything else. `scalar.mapper.ts`'s
+ * header carries the full argument.
  */
 export declare const VOCABULARY: readonly VocabularyEntry[];
 /**
@@ -71,18 +52,20 @@ export declare const VOCABULARY: readonly VocabularyEntry[];
  * refusal is the dictionary's own answer: a construct it has no word for.
  */
 export type PrismaDiscoveryDiagnosticCode = 
-/** A Prisma type name in neither PRISMA_SCALAR_TABLE nor `enums.ts` (C-809). */
+/** A Prisma type name in neither PRISMA_SCALAR_TABLE nor `enums.ts`. */
 "unmapped-prisma-type"
-/** PSL declares it, the 🟢 types do not expose it: omitted, with the reason said out loud (C-808). */
+/**
+ * PSL declares it, the 🟢 types do not expose it: omitted, with the reason said
+ * out loud.
+ */
  | "not-exposed"
-/** PSL and `enums.ts` disagree about an enum's members or their order (§19.2). */
+/** PSL and `enums.ts` disagree about an enum's members or their order. */
  | "enum-diverged";
 export type PrismaDiscoveryDiagnostic = {
     readonly code: PrismaDiscoveryDiagnosticCode;
     /** Written for the engineer who has to fix the schema, naming the entity it is about. */
     readonly message: string;
 };
-/** T-5 — a proven scalar identity, plus a format only where something proves it. */
 export type PrismaScalarMapping = {
     readonly scalar: BuiltInScalar;
     readonly format?: ScalarFormat;
@@ -90,7 +73,7 @@ export type PrismaScalarMapping = {
 export type PrismaScalarTable = Readonly<Record<string, PrismaScalarMapping>>;
 /**
  * Total and 1:1 over `BUILT_IN_SCALARS` **[CORE]**. There is no default arm: a
- * Prisma type name absent from this table is a diagnostic, not a guess (C-809).
+ * Prisma type name absent from this table is a diagnostic, not a guess.
  *
  * **No row carries a `format`**, and that is the point: a format is a property of
  * a *column*, not of a Prisma *type name*. `String` alone proves nothing, so the
@@ -109,21 +92,18 @@ export declare const PRISMA_SCALAR_TABLE: PrismaScalarTable;
  * `runtime/scalar-runtime.ts`]** — so a row that is merely probable would have
  * Aventara refuse writes the database accepts.
  *
- * `@db.Uuid` clears that bar: PostgreSQL's `uuid` column rejects
- * `'not-a-uuid'` (`ERROR: invalid input syntax for type uuid`) where a `text`
- * column takes it **[RUN8 — 2026-09-28, `aventara-postgres`, postgres:18]**.
+ * `@db.Uuid` clears that bar: PostgreSQL's `uuid` column rejects `'not-a-uuid'`
+ * (`ERROR: invalid input syntax for type uuid`) where a `text` column takes it
+ * **[RUN8 — 2026-09-28, `aventara-postgres`, postgres:18]**.
  *
- * `@default(uuid())` does **not** clear it, which is where T-5's wording is
- * narrowed: on a `String` column with no `@db.Uuid` the column is `text`, only
- * *generated* values are UUIDs, and a client may legally supply any string. That
- * intent belongs in `FrameworkScalarFieldConfig.format` **[CORE]**, which the
+ * That intent belongs in `FrameworkScalarFieldConfig.format` **[CORE]**, which the
  * Contract compiler already applies over the adapter's value.
  *
  * `@db.Decimal(10, 2)` and `@db.VarChar(255)` are absent because they prove no
  * *format*; they carry precision and width, which Aventara has no word for.
  */
 export declare const PRISMA_NATIVE_FORMATS: Readonly<Record<string, ScalarFormat>>;
-/** Whether a row was exercised against 7.10.0 or is carried forward unproven (§12). */
+/** Whether a row was exercised against 7.10.0 or is carried forward unproven. */
 export type PrismaEvidence = "RUN8" | "UNVERIFIED";
 export type PrismaDefaultRow = {
     /**
@@ -140,19 +120,11 @@ export type PrismaDefaultRow = {
     readonly evidence: PrismaEvidence;
 };
 /**
- * T-3.1's `@default` table.
- *
- * **`traits` is the whole trait set, where T-3.1's table lists only the trait the
- * *argument* adds.** The two are consistent, not contradictory: `DEFAULTED` comes
- * from `@default`'s **presence** (C-808: "`@default` → `DEFAULTED` and, when
- * generator-owned, `GENERATED_ON_CREATE`"), and C-811's acceptance criteria spell
- * the full sets out — `@default(autoincrement())` → `["DEFAULTED",
- * "GENERATED_ON_CREATE"]`, `@default("x")` → `["DEFAULTED"]`. This table states
- * the answer rather than half of it, so no consumer has to remember to add the
- * other half.
+ * This table states the answer rather than half of it, so no consumer has to
+ * remember to add the other half.
  *
- * The lookup that walks this table lives with the lifecycle projection (Task 4),
- * where it can be driven red; this pass owns the data only.
+ * The lookup that walks this table lives with the lifecycle projection, where it
+ * can be driven red; this pass owns the data only.
  */
 export declare const PRISMA_DEFAULT_TABLE: readonly PrismaDefaultRow[];
 /**
@@ -167,22 +139,17 @@ export declare const PRISMA_UNMATCHED_DEFAULT_TRAITS: readonly AdapterLifecycleT
  * The dictionary's other half: the point at which Prisma's spelling stops and
  * Aventara's begins.
  *
- * **One untyped `PRISMA_RENAMES` became six typed tables (2026-10-02, T-6).** The
- * single `Record<string, string>` could not make a mistake a compile error: a
- * rename to a word core does not have, or a Prisma key nobody decided about,
- * both typechecked. Each table below is keyed on the Prisma spelling and valued in
- * the ONE Aventara vocabulary that spelling can land in, so `"arrayContains"`
- * misspelt fails to compile. The table had no consumer, so nothing was broken by
- * splitting it.
+ * **One untyped `PRISMA_RENAMES` became six typed tables.** The single
+ * `Record<string, string>` could not make a mistake a compile error: a rename to a
+ * word core does not have, or a Prisma key nobody decided about, both typechecked.
+ * Each table below is keyed on the Prisma spelling and valued in the ONE Aventara
+ * vocabulary that spelling can land in, so `"arrayContains"` misspelt fails to
+ * compile. The table had no consumer, so nothing was broken by splitting it.
  *
  * `null` is a value, not an omission: it means **recognised, and Aventara has no
  * word for it** — the nested bulk writes, `distinct`, Prisma's `set` assignment.
- * A key absent from a table is a different thing entirely, and the deriver that
- * reads these refuses rather than dropping it silently, because a silently dropped
- * capability key is how C-855's failure mode begins.
  *
- * C-837's relation *translator* table — which Prisma argument each directive emits
- * — is still Task 9's. This is the vocabulary half only.
+ * This is the vocabulary half only.
  */
 /**
  * `<Kind>Filter` / `<Kind>NullableFilter` / `Json[Nullable]Filter` keys.
@@ -195,11 +162,9 @@ export declare const PRISMA_FILTER_OPERATORS: Readonly<Record<string, ScalarFilt
 /**
  * `[Nullable]ScalarRelationFilter` and `ListRelationFilter` keys.
  *
- * `is` and `isNot` both answer `match`: §18.5 has one to-one matching capability
- * and no `is`/`isNot` wrapper, so the two Prisma keys collapse into it. `nested`
- * and `null` are **not** keys of any filter input — they are read off the edge's
- * own `where` argument and off the edge's nullability — so they are absent here by
- * construction rather than by omission.
+ * `nested` and `null` are **not** keys of any filter input — they are read off the
+ * edge's own `where` argument and off the edge's nullability — so they are absent
+ * here by construction rather than by omission.
  */
 export declare const PRISMA_RELATION_FILTERS: Readonly<Record<string, RelationFilterCapability>>;
 /**
@@ -207,9 +172,7 @@ export declare const PRISMA_RELATION_FILTERS: Readonly<Record<string, RelationFi
  *
  * `set` is `null` because plain assignment is not a directive in Aventara: the
  * value is written directly, and `ScalarMutationDirective` has no `$set`
- * **[CORE]**. `unset` is carried although neither Phase 8 engine emits it — it is
- * Mongo's, and a key the dictionary recognises and never advertises is better than
- * one that makes the deriver throw the day a third provider is added.
+ * **[CORE]**.
  */
 export declare const PRISMA_SCALAR_DIRECTIVES: Readonly<Record<string, ScalarMutationDirective | null>>;
 /**
@@ -243,15 +206,13 @@ export type ObservedValueShape = {
     readonly evidence: PrismaEvidence;
 };
 /**
- * Task 1's observations, inlined with the engines they were made on
- * **[RUN8, `src/environment.spec.ts`]**. Identical through both driver adapters,
- * so the representation is not driver-dependent *between these two engines* —
- * which is a narrower claim than "not driver-dependent", and the narrower one is
- * what was measured.
+ * Identical through both driver adapters, so the representation is not
+ * driver-dependent *between these two engines* — which is a narrower claim than
+ * "not driver-dependent", and the narrower one is what was measured.
  *
  * A row is `RUN8` only where a read-back value was actually asserted. `String`,
  * `Boolean`, `Int` and `Float` were written into a row and never read back under
- * assertion, so they stay `[UNVERIFIED]` (§12): a plausible value shape is not an
+ * assertion, so they stay `[UNVERIFIED]`: a plausible value shape is not an
  * observed one, and this table exists precisely so that nobody has to guess which
  * is which.
  */