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

package/dist/discovery/model.discoverer.d.ts

@@ -2,74 +2,13 @@ import { type TransactionCapability } from "@aventara/core";
 import type { PrismaComposedArtifact, PrismaModelComposer } from "../generate/prisma.generate.js";
 import type { PrismaCapabilitySurface } from "./capability-surface.interface.js";
 import type { PrismaSchemaFacts } from "./schema-facts.interface.js";
-/**
- * Every rule it applies belongs to somebody else. This module **orders and
- * assembles**, and it owns exactly two judgements of its own:
- *
- * 1. **Which diagnostics are fatal.** A mapper answers with a diagnostic; whether
- *    the build stops is composition's call, because only composition knows that a
- *    model with an unmapped column cannot produce a Contract at all.
- * 2. **The scalar registry.** `ScalarRegistry` is the set of Aventara scalar
- *    identities the discovered fields actually use — a fact no single field can
- *    state and only the whole pass can.
- *
- * # Three halves, from one pass over one field list
- *
- * `model` is core's: canonicalized, hashed, compiled into the Contract.
- * `translation` is the adapter's Prisma addressing, and `referentialActions` is
- * what the resolved `@relation(onDelete:/onUpdate:)` arguments say. All three are
- * built from the SAME pass: the translation table from the same
- * `mapPrismaIdentifiers` answer the model's `identifiers` come from — `.members`
- * into the model, the whole address into the table — and the action table from the
- * same `projectPrismaField` answer the model's relation fields come from. Two
- * parallel passes would have to be kept in step; one pass cannot drift.
- *
- * `PrismaTranslationTable<M>` and `PrismaReferentialActionTable<M>` are mapped
- * types over the model's resources, so a resource this module adds to the model
- * and forgets to address — or forgets to answer the actions for — is a **compile
- * error** rather than a runtime `undefined` at the first unique read or the first
- * cascade question.
- *
- * The action table carries **only owning edges**, because only an owning edge has
- * an action: PSL forbids the back-reference from declaring one, so the
- * back-reference's answer is its partner's. Its direction is the one documented on
- * `PrismaReferentialEdge` and on `field.mapper.ts`'s `PrismaRelationEdge` —
- * *deleting a `target` does `onDelete` to rows of the enclosing resource* — and it
- * is carried out of field projection unchanged rather than re-derived here.
- *
- * # No provider reaches this module, and that is enforced by the input
- *
- * The composer is created with a {@link TransactionCapability} and nothing else.
- * `provider` is not a member anywhere on the path, so `if (provider === …)` is a
- * compile error rather than a convention. The generate step keeps `provider` only
- * to stamp the artifact, which is a recorded fact and not a branch.
- *
- * `transactions` is a **driver** fact and the driver is a runtime choice, so it is
- * declared to the composer at generate time. The two cannot silently disagree: an
- * artifact that says `"interactive"` loaded by an adapter whose declared driver
- * says `"none"` mounts no `transaction`, and core refuses construction with
- * `DISCOVERY_TRANSACTION_CAPABILITY_MISMATCH` **[CORE, framework.factory.ts]** — a
- * hard, legible failure rather than a silent one.
- *
- * The capability members are **scope-qualified** now, so the one record holds both
- * answers: the create stage is advertised at the `nested` write scope and not at
- * the bulk one. Composition asks for no variant, passes no `operation`, and
- * advertises nothing it cannot honour. The mutation translator keeps its refusal —
- * it is the belt to core's braces, not the only guard — but it is no longer the
- * ONLY place the restriction exists.
- */
-/** Composition refuses: the collected diagnostics, named and reported together. */
+/** Thrown when the schema cannot be composed into a model; lists every problem. */
 export declare class PrismaModelCompositionError extends Error {
     readonly name = "PrismaModelCompositionError";
     readonly diagnostics: readonly string[];
     constructor(diagnostics: readonly string[]);
 }
 export type PrismaModelCompositionOptions = {
-    /**
-     * The driver's transaction capability. The ONLY declared fact composition accepts,
-     * and deliberately not the whole profile: a `PrismaProviderProfile` carries
-     * `provider`.
-     */
     readonly transactions: TransactionCapability;
 };
 export type PrismaModelDiscoveryInput = PrismaModelCompositionOptions & {
@@ -80,12 +19,6 @@ export type PrismaModelDiscoveryInput = PrismaModelCompositionOptions & {
     /** Resource names the existence gate admitted, in PSL declaration order. */
     readonly admitted: readonly string[];
 };
-/**
- * The generate step's `composeModel` seam, filled.
- *
- * A factory rather than a bare function because the step's seam takes only the
- * readers' output — order and refusal over external effects is the step's job, and
- * the declared driver fact is the caller's.
- */
+/** Creates the composer `runPrismaGenerateStep` needs, for one transaction capability. */
 export declare function createPrismaModelComposer(options: PrismaModelCompositionOptions): PrismaModelComposer;
 export declare function discoverPrismaModel(input: PrismaModelDiscoveryInput): PrismaComposedArtifact;

package/dist/discovery/operations.deriver.d.ts

@@ -1,46 +1,10 @@
 import type { AdapterResource, ResourceOperations, TransactionCapability } from "@aventara/core";
 import type { PrismaAdapterModel } from "./discovery-artifact.interface.js";
-/**
- * No mapper, no discoverer, no emitter and no executor may drop a variant, because
- * an omission in two places is an omission nobody can audit.
- *
- * # Three inputs, and `provider` is not one of them
- *
- * ```text
- * findUnique, findUniqueOrThrow, findFirst, findFirstOrThrow, findMany, create,
- * createMany, createManyAndReturn, delete, update, deleteMany, updateMany,
- * updateManyAndReturn, upsert, count, aggregate, groupBy
- * ```
- *
- * The second input is the model's identifiers, because `find.unique`,
- * `update.unique`, `delete.unique` and `upsert.unique` are meaningless without
- * one. The third is `transactions` — the **only** declared profile row this gate
- * needs. The whole `PrismaProviderProfile` is deliberately NOT accepted: it
- * carries `provider`, and a module that cannot be handed a provider cannot branch
- * on one (dictionary invariant 6). `isolationLevels` is not a precondition of any
- * variant.
- *
- * `supportsEmulatedFirstVariants` is **derived, exactly `transactions !== "none"`,
- * and stored nowhere**. A stored copy would be a second source of truth for a
- * one-line derivation.
- *
- * # What is NOT gated here, and why that is deliberate
- *
- * So `update.first` reads `emulatedFirst && exposes("update")` and `delete.first`
- * reads `emulatedFirst && exposes("delete")`. Under Route B those cells would read
- * `updateManyAndReturn` and `deleteMany` instead — which is exactly why the write
- * call is NOT folded into `emulatedFirst`: a shared precondition naming one
- * route's call would assert a gate the other route does not have, an assertion
- * that cannot fail for the right reason.
- */
-/** Core's own identifier tuples for a discovered Resource. */
 type DiscoveredIdentifiers = AdapterResource<PrismaAdapterModel>["identifiers"];
 export type ResourceOperationsInput = {
-    /** `<M>Delegate`'s own methods, as the types reader read them. */
     readonly operations: readonly string[];
     /** The model's usable identifiers; empty means no unique addressing exists. */
     readonly identifiers: DiscoveredIdentifiers;
-    /** The one declared profile row this gate reads. */
     readonly transactions: TransactionCapability;
 };
 export declare function deriveResourceOperations(input: ResourceOperationsInput): ResourceOperations;

package/dist/discovery/scalar.mapper.d.ts

@@ -1,43 +1,12 @@
 import type { PrismaResourceSurface } from "./capability-surface.interface.js";
 import type { PrismaSchemaField } from "./schema-facts.interface.js";
 import { type PrismaDiscoveryDiagnostic, type PrismaScalarMapping } from "./vocabulary.dictionary.js";
-/**
- * # Four answers, no fifth, and no guess
- *
- * The outcome is a closed union because every way this can end is a decision
- * somebody has to be able to read back:
- *
- * - `scalar` — the Prisma type name had a row in the dictionary's total table.
- * - `enum` — the written type is an enum `enums.ts` confirms. `enum.mapper.ts`'s
- *   `projectEnumBackedColumn` is where that becomes a field type ref.
- * - `excluded` — PSL declares the column and the 🟢 types do not expose it.
- * - `unmapped` — a type name in neither table. A **diagnostic**, never a silent
- *   drop and never a nearest-neighbour guess.
- *
- * # Why `format` is emitted here at all — and why so little of it is
- *
- * What the plan row was *right* about is that most of what looks like a format is
- * policy. `format` is **enforced**: `normalizeScalarFieldValue` turns `format:
- * "uuid"` into a `V1003` rejection of request input **[CORE,
- * `runtime/scalar-runtime.ts`]**. So the bar for discovering one is not "the
- * schema suggests it" but "the column itself rejects what Aventara would then
- * reject". That intent belongs in `FrameworkScalarFieldConfig.format` **[CORE]**,
- * which the Contract compiler already layers over the adapter's value.
- *
- * That is the correct answer, not a gap.
- *
- * # Nothing here branches on a provider
- *
- * `@db.Uuid` is unwritable on SQLite, so the SQLite schema simply never carries it
- * and the same table gives the same right answer on both engines without a
- * provider arm.
- */
 export type ScalarMappingInput = {
     /** The PSL model name, carried so a diagnostic can name the column in full. */
     readonly resource: string;
     /** PSL — what the column IS. */
     readonly field: PrismaSchemaField;
-    /** TYPE — what this client exposes. The existence gate. */
+    /** TYPE — what this client exposes. */
     readonly surface: PrismaResourceSurface;
     /** TYPE — `enums.ts`, which is what makes an enum name an enum name. */
     readonly enums: Readonly<Record<string, readonly string[]>>;

package/dist/discovery/scalar.mapper.js

@@ -7,7 +7,7 @@ export function mapPrismaScalarField(input) {
             outcome: "excluded",
             diagnostic: {
                 code: "not-exposed",
-                message: `${column} is declared in schema.prisma and absent from the generated 🟢 types, so it is omitted: ${explainAbsence(field, surface)}`,
+                message: `${column} is declared in schema.prisma and absent from the generated client's types, so it is omitted: ${explainAbsence(field, surface)}`,
             },
         };
     }
@@ -37,7 +37,7 @@ function explainAbsence(field, surface) {
         return "it carries `@ignore`";
     }
     if (Object.hasOwn(surface.relationFields, field.name)) {
-        return "the 🟢 types expose it as a relation edge, not a scalar column";
+        return "the generated client's types expose it as a relation edge, not a scalar column";
     }
     return "no schema attribute explains it — a provider drop, an `Unsupported(…)` column or a preview-feature exclusion";
 }

