@aventara/prisma7-adapter 0.1.0-pilot.3 → 1.0.0-rc.0

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

@@ -1,38 +1,5 @@
 import type { RelationFieldCapabilities, ScalarFieldCapabilities, ScalarFilterOperator } from "@aventara/core";
 import type { PrismaRelationSurface, PrismaScalarSurface } from "./capability-surface.interface.js";
-/**
- * This module accepts `surface` alone, and that is deliberate: dictionary
- * invariant 6 says a capability is read from the client's own types and never
- * tabulated from a provider row, and the strongest available mechanism for that is
- * to make the provider **unrepresentable** rather than merely unread. A
- * `PrismaProviderProfile` in this input is a `provider` member one keystroke from
- * a branch; with no such member, `if (provider === …)` is a compile error, and the
- * three per-engine differences this pass exists to prove — `mode`, `JsonFilter`'s
- * ordering operators, and the `path` / `in` / `notIn` operand shapes — have to
- * come from the surface because nothing else is in scope.
- *
- * `mapping` went with them because nothing here reads an Aventara scalar identity
- * to answer a capability question.
- *
- * The answer is read off the recorded operand shape, which is already on the
- * surface; the Aventara scalar identity would have been a second, weaker source
- * for the same fact. `mapping` stays out.
- *
- * # Order is canonical, not incidental
- *
- * Every list is emitted in **core's own union declaration order**, held below as a
- * closed ordered array.
- *
- * # Absent and empty are different answers
- *
- * `create: []` / `update: []` mean **writable with no directive** — plain
- * assignment, which is what `set` alone is. An absent `create` / `update` means
- * **not writable**, and core enforces exactly that: `validateScalarMutation`
- * answers `V1006` *"is not writable during <stage>"* when the member is
- * `undefined` **[CORE, operations/operation-validator-core.ts]**. So the two must
- * not be conflated, and the surface's `null` (the client exposes no entry for this
- * column at this stage) is the only thing that produces the absent form.
- */
 /** A Prisma spelling that no dictionary table recognises: a build stop, never a drop. */
 export declare class PrismaCapabilityDerivationError extends Error {
     readonly name = "PrismaCapabilityDerivationError";
@@ -40,23 +7,11 @@ export declare class PrismaCapabilityDerivationError extends Error {
 export type ScalarCapabilityInput = {
     readonly surface: PrismaScalarSurface;
 };
-/**
- * A relation's capabilities are answered for the field, not for an operation.
- *
- * The `operation: "create.one" | "create.many"` parameter this input used to carry
- * is **gone**. The scope-qualified members hold both answers at once, so there is
- * nothing left to pick and no caller left to pick it.
- */
+/** A relation's capabilities are answered for the field, not for an operation. */
 export type RelationCapabilityInput = {
     readonly surface: PrismaRelationSurface;
 };
 export declare function deriveScalarCapabilities(input: ScalarCapabilityInput): ScalarFieldCapabilities;
-/**
- * The Prisma operand for each ADVERTISED operator, keyed by the Aventara name.
- *
- * A deriver that answered operator NAMES alone would report the two engines
- * identical where they are not, so the shape is carried beside the capability
- * rather than discarded.
- */
+/** The Prisma operand for each ADVERTISED operator, keyed by the Aventara name. */
 export declare function deriveScalarFilterOperands(input: ScalarCapabilityInput): Readonly<Partial<Record<ScalarFilterOperator, string>>>;
 export declare function deriveRelationCapabilities(input: RelationCapabilityInput): RelationFieldCapabilities;

package/dist/discovery/capability.deriver.js

@@ -157,6 +157,9 @@ export function deriveRelationCapabilities(input) {
             : {}),
         create: writableIn(directives(surface.createMutations), surface.bulkCreatable),
         update: writableIn(directives(surface.updateMutations), surface.bulkUpdatable),
+        ...(surface.scalarNestedWriteFilter
+            ? { nestedWriteFilter: "scalar" }
+            : {}),
     };
 }
 function look(table, key, what) {

package/dist/discovery/discovery-artifact.interface.d.ts

@@ -1,39 +1,23 @@
-import type { Adapter, AdapterResource, EnumDefinition, ScalarRegistry, TransactionCapability } from "@aventara/core";
+import type { Adapter, AdapterModel, EnumDefinition, ScalarRegistry, TransactionCapability } from "@aventara/core";
+import type { AdapterResource } from "@aventara/core/internal";
 import type { PrismaProvider } from "../provider/provider-profile.js";
-/**
- * A plain `type`, not `interface … extends`: `AdapterModel.resources` is
- * self-typed `AdapterResource<this>`, and a nominal `extends` hits TS2430.
- */
+/** The adapter model a discovery artifact carries, in Aventara's vocabulary. */
 export type PrismaAdapterModel = {
+    /** The scalar types the schema uses. */
     readonly scalars: ScalarRegistry;
+    /** The schema's enums, by name. */
     readonly enums: Readonly<Record<string, EnumDefinition>>;
+    /** The schema's models, as Resources. */
     readonly resources: Readonly<Record<string, AdapterResource<PrismaAdapterModel>>>;
+    /** Whether the driver supports interactive transactions. */
     readonly transactions: TransactionCapability;
+    /**
+     * Prisma takes one record's references one way at a time (its checked and
+     * unchecked write inputs), so every artifact states `"uniform"`.
+     */
+    readonly referenceWrites: NonNullable<AdapterModel["referenceWrites"]>;
 };
-/**
- * One identifier, and the **Prisma addressing key** that reaches it.
- *
- * `members` is the identifier as core carries it — derived from
- * `AdapterResource` rather than restated, so a change to core's identifier type
- * is a compile error here. `key` is the same criterion's *Prisma* spelling: the
- * key a `WhereUniqueInput` accepts, and the key the generated `AtLeast<…, K>`
- * union lists.
- *
- * The two are different facts, and the whole reason this type exists is that
- * they are not derivable from one another. Measured at 7.10.0 (2026-09-29):
- *
- * - a single-column criterion keys by the field name and does **not** wrap:
- *   `{ id: "x" }`;
- * - a compound keys by its members joined with `_` **in attribute order** and
- *   does wrap: `@@unique([b, a])` → `{ b_a: { b, a } }`;
- * - `name: "X"` **replaces** the positional form on both sides — `}, "id" |
- *   "altKey">` and `altKey?: Prisma.…CompoundUniqueInput`;
- * - `map:` affects neither: it reaches only the 🛑 inline-schema blob.
- *
- * So `key` is stored at generate time and **matched** at runtime, never
- * re-derived: `members.join("_")` is wrong for every named criterion, and
- * whether it wraps is `members.length > 1`.
- */
+/** One identifier, and the **Prisma addressing key** that reaches it. */
 export type PrismaIdentifierAddress = {
     readonly members: AdapterResource<PrismaAdapterModel>["identifiers"][number];
     readonly key: string;
@@ -42,110 +26,42 @@ export type PrismaIdentifierAddress = {
 export type PrismaResourceTranslation = {
     readonly identifierKeys: readonly PrismaIdentifierAddress[];
 };
-/**
- * The **translation table**: Prisma addressing for every discovered Resource.
- *
- * Keyed on `M`'s own resource keys, so a table missing a Resource — or naming
- * one the model does not have — is a compile error rather than a runtime
- * `undefined` at the first unique read.
- *
- * It sits **beside** {@link PrismaDiscoveryArtifact.model}, never inside it, and
- * that placement is the point: the model is canonicalized, hashed and compiled
- * into the Contract, so a Prisma addressing key in it would put a DB-side
- * rename into the Contract hash and force every client to be regenerated for a
- * change with zero semantic content. This half is adapter-private: the executor
- * reads it, core never sees it.
- */
+/** The **translation table**: Prisma addressing for every discovered Resource. */
 export type PrismaTranslationTable<M extends PrismaAdapterModel = PrismaAdapterModel> = {
     readonly [R in keyof M["resources"]]: PrismaResourceTranslation;
 };
-/**
- * A referential action in Aventara's own vocabulary.
- *
- * Prisma's set — `Cascade | Restrict | NoAction | SetNull | SetDefault` — is the
- * SQL-standard set spelled in PascalCase, so a faithful mapping exists and no
- * Prisma spelling has to travel with the fact. These words are SQL's own
- * (`ON DELETE SET NULL`), which is why the mapping is a rename and not a
- * translation: nothing about it is Prisma-shaped, and the next adapter can state
- * the same fact without inheriting this one's vocabulary.
- *
- * It is declared **here**, on the artifact side, rather than beside the PSL
- * facts that resolve it: the artifact is what carries the vocabulary off the
- * generate step and across the package boundary, and `schema-facts.interface.ts`
- * imports it from here so that there is one spelling and the dependency runs
- * generate-time → artifact rather than the other way about.
- */
+/** A referential action, as `onDelete`/`onUpdate` name it in the schema. */
 export type PrismaReferentialAction = "cascade" | "restrict" | "no-action" | "set-null" | "set-default";
-/**
- * One **owning** relation edge's resolved referential actions.
- *
- * # The direction, which is the whole point of this type
- *
- * `onDelete` is declared on the **child** — `Kid.parent @relation(…, onDelete:
- * Cascade)` — and fires when the **parent** is deleted. PSL enforces that itself:
- * `prisma validate` 7.10.0 refuses the action on the other edge, naming the
- * opposite field. So an entry under resource `R` reads:
- *
- * > **deleting a `target` row does `onDelete` to rows of `R`.**
- *
- * A consumer asking *"what does deleting an `X` do?"* scans every resource's
- * {@link PrismaResourceReferentialActions.owningEdges} for `target === "X"` and
- * reads the enclosing resource key off the table. It never has to work out which
- * side of a pair declared what.
- *
- * **Reversing that reading is silent.** Nothing in the shape distinguishes
- * `resource` from `target`, both are resource names, and a planner built on the
- * inverted reading cascades the wrong way with no type error and no runtime
- * complaint. That is why the convention is restated here as well as on
- * `field.mapper.ts`'s `PrismaRelationEdge`, which is where these values are
- * carried out of field projection.
- *
- * # Both members are resolved, so neither is nullable
- *
- * An absent `@relation(onDelete:)` is **not** a third state: it is Prisma's
- * effective default, measured at 7.10.0 with `prisma migrate diff` and identical
- * on `postgresql` and `sqlite` — `SET NULL` when every scalar in `fields:` is
- * optional, `RESTRICT` otherwise, and `CASCADE` on update
- * (`schema.reader.ts`'s `resolvePrismaReferentialDefaults`). An action the reader
- * cannot name is recorded in `unhandled` and fails the generate step, so no
- * artifact ever carries an unresolved one.
- */
+/** One **owning** relation edge's resolved referential actions. */
 export type PrismaReferentialEdge = {
     /** The edge's field name on the enclosing (child) resource. */
     readonly field: string;
     /** The resource the edge points AT — the parent, whose deletion fires `onDelete`. */
     readonly target: string;
+    /** Whether the edge holds one related row or many. */
     readonly cardinality: "one" | "many";
+    /**
+     * The scalar fields of the ENCLOSING resource that hold the reference — the
+     * relation's `@relation(fields: […])`, in schema order.
+     */
+    readonly references: readonly string[];
     /** What deleting a `target` row does to rows of the ENCLOSING resource. */
     readonly onDelete: PrismaReferentialAction;
     /** The same for an update of the referenced key. Read independently of `onDelete`. */
     readonly onUpdate: PrismaReferentialAction;
 };
 /**
- * One Resource's owning edges, in PSL field-declaration order.
- *
- * Only **owning** edges appear — the ones that declare `@relation(fields: …)`,
- * which is what makes an edge the foreign-key side and the only side PSL lets
- * carry an action. A back-reference's actions are its partner's, so an entry for
- * it would carry two nulls and no fact; a resource with no owning edge carries an
- * empty list, which is itself the answer that deleting anything leaves its rows
- * alone.
+ * One Resource's owning edges, in schema field order: the relation fields that
+ * declare `@relation(fields: …)`. An empty list means deleting rows elsewhere
+ * leaves this Resource's rows alone.
  */
 export type PrismaResourceReferentialActions = {
+    /** The Resource's owning edges, in schema order. */
     readonly owningEdges: readonly PrismaReferentialEdge[];
 };
 /**
  * The **referential-action table**: every discovered Resource's owning edges,
  * resolved.
- *
- * Keyed on `M`'s own resource keys for the reason {@link PrismaTranslationTable}
- * is — a resource the model carries and the table forgets is a compile error at
- * the generate step rather than a runtime `undefined` — and it sits **beside**
- * {@link PrismaDiscoveryArtifact.model} and outside `modelHash` for the reason
- * that one does: `modelHash` digests the model, and a referential action is not
- * part of the model. Putting it inside would push referential-action vocabulary
- * into the compiled Contract and the ClientContract, where core has no word for
- * it, and would move the Contract identity of every schema that has a relation.
  */
 export type PrismaReferentialActionTable<M extends PrismaAdapterModel = PrismaAdapterModel> = {
     readonly [R in keyof M["resources"]]: PrismaResourceReferentialActions;
@@ -154,26 +70,15 @@ export type PrismaReferentialActionTable<M extends PrismaAdapterModel = PrismaAd
  * What the generated Prisma client exposed when the artifact was generated: each
  * model it has a delegate for, keyed by the model's name, and that model's field
  * references (`prisma.<model>.fields`) in code-unit order.
- *
- * It is the artifact's record of the client it was read from, and the runtime
- * reads the same two facts off the client it is handed — the delegates the client
- * carries, and each one's public `fields`. When they disagree, the schema changed
- * and the client was regenerated without the artifact, and the adapter refuses to
- * start rather than serve a model that no longer matches. Prisma excludes
- * `Unsupported(…)` and `@ignore`d fields and `@@ignore`d models from both the
- * generated types and the runtime client, so the two readings agree by
- * construction on an unchanged schema.
- *
- * Beside the model and outside `modelHash`, like the translation table: it
- * describes the provider client, not the semantic model.
  */
 export type PrismaClientShape = Readonly<Record<string, readonly string[]>>;
 /**
  * What a create of each Resource cannot do without, already in core's words
  * (`Adapter["createRequirements"]`): a column the client must write, or a
- * required relation that may instead be written through the scalar fields that
- * hold its reference — and the relation's other end, through which a nested
- * create supplies it.
+ * required relation — which may instead be written through the scalar fields
+ * that hold its reference, read off the relation's referential edge
+ * (`references`), never restated here — and the relation's other end, through
+ * which a nested create supplies it.
  *
  * Read at generate time from the generated client's create inputs — the
  * question marks on `<M>UncheckedCreateInput` and `<M>CreateInput` — and from the
@@ -182,54 +87,40 @@ export type PrismaClientShape = Readonly<Record<string, readonly string[]>>;
  * model, and the Contract carries no foreign-key detail.
  */
 export type PrismaCreateRequirementTable = NonNullable<Adapter["createRequirements"]>;
+/** The current discovery artifact format. */
+export declare const DISCOVERY_ARTIFACT_FORMAT = 2;
 /**
- * One module written `as const satisfies AdapterModel` makes value and type the
- * same literal, and makes drift unrepresentable rather than merely detectable.
- *
- * It is still passive, serializable, introspectable, hashable and free of runtime
- * callbacks: a `.ts` module whose only expression is a frozen object literal is
- * JSON that carries its own type.
- *
- * `M` is the reason this type is generic at all. The emitted module's `model` is a
- * literal type; if this alias pinned `model` to the general {@link
- * PrismaAdapterModel}, every resource key and field key would be erased to
- * `string` on the way to `createPrismaAdapter`, `EffectiveFieldKey` would
- * degenerate, and core's whole config-typing workstream would buy nothing —
- * silently, with no compile error anywhere. `model: M` is a bare property
- * position, which is what makes `M` actually infer at the call site;
- * `typed-artifact.test-d.ts` is what proves it still does.
- *
- * The default keeps the unparameterised spelling meaning what it always meant:
- * "some Prisma adapter model".
+ * The discovery artifact: the module `aventara-prisma7-generate` writes from
+ * your schema and generated client. Import its `discovery` export and pass it
+ * to `createPrismaAdapter({ discovery })`.
  */
 export type PrismaDiscoveryArtifact<M extends PrismaAdapterModel = PrismaAdapterModel> = {
-    /** e.g. `"7.10.0"`; only the major is fenced. */
+    /**
+     * The artifact's format. A TypeScript error naming this property means the
+     * artifact was written by another version of `@aventara/prisma7-adapter`:
+     * regenerate it with `npm run aventara:prepare` (or `aventara-prisma7-generate`).
+     */
+    readonly regenerate_with_aventara_prepare: typeof DISCOVERY_ARTIFACT_FORMAT;
+    /** The Prisma version the artifact was generated with, such as `"7.10.0"`. */
     readonly prismaVersion: string;
+    /** The database provider: `"sqlite"` or `"postgresql"`. */
     readonly provider: PrismaProvider;
     /** `sha256:<hex>` of the canonicalized `model` below — and of nothing else. */
     readonly modelHash: string;
+    /** What the schema and the generated client agreed on. */
     readonly model: M;
-    /**
-     * Prisma addressing beside the model, and outside `modelHash` by
-     * construction: see {@link PrismaTranslationTable}.
-     */
+    /** Prisma addressing per Resource; not part of `modelHash`. */
     readonly translation: PrismaTranslationTable<M>;
     /**
-     * The resolved referential actions, beside the model and outside `modelHash`
-     * on the same construction: see {@link PrismaReferentialActionTable}.
-     *
-     * Direction, because getting it backwards is silent: an entry under resource
-     * `R` says **deleting a `target` row does `onDelete` to rows of `R`**.
+     * The schema's referential actions; not part of `modelHash`. An entry under
+     * resource `R` says **deleting a `target` row does `onDelete` to rows of `R`**.
      */
     readonly referentialActions: PrismaReferentialActionTable<M>;
     /**
-     * The client this artifact was generated against, beside the model and
-     * outside `modelHash`: see {@link PrismaClientShape}.
+     * The models and field references of the client the artifact was generated
+     * against; not part of `modelHash`.
      */
     readonly client: PrismaClientShape;
-    /**
-     * The create requirements, beside the model and outside `modelHash`: see
-     * {@link PrismaCreateRequirementTable}.
-     */
+    /** What a create of each Resource cannot do without; not part of `modelHash`. */
     readonly createRequirements: PrismaCreateRequirementTable;
 };

package/dist/discovery/discovery-artifact.interface.js

@@ -1 +1 @@
-export {};
+export const DISCOVERY_ARTIFACT_FORMAT = 2;

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

@@ -1,29 +1,9 @@
 import type { EnumDefinition } from "@aventara/core";
 import type { PrismaSchemaEnum } from "./schema-facts.interface.js";
 import type { PrismaDiscoveryDiagnostic } from "./vocabulary.dictionary.js";
-/**
- * # Declaration order is semantic, so nothing here sorts
- *
- * # What a cross-check failure means
- *
- * `enums.ts` and `schema.prisma` were read in the same instant by the same
- * generate step. If they disagree, one of them is stale, and the answer is
- * `diverged` — a build stop — rather than a preference for either. The message
- * prints both orders because "the enum diverged" without them costs the reader a
- * second investigation.
- *
- * # A member-level `@map` never reaches here, from either side
- *
- * PSL's reader discards it as bucket 2 (a database name, which Aventara has no
- * word for), and the generated `enums.ts` writes the member name on *both* sides
- * of a mapped member — `GAMMA: 'GAMMA'`, not `GAMMA: 'g'` **[RUN8 — 2026-09-28,
- * prisma 7.10.0]**. So the cross-check compares Aventara identities on both sides,
- * and the mapper has nothing to resurrect.
- */
 export type EnumMappingInput = {
     /** PSL — the source of the values and their order. */
     readonly declared: PrismaSchemaEnum;
-    /** TYPE — `enums.ts`'s member list, or `undefined` when the 🟢 types omit the enum entirely. */
     readonly exposed: readonly string[] | undefined;
 };
 export type EnumMappingOutcome = {
@@ -37,10 +17,6 @@ export type EnumMappingOutcome = {
     readonly outcome: "diverged";
     readonly diagnostic: PrismaDiscoveryDiagnostic;
 };
-/**
- * The `kind` is a literal `"scalar"`, so a third structural kind cannot be
- * introduced here without the type changing.
- */
 export type EnumBackedColumn = {
     readonly kind: "scalar";
     readonly type: {

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

@@ -1,95 +1,17 @@
-import { type AdapterLifecycleTrait, type AdapterRelationField, type AdapterScalarField } from "@aventara/core";
+import { type AdapterLifecycleTrait, type AdapterRelationField, type AdapterScalarField } from "@aventara/core/internal";
 import type { PrismaResourceSurface } from "./capability-surface.interface.js";
 import type { PrismaAdapterModel, PrismaReferentialAction } from "./discovery-artifact.interface.js";
 import type { PrismaSchemaField, PrismaSchemaUnknown } from "./schema-facts.interface.js";
 import { type PrismaDiscoveryDiagnostic, type PrismaEvidence } from "./vocabulary.dictionary.js";
-/**
- * # Nullability comes from PSL, and the required `Json` column is why
- *
- * `nullable` is `PrismaSchemaField.optional` — PSL's `?` — and **nothing else**.
- * The type surface cannot answer the question, and the damage is not hypothetical:
- * `$MetricPayload.scalars.sJson` resolves to `null | string | number | false |
- * true | JsonObject | JsonArray` while PSL says `sJson Json`, required, because
- * JSON null is a *value*. The reader's own facts point the same wrong way —
- * `JsonFilterBase.array_contains` admits `| null` and `equals` admits
- * `JsonNullValueFilter` on that same required column — so a plausible "the
- * operands mention null, therefore the column is nullable" rule is wrong for
- * **every** `Json` field while being right everywhere else. That is the whole
- * reason this rule is stated as a rule rather than left to taste.
- *
- * # The create-optional marker is a cross-check, never a source
- *
- * {@link crossCheckCreateOptional} is a separate function that *consumes* this
- * projection, and the data flows one way only: the marker never reaches {@link
- * projectPrismaField}. `<M>UncheckedCreateInput`'s `?` is **one bit over several
- * causes** — `@default(uuid())`, `@default(BRONZE)`, `@default(now())`,
- * `@updatedAt`, plain nullability, and a scalar list, which needs no value because
- * the empty list is one — and nothing on the 🟢 surface tells them apart. Deriving
- * a trait *from* the marker would invert the check into the bug it exists to
- * catch: it would make the two readers agree by construction and detect nothing.
- *
- * # `@default` is matched, never parsed
- *
- * {@link matchPrismaDefault} walks `PRISMA_DEFAULT_TABLE` over the raw argument
- * text the PSL reader carried across unchanged.
- *
- * The matcher adds **one** discriminant the dictionary's table does not state, and
- * it is a shape test rather than a parse: an argument that begins with an
- * identifier followed by `(` is a *generator form*, and anything else is a *static
- * value*. Both are `DEFAULTED`; only an unrecognised generator form records an
- * unknown. The test never reads *inside* the argument, so
- * `dbgenerated("gen_random_uuid()")` remains a key and `"a, b // not a comment"`
- * remains opaque text.
- *
- * # A relation carries four members, and the FK is not one of them
- *
- * `target`, `cardinality`, `nullable`, and `capabilities`. The `@relation(fields:
- * […], references: […])` scalars are read, used to identify the FK column and
- * check it against the edge's own optionality, and then **discarded**.
- * `@relation`'s *name* is not an Aventara concept either, and its referential
- * actions are not core's yet, so both travel beside the projection as {@link
- * PrismaRelationEdge} rather than inside it: pairing is discovery-internal, and it
- * is **PSL-only** — the name appears nowhere on the 🟢 surface, so from the types
- * alone `Author` has two `Author` edges with nothing to pair them.
- *
- * # Two failure vocabularies, kept apart
- *
- * A **diagnostic** is about the schema: PSL declares a column the 🟢 types do not
- * expose, or a Prisma type name in no table. A **throw** is about the readers: the
- * two sources disagree about a fact they both state, which no schema can cause and
- * no diagnostic vocabulary describes. The types reader draws the same line.
- */
 /** A reader-versus-reader disagreement: not a schema problem, and not recoverable. */
 export declare class PrismaFieldProjectionError extends Error {
     readonly name = "PrismaFieldProjectionError";
 }
-/**
- * `Omit` rather than a restatement, so the composed field is the core type by
- * construction.
- */
 export type ProjectedScalarField = Omit<AdapterScalarField<PrismaAdapterModel>, "capabilities">;
 export type ProjectedRelationField = Omit<AdapterRelationField<PrismaAdapterModel>, "capabilities">;
 /**
  * One relation edge as PSL states it — the pairing evidence and the referential
  * actions, neither of which the projected field carries.
- *
- * # Why the actions ride here and not on `AdapterRelationField`
- *
- * Wiring a referential action into the Contract is a core change and belongs to
- * the task that owns core's transaction planner, not to discovery. Until then the
- * fact lives where discovery can state it truthfully.
- *
- * # The lookup is inverted, and the edge is shaped so a consumer need not invert
- *
- * `onDelete` is declared on the CHILD — `Kid.parent @relation(…, onDelete:
- * Cascade)` — and fires when the PARENT is deleted. So an edge reads: **deleting a
- * `target` does `onDelete` to rows of `resource`.** A consumer asking "what does
- * deleting `X` remove?" filters `target === X && onDelete === "cascade"` and reads
- * off `resource`; it does not have to re-derive which side of a pair declared
- * what.
- *
- * `null` on both members means this edge is not the owning side (it declares no
- * `fields:`), so the actions are on its partner — never that no action applies.
  */
 export type PrismaRelationEdge = {
     /** The model DECLARING the edge — the child, where an owning edge is concerned. */
@@ -100,11 +22,6 @@ export type PrismaRelationEdge = {
     readonly cardinality: "one" | "many";
     /** `@relation("Name")`, or `null` where PSL wrote none. PSL-only. */
     readonly relationName: string | null;
-    /**
-     * What deleting a `target` row does to this `resource` row, resolved (an
-     * absent PSL argument already carries Prisma's measured default). `null` on a
-     * non-owning edge.
-     */
     readonly onDelete: PrismaReferentialAction | null;
     /** The same for an update of the referenced key. `null` on a non-owning edge. */
     readonly onUpdate: PrismaReferentialAction | null;
@@ -115,7 +32,7 @@ export type FieldProjectionInput = {
     readonly field: PrismaSchemaField;
     /** The model's other fields: the only way to identify an FK scalar by name. */
     readonly siblings: readonly 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[]>>;
@@ -126,7 +43,6 @@ export type FieldProjection = {
     readonly outcome: "scalar";
     readonly name: string;
     readonly field: ProjectedScalarField;
-    /** Recorded unknowns; a non-empty list FAILS the generate step. */
     readonly unknowns: readonly PrismaSchemaUnknown[];
 } | {
     readonly outcome: "relation";
@@ -158,10 +74,6 @@ export type PrismaDefaultOutcome =
     readonly form: "unrecognised-generator";
     readonly traits: readonly AdapterLifecycleTrait[];
 };
-/**
- * The argument arrives as opaque text precisely so that this function can be a
- * lookup.
- */
 export declare function matchPrismaDefault(argument: string): PrismaDefaultOutcome;
 /** Why a field is legitimately optional in `<M>UncheckedCreateInput`. */
 export type CreateOptionalCause = AdapterLifecycleTrait | "nullable"
@@ -192,16 +104,7 @@ export type CreateOptionalCrossCheck = {
     readonly unexplained: readonly string[];
     readonly messages: readonly string[];
 };
-/**
- * TYPE's only contribution to lifecycle: a check, run in one direction.
- *
- * Every field the 🟢 `<M>UncheckedCreateInput` marks optional must carry a PSL
- * cause. A field the types mark optional with no cause means **one of the two
- * readers is wrong** — that is the entire signal, and it is why the marker is
- * never read as a trait. Names the types mark that this model does not project
- * as a scalar (relation edges) are skipped rather than reported: their
- * optionality is structural.
- */
+/** TYPE's only contribution to lifecycle: a check, run in one direction. */
 export declare function crossCheckCreateOptional(input: CreateOptionalCrossCheckInput): CreateOptionalCrossCheck;
 export type PrismaRelationPair = readonly [
     PrismaRelationEdge,
@@ -212,19 +115,5 @@ export type PrismaRelationPairing = {
     /** Edges nothing pairs: a back-reference the schema never declared, or an ambiguity. */
     readonly unpaired: readonly PrismaRelationEdge[];
 };
-/**
- * Pairs each edge with its back-reference, which **only PSL can do**.
- *
- * An explicit `@relation("Name")` is the pairing evidence, and for the two
- * `Author` → `Author` edges it is the *only* evidence: the name appears nowhere
- * on the 🟢 surface, so from the types alone there are two self-edges and
- * nothing to say they are one relation.
- *
- * Unnamed edges are paired by the unordered model pair, which is unambiguous
- * because PSL requires a name as soon as two relations connect the same two
- * models. Where an unordered pair still has more than two edges, they are left
- * unpaired rather than guessed: the implicit name Prisma would compute lives in
- * the 🛑 runtime data model, and re-deriving it here would be this module
- * reimplementing the generator.
- */
+/** Pairs each edge with its back-reference, which **only PSL can do**. */
 export declare function pairPrismaRelationEdges(edges: readonly PrismaRelationEdge[]): PrismaRelationPairing;

package/dist/discovery/field.mapper.js

@@ -1,4 +1,4 @@
-import { LIFECYCLE_TRAITS, } from "@aventara/core";
+import { LIFECYCLE_TRAITS, } from "@aventara/core/internal";
 import { projectEnumBackedColumn } from "./enum.mapper.js";
 import { mapPrismaScalarField } from "./scalar.mapper.js";
 import { PRISMA_DEFAULT_TABLE, PRISMA_UNMATCHED_DEFAULT_TRAITS, } from "./vocabulary.dictionary.js";
@@ -44,10 +44,10 @@ function assertTokenAgrees(resource, field, token) {
     const listed = token.endsWith("[]");
     const base = listed ? token.slice(0, -2) : token;
     if (base !== field.type) {
-        throw new PrismaFieldProjectionError(`${resource}.${field.name} is written \`${field.type}\` in schema.prisma and the 🟢 types carry the FieldRef token \`${token}\`. The two readers describe one instant, so this is a stale generated client or a reader defect, not a schema the adapter can translate.`);
+        throw new PrismaFieldProjectionError(`${resource}.${field.name} is written \`${field.type}\` in schema.prisma and the generated client's types carry the FieldRef token \`${token}\`. The two readers describe one instant, so this is a stale generated client or a reader defect, not a schema the adapter can translate.`);
     }
     if (listed !== field.list) {
-        throw new PrismaFieldProjectionError(`${resource}.${field.name} is ${field.list ? "a list" : "not a list"} in schema.prisma and the 🟢 types carry the FieldRef token \`${token}\`, which says the opposite.`);
+        throw new PrismaFieldProjectionError(`${resource}.${field.name} is ${field.list ? "a list" : "not a list"} in schema.prisma and the generated client's types carry the FieldRef token \`${token}\`, which says the opposite.`);
     }
 }
 const ADAPTER_TRAIT_ORDER = LIFECYCLE_TRAITS.filter((trait) => trait === "DEFAULTED" ||
@@ -138,20 +138,20 @@ function projectRelationField(input) {
             outcome: "excluded",
             diagnostic: {
                 code: "not-exposed",
-                message: `${column} is declared in schema.prisma as an edge to \`${field.type}\` and absent from the generated 🟢 types, so it is omitted: ${field.ignored ? "it carries `@ignore`" : "no schema attribute explains it — a provider drop or a preview-feature exclusion"}.`,
+                message: `${column} is declared in schema.prisma as an edge to \`${field.type}\` and absent from the generated client's types, so it is omitted: ${field.ignored ? "it carries `@ignore`" : "no schema attribute explains it — a provider drop or a preview-feature exclusion"}.`,
             },
         };
     }
     const cardinality = field.list ? "many" : "one";
     const nullable = cardinality === "many" ? false : field.optional;
     if (exposed.many !== field.list) {
-        throw new PrismaFieldProjectionError(`${column} is ${field.list ? "a list" : "a single edge"} in schema.prisma and the 🟢 payload says the opposite.`);
+        throw new PrismaFieldProjectionError(`${column} is ${field.list ? "a list" : "a single edge"} in schema.prisma and the generated client's payload type says the opposite.`);
     }
     if (exposed.nullable !== nullable) {
-        throw new PrismaFieldProjectionError(`${column} is ${nullable ? "optional" : "required"} in schema.prisma and the 🟢 payload ${exposed.nullable ? "admits" : "refuses"} \`null\`.`);
+        throw new PrismaFieldProjectionError(`${column} is ${nullable ? "optional" : "required"} in schema.prisma and the generated client's payload type ${exposed.nullable ? "admits" : "refuses"} \`null\`.`);
     }
     if (exposed.target !== field.type) {
-        throw new PrismaFieldProjectionError(`${column} targets \`${field.type}\` in schema.prisma and \`${exposed.target}\` on the 🟢 payload.`);
+        throw new PrismaFieldProjectionError(`${column} targets \`${field.type}\` in schema.prisma and \`${exposed.target}\` in the generated client's payload type.`);
     }
     assertForeignKeyAgrees(column, field, siblings, nullable);
     return {