@aventara/prisma7-adapter 0.1.0-pilot.0

package/dist/discovery/vocabulary.dictionary.d.ts

@@ -0,0 +1,258 @@
+import type { AdapterLifecycleTrait, BuiltInScalar, PaginationCapability, RelationFilterCapability, RelationMutationDirective, ScalarFilterOperator, ScalarFormat, ScalarMutationDirective } from "@aventara/core";
+/**
+ * T-3.1 — the vocabulary dictionary: where PSL, the 🟢 generated types and the
+ * observed runtime meet Aventara's own words.
+ *
+ * # It is data, not conditionals
+ *
+ * Every table below is a value a reader can hold beside T-3.1's table and check
+ * row by row. Nothing here branches on a provider, a field name or a schema: a
+ * module that learns a fact by asking `if (provider === "sqlite")` is tabulating
+ * what the sources already state, which is the cover-up C-854 forbids
+ * (T-3.1 invariant 6).
+ *
+ * # Every entry names its source class (invariant 1)
+ *
+ * `VOCABULARY` carries one row per Aventara fact with its source code — `PSL`,
+ * `TYPE`, `RUN`, `DRIVER` or `CFG`. `VocabularyEntry.sources` is a **non-empty**
+ * tuple, so "an entry with no source" is a compile error rather than a silent
+ * default.
+ *
+ * # `@default` is matched, never parsed (invariant 5)
+ *
+ * `PRISMA_DEFAULT_TABLE` is looked up with the raw text the PSL reader carried
+ * across unchanged. `dbgenerated("gen_random_uuid()")` is a **key**, not an
+ * expression: the day this module evaluates one, the reader behind it has become
+ * a parser and needs a different decision (T-3). An unmatched form falls back to
+ * `PRISMA_UNMATCHED_DEFAULT_TRAITS` **plus** a recorded unknown that fails the
+ * generate step — never an inferred trait.
+ *
+ * `@db.*` is matched the same way, by its **exact written spelling**
+ * (`PRISMA_NATIVE_FORMATS`). `@db.Decimal(10, 2)` matches no key and therefore
+ * proves no format, which is the right answer arrived at without splitting an
+ * argument list.
+ *
+ * # This dictionary proposes no `CONTEXT.md` term
+ *
+ * It is adapter-internal data, not framework vocabulary. Its job is the opposite:
+ * no Prisma term reaches `AdapterModel` (invariant 2) — `AtLeast`,
+ * `WhereUniqueInput`, `FieldRef`, `@@map`, `take`/`skip` all die here.
+ */
+/**
+ * `PSL` — `schema.prisma` · `TYPE` — the 🟢 generated types ·
+ * `RUN` — observed runtime behaviour · `DRIVER` — the configured Prisma driver
+ * adapter · `CFG` — framework configuration, which is policy and not discovery.
+ */
+export type VocabularySource = "PSL" | "TYPE" | "RUN" | "DRIVER" | "CFG";
+export type VocabularyEntry = {
+    /** The Aventara fact, spelled as T-3.1's left column spells it. */
+    readonly fact: string;
+    /** Non-empty by construction: invariant 1 is enforced by the type, not by a comment. */
+    readonly sources: readonly [VocabularySource, ...VocabularySource[]];
+    readonly rule: string;
+};
+/**
+ * T-3.1's table, row for row, so a reader can audit one against the other.
+ *
+ * **`format?` diverges from T-3.1's table deliberately, and the plan row is the
+ * one that is wrong.** T-3.1 says `format?` is `CFG` — "PSL's `@db.*` is a hint
+ * only … policy, not discovery". Spec §6.1 says the opposite in as many words:
+ * UUID "is a string scalar plus passive format metadata **when the adapter can
+ * prove the format**", §18.3's discovery mapping reads "scalar type → stable
+ * framework scalar + optional format", C-809 restates both, T-5 restates them
+ * again, and `AdapterScalarField.format?` exists **[CORE]** — a member with no
+ * producer if discovery never emits one. So the source is `PSL` **and** `CFG`:
+ * discovery emits what the provider's own column type proves, configuration owns
+ * everything else. `scalar.mapper.ts`'s header carries the full argument.
+ */
+export declare const VOCABULARY: readonly VocabularyEntry[];
+/**
+ * The closed set of ways a mapper refuses. It is dictionary data because a
+ * refusal is the dictionary's own answer: a construct it has no word for.
+ */
+export type PrismaDiscoveryDiagnosticCode = 
+/** A Prisma type name in neither PRISMA_SCALAR_TABLE nor `enums.ts` (C-809). */
+"unmapped-prisma-type"
+/** PSL declares it, the 🟢 types do not expose it: omitted, with the reason said out loud (C-808). */
+ | "not-exposed"
+/** PSL and `enums.ts` disagree about an enum's members or their order (§19.2). */
+ | "enum-diverged";
+export type PrismaDiscoveryDiagnostic = {
+    readonly code: PrismaDiscoveryDiagnosticCode;
+    /** Written for the engineer who has to fix the schema, naming the entity it is about. */
+    readonly message: string;
+};
+/** T-5 — a proven scalar identity, plus a format only where something proves it. */
+export type PrismaScalarMapping = {
+    readonly scalar: BuiltInScalar;
+    readonly format?: ScalarFormat;
+};
+export type PrismaScalarTable = Readonly<Record<string, PrismaScalarMapping>>;
+/**
+ * Total and 1:1 over `BUILT_IN_SCALARS` **[CORE]**. There is no default arm: a
+ * Prisma type name absent from this table is a diagnostic, not a guess (C-809).
+ *
+ * **No row carries a `format`**, and that is the point: a format is a property of
+ * a *column*, not of a Prisma *type name*. `String` alone proves nothing, so the
+ * one thing that can prove something — the native column type — is a separate
+ * lookup (`PRISMA_NATIVE_FORMATS`).
+ */
+export declare const PRISMA_SCALAR_TABLE: PrismaScalarTable;
+/**
+ * The only `@db.*` spellings that **prove** a format, matched by exact written
+ * spelling and never parsed.
+ *
+ * The bar for a row here is not "the name suggests a format". It is: **the column
+ * type itself rejects the values `format` would later reject.** `format` is
+ * enforced, not decorative — `normalizeScalarFieldValue` turns `format: "uuid"`
+ * into a `V1003` rejection of request input **[CORE,
+ * `runtime/scalar-runtime.ts`]** — so a row that is merely probable would have
+ * Aventara refuse writes the database accepts.
+ *
+ * `@db.Uuid` clears that bar: PostgreSQL's `uuid` column rejects
+ * `'not-a-uuid'` (`ERROR: invalid input syntax for type uuid`) where a `text`
+ * column takes it **[RUN8 — 2026-09-28, `aventara-postgres`, postgres:18]**.
+ *
+ * `@default(uuid())` does **not** clear it, which is where T-5's wording is
+ * narrowed: on a `String` column with no `@db.Uuid` the column is `text`, only
+ * *generated* values are UUIDs, and a client may legally supply any string. That
+ * intent belongs in `FrameworkScalarFieldConfig.format` **[CORE]**, which the
+ * Contract compiler already applies over the adapter's value.
+ *
+ * `@db.Decimal(10, 2)` and `@db.VarChar(255)` are absent because they prove no
+ * *format*; they carry precision and width, which Aventara has no word for.
+ */
+export declare const PRISMA_NATIVE_FORMATS: Readonly<Record<string, ScalarFormat>>;
+/** Whether a row was exercised against 7.10.0 or is carried forward unproven (§12). */
+export type PrismaEvidence = "RUN8" | "UNVERIFIED";
+export type PrismaDefaultRow = {
+    /**
+     * Matched against `PrismaSchemaField.defaultArgument` exactly as the PSL
+     * reader carried it. A `literal` is compared with `===`; a `pattern` is
+     * tested. Neither reads *inside* the argument.
+     */
+    readonly match: {
+        readonly literal: string;
+    } | {
+        readonly pattern: RegExp;
+    };
+    readonly traits: readonly AdapterLifecycleTrait[];
+    readonly evidence: PrismaEvidence;
+};
+/**
+ * T-3.1's `@default` table.
+ *
+ * **`traits` is the whole trait set, where T-3.1's table lists only the trait the
+ * *argument* adds.** The two are consistent, not contradictory: `DEFAULTED` comes
+ * from `@default`'s **presence** (C-808: "`@default` → `DEFAULTED` and, when
+ * generator-owned, `GENERATED_ON_CREATE`"), and C-811's acceptance criteria spell
+ * the full sets out — `@default(autoincrement())` → `["DEFAULTED",
+ * "GENERATED_ON_CREATE"]`, `@default("x")` → `["DEFAULTED"]`. This table states
+ * the answer rather than half of it, so no consumer has to remember to add the
+ * other half.
+ *
+ * The lookup that walks this table lives with the lifecycle projection (Task 4),
+ * where it can be driven red; this pass owns the data only.
+ */
+export declare const PRISMA_DEFAULT_TABLE: readonly PrismaDefaultRow[];
+/**
+ * Any other text — `"BRONZE"`, `"x"`, `sequence()`, `nanoid()`, a spelling added
+ * after 7.10.0. The value is still `DEFAULTED`, because `@default` is present;
+ * the *unknown* is what fails the generate step, so an unrecognised generator
+ * function is a build stop rather than a column Aventara quietly thinks the
+ * client must supply.
+ */
+export declare const PRISMA_UNMATCHED_DEFAULT_TRAITS: readonly AdapterLifecycleTrait[];
+/**
+ * The dictionary's other half: the point at which Prisma's spelling stops and
+ * Aventara's begins.
+ *
+ * **One untyped `PRISMA_RENAMES` became six typed tables (2026-10-02, T-6).** The
+ * single `Record<string, string>` could not make a mistake a compile error: a
+ * rename to a word core does not have, or a Prisma key nobody decided about,
+ * both typechecked. Each table below is keyed on the Prisma spelling and valued in
+ * the ONE Aventara vocabulary that spelling can land in, so `"arrayContains"`
+ * misspelt fails to compile. The table had no consumer, so nothing was broken by
+ * splitting it.
+ *
+ * `null` is a value, not an omission: it means **recognised, and Aventara has no
+ * word for it** — the nested bulk writes, `distinct`, Prisma's `set` assignment.
+ * A key absent from a table is a different thing entirely, and the deriver that
+ * reads these refuses rather than dropping it silently, because a silently dropped
+ * capability key is how C-855's failure mode begins.
+ *
+ * C-837's relation *translator* table — which Prisma argument each directive emits
+ * — is still Task 9's. This is the vocabulary half only.
+ */
+/**
+ * `<Kind>Filter` / `<Kind>NullableFilter` / `Json[Nullable]Filter` keys.
+ *
+ * Total and 1:1 over `ScalarFilterOperator` **[CORE]** at 7.10.0, measured over
+ * both generated clients: 23 Prisma keys, 23 Aventara operators, no survivor on
+ * either side.
+ */
+export declare const PRISMA_FILTER_OPERATORS: Readonly<Record<string, ScalarFilterOperator>>;
+/**
+ * `[Nullable]ScalarRelationFilter` and `ListRelationFilter` keys.
+ *
+ * `is` and `isNot` both answer `match`: §18.5 has one to-one matching capability
+ * and no `is`/`isNot` wrapper, so the two Prisma keys collapse into it. `nested`
+ * and `null` are **not** keys of any filter input — they are read off the edge's
+ * own `where` argument and off the edge's nullability — so they are absent here by
+ * construction rather than by omission.
+ */
+export declare const PRISMA_RELATION_FILTERS: Readonly<Record<string, RelationFilterCapability>>;
+/**
+ * `<Kind>FieldUpdateOperationsInput` and `<M><Stage><field>Input` keys.
+ *
+ * `set` is `null` because plain assignment is not a directive in Aventara: the
+ * value is written directly, and `ScalarMutationDirective` has no `$set`
+ * **[CORE]**. `unset` is carried although neither Phase 8 engine emits it — it is
+ * Mongo's, and a key the dictionary recognises and never advertises is better than
+ * one that makes the deriver throw the day a third provider is added.
+ */
+export declare const PRISMA_SCALAR_DIRECTIVES: Readonly<Record<string, ScalarMutationDirective | null>>;
+/**
+ * `<M>Update<edge>Without<M>NestedInput` / `<M>Create<edge>…NestedInput` keys.
+ *
+ * `createMany`, `updateMany` and `deleteMany` are `null`: they are nested BULK
+ * writes, and `RelationMutationDirective` models per-row intent only **[CORE]**.
+ * Aventara expresses the same effect by addressing the target Resource, so
+ * advertising them would promise an argument no directive could carry.
+ */
+export declare const PRISMA_RELATION_DIRECTIVES: Readonly<Record<string, RelationMutationDirective | null>>;
+/**
+ * `<M>$<edge>Args` keys, valued in `PaginationCapability`.
+ *
+ * `null` means the argument is read for something else, or for nothing:
+ * `orderBy` answers `order`, `where` answers the `nested` filter capability,
+ * `select`/`omit`/`include` answer projection, and `distinct` is a Prisma concept
+ * Aventara has no word for. The table is total over the keys both clients write,
+ * so a new edge argument at 7.11 is an unrecognised key rather than a silent drop.
+ */
+export declare const PRISMA_EDGE_ARGUMENTS: Readonly<Record<string, PaginationCapability | null>>;
+/** `_count` on `<M>Include` / `<M>CountOutputType`. */
+export declare const PRISMA_REDUCERS: Readonly<Record<string, "$count">>;
+export type ObservedValueShape = {
+    /** The Prisma type name, as PSL writes it. */
+    readonly prismaType: string;
+    /** The JavaScript value the client hands back, stated exactly. */
+    readonly shape: string;
+    /** The driver adapters it was observed through — inlined, never generalised. */
+    readonly engines: readonly string[];
+    readonly evidence: PrismaEvidence;
+};
+/**
+ * Task 1's observations, inlined with the engines they were made on
+ * **[RUN8, `src/environment.spec.ts`]**. Identical through both driver adapters,
+ * so the representation is not driver-dependent *between these two engines* —
+ * which is a narrower claim than "not driver-dependent", and the narrower one is
+ * what was measured.
+ *
+ * A row is `RUN8` only where a read-back value was actually asserted. `String`,
+ * `Boolean`, `Int` and `Float` were written into a row and never read back under
+ * assertion, so they stay `[UNVERIFIED]` (§12): a plausible value shape is not an
+ * observed one, and this table exists precisely so that nobody has to guess which
+ * is which.
+ */
+export declare const OBSERVED_VALUE_SHAPES: readonly ObservedValueShape[];