package/dist/discovery/schema-facts.interface.d.ts

@@ -1,15 +1,6 @@
-/**
- * Nothing here is imported from `@prisma/client`: these are this adapter's own
- * facts over schema text, which is what keeps discovery a pure function of plain
- * data and unit-testable without a generated client.
- *
- * Read `schema.reader.ts`'s header for the boundary these facts are drawn on: the
- * reader **locates** tokens and never **evaluates** them.
- */
 import type { PrismaReferentialAction } from "./discovery-artifact.interface.js";
 /** Where a fact — or an unhandled construct — was found. One-based lines, as `prisma validate` reports them. */
 export type PrismaSchemaSite = {
-    /** The schema file as the caller named it; a folder read names each member file. */
     readonly file: string;
     readonly line: number;
 };
@@ -17,17 +8,6 @@ export type PrismaSchemaSite = {
  * A construct the reader **does not recognise at all** — bucket 3 of the reader's
  * three-way classification: a `type`/`view` block, an unrecognised `@relation`
  * argument, or any attribute spelling added after 7.10.0.
- *
- * `@map`, `@@map`, `@@index` and `@@id`/`@@unique`'s `map:` are **not** here: they
- * are recognised and deliberately discarded (bucket 2, the reader's explicit
- * `DISCARDED_ATTRIBUTES` list), because their values appear nowhere on the 🟢
- * generated surface. Recording them would fail the generate step on any schema
- * that maps a column name. `name:` is **not** discarded — see {@link
- * PrismaSchemaBlockIdentifier}.
- *
- * Bucket 3 is recorded rather than dropped because silently dropping an
- * unrecognised attribute is how a grammar change becomes wrong output instead of a
- * build stop. A non-empty `PrismaSchemaFacts.unhandled` FAILS the generate step.
  */
 export type PrismaSchemaUnknown = {
     readonly kind: PrismaSchemaUnknownKind;
@@ -41,11 +21,7 @@ export type PrismaSchemaUnknown = {
 };
 export type PrismaSchemaUnknownKind = 
 /** An `@…` on a field declaration. */
-"field-attribute"
-/** An `@@…` on its own line inside a block. */
- | "block-attribute"
-/** A named argument of a recognised attribute that the reader neither models nor deliberately discards. */
- | "attribute-argument"
+"field-attribute" | "block-attribute" | "attribute-argument"
 /** A top-level block whose keyword is neither `model`, `enum`, `generator` nor `datasource`. */
  | "block"
 /** A line the reader could not classify at all. */
@@ -55,48 +31,15 @@ export type PrismaSchemaFacts = {
     readonly models: readonly PrismaSchemaModel[];
     /**
      * Attributes and blocks the reader does not recognise at all (a `type`/`view`
-     * block, an unrecognised argument, any spelling added after 7.10.0).
-     * `@map`/`@@map`/`@@index` are recognised and deliberately discarded instead, so
-     * they never appear here. Never silently dropped: a non-empty list FAILS the
-     * generate step.
+     * block, an  unrecognised argument, any spelling added after 7.10.0).
      */
     readonly unhandled: readonly PrismaSchemaUnknown[];
 };
 export type PrismaSchemaEnum = {
     readonly name: string;
-    /**
-     * Declaration order is semantic; a member-level `@map` is discarded (bucket 2),
-     * not recorded.
-     */
     readonly values: readonly string[];
     readonly site: PrismaSchemaSite;
 };
-/**
- * A block-level uniqueness criterion — `@@id([…])` or `@@unique([…])` — as PSL
- * states it: the members in **the attribute's own order**, and `name:`'s value
- * when the attribute carries one.
- *
- * `name:` is carried rather than discarded because bucket 2's rule is that an
- * attribute argument is discardable **iff its value appears nowhere on the 🟢
- * surface**, and this one appears there twice. Measured at 7.10.0 (regenerated
- * 2026-09-29): `@@unique([b, a], name: "altKey")` emits
- * `altKey?: Prisma.NamedUniqueAltKeyCompoundUniqueInput` in `WhereUniqueInput`
- * and keys `}, "id" | "altKey">`, and `@@id([a, b], name: "pk")` keys `}, "pk">`
- * — the custom name **replaces** the positional `b_a` / `a_b` alias. `map:` does
- * stay discarded: `named_idx` appears in the whole generated tree only in the 🛑
- * `internal/class.ts` inline-schema blob.
- *
- * The list itself is read from the positional argument or from `fields:`,
- * whichever the schema writes, and in whatever order the other arguments follow:
- * `@@unique([b, a])`, `@@unique(fields: [b, a])` and
- * `@@unique(name: "k", map: "m", fields: [b, a])` are all valid at 7.10.0 and the
- * first two produce the identical generated key `b_a`.
- *
- * `null` means the attribute wrote no `name:`, not "the positional form": the
- * positional key is derivable from `members`, and a name is derivable from
- * nothing, so only the undecidable half is recorded. What derives the addressing
- * key from the pair is `identifier.mapper.ts`.
- */
 export type PrismaSchemaBlockIdentifier = {
     /** Member order as written in the attribute's list. Never sorted. */
     readonly members: readonly string[];
@@ -120,7 +63,6 @@ export type PrismaSchemaField = {
     readonly type: string;
     /** `[]` */
     readonly list: boolean;
-    /** `?` — the ONLY source of nullability. */
     readonly optional: boolean;
     /** `@id` */
     readonly id: boolean;
@@ -128,15 +70,9 @@ export type PrismaSchemaField = {
     readonly unique: boolean;
     /** `@updatedAt` */
     readonly updatedAt: boolean;
-    /** `@default(…)`'s argument as RAW TEXT — matched against a table, never parsed. */
     readonly defaultArgument: string | null;
     readonly relation: PrismaSchemaRelation | null;
-    /**
-     * `@db.*` as written, e.g. `@db.Decimal(10, 2)`. Kept verbatim and never parsed. A
-     * native type is the **only** proof discovery accepts for `format`; configuration
-     * may then override it, since `AdapterScalarField.format` and
-     * `FrameworkScalarFieldConfig.format` are separate members the compiler layers.
-     */
+    /** `@db.*` as written, e.g. `@db.Decimal(10, 2)`. */
     readonly native: readonly string[];
     /** `@ignore` */
     readonly ignored: boolean;
@@ -145,7 +81,6 @@ export type PrismaSchemaField = {
 export type PrismaSchemaRelation = {
     /** `@relation("Name")` — the ONLY evidence pairing a back-reference with its forward reference. */
     readonly name: string | null;
-    /** The FK scalar(s); read, used, then discarded. */
     readonly fields: readonly string[] | null;
     readonly references: readonly string[] | null;
     /**
@@ -153,21 +88,6 @@ export type PrismaSchemaRelation = {
      * absent argument carries Prisma's effective default rather than a third
      * state, because an absent action and the explicitly-written default are one
      * fact about what a delete does.
-     *
-     * `null` means **this edge is not the owning side** — it declares no
-     * `fields:`, so no foreign key and no action belong to it. PSL enforces that
-     * itself: `prisma validate` 7.10.0 answers *"The relation field `reqs` on
-     * Model `Alpha` must not specify the `onDelete` or `onUpdate` argument in the
-     * @relation attribute. You must only specify it on the opposite field `alpha`
-     * on model `Req`"*. `null` therefore reads as "ask the other edge", never as
-     * "no action applies". It is also what an unreadable action spelling leaves
-     * behind, and that case is recorded in `unhandled` and fails the generate
-     * step, so no consumer sees it.
-     *
-     * The inversion matters to every consumer: the action is declared on the
-     * CHILD and fires when the PARENT is deleted. Read with
-     * `PrismaSchemaField.type` — the target model — one owning edge says
-     * "deleting a `<type>` does `<onDelete>` to a row of the enclosing model".
      */
     readonly onDelete: PrismaReferentialAction | null;
     /** `@relation(onUpdate: …)`, resolved the same way. Read independently of `onDelete`. */

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

@@ -1,137 +1,4 @@
 import type { PrismaSchemaFacts } from "./schema-facts.interface.js";
-/**
- * # The boundary, and why this file is a reader and not a parser
- *
- * It **locates** tokens and never **evaluates** them.
- *
- * PSL's model body is line-oriented by the language's own rule, not by this
- * reader's assumption. Re-measured against `prisma` 7.10.0 on 2026-09-28, all four
- * constructs that would let a declaration legally span lines are **rejected** with
- * `Error code: P1012` — so the classic regex-parser failure cannot occur:
- *
- * 1. a wrapped `@@unique([…])` — the error COUNT is layout-dependent, the
- *    rejection is not. A two-line wrap (`@@unique([x,` / `y])`) gives 2 errors,
- *    both `error: Error validating: This line is not a valid field or attribute
- *    definition.`; a four-line wrap gives 4 — three of that sentence plus one
- *    `Error validating model "A": This field declaration is invalid. It is either
- *    missing a name or a type.`
- * 2. a wrapped field attribute (`@default(uuid())` on the line below `id String
- *    @id`) — 1 error, `This line is not a valid field or attribute definition.`
- * 3. two block attributes on one line (`@@unique([x]) @@index([y])`) — 1 error,
- *    `This line is not a valid field or attribute definition.`
- * 4. a split field declaration (`id` then `String @id`) — 2 errors, **both**
- *    `Error validating model "A": This field declaration is invalid. It is either
- *    missing a name or a type.`
- *
- * All four are indeed `P1012`, **and the line-oriented conclusion holds
- * unchanged** — the design did not move. But case 4 never emits that sentence at
- * all (it emits *"This field declaration is invalid. It is either missing a name
- * or a type."* twice), and case 1 emits a second, different sentence besides it.
- * The evidence supports the rule; the single-sentence attribution does not, and
- * the plan now says so.
- *
- * Re-running it: `prisma` lives at `packages/prisma7-adapter/node_modules/.bin/
- * prisma`, not the worktree root. Invoked from the root it silently produces no
- * output, which looks exactly like "no errors".
- *
- * # What crossing the boundary would mean
- *
- * The day this reader **evaluates** — resolving `env()`, interpreting
- * `dbgenerated(…)`, modelling `type`/`view` blocks, following `@@schema`, or
- * reconstructing relations without `@relation` names — it has become a parser and
- * needs a different decision. Hence:
- *
- * - `@default`'s argument is kept as **raw text** and matched against a table
- *   downstream, never parsed.
- * - `@db.*` is kept **as written** and never parsed. It is the only proof
- *   discovery accepts for `format`; configuration overrides it later.
- * - a field's `type` stays the written token — `Grade` is not resolved to the
- *   enum, which is also why a schema **folder** needs no linker (below).
- * - an attribute is classified three ways, not two (below), and only the third
- *   class is recorded in `unhandled`. A non-empty `unhandled` fails the generate
- *   step: silently dropping an **unrecognised** attribute is how a grammar change
- *   becomes wrong output instead of a build stop. The version fence is what
- *   converts a grammar change from silent wrongness into a build stop.
- *
- * # The three-way classification (corrected 2026-09-28)
- *
- * 1. **recognised and modelled** — `FIELD_ATTRIBUTES`, `BLOCK_ATTRIBUTES`, `@db.*`
- *    and `RELATION_ARGUMENTS`.
- * 2. **recognised and deliberately discarded**, via the explicit
- *    `DISCARDED_ATTRIBUTES` / `DISCARDED_BLOCK_ATTRIBUTE_ARGUMENTS` lists —
- *    `@map`, `@@map`, `@@index`, and `@@id`/`@@unique`'s `map:` argument. The rule
- *    is one line long: an argument is discardable **iff its value appears nowhere
- *    on the 🟢 surface**. The list being explicit is the point: the discard is a
- *    decision a reader can see and audit, not an omission. That rule is also what
- *    took `name:` back OFF this list (2026-09-29): its value is a
- *    `WhereUniqueInput` key and an `AtLeast` key, so it is carried on
- *    `PrismaSchemaBlockIdentifier`.
- * 3. **unrecognised** — on neither list, therefore `unhandled`, therefore a build
- *    stop.
- *
- * # Surface-invisibility was EVIDENCE, not the meaning (2026-09-29)
- *
- * Bucket 2's rule reads "discardable iff the value appears nowhere on the 🟢
- * surface", and `@relation(onDelete: Cascade)` passes that test: measured at
- * 7.10.0, `Cascade` reaches nothing but the 🛑 `internal/class.ts` inline-schema
- * blob. It is still **not** discardable, and this is the first construct where the
- * test and the rule it stands for come apart.
- *
- * The rule's *reason* was that such attributes configure the database below the
- * ORM entrypoint and therefore carry no framework meaning. A referential action
- * fails that reason while passing the test: it changes what a delete **does** —
- * rows disappear that the caller never named — which is exactly what a transaction
- * planner must reason about before it agrees to run a plan. So invisibility on the
- * generated types is *evidence* for "no framework meaning", and evidence can be
- * outweighed; it was never the meaning itself. `@map` and `@@index` remain
- * discarded because they fail the test AND the reason. `@relation`'s `map:` joins
- * them: a foreign-key constraint name is genuinely DB-side, and it was bucket 3
- * until now, which made `@relation(map: …)` — valid PSL — a build stop on its own.
- *
- * Actions are read on both arguments and carried **resolved**: an absent argument
- * is not a third state, it is Prisma's effective default, measured rather than
- * assumed (see `REFERENTIAL_ACTIONS` and `resolvePrismaReferentialDefaults`).
- *
- * Bucket 2 previously did not exist, and a field-level `@map` landed in
- * `unhandled`: the framework would have refused to build against any schema that
- * maps a column name, which is most real Prisma schemas.
- *
- * # Arguments are located by NAME, never by position (added 2026-09-29)
- *
- * PSL lets the same argument list arrive positionally or named, and lets the named
- * arguments come in any order. Measured against `prisma validate` 7.10.0 and
- * against a generated client on 2026-09-29: `@@unique([b, a])`, `@@unique(fields:
- * [b, a])`, `@@unique(name: "k", map: "m", fields: [b, a])` and every other
- * permutation are accepted, and the client keys the unnamed ones `b_a` and the
- * named ones `k` regardless of the order they were written in. The spelling is
- * therefore not a fact about the schema, and a reader that took the list to be the
- * FIRST argument read `@@unique(fields: [b, a])` as one member called `fields: [b,
- * a]` — silently, with `unhandled` empty — so the generate step refused a schema
- * Prisma accepts. ARGUMENT order does not matter; MEMBER order inside the list
- * still does, because it is part of the identity and of the addressing key.
- *
- * The same rule applies to `@relation`, which mixes a positional argument (the
- * relation name) with named ones; it was already order-independent and its FK read
- * was unaffected.
- *
- * A list whose members are not plain field names — `@@unique([a(sort: Desc)])`,
- * valid PSL at 7.10.0 — cannot be located without evaluating, so it is bucket 3
- * rather than a guess.
- *
- * # One deliberate non-recording beyond the buckets
- *
- * `generator` and `datasource` block bodies are skipped, not recorded: they are
- * tooling configuration, not model content, and their contents are exactly what
- * this reader must not evaluate (`env()` lives there).
- *
- * # A schema folder is readdir plus merge
- *
- * Prisma 7 accepts a folder (`prisma validate --schema <folder>` verified at
- * 7.10.0). Blocks are file-local and references are by name, so there is no
- * cross-file grammar and **no linker**: reading a folder appends each file's facts
- * in filename order and nothing is rewritten. Every fact keeps the file and line
- * it was written on.
- */
 export type PrismaSchemaSource = {
     readonly file: string;
     readonly text: string;

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

@@ -2,19 +2,11 @@ import ts from "typescript";
 import type { PrismaCapabilitySurface } from "./capability-surface.interface.js";
 export type PrismaTypesReadResult = {
     readonly surface: PrismaCapabilitySurface;
-    /**
-     * Every file under the client directory the reader actually opened. Reported
-     * rather than assumed: the 🛑 files are absent by refusal, not by luck, and a
-     * caller — or a spec — can assert the file **set** and not only the output.
-     */
+    /** Every file under the client directory the reader actually opened. */
     readonly filesRead: readonly string[];
 };
 export declare class PrismaTypesReaderError extends Error {
     readonly name = "PrismaTypesReaderError";
 }
-/**
- * The reader's one checker question, exported because it is the distinction the
- * whole reader rests on and therefore has to be testable on its own.
- */
 export declare function readWrittenTypeArguments(checker: ts.TypeChecker, reference: ts.TypeReferenceNode): readonly string[];
 export declare function readPrismaCapabilitySurface(clientDirectory: string): PrismaTypesReadResult;

package/dist/discovery/types.reader.js

@@ -21,7 +21,7 @@ export function readPrismaCapabilitySurface(clientDirectory) {
     const root = path.resolve(clientDirectory);
     const publicFiles = listPublicFiles(root);
     if (publicFiles.length === 0) {
-        throw new PrismaTypesReaderError(`no generated 🟢 file was found under ${root}`);
+        throw new PrismaTypesReaderError(`no generated Prisma client file was found under ${root}`);
     }
     const filesRead = new Set();
     const host = createPublicOnlyHost(root, filesRead);
@@ -63,11 +63,11 @@ function createPublicOnlyHost(root, filesRead) {
             return undefined;
         }
         if (isPrivatePath(root, resolved)) {
-            throw new PrismaTypesReaderError(`the types reader asked for ${path.relative(root, resolved)}, which is a 🛑 file`);
+            throw new PrismaTypesReaderError(`the types reader asked for ${path.relative(root, resolved)}, which is an internal file of the generated client that must not be imported`);
         }
         const text = readFileSync(resolved, "utf8");
         if (text.includes(RED_BANNER) || !text.includes(GREEN_BANNER)) {
-            throw new PrismaTypesReaderError(`${path.relative(root, resolved)} does not carry the 🟢 banner`);
+            throw new PrismaTypesReaderError(`${path.relative(root, resolved)} does not carry Prisma's "${GREEN_BANNER}" banner`);
         }
         filesRead.add(resolved);
         return text;
@@ -128,7 +128,7 @@ function projectionMembers(index, name) {
         ? written.typeArguments?.[0]
         : written;
     if (literal === undefined || !ts.isTypeLiteralNode(literal)) {
-        throw new PrismaTypesReaderError(`${name} is declared by the 🟢 types and is not a written object type, so its projection members cannot be read`);
+        throw new PrismaTypesReaderError(`${name} is declared by the generated client's types and is not a written object type, so its projection members cannot be read`);
     }
     return new Set(memberNames(literal.members.filter(ts.isPropertySignature)));
 }
@@ -197,7 +197,7 @@ function keysOfReferenced(index, node, accept) {
     }
     const members = membersOf(index, referencedName(reference));
     if (members === null) {
-        throw new PrismaTypesReaderError(`${referencedName(reference)} is referenced by the 🟢 types but declared nowhere in them`);
+        throw new PrismaTypesReaderError(`${referencedName(reference)} is referenced by the generated client's types but declared nowhere in them`);
     }
     return memberNames(members);
 }
@@ -325,7 +325,7 @@ function readMutationOperations(index, model, stage, field, member) {
     }
     const members = membersOf(index, referencedName(reference));
     if (members === null) {
-        throw new PrismaTypesReaderError(`${referencedName(reference)} is referenced by ${model}Unchecked${stage}Input.${field} and declared nowhere in the 🟢 types`);
+        throw new PrismaTypesReaderError(`${referencedName(reference)} is referenced by ${model}Unchecked${stage}Input.${field} and declared nowhere in the generated client's types`);
     }
     return memberNames(members);
 }
@@ -371,7 +371,7 @@ function readRelationFields(checker, index, payload, where, create, update, incl
         }
         const targetMembers = membersOf(index, referencedName(targetPayload));
         if (targetMembers === null) {
-            throw new PrismaTypesReaderError(`${referencedName(targetPayload)} is declared nowhere in the 🟢 types`);
+            throw new PrismaTypesReaderError(`${referencedName(targetPayload)} is declared nowhere in the generated client's types`);
         }
         const edge = findReference(include.get(name)?.type, (n) => n.endsWith("Args"));
         const edgeArguments = edge === null