@aventara/prisma7-adapter 0.1.0-pilot.0

package/dist/generate/artifact.emitter.js

@@ -0,0 +1,105 @@
+import { canonicalizeJson } from "@aventara/core";
+import { computeModelHash } from "../discovery/artifact.loader.js";
+/**
+ * Biome formats and lints checked-in `.ts`, and this file's bytes are the
+ * contract. The suppressions are emitted rather than configured so the artifact
+ * stays correct wherever a consumer drops it, including a repository whose
+ * formatter nobody here chose.
+ */
+const BANNER = [
+    "// biome-ignore-all format: generated output; these bytes are the artifact",
+    "// biome-ignore-all lint: generated output",
+    "/* !!! Generated by @aventara/prisma7-adapter's generate step. Do not edit. !!! */",
+    "/* Regenerate with `aventara-prisma7-generate`. */",
+];
+const TRANSLATION_DOC = [
+    "/**",
+    " * Prisma addressing, beside the model and never inside it.",
+    " *",
+    " * `key` is the key a `WhereUniqueInput` accepts for that identifier: the field",
+    " * name for a single column, the members joined with `_` in ATTRIBUTE order for",
+    " * a compound, or `@@id`/`@@unique`'s `name:` where one replaces it. Computed",
+    ' * once here and MATCHED at runtime, never re-derived — `members.join("_")` is',
+    " * wrong for every named criterion. A key wraps its members iff `members.length",
+    " * > 1`.",
+    " *",
+    " * This half is adapter-private. It is excluded from `modelHash` by",
+    " * construction, so a DB-side rename never moves the Contract identity.",
+    " */",
+];
+const REFERENTIAL_ACTIONS_DOC = [
+    "/**",
+    " * The resolved referential actions, beside the model and never inside it.",
+    " *",
+    " * One entry per Resource, listing that Resource's OWNING relation edges — the",
+    " * ones that declare `@relation(fields: …)`, which is the only side PSL lets",
+    " * carry an action. Each edge reads in ONE direction, and reversing it is",
+    " * silent:",
+    " *",
+    " *   deleting a `target` row does `onDelete` to rows of the ENCLOSING resource.",
+    " *",
+    ' * So "what does deleting an `X` do?" is answered by scanning every',
+    ' * Resource\'s `owningEdges` for `target === "X"` and reading the enclosing',
+    " * Resource key — never by looking under `X` itself.",
+    " *",
+    " * Both members are resolved: an absent PSL argument is not a third state but",
+    " * Prisma's measured effective default (`set-null` where every foreign-key",
+    " * scalar is optional, `restrict` otherwise, `cascade` on update). An action the",
+    " * reader cannot name fails the generate step instead of reaching this table.",
+    " *",
+    " * Excluded from `modelHash` by construction: the hash digests the model, and a",
+    " * referential action is not part of the model.",
+    " */",
+];
+const MODEL_DOC = [
+    "/**",
+    " * The Base Contract: what the schema and the generated client agreed on,",
+    " * read once at generate time and never re-derived.",
+    " *",
+    " * `as const satisfies AdapterModel` is load-bearing. `as const` keeps every",
+    " * resource key, field key and enum member a literal type, which is what",
+    " * `EffectiveFieldKey` narrows on downstream; `satisfies` checks the shape",
+    " * without widening it. Drop either half and the model still *runs* while",
+    " * every narrowing keyed on it silently degrades to `string`.",
+    " */",
+];
+const DISCOVERY_DOC = [
+    "/** Pass this to `createPrismaAdapter({ discovery })`. */",
+];
+/**
+ * Canonical JSON, re-indented as a TypeScript object literal.
+ *
+ * Both halves go through this one function, so C-843 holds over the whole file
+ * rather than over the model alone: whatever key order the readers happened to
+ * build, two runs over one schema emit byte-identical bytes.
+ */
+function canonicalLiteral(value) {
+    return JSON.stringify(JSON.parse(canonicalizeJson(value)), null, "\t");
+}
+export async function emitDiscoveryArtifactModule(emission) {
+    const modelHash = await computeModelHash(emission.model);
+    return `${[
+        ...BANNER,
+        "",
+        'import type { AdapterModel } from "@aventara/core";',
+        "",
+        ...MODEL_DOC,
+        `export const model = ${canonicalLiteral(emission.model)} as const satisfies AdapterModel;`,
+        "",
+        ...TRANSLATION_DOC,
+        `export const translation = ${canonicalLiteral(emission.translation)} as const;`,
+        "",
+        ...REFERENTIAL_ACTIONS_DOC,
+        `export const referentialActions = ${canonicalLiteral(emission.referentialActions)} as const;`,
+        "",
+        ...DISCOVERY_DOC,
+        "export const discovery = {",
+        `\tprismaVersion: ${JSON.stringify(emission.prismaVersion)},`,
+        `\tprovider: ${JSON.stringify(emission.provider)},`,
+        `\tmodelHash: ${JSON.stringify(modelHash)},`,
+        "\tmodel,",
+        "\ttranslation,",
+        "\treferentialActions,",
+        "} as const;",
+    ].join("\n")}\n`;
+}

