@aventara/prisma7-adapter 0.1.0-pilot.0

package/dist/discovery/types.reader.d.ts

@@ -0,0 +1,24 @@
+import ts from "typescript";
+import type { PrismaCapabilitySurface } from "./capability-surface.interface.js";
+export type PrismaTypesReadResult = {
+    readonly surface: PrismaCapabilitySurface;
+    /**
+     * Every file under the client directory the reader actually opened. Reported
+     * rather than assumed: the 🛑 files are absent by refusal, not by luck, and a
+     * caller — or a spec — can assert the file **set** and not only the output.
+     */
+    readonly filesRead: readonly string[];
+};
+export declare class PrismaTypesReaderError extends Error {
+    readonly 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 declare function readWrittenTypeArguments(checker: ts.TypeChecker, reference: ts.TypeReferenceNode): readonly string[];
+export declare function readPrismaCapabilitySurface(clientDirectory: string): PrismaTypesReadResult;

package/dist/discovery/types.reader.js

@@ -0,0 +1,617 @@
+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",
+    "include",
+    "where",
+]);
+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)));
+}
+export function readPrismaCapabilitySurface(clientDirectory) {
+    const root = path.resolve(clientDirectory);
+    const publicFiles = listPublicFiles(root);
+    if (publicFiles.length === 0) {
+        throw new PrismaTypesReaderError(`no generated 🟢 file was found under ${root}`);
+    }
+    const filesRead = new Set();
+    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,
+            target: ts.ScriptTarget.ESNext,
+            moduleDetection: ts.ModuleDetectionKind.Force,
+        },
+        host,
+    });
+    const checker = program.getTypeChecker();
+    const index = indexDeclarations(program, publicFiles);
+    return {
+        surface: {
+            resources: readResources(checker, index),
+            enums: readEnums(program, root),
+        },
+        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() &&
+        entry.name.endsWith(".ts") &&
+        !isPrivatePath(root, path.join(entry.parentPath, entry.name)))
+        .map((entry) => path.join(entry.parentPath, entry.name))
+        .sort();
+}
+function isPrivatePath(root, file) {
+    return path.relative(root, file).split(path.sep).includes(PRIVATE_DIRECTORY);
+}
+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)) {
+            throw new PrismaTypesReaderError(`the types reader asked for ${path.relative(root, resolved)}, which is a 🛑 file`);
+        }
+        const text = readFileSync(resolved, "utf8");
+        if (text.includes(RED_BANNER) || !text.includes(GREEN_BANNER)) {
+            throw new PrismaTypesReaderError(`${path.relative(root, resolved)} does not carry the 🟢 banner`);
+        }
+        filesRead.add(resolved);
+        return text;
+    };
+    return {
+        getSourceFile: (fileName, languageVersionOrOptions) => {
+            const text = readPublicFile(fileName);
+            return text === undefined
+                ? undefined
+                : ts.createSourceFile(fileName, text, languageVersionOrOptions, true);
+        },
+        getDefaultLibFileName: () => "lib.d.ts",
+        writeFile: () => undefined,
+        getCurrentDirectory: () => root,
+        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) &&
+                !isPrivatePath(root, resolved) &&
+                resolved.endsWith(".ts") &&
+                statSync(resolved, { throwIfNoEntry: false })?.isFile() === true);
+        },
+        readFile: readPublicFile,
+    };
+}
+function indexDeclarations(program, publicFiles) {
+    const index = new Map();
+    for (const file of publicFiles) {
+        const source = program.getSourceFile(file);
+        if (source === undefined) {
+            throw new PrismaTypesReaderError(`${file} did not enter the program`);
+        }
+        for (const statement of source.statements) {
+            if (ts.isTypeAliasDeclaration(statement) ||
+                ts.isInterfaceDeclaration(statement)) {
+                index.set(statement.name.text, statement);
+            }
+        }
+    }
+    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) {
+        return null;
+    }
+    if (ts.isInterfaceDeclaration(declaration)) {
+        return new Set(memberNames(declaration.members.filter(ts.isPropertySignature)));
+    }
+    const written = declaration.type;
+    const literal = ts.isTypeReferenceNode(written)
+        ? written.typeArguments?.[0]
+        : written;
+    if (literal === undefined || !ts.isTypeLiteralNode(literal)) {
+        throw new PrismaTypesReaderError(`${name} is declared by the 🟢 types and is not a written object type, so its projection members cannot be read`);
+    }
+    return new Set(memberNames(literal.members.filter(ts.isPropertySignature)));
+}
+function readBulkSurface(index, model) {
+    const declared = (names) => names
+        .map((name) => projectionMembers(index, name))
+        .filter((members) => members !== null);
+    return {
+        select: declared(BULK_RETURNING_WRITES.map((call) => `${model}Select${call}`)),
+        include: declared(BULK_RETURNING_WRITES.map((call) => `${model}Include${call}`)),
+        create: new Set(memberNames(membersOf(index, `${model}CreateManyInput`) ?? [])),
+        update: new Set([
+            ...memberNames(membersOf(index, `${model}UpdateManyMutationInput`) ?? []),
+            ...memberNames(membersOf(index, `${model}UncheckedUpdateManyInput`) ?? []),
+        ]),
+    };
+}
+/** The members of a named declaration, following Prisma's one `…Base` indirection. */
+function membersOf(index, name) {
+    const declaration = index.get(name);
+    if (declaration === undefined) {
+        return null;
+    }
+    if (ts.isInterfaceDeclaration(declaration)) {
+        return declaration.members.filter(ts.isPropertySignature);
+    }
+    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) {
+    return ts.isIdentifier(member.name) || ts.isStringLiteral(member.name)
+        ? member.name.text
+        : member.name.getText();
+}
+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;
+    }
+    let found = null;
+    const visit = (current) => {
+        if (found !== null) {
+            return;
+        }
+        if (ts.isTypeReferenceNode(current) && accept(referencedName(current))) {
+            found = current;
+            return;
+        }
+        ts.forEachChild(current, visit);
+    };
+    visit(node);
+    return found;
+}
+function keysOfReferenced(index, node, accept) {
+    const reference = findReference(node, accept);
+    if (reference === null) {
+        return [];
+    }
+    const members = membersOf(index, referencedName(reference));
+    if (members === null) {
+        throw new PrismaTypesReaderError(`${referencedName(reference)} is referenced by the 🟢 types but declared nowhere in them`);
+    }
+    return memberNames(members);
+}
+/* ------------------------------------------------------------------ *
+ * Enums                                                              *
+ * ------------------------------------------------------------------ */
+function readEnums(program, root) {
+    const source = program.getSourceFile(path.join(root, "enums.ts"));
+    if (source === undefined) {
+        throw new PrismaTypesReaderError(`enums.ts is absent from ${root}`);
+    }
+    const enums = {};
+    for (const statement of source.statements) {
+        if (!ts.isVariableStatement(statement)) {
+            continue;
+        }
+        for (const declaration of statement.declarationList.declarations) {
+            const initializer = declaration.initializer;
+            if (initializer === undefined ||
+                !ts.isAsExpression(initializer) ||
+                !ts.isObjectLiteralExpression(initializer.expression) ||
+                !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)
+                ? property.name.text
+                : property.name.getText());
+        }
+    }
+    return enums;
+}
+/* ------------------------------------------------------------------ *
+ * Resources                                                          *
+ * ------------------------------------------------------------------ */
+function readResources(checker, index) {
+    const resources = {};
+    for (const name of [...index.keys()].sort()) {
+        const model = /^\$(.+)Payload$/.exec(name)?.[1];
+        if (model === undefined) {
+            continue;
+        }
+        resources[model] = readResource(checker, index, model);
+    }
+    return resources;
+}
+function readResource(checker, index, model) {
+    const payload = membersOf(index, `$${model}Payload`);
+    if (payload === null) {
+        throw new PrismaTypesReaderError(`$${model}Payload has no written members`);
+    }
+    const declaredName = payloadName(checker, payload);
+    if (declaredName !== 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`) ?? [];
+    const include = membersOf(index, `${model}Include`) ?? [];
+    const counted = new Set(memberNames(membersOf(index, `${model}CountOutputType`) ?? []));
+    const byName = (members) => new Map(members.map((member) => [memberName(member), member]));
+    const operations = readOperations(index, model);
+    return {
+        scalarFields: readScalarFields(checker, index, model, payload, byName(where), byName(uncheckedCreate), byName(uncheckedUpdate), byName(orderBy)),
+        relationFields: readRelationFields(checker, index, payload, byName(where), byName(create), byName(update), byName(include), byName(orderBy), counted, readBulkSurface(index, model)),
+        uniqueKeys: readUniqueKeys(checker, index, model),
+        operations,
+        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) {
+        throw new PrismaTypesReaderError("a payload carries no `name` member");
+    }
+    return unquote(checker.typeToString(checker.getTypeFromTypeNode(member.type)));
+}
+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]
+        : undefined;
+    if (literal === undefined || !ts.isTypeLiteralNode(literal)) {
+        throw new PrismaTypesReaderError(`$${model}Payload.scalars is not a written object type`);
+    }
+    const names = [
+        ...new Set([
+            ...memberNames(literal.members.filter(ts.isPropertySignature)),
+            ...tokens.keys(),
+        ]),
+    ];
+    const fields = {};
+    for (const name of names) {
+        const token = tokens.get(name);
+        if (token === undefined) {
+            throw new PrismaTypesReaderError(`${model}.${name} is a payload scalar with no ${model}FieldRefs entry`);
+        }
+        const filter = findReference(where.get(name)?.type, (n) => n.endsWith("Filter"));
+        const filterMembers = filter === null ? [] : (membersOf(index, referencedName(filter)) ?? []);
+        const order = orderBy.get(name);
+        fields[name] = {
+            token,
+            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,
+            nullsOrderable: findReference(order?.type, (n) => n === "SortOrderInput") !== null,
+        };
+    }
+    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;
+    }
+    const listInput = `${model}${stage}${field}Input`;
+    const reference = findReference(member.type, (name) => name === listInput || name.endsWith("FieldUpdateOperationsInput"));
+    if (reference === null) {
+        return [];
+    }
+    const members = membersOf(index, referencedName(reference));
+    if (members === null) {
+        throw new PrismaTypesReaderError(`${referencedName(reference)} is referenced by ${model}Unchecked${stage}Input.${field} and declared nowhere in the 🟢 types`);
+    }
+    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) {
+        throw new PrismaTypesReaderError(`${model}FieldRefs is absent`);
+    }
+    const tokens = new Map();
+    for (const member of members) {
+        const reference = findReference(member.type, (n) => n === "FieldRef");
+        if (reference === null) {
+            throw new PrismaTypesReaderError(`${model}FieldRefs.${memberName(member)} is not a FieldRef`);
+        }
+        const written = readWrittenTypeArguments(checker, reference);
+        const token = written[1];
+        if (token === undefined) {
+            throw new PrismaTypesReaderError(`${model}FieldRefs.${memberName(member)} carries no scalar token`);
+        }
+        tokens.set(memberName(member), unquote(token));
+    }
+    return tokens;
+}
+function readRelationFields(checker, index, payload, where, create, update, include, orderBy, counted, bulk) {
+    const objects = payload.find((m) => memberName(m) === "objects");
+    if (objects?.type === undefined || !ts.isTypeLiteralNode(objects.type)) {
+        return {};
+    }
+    const fields = {};
+    for (const member of objects.type.members.filter(ts.isPropertySignature)) {
+        const name = memberName(member);
+        const written = member.type;
+        if (written === undefined) {
+            continue;
+        }
+        const parts = ts.isUnionTypeNode(written) ? written.types : [written];
+        const many = parts.some(ts.isArrayTypeNode);
+        const nullable = parts.some((part) => ts.isLiteralTypeNode(part) &&
+            part.literal.kind === ts.SyntaxKind.NullKeyword);
+        const targetPayload = findReference(written, (n) => n.startsWith("$"));
+        if (targetPayload === null) {
+            throw new PrismaTypesReaderError(`a relation edge "${name}" references no payload`);
+        }
+        const targetMembers = membersOf(index, referencedName(targetPayload));
+        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)),
+            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"),
+            bulkCreatable: bulk.create.has(name),
+            bulkUpdatable: bulk.update.has(name),
+        };
+    }
+    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`);
+    if (declaration === undefined || !ts.isTypeAliasDeclaration(declaration)) {
+        return [];
+    }
+    const atLeast = findReference(declaration.type, (n) => n === "AtLeast");
+    const keys = atLeast?.typeArguments?.[1];
+    if (keys === undefined) {
+        return [];
+    }
+    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)) {
+        throw new PrismaTypesReaderError(`${model}Delegate is absent`);
+    }
+    return declaration.members
+        .filter(ts.isMethodSignature)
+        .map((member) => ts.isIdentifier(member.name) ? member.name.text : member.name.getText());
+}
+function readManyWriteArguments(index, model, operations) {
+    const arguments_ = {};
+    for (const operation of operations) {
+        if (!MANY_WRITE_OPERATION.test(operation)) {
+            continue;
+        }
+        const capitalised = operation[0]?.toUpperCase() + operation.slice(1);
+        const members = membersOf(index, `${model}${capitalised}Args`);
+        if (members === null) {
+            throw new PrismaTypesReaderError(`${model}${capitalised}Args is absent although ${model}Delegate declares ${operation}`);
+        }
+        arguments_[operation] = memberNames(members);
+    }
+    return arguments_;
+}
+function unquote(value) {
+    return value.replace(/^['"]|['"]$/g, "");
+}