package/dist/discovery/vocabulary.dictionary.js

@@ -0,0 +1,429 @@
+/**
+ * T-3.1's table, row for row, so a reader can audit one against the other.
+ *
+ * **`format?` diverges from T-3.1's table deliberately, and the plan row is the
+ * one that is wrong.** T-3.1 says `format?` is `CFG` — "PSL's `@db.*` is a hint
+ * only … policy, not discovery". Spec §6.1 says the opposite in as many words:
+ * UUID "is a string scalar plus passive format metadata **when the adapter can
+ * prove the format**", §18.3's discovery mapping reads "scalar type → stable
+ * framework scalar + optional format", C-809 restates both, T-5 restates them
+ * again, and `AdapterScalarField.format?` exists **[CORE]** — a member with no
+ * producer if discovery never emits one. So the source is `PSL` **and** `CFG`:
+ * discovery emits what the provider's own column type proves, configuration owns
+ * everything else. `scalar.mapper.ts`'s header carries the full argument.
+ */
+export const VOCABULARY = [
+    {
+        fact: 'kind: "scalar" / "relation"',
+        sources: ["PSL", "TYPE"],
+        rule: "PSL decides by whether the written type name is a model name; TYPE gates existence.",
+    },
+    {
+        fact: "nullable",
+        sources: ["PSL"],
+        rule: "Never TYPE (invariant 4): `JsonValue` contains `null` because JSON null is a value, so a types-derived nullable is wrong for every Json field.",
+    },
+    {
+        fact: "list",
+        sources: ["PSL", "TYPE"],
+        rule: "PSL states it; TYPE states whether this provider exposes it. A list in PSL that the types drop is a generate-time error.",
+    },
+    {
+        fact: "type.scalar / type.enum",
+        sources: ["PSL", "TYPE"],
+        rule: "PRISMA_SCALAR_TABLE is total and 1:1 over the nine built-ins; an enum name is confirmed against `enums.ts`.",
+    },
+    {
+        fact: "format?",
+        sources: ["PSL", "CFG"],
+        rule: "PSL supplies it only through PRISMA_NATIVE_FORMATS — a native column type that itself rejects the values `format` would later reject. Every other format is CFG. See this constant's doc comment.",
+    },
+    {
+        fact: "relation target / cardinality / nullable",
+        sources: ["PSL", "TYPE"],
+        rule: "—",
+    },
+    {
+        fact: "relation pairing",
+        sources: ["PSL"],
+        rule: '`@relation("Mentorship")` on both sides is the only pairing evidence; the name appears nowhere on the 🟢 surface.',
+    },
+    {
+        fact: "lifecycle traits",
+        sources: ["PSL"],
+        rule: "PRISMA_DEFAULT_TABLE plus `@updatedAt`; TYPE is a cross-check only, because the create-optional marker is one bit over four causes.",
+    },
+    {
+        fact: "identifiers",
+        sources: ["PSL"],
+        rule: "`@id`/`@@id`/`@unique`/`@@unique`, member order as written; cross-checked against TYPE's key set as a subset with one closed explanation.",
+    },
+    {
+        fact: "enum values",
+        sources: ["PSL"],
+        rule: "Declaration order is semantic (§19.2) and is never sorted; cross-checked against `enums.ts`.",
+    },
+    {
+        fact: "field & operation capabilities",
+        sources: ["TYPE"],
+        rule: "Per-kind filter sets, mutation directives, edge pagination, `_count`, and `<M>Delegate`'s own method set — read, never tabulated.",
+    },
+    {
+        fact: "JS value shapes",
+        sources: ["RUN"],
+        rule: "OBSERVED_VALUE_SHAPES; anything not observed stays [UNVERIFIED] and is never promoted.",
+    },
+    {
+        fact: "transactions",
+        sources: ["DRIVER"],
+        rule: "F-801 — the configured driver adapter, not the provider name.",
+    },
+    {
+        fact: "COMPUTED_* / VIRTUAL",
+        sources: ["CFG"],
+        rule: "Outside `AdapterLifecycleTrait` by construction [CORE]; the adapter cannot emit them.",
+    },
+];
+/**
+ * Total and 1:1 over `BUILT_IN_SCALARS` **[CORE]**. There is no default arm: a
+ * Prisma type name absent from this table is a diagnostic, not a guess (C-809).
+ *
+ * **No row carries a `format`**, and that is the point: a format is a property of
+ * a *column*, not of a Prisma *type name*. `String` alone proves nothing, so the
+ * one thing that can prove something — the native column type — is a separate
+ * lookup (`PRISMA_NATIVE_FORMATS`).
+ */
+export const PRISMA_SCALAR_TABLE = {
+    String: { scalar: "string" },
+    Boolean: { scalar: "boolean" },
+    Int: { scalar: "int" },
+    Float: { scalar: "float" },
+    BigInt: { scalar: "bigint" },
+    Decimal: { scalar: "decimal" },
+    DateTime: { scalar: "datetime" },
+    Bytes: { scalar: "bytes" },
+    Json: { scalar: "json" },
+};
+/**
+ * The only `@db.*` spellings that **prove** a format, matched by exact written
+ * spelling and never parsed.
+ *
+ * The bar for a row here is not "the name suggests a format". It is: **the column
+ * type itself rejects the values `format` would later reject.** `format` is
+ * enforced, not decorative — `normalizeScalarFieldValue` turns `format: "uuid"`
+ * into a `V1003` rejection of request input **[CORE,
+ * `runtime/scalar-runtime.ts`]** — so a row that is merely probable would have
+ * Aventara refuse writes the database accepts.
+ *
+ * `@db.Uuid` clears that bar: PostgreSQL's `uuid` column rejects
+ * `'not-a-uuid'` (`ERROR: invalid input syntax for type uuid`) where a `text`
+ * column takes it **[RUN8 — 2026-09-28, `aventara-postgres`, postgres:18]**.
+ *
+ * `@default(uuid())` does **not** clear it, which is where T-5's wording is
+ * narrowed: on a `String` column with no `@db.Uuid` the column is `text`, only
+ * *generated* values are UUIDs, and a client may legally supply any string. That
+ * intent belongs in `FrameworkScalarFieldConfig.format` **[CORE]**, which the
+ * Contract compiler already applies over the adapter's value.
+ *
+ * `@db.Decimal(10, 2)` and `@db.VarChar(255)` are absent because they prove no
+ * *format*; they carry precision and width, which Aventara has no word for.
+ */
+export const PRISMA_NATIVE_FORMATS = {
+    "@db.Uuid": "uuid",
+};
+/**
+ * T-3.1's `@default` table.
+ *
+ * **`traits` is the whole trait set, where T-3.1's table lists only the trait the
+ * *argument* adds.** The two are consistent, not contradictory: `DEFAULTED` comes
+ * from `@default`'s **presence** (C-808: "`@default` → `DEFAULTED` and, when
+ * generator-owned, `GENERATED_ON_CREATE`"), and C-811's acceptance criteria spell
+ * the full sets out — `@default(autoincrement())` → `["DEFAULTED",
+ * "GENERATED_ON_CREATE"]`, `@default("x")` → `["DEFAULTED"]`. This table states
+ * the answer rather than half of it, so no consumer has to remember to add the
+ * other half.
+ *
+ * The lookup that walks this table lives with the lifecycle projection (Task 4),
+ * where it can be driven red; this pass owns the data only.
+ */
+export const PRISMA_DEFAULT_TABLE = [
+    {
+        match: { literal: "uuid()" },
+        traits: ["DEFAULTED", "GENERATED_ON_CREATE"],
+        evidence: "RUN8",
+    },
+    {
+        match: { literal: "uuid(4)" },
+        traits: ["DEFAULTED", "GENERATED_ON_CREATE"],
+        evidence: "UNVERIFIED",
+    },
+    {
+        match: { literal: "uuid(7)" },
+        traits: ["DEFAULTED", "GENERATED_ON_CREATE"],
+        evidence: "UNVERIFIED",
+    },
+    {
+        match: { literal: "cuid()" },
+        traits: ["DEFAULTED", "GENERATED_ON_CREATE"],
+        evidence: "RUN8",
+    },
+    {
+        match: { literal: "cuid(1)" },
+        traits: ["DEFAULTED", "GENERATED_ON_CREATE"],
+        evidence: "UNVERIFIED",
+    },
+    {
+        match: { literal: "cuid(2)" },
+        traits: ["DEFAULTED", "GENERATED_ON_CREATE"],
+        evidence: "UNVERIFIED",
+    },
+    {
+        match: { literal: "autoincrement()" },
+        traits: ["DEFAULTED", "GENERATED_ON_CREATE"],
+        evidence: "RUN8",
+    },
+    {
+        match: { literal: "now()" },
+        traits: ["DEFAULTED", "GENERATED_ON_CREATE"],
+        evidence: "RUN8",
+    },
+    {
+        match: { pattern: /^dbgenerated\(/ },
+        traits: ["DEFAULTED", "GENERATED_ON_CREATE"],
+        evidence: "RUN8",
+    },
+    {
+        // Mongo; unreachable for the SQL providers Phase 8 supports.
+        match: { pattern: /^auto\(\)$/ },
+        traits: ["DEFAULTED", "GENERATED_ON_CREATE"],
+        evidence: "UNVERIFIED",
+    },
+];
+/**
+ * Any other text — `"BRONZE"`, `"x"`, `sequence()`, `nanoid()`, a spelling added
+ * after 7.10.0. The value is still `DEFAULTED`, because `@default` is present;
+ * the *unknown* is what fails the generate step, so an unrecognised generator
+ * function is a build stop rather than a column Aventara quietly thinks the
+ * client must supply.
+ */
+export const PRISMA_UNMATCHED_DEFAULT_TRAITS = ["DEFAULTED"];
+/* ------------------------------------------------------------------ *
+ * Prisma → Aventara renames (invariant 2)                            *
+ * ------------------------------------------------------------------ */
+/**
+ * The dictionary's other half: the point at which Prisma's spelling stops and
+ * Aventara's begins.
+ *
+ * **One untyped `PRISMA_RENAMES` became six typed tables (2026-10-02, T-6).** The
+ * single `Record<string, string>` could not make a mistake a compile error: a
+ * rename to a word core does not have, or a Prisma key nobody decided about,
+ * both typechecked. Each table below is keyed on the Prisma spelling and valued in
+ * the ONE Aventara vocabulary that spelling can land in, so `"arrayContains"`
+ * misspelt fails to compile. The table had no consumer, so nothing was broken by
+ * splitting it.
+ *
+ * `null` is a value, not an omission: it means **recognised, and Aventara has no
+ * word for it** — the nested bulk writes, `distinct`, Prisma's `set` assignment.
+ * A key absent from a table is a different thing entirely, and the deriver that
+ * reads these refuses rather than dropping it silently, because a silently dropped
+ * capability key is how C-855's failure mode begins.
+ *
+ * C-837's relation *translator* table — which Prisma argument each directive emits
+ * — is still Task 9's. This is the vocabulary half only.
+ */
+/**
+ * `<Kind>Filter` / `<Kind>NullableFilter` / `Json[Nullable]Filter` keys.
+ *
+ * Total and 1:1 over `ScalarFilterOperator` **[CORE]** at 7.10.0, measured over
+ * both generated clients: 23 Prisma keys, 23 Aventara operators, no survivor on
+ * either side.
+ */
+export const PRISMA_FILTER_OPERATORS = {
+    equals: "equals",
+    not: "not",
+    in: "in",
+    notIn: "notIn",
+    lt: "lt",
+    lte: "lte",
+    gt: "gt",
+    gte: "gte",
+    contains: "contains",
+    startsWith: "startsWith",
+    endsWith: "endsWith",
+    mode: "mode",
+    has: "has",
+    hasEvery: "hasEvery",
+    hasSome: "hasSome",
+    isEmpty: "isEmpty",
+    path: "path",
+    string_contains: "stringContains",
+    string_starts_with: "stringStartsWith",
+    string_ends_with: "stringEndsWith",
+    array_contains: "arrayContains",
+    array_starts_with: "arrayStartsWith",
+    array_ends_with: "arrayEndsWith",
+};
+/**
+ * `[Nullable]ScalarRelationFilter` and `ListRelationFilter` keys.
+ *
+ * `is` and `isNot` both answer `match`: §18.5 has one to-one matching capability
+ * and no `is`/`isNot` wrapper, so the two Prisma keys collapse into it. `nested`
+ * and `null` are **not** keys of any filter input — they are read off the edge's
+ * own `where` argument and off the edge's nullability — so they are absent here by
+ * construction rather than by omission.
+ */
+export const PRISMA_RELATION_FILTERS = {
+    is: "match",
+    isNot: "match",
+    some: "some",
+    every: "every",
+    none: "none",
+};
+/**
+ * `<Kind>FieldUpdateOperationsInput` and `<M><Stage><field>Input` keys.
+ *
+ * `set` is `null` because plain assignment is not a directive in Aventara: the
+ * value is written directly, and `ScalarMutationDirective` has no `$set`
+ * **[CORE]**. `unset` is carried although neither Phase 8 engine emits it — it is
+ * Mongo's, and a key the dictionary recognises and never advertises is better than
+ * one that makes the deriver throw the day a third provider is added.
+ */
+export const PRISMA_SCALAR_DIRECTIVES = {
+    set: null,
+    increment: "$increment",
+    decrement: "$decrement",
+    multiply: "$multiply",
+    divide: "$divide",
+    push: "$push",
+    unset: "$unset",
+};
+/**
+ * `<M>Update<edge>Without<M>NestedInput` / `<M>Create<edge>…NestedInput` keys.
+ *
+ * `createMany`, `updateMany` and `deleteMany` are `null`: they are nested BULK
+ * writes, and `RelationMutationDirective` models per-row intent only **[CORE]**.
+ * Aventara expresses the same effect by addressing the target Resource, so
+ * advertising them would promise an argument no directive could carry.
+ */
+export const PRISMA_RELATION_DIRECTIVES = {
+    create: "$create",
+    connect: "$connect",
+    connectOrCreate: "$connectOrCreate",
+    disconnect: "$disconnect",
+    set: "$set",
+    update: "$update",
+    delete: "$delete",
+    upsert: "$upsert",
+    createMany: null,
+    updateMany: null,
+    deleteMany: null,
+};
+/**
+ * `<M>$<edge>Args` keys, valued in `PaginationCapability`.
+ *
+ * `null` means the argument is read for something else, or for nothing:
+ * `orderBy` answers `order`, `where` answers the `nested` filter capability,
+ * `select`/`omit`/`include` answer projection, and `distinct` is a Prisma concept
+ * Aventara has no word for. The table is total over the keys both clients write,
+ * so a new edge argument at 7.11 is an unrecognised key rather than a silent drop.
+ */
+export const PRISMA_EDGE_ARGUMENTS = {
+    take: "limit",
+    skip: "offset",
+    cursor: "cursor",
+    orderBy: null,
+    distinct: null,
+    select: null,
+    omit: null,
+    include: null,
+    where: null,
+};
+/** `_count` on `<M>Include` / `<M>CountOutputType`. */
+export const PRISMA_REDUCERS = {
+    _count: "$count",
+};
+const BOTH_ENGINES = [
+    "@prisma/adapter-better-sqlite3",
+    "@prisma/adapter-pg",
+];
+/**
+ * Task 1's observations, inlined with the engines they were made on
+ * **[RUN8, `src/environment.spec.ts`]**. Identical through both driver adapters,
+ * so the representation is not driver-dependent *between these two engines* —
+ * which is a narrower claim than "not driver-dependent", and the narrower one is
+ * what was measured.
+ *
+ * A row is `RUN8` only where a read-back value was actually asserted. `String`,
+ * `Boolean`, `Int` and `Float` were written into a row and never read back under
+ * assertion, so they stay `[UNVERIFIED]` (§12): a plausible value shape is not an
+ * observed one, and this table exists precisely so that nobody has to guess which
+ * is which.
+ */
+export const OBSERVED_VALUE_SHAPES = [
+    {
+        prismaType: "Decimal",
+        shape: 'an object whose constructor is `Decimal2` (Prisma\'s bundled decimal.js), carrying `toFixed`, whose `JSON.stringify` is a string ("1.25") and which is never a number',
+        engines: BOTH_ENGINES,
+        evidence: "RUN8",
+    },
+    {
+        prismaType: "BigInt",
+        shape: "a `bigint` primitive; 9007199254740993n round-tripped exactly, beyond Number.MAX_SAFE_INTEGER",
+        engines: BOTH_ENGINES,
+        evidence: "RUN8",
+    },
+    {
+        prismaType: "DateTime",
+        shape: "a `Date`",
+        engines: BOTH_ENGINES,
+        evidence: "RUN8",
+    },
+    {
+        prismaType: "Bytes",
+        shape: "a `Uint8Array` with `Buffer.isBuffer(v) === false`",
+        engines: BOTH_ENGINES,
+        evidence: "RUN8",
+    },
+    {
+        prismaType: "Json",
+        shape: "a plain object",
+        engines: BOTH_ENGINES,
+        evidence: "RUN8",
+    },
+    {
+        prismaType: "<enum>",
+        shape: "a plain string — the PSL member name, never the `@map`ped database name",
+        engines: BOTH_ENGINES,
+        evidence: "RUN8",
+    },
+    {
+        prismaType: "<absent nullable>",
+        shape: "`null`",
+        engines: BOTH_ENGINES,
+        evidence: "RUN8",
+    },
+    {
+        prismaType: "String",
+        shape: "[UNVERIFIED]",
+        engines: BOTH_ENGINES,
+        evidence: "UNVERIFIED",
+    },
+    {
+        prismaType: "Boolean",
+        shape: "[UNVERIFIED]",
+        engines: BOTH_ENGINES,
+        evidence: "UNVERIFIED",
+    },
+    {
+        prismaType: "Int",
+        shape: "[UNVERIFIED]",
+        engines: BOTH_ENGINES,
+        evidence: "UNVERIFIED",
+    },
+    {
+        prismaType: "Float",
+        shape: "[UNVERIFIED]",
+        engines: BOTH_ENGINES,
+        evidence: "UNVERIFIED",
+    },
+];