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

package/dist/generate/declared-support.reader.js

@@ -20,16 +20,6 @@ function compare(left, right) {
     }
     return 0;
 }
-/**
- * Whether `version` satisfies `range`, for the range forms a peer declaration
- * here uses: space-separated comparators (`>=5.5.0 <7`), each `^`, `>=`, `>`,
- * `<=`, `<`, `=` or bare, with missing minor and patch read as `0`.
- *
- * Only a plain release can satisfy: a pre-release (`8.0.0-rc.20`) never does,
- * which is semver's own rule for a range whose comparators carry no pre-release
- * tag. A range in any other form is a defect in this package's manifest, so it
- * throws rather than answering a guess.
- */
 export function satisfiesDeclaredRange(version, range) {
     const release = RELEASE.exec(version);
     if (release === null) {
@@ -45,8 +35,6 @@ export function satisfiesDeclaredRange(version, range) {
         .split(/\s+/)
         .every((comparator) => {
         const parsed = COMPARATOR.exec(comparator);
-        // `^0.x` means something narrower than "same major", and no peer here
-        // declares one, so it is refused with the forms this does not read.
         if (parsed === null || (parsed[1] === "^" && parsed[2] === "0")) {
             throw new Error(`the declared range \`${range}\` has a comparator, \`${comparator}\`, that the generate step does not read`);
         }

package/dist/generate/discovery.bin.js

@@ -1,15 +1,5 @@
 #!/usr/bin/env node
 import { refuseUnsupportedNode } from "./node-version.guard.js";
-/**
- * `aventara-prisma7-generate`'s entry, what the manifest's `bin` names (F-855). It always runs — no
- * `import.meta.main` — and checks this Node against the package's
- * `engines.node` before it loads anything else: the program is imported only
- * once the guard admits this Node, so an older Node meets one sentence and exit
- * 1, never a silent exit 0 or a parse error from a module it cannot run.
- *
- * A promise chain rather than a top-level `await`, which Node 12 cannot parse:
- * this file is read by the Nodes the package does not support.
- */
 if (!refuseUnsupportedNode("aventara-prisma7-generate", new URL("../../package.json", import.meta.url))) {
     void import("./discovery.cli.js").then((program) => program.runFromProcess());
 }

package/dist/generate/discovery.cli.js

@@ -1,40 +1,6 @@
 import path from "node:path";
 import { PRISMA_DRIVERS, PRISMA_PROVIDERS, } from "../provider/provider-profile.js";
 import { generatePrismaDiscoveryArtifact } from "./index.js";
-/**
- * F-805 — `aventara-prisma7-generate`: the published binary that produces the
- * discovery artifact `createPrismaAdapter({ discovery })` requires.
- *
- * Before this existed, `package.json` declared no `bin`, one `"."` export and
- * `files: ["dist"]` over a build that excluded `src/generate/**` — so a consumer
- * of the published package could not produce an artifact for their own schema at
- * all, and the only artifacts in existence were the two this repository generates
- * for its own tests. The package was unusable as published.
- *
- * # It reads nothing it was not told
- *
- * Every input is an argument. There is no repository path, no fixture schema, no
- * convention-over-configuration search and no tsconfig of this package's: the
- * types reader builds its own program over the client directory it is given. That
- * is the whole reason this file is a flag parser and `discovery.generate.ts` — the
- * repository's own two-engine script — is a separate file that happens to call the
- * same function.
- *
- * `--provider` and `--driver` are required rather than sniffed. The provider is
- * stamped into the artifact as a recorded fact, and the driver decides
- * `AdapterModel.transactions`, which is a **driver** fact the schema cannot state:
- * a `datasource` block names `postgresql`, not whether the application will drive
- * it through `@prisma/adapter-pg`. Guessing either would put a guess in the
- * artifact; D-804's rule is that the caller declares.
- *
- * # Failure is a message and an exit code, never a stack
- *
- * The step's refusals are deliberate, legible and aimed at the person running the
- * build — a `prisma` major this reader has never seen, a generated tree whose
- * runtime does not resolve, a schema construct the reader does not model. Printing
- * a V8 stack trace over them would bury the sentence that says what to do. An
- * unexpected error keeps its stack, because that one is a defect.
- */
 const USAGE = `aventara-prisma7-generate — emit a @aventara/prisma7-adapter discovery artifact.
 
 Usage:
@@ -69,14 +35,6 @@ const FLAGS = {
     "--driver": "driver",
     "--out": "artifactFile",
 };
-/**
- * The flags, parsed. Exported so a case can drive it without a child process:
- * the parse is the only judgement this file makes, and the rest is the step's.
- *
- * `--flag value` only. `--flag=value` is deliberately not accepted, because
- * accepting both spellings means two code paths over one fact for a binary whose
- * entire surface is five required flags.
- */
 export function parsePrismaGenerateArguments(argv) {
     const seen = {};
     for (let index = 0; index < argv.length; index += 1) {
@@ -107,8 +65,6 @@ export function parsePrismaGenerateArguments(argv) {
     if (!PRISMA_DRIVERS.includes(driver)) {
         throw new PrismaGenerateCliError(`\`--driver ${seen.driver}\` is not one of ${PRISMA_DRIVERS.join(", ")}.`);
     }
-    // Resolved against the process's own directory, so every path in the output
-    // names one place and a relative `--out` lands where the caller meant.
     return {
         schema: path.resolve(seen.schema),
         clientDirectory: path.resolve(seen.clientDirectory),
@@ -129,27 +85,16 @@ async function main(argv) {
     for (const absence of result.excluded) {
         process.stdout.write(`excluded: ${absence.message}\n`);
     }
-    // Printed every run, because a cross-check whose exemptions are invisible is a
-    // cross-check nobody can audit.
     for (const exemption of result.exemptions) {
         process.stdout.write(`exempt (${exemption.kind}) ${exemption.entity}: ${exemption.reason}\n`);
     }
     return 0;
 }
-/**
- * Runs `aventara-prisma7-generate` over this process — its arguments, its
- * output, its exit code. Called by the bin's entry (`discovery.bin.ts`) once the
- * Node guard has admitted this Node; importing this module runs nothing, which
- * is what lets the parse be tested without the process exiting.
- */
 export async function runFromProcess() {
     try {
         process.exitCode = await main(process.argv.slice(2));
     }
     catch (error) {
-        // A refusal from the step or this parser is a sentence the person running the
-        // build has to read; a stack trace in front of it is noise. Anything else is
-        // a defect and keeps its stack.
         const named = error instanceof PrismaGenerateCliError ||
             (error instanceof Error &&
                 (error.name === "PrismaGenerateStepError" ||

package/dist/generate/existence.gate.d.ts

@@ -1,45 +1,39 @@
 import type { PrismaCapabilitySurface } from "../discovery/capability-surface.interface.js";
 import type { PrismaSchemaFacts, PrismaSchemaSite } from "../discovery/schema-facts.interface.js";
 /**
- * T-3.1 invariant 3 / C-808 — **existence is gated by TYPE; attributes come
- * from PSL.**
- *
- * An entity enters the `AdapterModel` iff the 🟢 generated types expose it.
- * The gate is strictly stronger than any attribute list: it catches `@ignore`,
+ * An entity enters the `AdapterModel` iff the 🟢 generated types expose it. The
+ * gate is strictly stronger than any attribute list: it catches `@ignore`,
  * `@@ignore`, preview-feature exclusions, provider drops and `Unsupported(…)`
  * columns with no special case for any of them, because all of them show up the
  * same way — as a name PSL declares and the client does not carry
- * (`Unsupported(…)` confirmed absent from `$Payload.scalars` and from
- * `FieldRefs` at 7.10.0 **[RUN8]**).
+ * (`Unsupported(…)` confirmed absent from `$Payload.scalars` and from `FieldRefs`
+ * at 7.10.0 **[RUN8]**).
  *
- * `@ignore` and `@@ignore` are parsed **anyway**, and that is this module's
- * whole subtlety. They do not drive the gate — the types do. They exist so the
- * gate's report can say *why* an entity is absent rather than emitting the
- * useless "present in schema, absent from client", and so the two outcomes can
- * be told apart:
+ * `@ignore` and `@@ignore` are parsed **anyway**, and that is this module's whole
+ * subtlety. They do not drive the gate — the types do. They exist so the gate's
+ * report can say *why* an entity is absent rather than emitting the useless
+ * "present in schema, absent from client", and so the two outcomes can be told
+ * apart:
  *
- * - **Explained** — PSL itself instructed the exclusion. Recorded, reported,
- *   and **not fatal**. `@ignore` is a documented Prisma instruction with a
- *   deliberate author behind it; stopping the build on it would leave the
- *   developer no remedy but to delete the instruction, and an error with no
- *   remedy is a defect rather than a fence.
- * - **Unexplained** — nothing in the schema accounts for the absence.
- *   **Fatal.** Emitting the entity would hand the framework a Resource the
- *   adapter can never execute against; omitting it silently would ship a model
- *   that is quietly missing something the developer wrote.
+ * - **Explained** — PSL itself instructed the exclusion. Recorded, reported, and
+ *   **not fatal**. `@ignore` is a documented Prisma instruction with a deliberate
+ *   author behind it; stopping the build on it would leave the developer no remedy
+ *   but to delete the instruction, and an error with no remedy is a defect rather
+ *   than a fence.
+ * - **Unexplained** — nothing in the schema accounts for the absence. **Fatal.**
+ *   Emitting the entity would hand the framework a Resource the adapter can never
+ *   execute against; omitting it silently would ship a model that is quietly
+ *   missing something the developer wrote.
  *
- * (Recorded conflict, for whoever reconciles the plan: Task 3's checklist reads
- * "a PSL-only entity is a generate-time error" flatly, while C-808's own proof
- * line reads "absent, with the exclusion explained". This module implements the
- * split above, which is the only reading under which the stated *reason* for
- * the error — "otherwise the adapter hands the framework a Resource it can
- * never execute against" — survives: once the entity is excluded, no such
- * Resource is handed over, and what remains to decide is only whether to stop
- * the build. It is worth stopping for the absence nobody asked for.)
+ * This module implements the split above, which is the only reading under which
+ * the stated *reason* for the error — "otherwise the adapter hands the framework a
+ * Resource it can never execute against" — survives: once the entity is excluded,
+ * no such Resource is handed over, and what remains to decide is only whether to
+ * stop the build. It is worth stopping for the absence nobody asked for.)
  *
- * The reverse direction — a resource the types expose and PSL does not declare
- * — is a reader inconsistency rather than an existence question, and belongs to
- * `reader-crosscheck.ts` (Task 6). This module does not answer it.
+ * The reverse direction — a resource the types expose and PSL does not declare —
+ * is a reader inconsistency rather than an existence question, and belongs to
+ * `reader-crosscheck.ts`. This module does not answer it.
  */
 export type PrismaAbsenceKind = "model" | "field";
 /** What PSL said, when PSL said anything. */

package/dist/generate/existence.gate.js

@@ -28,12 +28,6 @@ function unexplainedMessage(entity, kind, site) {
         : "Admitting it would put a field in the Contract that no query, filter or write can ever name";
     return `\`${entity}\` is declared at ${where(site)} but ${surfaceSays(entity, kind)}, and nothing in the schema explains the absence — there is no ${instruction} on it. ${cost}, and dropping it silently would ship a model quietly missing something the schema declares. ${CAUSES}.`;
 }
-/**
- * Runs the gate. Returns what was admitted and what PSL explained away; throws
- * {@link PrismaExistenceGateError} listing every unexplained absence at once,
- * because fixing them one build at a time is how a schema migration becomes a
- * week.
- */
 export function applyExistenceGate(facts, surface) {
     const admitted = [];
     const explained = [];

package/dist/generate/index.d.ts

@@ -1,13 +1,11 @@
 import type { PrismaDriver, PrismaProvider } from "../provider/provider-profile.js";
 import type { PrismaGenerateResult, PrismaGenerateToolchain } from "./prisma.generate.js";
 /**
- * F-805 — the package's **second published entry**: `@aventara/prisma7-adapter/generate`.
- *
  * # Why a second entry rather than a second package or a wider `"."`
  *
  * The runtime entry (`"."`) depends on `@aventara/core` and the caller's own
- * generated client, and on nothing else. The generate path needs `typescript`
- * (the types reader builds a real TypeScript program over the generated tree) and
+ * generated client, and on nothing else. The generate path needs `typescript` (the
+ * types reader builds a real TypeScript program over the generated tree) and
  * `prisma` (the step runs `prisma generate` itself, so that both sources describe
  * one instant). Those two are declared as **optional peer dependencies**, not as
  * dependencies, and the split is what keeps the plan's guarantee that *no
@@ -16,9 +14,9 @@ import type { PrismaGenerateResult, PrismaGenerateToolchain } from "./prisma.gen
  * optional peer is not installed on their behalf.
  *
  * The published build therefore carries both halves and the `exports` map is what
- * separates them. Nothing reachable from `"."` imports anything under
- * `generate/`; `artifact.loader.spec.ts` asserts that from the import graph
- * rather than from this paragraph.
+ * separates them. Nothing reachable from `"."` imports anything under `generate/`;
+ * `artifact.loader.spec.ts` asserts that from the import graph rather than from
+ * this paragraph.
  *
  * # What this entry is for
  *
@@ -29,9 +27,9 @@ import type { PrismaGenerateResult, PrismaGenerateToolchain } from "./prisma.gen
  * already has a build script and would rather call it.
  *
  * Everything the step itself exposes is re-exported, because the seams are the
- * point: a consumer with an unusual toolchain can supply their own
- * {@link PrismaGenerateToolchain}, and one with their own composition rules can
- * call {@link runPrismaGenerateStep} directly.
+ * point: a consumer with an unusual toolchain can supply their own {@link
+ * PrismaGenerateToolchain}, and one with their own composition rules can call
+ * {@link runPrismaGenerateStep} directly.
  */
 export { createPrismaModelComposer, PrismaModelCompositionError, } from "../discovery/model.discoverer.js";
 export type { PrismaEntityAbsence } from "./existence.gate.js";
@@ -42,8 +40,8 @@ export type { PrismaReaderExemption } from "./reader-crosscheck.js";
  * One engine's generate request, as a consumer states it.
  *
  * `driver` is here and is not on {@link PrismaGenerateRequest} for a reason the
- * step's own header gives: `AdapterModel.transactions` is a **driver** fact (T-2)
- * that is stamped into the artifact at generate time, while the step itself is
+ * step's own header gives: `AdapterModel.transactions` is a **driver** fact that
+ * is stamped into the artifact at generate time, while the step itself is
  * forbidden to know a provider or a driver at all — composition is created with a
  * transaction capability and nothing else, so `if (provider === …)` inside
  * discovery is a compile error rather than a convention. This function is the one

package/dist/generate/index.js

@@ -1,50 +1,8 @@
 import { createPrismaModelComposer } from "../discovery/model.discoverer.js";
 import { resolveProviderProfile } from "../provider/provider-profile.js";
 import { runPrismaGenerateStep } from "./prisma.generate.js";
-/**
- * F-805 — the package's **second published entry**: `@aventara/prisma7-adapter/generate`.
- *
- * # Why a second entry rather than a second package or a wider `"."`
- *
- * The runtime entry (`"."`) depends on `@aventara/core` and the caller's own
- * generated client, and on nothing else. The generate path needs `typescript`
- * (the types reader builds a real TypeScript program over the generated tree) and
- * `prisma` (the step runs `prisma generate` itself, so that both sources describe
- * one instant). Those two are declared as **optional peer dependencies**, not as
- * dependencies, and the split is what keeps the plan's guarantee that *no
- * compiler, no parser and no Prisma tooling enters the deployed runtime*: a
- * consumer who imports only `"."` never loads a module that names either, and an
- * optional peer is not installed on their behalf.
- *
- * The published build therefore carries both halves and the `exports` map is what
- * separates them. Nothing reachable from `"."` imports anything under
- * `generate/`; `artifact.loader.spec.ts` asserts that from the import graph
- * rather than from this paragraph.
- *
- * # What this entry is for
- *
- * Producing the discovery artifact `createPrismaAdapter({ discovery })` requires,
- * from the consumer's own `schema.prisma` and their own generated client. The
- * `aventara-prisma7-generate` binary (`discovery.cli.ts`) is this function with an
- * argument parser in front of it; this module is the same thing for a consumer who
- * already has a build script and would rather call it.
- *
- * Everything the step itself exposes is re-exported, because the seams are the
- * point: a consumer with an unusual toolchain can supply their own
- * {@link PrismaGenerateToolchain}, and one with their own composition rules can
- * call {@link runPrismaGenerateStep} directly.
- */
 export { createPrismaModelComposer, PrismaModelCompositionError, } from "../discovery/model.discoverer.js";
 export { createPrismaGenerateToolchain, PINNED_PRISMA_MAJOR, PrismaGenerateStepError, runPrismaGenerateStep, } from "./prisma.generate.js";
-/**
- * The generate step, wired: provider profile → transaction capability →
- * composition → the step.
- *
- * Every decision stays where it already lived. This function resolves the profile
- * and builds the composer; it makes no judgement of its own, which is why there is
- * nothing here to test beyond that it is the wiring the CLI and the repository's
- * own `generate` script both use.
- */
 export async function generatePrismaDiscoveryArtifact(request) {
     const profile = resolveProviderProfile({
         provider: request.provider,

package/dist/generate/node-version.guard.js

@@ -1,4 +1,3 @@
-// biome-ignore lint/style/useNodejsImportProtocol: Node 14.0–14.13.0 resolves no "node:" specifier in an ES module, and this module runs on the Nodes the packages do not support.
 import { readFileSync } from "fs";
 function versionOf(text) {
     const match = /^v?(\d+)\.(\d+)\.(\d+)/.exec(text);
@@ -16,11 +15,6 @@ function compareVersions(left, right) {
     }
     return 0;
 }
-/**
- * Whether `range` admits `version`. Reads `^x.y.z` (the same major, from the
- * floor; majors ≥ 1) and `>=x.y.z`, joined by `||`; anything else throws rather
- * than admit or refuse by guess.
- */
 function admits(range, version) {
     return range.split("||").some((part) => {
         const comparator = /^\s*(\^|>=)(\d+\.\d+\.\d+)\s*$/.exec(part);
@@ -32,17 +26,11 @@ function admits(range, version) {
             (comparator[1] === ">=" || version[0] === floor[0]));
     });
 }
-/** The sentence a bin answers on `version`, or `undefined` when `range` admits it. */
 export function nodeVersionRefusal(bin, packageName, range, version) {
     return admits(range, versionOf(version))
         ? undefined
         : `${bin}: Node ${version} is not supported; ${packageName} needs Node ${range}.`;
 }
-/**
- * Reads the manifest at `manifestUrl`; on a Node its `engines.node` does not
- * admit, writes the sentence to stderr, sets exit code 1 and answers `true` —
- * the bin then loads nothing else.
- */
 export function refuseUnsupportedNode(bin, manifestUrl) {
     const manifest = JSON.parse(readFileSync(manifestUrl, "utf8"));
     const range = manifest.engines === undefined ? undefined : manifest.engines.node;

package/dist/generate/prisma-cli.resolver.d.ts

@@ -1,11 +1,9 @@
 /**
- * D11 — which Prisma CLI the generate step runs.
- *
- * `prisma`'s `latest` is a Prisma 8 release candidate (plan B32), so `npm i
- * prisma` in a Prisma 7 project now installs a CLI this adapter's readers were
- * never written against. Prisma's own upgrade path keeps the Prisma 7 CLI side by
- * side as **`@prisma/prisma7`**, bin `prisma7` — the same CLI under a
- * version-specific name. So, in this order:
+ * `prisma`'s `latest` is a Prisma 8 release candidate, so `npm i prisma` in a
+ * Prisma 7 project now installs a CLI this adapter's readers were never written
+ * against. Prisma's own upgrade path keeps the Prisma 7 CLI side by side as
+ * **`@prisma/prisma7`**, bin `prisma7` — the same CLI under a version-specific
+ * name. So, in this order:
  *
  * 1. `@prisma/prisma7` installed → its `prisma7` bin runs, provided the `prisma`
  *    it wraps is in the declared range;
@@ -17,10 +15,10 @@
  *
  * Each package is looked up first from this module — the adapter's own install,
  * where an optional peer is linked — and then from the project the step runs in
- * (its working directory), where a strict installer such as pnpm leaves a
- * package the adapter does not declare. A found package is followed to its real
- * path, so the `prisma` that `@prisma/prisma7` wraps is the one beside it and not
- * a `prisma` 8 hoisted next to the link.
+ * (its working directory), where a strict installer such as pnpm leaves a package
+ * the adapter does not declare. A found package is followed to its real path, so
+ * the `prisma` that `@prisma/prisma7` wraps is the one beside it and not a
+ * `prisma` 8 hoisted next to the link.
  */
 export type PrismaCli = {
     /** The package whose bin runs: `@prisma/prisma7` or `prisma`. */

package/dist/generate/prisma-cli.resolver.js

@@ -2,13 +2,6 @@ import { existsSync, readFileSync, realpathSync } from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { satisfiesDeclaredRange } from "./declared-support.reader.js";
-/**
- * The first `node_modules/<name>/package.json` on the way up from each place in
- * turn — Node's own lookup order, walked by hand because the manifest is all
- * that is wanted: no `exports` map can hide it, and no `NODE_PATH` can answer
- * from outside the install (a test runner sets one, and a resolution answered
- * through it has produced a false green in this package before).
- */
 function locate(name, searchFrom) {
     for (const base of searchFrom) {
         let directory = path.dirname(base.startsWith("file:") ? fileURLToPath(base) : base);
@@ -48,16 +41,10 @@ function binEntry(located, bin) {
         ? path.join(located.directory, relative)
         : undefined;
 }
-/**
- * The Prisma CLI to run, or why there is none. `searchFrom` holds the places to
- * resolve from, in order — a module URL or a path of a file in the directory to
- * start from; `range` is the adapter's declared `prisma` range.
- */
 export function resolvePrismaCli(input) {
     const install = `\`npm i -D "@prisma/prisma7@${input.range}"\``;
     const prisma7 = locate("@prisma/prisma7", input.searchFrom);
     if (prisma7 !== undefined) {
-        // The version is the wrapped CLI's, looked up from beside the wrapper.
         const wrapped = locate("prisma", [
             path.join(prisma7.directory, "package.json"),
         ]);

package/dist/generate/prisma.generate.d.ts

@@ -1,62 +1,52 @@
 import type { PrismaCapabilitySurface } from "../discovery/capability-surface.interface.js";
-import type { PrismaAdapterModel, PrismaReferentialActionTable, PrismaTranslationTable } from "../discovery/discovery-artifact.interface.js";
+import type { PrismaAdapterModel, PrismaCreateRequirementTable, PrismaReferentialActionTable, PrismaTranslationTable } from "../discovery/discovery-artifact.interface.js";
 import type { PrismaSchemaFacts } from "../discovery/schema-facts.interface.js";
 import type { PrismaProvider } from "../provider/provider-profile.js";
 import type { PrismaEntityAbsence } from "./existence.gate.js";
 import { type PrismaCli } from "./prisma-cli.resolver.js";
 import type { PrismaReaderExemption } 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.
+ * 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).
+ * 1. **The pinned `prisma` major**. 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**. 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, 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.
  *
- * 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 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). */
+/** The `prisma` major this reader's grammar was written against. */
 export declare const PINNED_PRISMA_MAJOR = 7;
 export declare class PrismaGenerateStepError extends Error {
     readonly name = "PrismaGenerateStepError";
@@ -77,14 +67,15 @@ export type PrismaComposedArtifact = {
     readonly model: PrismaAdapterModel;
     readonly translation: PrismaTranslationTable;
     readonly referentialActions: PrismaReferentialActionTable;
+    readonly createRequirements: PrismaCreateRequirementTable;
 };
 /**
  * Composition of the two readers' facts into the artifact's two halves.
  *
  * It is a parameter rather than a call, because composition is
- * `discovery/model.discoverer.ts`'s (Task 6) and this step's job is order and
- * refusal over external effects. The step hands over only what it has verified:
- * both readers' output, and the resource names the existence gate admitted.
+ * `discovery/model.discoverer.ts`'s and this step's job is order and refusal over
+ * external effects. The step hands over only what it has verified: both readers'
+ * output, and the resource names the existence gate admitted.
  */
 export type PrismaModelComposer = (input: {
     readonly facts: PrismaSchemaFacts;
@@ -129,18 +120,14 @@ export type PrismaGenerateResult = {
     /** PSL-only entities the schema itself explained away. */
     readonly excluded: readonly PrismaEntityAbsence[];
     /**
-     * Reader disagreements that are understood — the `Json` nullability one and
-     * C-815's unexplained `AtLeast` key. Carried out rather than swallowed, so a
-     * caller can print them and a spec can assert them by name and reason.
+     * Carried out rather than swallowed, so a caller can print them and a spec can
+     * assert them by name and reason.
      */
     readonly exemptions: readonly PrismaReaderExemption[];
 };
 /**
- * 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.
+ * Looked up from this package — where an optional peer is linked — and then from
+ * the project the step runs in.
  */
 export declare function resolveInstalledPrismaCli(): PrismaCli;
 /**
@@ -151,13 +138,10 @@ export declare function resolveInstalledPrismaCli(): PrismaCli;
  */
 export declare function readInstalledPrismaVersion(): Promise<string>;
 /**
- * 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`.
+ * 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 declare function clientRuntimeResolves(clientDirectory: string): boolean;
 export declare function createPrismaGenerateToolchain(): PrismaGenerateToolchain;