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

package/dist/execution/result.shaper.d.ts

@@ -1,61 +1,5 @@
 import type { AdapterModel } from "@aventara/core";
 import type { PrismaProjectionPlan } from "../translation/projection.translator.js";
-/**
- * **The envelope is the adapter's to build, not core's.** `output-validator.ts`
- * accepts exactly `["count"]` or `["data","count"]` for a relation whose plan
- * carries the `$count` reducer, and rejects any key outside the projection — which
- * includes Prisma's own `_count` **[CORE, runtime/output-validator.ts]**. So
- * Prisma's answer `{ id, posts: [...], _count: { posts: 3 } }` must leave here as
- * `{ id, posts: { data: [...], count: 3 } }`, with `_count` gone.
- *
- * | nested select | shape | this module | |---|---|---| | `["id","title"]` | array
- * | returns Prisma's rows, values converted | | `["$count"]` | `{ count }` | reads
- * `_count.<edge>`; no rows were selected | | `["id","$count"]` | `{ data, count }`
- * | pairs the rows with `_count.<edge>` |
- *
- * The same validator that rejects a spare key also checks every projected scalar's
- * runtime form, and a decimal must be core's own `Decimal` **[CORE,
- * output-validator.ts → `normalizeScalarFieldValue`]**. Prisma returns an object
- * whose constructor is `Decimal2`, so before this conversion existed every read of
- * a decimal column failed core's output validation and the caller was told `A3000`
- * — measured through `createFramework(...).execute(...)` on both engines
- * (2026-10-02). The conversion itself belongs to
- * `translation/scalar.conversion.ts`, the one table that knows how each scalar
- * crosses the boundary in either direction; this module owns only *which field a
- * returned value belongs to*.
- *
- * **It answers that from the discovered model, not from the value.** The shaper
- * walks a row against `AdapterModel`: a key that names a scalar field converts
- * under that field's scalar, a key that names a relation recurses into the edge's
- * TARGET Resource, and a key the model does not know passes through for core to
- * accept or reject. Sniffing the runtime shape instead would be wrong in both
- * directions at once — a `Decimal2` and a `Json` document are both objects, and a
- * `Json` column holding the string `"12.5"` is indistinguishable from a decimal
- * string, so the first `Json` column holding numeric text would quietly come back
- * as a `Decimal`.
- *
- * The plan is still what places a `$count` envelope, and only that. The two are
- * complementary and neither can do the other's job: the plan records only the
- * edges that need reshaping (so it cannot drive a walk that must reach every
- * scalar), and the model does not know which edges requested a reducer (so it
- * cannot place an envelope).
- *
- * **Cardinality is never assumed.** `AdapterOperation` carries no plan, and the
- * arguments the plan is reconstructed from do not say whether an edge is to-one or
- * to-many. So recursion is driven by the value Prisma actually returned — an array
- * is shaped elementwise, a record is shaped as one row, `null` passes through —
- * which is total without knowing the cardinality at all.
- *
- * Nothing here invents a number. A missing or non-numeric `_count` entry for a
- * planned reducer is a translation/driver disagreement, and it raises rather than
- * defaulting to `0`: a wrong count that validates is worse than a loud failure,
- * because core would forward it to the caller as fact.
- *
- * **Nothing Prisma returned is written into.** A row is copied only when some
- * value in it actually changed, so a result needing no conversion and no envelope
- * comes back by identity.
- */
-/** What a Prisma result must be read against: the model, the Resource, the plan. */
 export type PrismaRowShaping = {
     /** The discovered model: field kinds, scalars, relation targets. */
     readonly model: AdapterModel;

package/dist/execution/transaction.executor.d.ts

@@ -1,110 +1,12 @@
 import type { AdapterModel, AdapterOperationExecutor } from "@aventara/core";
 import type { PrismaResourceTranslation } from "../discovery/discovery-artifact.interface.js";
 import type { PrismaDelegateHost, PrismaTransactionOptions } from "../prisma-client.interface.js";
-/**
- * The body is one `client.$transaction(async (tx) => work(scopedExecutorFor(tx)),
- * options)`. Everything interesting about this module is what it deliberately does
- * **not** do, so each omission is recorded here rather than left to be
- * rediscovered.
- *
- * Prisma's array form — `$transaction` applied to a list of prepared calls —
- * cannot honour a plan at all. An Aventara plan is **sequential by contract**:
- * operation *n* may carry a `$ref` resolved from operation *n − 1*'s final data,
- * and core resolves it between calls, so the second call's arguments do not exist
- * until the first has answered. The array form takes every call up front. It is
- * therefore a framework invariant and not a preference, and it is protected twice:
- * {@link PrismaDelegateHost} declares `$transaction` in its callback form only, so
- * the array overload is not *representable* through the seam this adapter holds,
- * and `transaction.executor.spec.ts` asserts both that every call this adapter
- * makes passes a function and that the array form's own opening token occurs
- * nowhere in `src` (that spec assembles the token rather than writing it, for the
- * same reason this sentence does not quote it).
- *
- * `scopedExecutorFor` closes over the callback's `tx` and nothing else, so no plan
- * operation can reach the client this module was constructed with — there is no
- * path to it from the value core is handed.
- *
- * Core throws a private frozen abort sentinel out of `work` after it has recorded
- * a failing operation, and recognises the rejection **by `===` alone**.
- *
- * **Induced, not assumed** (2026-10-02, PostgreSQL 18): a write inside a
- * transaction, the backend terminated from a second connection, a frozen sentinel
- * thrown from the callback. Prisma's `ROLLBACK` failed — `prisma:client rollback
- * attempt 1/1 failed: '{}'` appears under `DEBUG=prisma*` — and the value the
- * caller received was still that sentinel, by identity, carrying nothing about the
- * rollback at all. Two consequences, both deliberate: core's `A3002`-on-rollback-
- * failure branch is **unreachable with this adapter** (it stays for adapters whose
- * provider reports the failure), and this adapter never claims a rollback
- * succeeded, because it cannot observe that it did. A commit failure is different:
- * it is thrown from inside the same `try` and rejects like a callback throw.
- *
- * They are provider concepts: core's `Adapter.transaction(work)` carries no
- * options and must not grow any, so they are set once at `createPrismaAdapter({
- * transactionOptions })` and are not part of Aventara's public configuration.
- * Prisma's own defaults stand when they are absent — `maxWait` 2000 ms, `timeout`
- * 5000 ms **[PKG, `runtime/client.d.ts`]** — and the supported isolation levels
- * come from the provider profile, which discovered them, rather than from a table
- * written here.
- *
- * The options are **not** forwarded to the scoped executor. At `"transaction"`
- * scope `operation.executor.ts` never opens a transaction, so an option passed
- * there would be dead configuration that reads as if it did something.
- *
- * Induced against PostgreSQL 18 on `@prisma/client` 7.10.0, 2026-10-02 (the
- * assertions live in `conformance/postgres.conformance.spec.ts`):
- *
- * ```text
- * timeout 1 ms, a query issued after expiry
- *   P2028  meta = { modelName: "Author", operation: "query", timeout: 1, timeTaken: 66 }
- * timeout 1 ms, no query after the sleep — the COMMIT is what fails
- *   P2028  meta = { operation: "commit", timeout: 1, timeTaken: 62 }
- * maxWait 1 ms with the one connection already held by another transaction
- *   P2028  meta = {}                     <- EMPTY
- * isolationLevel: "Bogus"
- *   P2023  meta = { providedIsolationLevel: "Bogus" }   <- NOT P2028
- * ```
- *
- * The table above is the `isolationLevel` arm only as far as a **malformed** level
- * goes. A level that IS one of Prisma's five and is simply unsupported by the
- * provider reaches the transaction manager and raises a `meta`-carrying `P2028` of
- * its own, measured on both engines (2026-10-02):
- *
- * ```text
- * isolationLevel: "Snapshot"  (a SQL Server level; one of Prisma's five)
- *   P2028  meta = { isolationLevel: "SNAPSHOT" }
- * ```
- *
- * So of the seven `P2028` classes in 7.10.0 — `TransactionManagerError` plus
- * `nt`/`un`/`cn`/`fr`/`pn`/`Me`/`dn` **[PKG, `runtime/client.js`]** — the
- * separable-by-`meta` set is **three**: the transaction-timeout expiry carries `{
- * operation, timeout, timeTaken }`, the unsupported isolation level carries `{
- * isolationLevel }`, and the acquisition timeout carries nothing and is separable
- * *by* that emptiness from the other two. An earlier revision of this comment
- * withdrew the claim outright; it was measured on the wrong input, and
- * `conformance/postgres.conformance.spec.ts` and
- * `conformance/sqlite.conformance.spec.ts` both assert the corrected fact.
- *
- * A `P2028` that ends the transaction rejects out of `$transaction` itself, is not
- * core's sentinel, and core's own `infrastructureFailure` answers `A3002`. A
- * `P2028` raised by a *delegate call* inside the callback is a different route: it
- * is unclassified by the closed table, so core's `AdapterBoundary` attributes
- * `A3001` to that operation. `A3002` is therefore the answer for the failure that
- * ends the transaction, not a uniform answer for the code — recorded here because
- * the difference is invisible from the table alone.
- */
 export type PrismaTransactionExecutorDependencies = {
-    /** The client the transaction is opened on: the application's own. */
     readonly client: PrismaDelegateHost;
     readonly model: AdapterModel;
     /** The generate-time translation table (Prisma addressing per Resource). */
     readonly translation: Readonly<Record<string, PrismaResourceTranslation>>;
-    /** Adapter-owned, never Aventara public configuration. */
     readonly transactionOptions?: PrismaTransactionOptions;
 };
-/**
- * `Adapter<M>["transaction"]` without the optionality: the adapter mounts it
- * exactly when the discovered model declares `transactions: "interactive"`, so the
- * function itself is total.
- */
 export type PrismaTransactionRunner<M extends AdapterModel> = <T>(work: (executor: AdapterOperationExecutor<M>) => Promise<T>) => Promise<T>;
 export declare function createPrismaTransactionExecutor<M extends AdapterModel>(dependencies: PrismaTransactionExecutorDependencies): PrismaTransactionRunner<M>;

package/dist/generate/artifact.emitter.d.ts

@@ -1,40 +1,6 @@
-import type { PrismaAdapterModel, PrismaClientShape, PrismaCreateRequirementTable, PrismaReferentialActionTable, PrismaTranslationTable } from "../discovery/discovery-artifact.interface.js";
+import { type PrismaAdapterModel, type PrismaClientShape, type PrismaCreateRequirementTable, type PrismaReferentialActionTable, type PrismaTranslationTable } from "../discovery/discovery-artifact.interface.js";
 import type { PrismaProvider } from "../provider/provider-profile.js";
-/**
- * It predates the ADR and loses to it, for a reason the ADR states plainly:
- * `resolveJsonModule` widens `"string"` to `string`, so a JSON model carries no
- * literals, and carrying them would take a second emitted `.d.ts` beside the data
- * — two emissions from one source, which can drift. One module written `as const
- * satisfies AdapterModel` makes the value and the type the same expression, so
- * drift is not merely detectable but unrepresentable.
- *
- * The emitted module is still passive, serializable, introspectable, hashable and
- * free of runtime callbacks. It contains three `const` bindings and no executable
- * statement; `discovery.model` and `discovery.translation` *reference* their
- * bindings rather than restating them, so there is exactly one representation of
- * each half in the file.
- *
- * **Three halves, and the seam between them is deliberate.** `model` is what core
- * consumes: canonicalized, digested into `modelHash`, and compiled into the
- * Contract. `translation` is Prisma addressing — which key a `WhereUniqueInput`
- * answers to for each identifier. `referentialActions` is what deleting a parent
- * row does to its children, resolved. Both of the latter sit BESIDE the model
- * precisely because they must not reach the hash: a `@@unique(name:)` rename
- * carries no semantic content, and inside the model it would change the Contract
- * identity and force every generated client to be regenerated for nothing; a
- * referential action is not part of the model at all, and inside it the action
- * would reach the compiled Contract and the ClientContract, which have no word for
- * one.
- *
- * **Determinism.** The model text is the canonical JSON core already uses for
- * Contract identity, re-indented — not `JSON.stringify` over whatever key order
- * the readers happened to build. So two generate runs over one schema emit
- * byte-identical modules, and `modelHash` is a digest of exactly the bytes the
- * module carries, computed by the same `computeModelHash` the runtime loader
- * checks it with. One hash function, one canonicalization, both halves.
- */
 export type PrismaArtifactEmission = {
-    /** e.g. `"7.10.0"`; only the major is fenced at load. */
     readonly prismaVersion: string;
     readonly provider: PrismaProvider;
     readonly model: PrismaAdapterModel;

package/dist/generate/artifact.emitter.js

@@ -1,48 +1,32 @@
 import { canonicalizeJson } from "@aventara/core";
 import { computeModelHash } from "../discovery/artifact.loader.js";
+import { DISCOVERY_ARTIFACT_FORMAT, } from "../discovery/discovery-artifact.interface.js";
 const BANNER = [
-    "// biome-ignore-all format: generated output; these bytes are the artifact",
+    "// biome-ignore-all format: generated output",
     "// 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.",
+    " * Prisma addressing per Resource: for each identifier, the key a",
+    " * `WhereUniqueInput` accepts — the field name for a single column, the members",
+    " * joined with `_` for a compound, or the `name:` of `@@id`/`@@unique` where",
+    " * one is given. Not part of `modelHash`.",
     " */",
 ];
 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:",
+    " * The schema's referential actions, per Resource: the relation fields that",
+    " * declare `@relation(fields: …)`, each with its resolved `onDelete` and",
+    " * `onUpdate`. An edge under Resource `R` reads:",
     " *",
-    " *   deleting a `target` row does `onDelete` to rows of the ENCLOSING resource.",
+    " *   deleting a `target` row does `onDelete` to rows of `R`.",
     " *",
-    ' * 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.",
+    ' * So "what does deleting an `X` do?" is answered by every edge whose',
+    ' * `target` is `"X"`, under the Resource that holds it. An action the schema',
+    " * leaves out is Prisma's default: `set-null` where every foreign-key field is",
+    " * optional, `restrict` otherwise, `cascade` on update. Not part of `modelHash`.",
     " */",
 ];
 const CLIENT_DOC = [
@@ -51,8 +35,8 @@ const CLIENT_DOC = [
     " * delegate for, and that model's field references (`prisma.<model>.fields`).",
     " *",
     " * `createPrismaAdapter` reads the same facts off the client it is given and",
-    " * refuses to start when they differ — the schema changed and the client was",
-    " * regenerated without this artifact. Beside the model and outside `modelHash`.",
+    " * refuses to start when they differ: the schema changed and the client was",
+    " * regenerated without this artifact. Not part of `modelHash`.",
     " */",
 ];
 const CREATE_REQUIREMENTS_DOC = [
@@ -62,21 +46,15 @@ const CREATE_REQUIREMENTS_DOC = [
     " * the scalar fields holding its reference — and which a nested create",
     " * reached through its `inverse` gets from the parent.",
     " *",
-    " * The framework checks every create against it after pipes and computed",
-    " * behaviours and answers a missing value as `A2004`/`V1000` at its path,",
-    " * before the database is reached. Beside the model and outside `modelHash`.",
+    " * Every create is checked against it and a missing value is answered as",
+    " * `A2004`/`V1000` at its path, before the database is reached. Not part of",
+    " * `modelHash`.",
     " */",
 ];
 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`.",
+    " * What the schema and the generated client agreed on: the model Aventara",
+    " * compiles its Contracts from.",
     " */",
 ];
 const DISCOVERY_DOC = [
@@ -109,6 +87,11 @@ export async function emitDiscoveryArtifactModule(emission) {
         "",
         ...DISCOVERY_DOC,
         "export const discovery = {",
+        "\t/**",
+        "\t * The artifact's format. A TypeScript error naming this property means this",
+        "\t * file is out of date: regenerate it.",
+        "\t */",
+        `\tregenerate_with_aventara_prepare: ${DISCOVERY_ARTIFACT_FORMAT},`,
         `\tprismaVersion: ${JSON.stringify(emission.prismaVersion)},`,
         `\tprovider: ${JSON.stringify(emission.provider)},`,
         `\tmodelHash: ${JSON.stringify(modelHash)},`,

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

@@ -1,18 +1,3 @@
-/**
- * What this adapter **declares** it supports, read from its own manifest — the one
- * place the fact is stated.
- *
- * The generate step needs two of those facts at run time: the `prisma` range, to
- * decide whether a `prisma` CLI it found may run, and the `typescript` range, to
- * name in the sentence that refuses a compiler with no classic API. Both are
- * `peerDependencies` entries. 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;
@@ -24,10 +9,5 @@ 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/discovery.cli.d.ts

@@ -9,10 +9,6 @@ export type PrismaGenerateCliOptions = {
 /**
  * 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;
 /**

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

@@ -1,50 +1,16 @@
 import type { PrismaCapabilitySurface } from "../discovery/capability-surface.interface.js";
 import type { PrismaSchemaFacts, PrismaSchemaSite } from "../discovery/schema-facts.interface.js";
-/**
- * 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.
- *
- * 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`. This module does not answer it.
- */
 export type PrismaAbsenceKind = "model" | "field";
 /** What PSL said, when PSL said anything. */
 export type PrismaAbsenceExplanation = "@ignore" | "@@ignore";
+/** A schema model or field that was left out because the schema says to ignore it. */
 export type PrismaEntityAbsence = {
     readonly kind: PrismaAbsenceKind;
-    /** `Skipped`, or `Kept.hidden` — as a developer would name it. */
+    /** The model or field, as `Model` or `Model.field`. */
     readonly entity: string;
     readonly explanation: PrismaAbsenceExplanation | null;
     readonly site: PrismaSchemaSite;
-    /** The sentence reported or thrown. Composed here so both paths read alike. */
+    /** A sentence describing the absence. */
     readonly message: string;
 };
 export type PrismaExistenceGateResult = {

package/dist/generate/index.d.ts

@@ -1,59 +1,11 @@
 import type { PrismaDriver, PrismaProvider } from "../provider/provider-profile.js";
 import type { PrismaGenerateResult, PrismaGenerateToolchain } from "./prisma.generate.js";
-/**
- * # 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 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`.
- */
+/** One engine's generate request, as a consumer states it. */
 export type PrismaDiscoveryGenerateRequest = {
     /** The `schema.prisma` file, or a Prisma 7 schema folder. */
     readonly schema: string;
@@ -64,16 +16,11 @@ export type PrismaDiscoveryGenerateRequest = {
     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. */
+    /** Replaces the step's external effects; omit it to use the installed Prisma and TypeScript. */
     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.
+ * Generates the discovery artifact for one schema: what the
+ * `aventara-prisma7-generate` command runs.
  */
 export declare function generatePrismaDiscoveryArtifact(request: PrismaDiscoveryGenerateRequest): Promise<PrismaGenerateResult>;

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

@@ -1,25 +1,3 @@
-/**
- * `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;
- * 2. otherwise `prisma`, **only** when its version is in the adapter's declared
- *    range (`peerDependencies.prisma`, read by the caller);
- * 3. otherwise a refusal naming both, with the install command.
- *
- * # Where it looks
- *
- * 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.
- */
 export type PrismaCli = {
     /** The package whose bin runs: `@prisma/prisma7` or `prisma`. */
     readonly package: "@prisma/prisma7" | "prisma";