package/dist/generate/declared-support.reader.d.ts

@@ -0,0 +1,33 @@
+/**
+ * What this adapter **declares** it supports, read from its own manifest — the
+ * one place the fact is stated (R7: support is the adapter's to declare).
+ *
+ * The generate step needs two of those facts at run time: the `prisma` range,
+ * to decide whether a `prisma` CLI it found may run (D11), and the `typescript`
+ * range, to name in the sentence that refuses a compiler with no classic API
+ * (D4). Both are `peerDependencies` entries (D8). Reading them here rather than
+ * restating them as literals is what keeps the refusal sentences, the version
+ * check and the published manifest from drifting apart.
+ *
+ * The manifest is two directories up from this module wherever it runs: `src/generate/`
+ * under the specs, `dist/generate/` in a consumer's install, `.generate/generate/`
+ * under this package's own `generate` script.
+ */
+export type DeclaredSupport = {
+    /** `peerDependencies.prisma`: the Prisma CLI versions the readers were written against. */
+    readonly prisma: string;
+    /** `peerDependencies.typescript`: the compilers the types reader runs on. */
+    readonly typescript: string;
+};
+export declare function readDeclaredSupport(): DeclaredSupport;
+/**
+ * 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 declare function satisfiesDeclaredRange(version: string, range: string): boolean;

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

@@ -0,0 +1,74 @@
+import { readFileSync } from "node:fs";
+const MANIFEST = new URL("../../package.json", import.meta.url);
+export function readDeclaredSupport() {
+    const manifest = JSON.parse(readFileSync(MANIFEST, "utf8"));
+    const prisma = manifest.peerDependencies?.prisma;
+    const typescript = manifest.peerDependencies?.typescript;
+    if (prisma === undefined || typescript === undefined) {
+        throw new Error(`${MANIFEST.pathname} declares no \`prisma\` or no \`typescript\` peer range, so the generate step cannot tell which toolchain it supports`);
+    }
+    return { prisma, typescript };
+}
+const RELEASE = /^(\d+)\.(\d+)\.(\d+)$/;
+const COMPARATOR = /^(\^|>=|>|<=|<|=)?(\d+)(?:\.(\d+))?(?:\.(\d+))?$/;
+function compare(left, right) {
+    for (let index = 0; index < 3; index += 1) {
+        const difference = left[index] - right[index];
+        if (difference !== 0) {
+            return difference;
+        }
+    }
+    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) {
+        return false;
+    }
+    const candidate = [
+        Number(release[1]),
+        Number(release[2]),
+        Number(release[3]),
+    ];
+    return range
+        .trim()
+        .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`);
+        }
+        const bound = [
+            Number(parsed[2]),
+            Number(parsed[3] ?? 0),
+            Number(parsed[4] ?? 0),
+        ];
+        const order = compare(candidate, bound);
+        switch (parsed[1]) {
+            case "^":
+                return order >= 0 && candidate[0] === bound[0];
+            case ">=":
+                return order >= 0;
+            case ">":
+                return order > 0;
+            case "<=":
+                return order <= 0;
+            case "<":
+                return order < 0;
+            default:
+                return order === 0;
+        }
+    });
+}

package/dist/generate/discovery.bin.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/generate/discovery.bin.js

@@ -0,0 +1,15 @@
+#!/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.d.ts

@@ -0,0 +1,24 @@
+import { type PrismaDriver, type PrismaProvider } from "../provider/provider-profile.js";
+export type PrismaGenerateCliOptions = {
+    readonly schema: string;
+    readonly clientDirectory: string;
+    readonly provider: PrismaProvider;
+    readonly driver: PrismaDriver;
+    readonly artifactFile: string;
+};
+/**
+ * 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 declare function parsePrismaGenerateArguments(argv: readonly string[]): PrismaGenerateCliOptions;
+/**
+ * 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 declare function runFromProcess(): Promise<void>;

package/dist/generate/discovery.cli.js

@@ -0,0 +1,163 @@
+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:
+  aventara-prisma7-generate --schema <path> --client <dir> --provider <name> \\
+                           --driver <name> --out <file>
+
+Options:
+  --schema    <path>  The schema.prisma file, or a Prisma 7 schema folder.
+  --client    <dir>   The generated client's root: your generator block's \`output\`.
+  --provider  <name>  ${PRISMA_PROVIDERS.join(" | ")}
+  --driver    <name>  ${PRISMA_DRIVERS.join(" | ")}
+  --out       <file>  Where to write the emitted artifact module (a .ts file).
+  -h, --help          Print this and exit 0.
+
+The artifact must NOT be written inside --client: the types reader reads every
+.ts file under that root and refuses one that is not generated-client output.
+
+Requires a Prisma 7 CLI and \`typescript\` to be resolvable from your project.
+Both are optional peer dependencies of this package, so neither is installed on
+your behalf and neither is reachable from the package's runtime entry. The CLI
+is \`@prisma/prisma7\` (bin \`prisma7\`) when it is installed, else \`prisma\`
+when its version is in this package's declared range; TypeScript 7, which has
+no classic compiler API, is refused.`;
+const PROVIDERS = PRISMA_PROVIDERS;
+class PrismaGenerateCliError extends Error {
+    name = "PrismaGenerateCliError";
+}
+const FLAGS = {
+    "--schema": "schema",
+    "--client": "clientDirectory",
+    "--provider": "provider",
+    "--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) {
+        const flag = argv[index];
+        const member = FLAGS[flag];
+        if (member === undefined) {
+            throw new PrismaGenerateCliError(`unknown argument \`${flag}\`.\n\n${USAGE}`);
+        }
+        const value = argv[index + 1];
+        if (value === undefined || value.startsWith("--")) {
+            throw new PrismaGenerateCliError(`\`${flag}\` takes a value.\n\n${USAGE}`);
+        }
+        seen[member] = value;
+        index += 1;
+    }
+    const missing = Object.values(FLAGS).filter((member) => seen[member] === undefined);
+    if (missing.length > 0) {
+        throw new PrismaGenerateCliError(`missing required argument(s): ${missing
+            .map((member) => Object.entries(FLAGS).find(([, name]) => name === member)?.[0] ??
+            member)
+            .join(", ")}.\n\n${USAGE}`);
+    }
+    const provider = seen.provider;
+    if (!PROVIDERS.includes(provider)) {
+        throw new PrismaGenerateCliError(`\`--provider ${seen.provider}\` is not one of ${PROVIDERS.join(", ")}.`);
+    }
+    const driver = seen.driver;
+    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),
+        provider,
+        driver,
+        artifactFile: path.resolve(seen.artifactFile),
+    };
+}
+async function main(argv) {
+    if (argv.includes("-h") || argv.includes("--help")) {
+        process.stdout.write(`${USAGE}\n`);
+        return 0;
+    }
+    const options = parsePrismaGenerateArguments(argv);
+    const result = await generatePrismaDiscoveryArtifact(options);
+    process.stdout.write(`${result.artifactFile} — ${result.modelHash}\n`);
+    process.stdout.write(`resources: ${result.admitted.join(", ")}\n`);
+    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" ||
+                    error.name === "PrismaModelCompositionError" ||
+                    error.name === "PrismaSchemaReaderError"));
+        process.stderr.write(named
+            ? `aventara-prisma7-generate: ${error.message}\n`
+            : `${String(error instanceof Error ? error.stack : error)}\n`);
+        process.exitCode = 1;
+    }
+}

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

@@ -0,0 +1,73 @@
+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`,
+ * `@@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]**).
+ *
+ * `@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.
+ *
+ * (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.)
+ *
+ * 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.
+ */
+export type PrismaAbsenceKind = "model" | "field";
+/** What PSL said, when PSL said anything. */
+export type PrismaAbsenceExplanation = "@ignore" | "@@ignore";
+export type PrismaEntityAbsence = {
+    readonly kind: PrismaAbsenceKind;
+    /** `Skipped`, or `Kept.hidden` — as a developer would name it. */
+    readonly entity: string;
+    readonly explanation: PrismaAbsenceExplanation | null;
+    readonly site: PrismaSchemaSite;
+    /** The sentence reported or thrown. Composed here so both paths read alike. */
+    readonly message: string;
+};
+export type PrismaExistenceGateResult = {
+    /** Resource names admitted into the `AdapterModel`, in PSL declaration order. */
+    readonly admitted: readonly string[];
+    /** Absences PSL itself explains. Reported; never fatal. */
+    readonly excluded: readonly PrismaEntityAbsence[];
+};
+export declare class PrismaExistenceGateError extends Error {
+    readonly name = "PrismaExistenceGateError";
+    readonly absences: readonly PrismaEntityAbsence[];
+    constructor(absences: readonly PrismaEntityAbsence[]);
+}
+/**
+ * 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 declare function applyExistenceGate(facts: PrismaSchemaFacts, surface: PrismaCapabilitySurface): PrismaExistenceGateResult;

package/dist/generate/existence.gate.js

@@ -0,0 +1,91 @@
+export class PrismaExistenceGateError extends Error {
+    name = "PrismaExistenceGateError";
+    absences;
+    constructor(absences) {
+        super([
+            "the generated client does not expose everything the schema declares, and the schema does not say why:",
+            ...absences.map((absence) => `  - ${absence.message}`),
+        ].join("\n"));
+        this.absences = absences;
+    }
+}
+function where(site) {
+    return `${site.file}:${site.line}`;
+}
+const CAUSES = "A provider drop, a preview-feature gate, or an `Unsupported(...)` column are the usual causes";
+function surfaceSays(entity, kind) {
+    return kind === "model"
+        ? "the generated client exposes no such model"
+        : `the generated surface for \`${entity.split(".")[0]}\` does not expose it`;
+}
+function explainedMessage(entity, kind, explanation, site) {
+    return `\`${entity}\` is declared at ${where(site)} and ${surfaceSays(entity, kind)}, because the schema marks it \`${explanation}\`. It is excluded from the AdapterModel, which an entity enters only where the generated types expose it.`;
+}
+function unexplainedMessage(entity, kind, site) {
+    const instruction = kind === "model" ? "`@@ignore`" : "`@ignore`";
+    const cost = kind === "model"
+        ? "Admitting it would hand the framework a Resource the adapter can never execute against"
+        : "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 = [];
+    const unexplained = [];
+    for (const model of facts.models) {
+        const exposed = surface.resources[model.name];
+        if (exposed === undefined) {
+            const absence = model.ignored
+                ? {
+                    kind: "model",
+                    entity: model.name,
+                    explanation: "@@ignore",
+                    site: model.site,
+                    message: explainedMessage(model.name, "model", "@@ignore", model.site),
+                }
+                : {
+                    kind: "model",
+                    entity: model.name,
+                    explanation: null,
+                    site: model.site,
+                    message: unexplainedMessage(model.name, "model", model.site),
+                };
+            (absence.explanation === null ? unexplained : explained).push(absence);
+            continue;
+        }
+        admitted.push(model.name);
+        for (const field of model.fields) {
+            if (field.name in exposed.scalarFields ||
+                field.name in exposed.relationFields) {
+                continue;
+            }
+            const entity = `${model.name}.${field.name}`;
+            const absence = field.ignored
+                ? {
+                    kind: "field",
+                    entity,
+                    explanation: "@ignore",
+                    site: field.site,
+                    message: explainedMessage(entity, "field", "@ignore", field.site),
+                }
+                : {
+                    kind: "field",
+                    entity,
+                    explanation: null,
+                    site: field.site,
+                    message: unexplainedMessage(entity, "field", field.site),
+                };
+            (absence.explanation === null ? unexplained : explained).push(absence);
+        }
+    }
+    if (unexplained.length > 0) {
+        throw new PrismaExistenceGateError(unexplained);
+    }
+    return { admitted, excluded: explained };
+}

package/dist/generate/index.d.ts

@@ -0,0 +1,81 @@
+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
+ * `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 type { PrismaEntityAbsence } from "./existence.gate.js";
+export type { PrismaComposedArtifact, PrismaGenerateRequest, PrismaGenerateResult, PrismaGenerateToolchain, PrismaModelComposer, } from "./prisma.generate.js";
+export { createPrismaGenerateToolchain, PINNED_PRISMA_MAJOR, PrismaGenerateStepError, runPrismaGenerateStep, } from "./prisma.generate.js";
+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
+ * 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
+ * place the two meet: it resolves the profile and hands composition the single
+ * fact it accepts.
+ *
+ * The declared driver must be the driver the application will construct the
+ * adapter with. The two cannot drift silently: an artifact that says
+ * `"interactive"` loaded by an adapter whose driver says `"none"` mounts no
+ * `transaction`, and core refuses construction with
+ * `DISCOVERY_TRANSACTION_CAPABILITY_MISMATCH`.
+ */
+export type PrismaDiscoveryGenerateRequest = {
+    /** The `schema.prisma` file, or a Prisma 7 schema folder. */
+    readonly schema: string;
+    /** The generator's `output` directory: the generated client's root. */
+    readonly clientDirectory: string;
+    readonly provider: PrismaProvider;
+    /** The driver the application will pass to `createPrismaAdapter`. */
+    readonly driver: PrismaDriver;
+    /** Where the emitted TypeScript artifact module is written. */
+    readonly artifactFile: string;
+    /** Injectable only so a caller can replace the step's external effects. */
+    readonly toolchain?: PrismaGenerateToolchain;
+};
+/**
+ * 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 declare function generatePrismaDiscoveryArtifact(request: PrismaDiscoveryGenerateRequest): Promise<PrismaGenerateResult>;