@aventara/prisma7-adapter 0.1.0-pilot.0

package/dist/translation/order-pagination.translator.d.ts

@@ -0,0 +1,86 @@
+import { type AdapterModel } from "@aventara/core";
+import type { PrismaIdentifierAddress } from "../discovery/discovery-artifact.interface.js";
+/**
+ * T-7 — `orderBy` and pagination translation. Pure functions over plain data:
+ * no client, no database, no provider name.
+ *
+ * # C-831 is a one-directional rename, and this module is the only place it happens
+ *
+ * The public names are `limit`, `offset` and `cursor`. `take` and `skip` are
+ * Prisma's and appear nowhere in this adapter's public types — they are produced
+ * here and nowhere else. The tables below are TOTAL over core's own unions, so a
+ * pagination capability or a reducer added to core with no emission site is a
+ * compile error (C-855).
+ *
+ * # An absent argument and an `undefined` one are different arguments
+ *
+ * `take: undefined` is a present key with no value, and `"take" in args` is what
+ * a provider sees. Every key below is added only when its Aventara argument is
+ * present, which is also why `0` is carried through rather than tested for
+ * truthiness.
+ */
+/** An order or cursor the discovered model does not license. */
+export declare class PrismaOrderTranslationError extends Error {
+    readonly name = "PrismaOrderTranslationError";
+}
+/** A Prisma `<M>OrderByWithRelationInput`, as plain data. */
+export type PrismaOrderByInput = Readonly<Record<string, unknown>>;
+/** `take` / `skip` / `cursor`, exactly as many of them as were asked for. */
+export type PrismaPaginationArguments = Readonly<Record<string, unknown>>;
+export type PaginationTranslation = {
+    readonly limit?: number;
+    readonly offset?: number;
+    /**
+     * The Aventara cursor: the active ordered scalar fields and their values.
+     *
+     * **Only the identifier subset is emitted, and that is faithful translation
+     * rather than a silent drop (C-855).** Settled 2026-10-02; do not re-open
+     * without reading `validateCursor` first.
+     *
+     * Core's `CursorInput` type is `Partial<Record<ScalarFieldKey, unknown>>`,
+     * which reads as permissive, but `operation-validator-core.ts`'s
+     * `validateCursor` pins it exactly: the cursor's keys must **equal** the
+     * active ordered scalar fields, and `orderBy` must include a complete
+     * Resource identifier as a tie-breaker. So the non-identifier keys are not
+     * optional context a caller happened to send — core requires every one of
+     * them, and has already verified they match `orderBy`.
+     *
+     * Prisma's `cursor` is a `<M>WhereUniqueInput`: it locates a *row*, and the
+     * ordering comes from `orderBy`, which this module translates alongside. The
+     * identifier therefore determines the position completely, and the remaining
+     * ordered keys are already expressed in the emitted `orderBy`. Nothing is
+     * lost — which is why this is translation and not the MikroORM failure mode
+     * C-855 names.
+     *
+     * Two things follow, both load-bearing. Passing the extra keys through would
+     * make them equality members of a where-unique, *narrowing* the lookup: a key
+     * whose value no longer matches the stored row would resolve the cursor to
+     * nothing and return an empty page instead of a correct one. And narrowing
+     * core's `CursorInput` to the identifier — considered and rejected — would
+     * break the determinism contract `validateCursor` enforces, since core needs
+     * the full ordered set to know the position is unambiguous.
+     *
+     * The type is loose because the Contract is passive data; the precision lives
+     * in the validator. That is the pattern throughout `operation-arguments.ts`,
+     * and reading the type without its validator is how this was briefly
+     * mis-analysed.
+     */
+    readonly cursor?: Readonly<Record<string, unknown>>;
+    /**
+     * The Resource's Prisma addressing, from the generate-time translation table.
+     *
+     * Required rather than optional because Prisma's `cursor` is a
+     * `<M>WhereUniqueInput`, not a free scalar map: a compound identifier is keyed
+     * by its members joined in attribute order and WRAPPED, and that key is
+     * recorded at generate time and matched here, never re-derived.
+     */
+    readonly identifiers: readonly PrismaIdentifierAddress[];
+};
+export type OrderByTranslation = {
+    readonly model: AdapterModel;
+    readonly resource: string;
+    /** A validated Aventara `OrderByInput`: one entry, or a precedence list. */
+    readonly orderBy: unknown;
+};
+export declare function translatePagination(input: PaginationTranslation): PrismaPaginationArguments;
+export declare function translateOrderBy(input: OrderByTranslation): PrismaOrderByInput | readonly PrismaOrderByInput[];

package/dist/translation/order-pagination.translator.js

@@ -0,0 +1,159 @@
+import { advertisedReducers, } from "@aventara/core";
+import { addressIdentifier } from "./identifier.addressing.js";
+/**
+ * T-7 — `orderBy` and pagination translation. Pure functions over plain data:
+ * no client, no database, no provider name.
+ *
+ * # C-831 is a one-directional rename, and this module is the only place it happens
+ *
+ * The public names are `limit`, `offset` and `cursor`. `take` and `skip` are
+ * Prisma's and appear nowhere in this adapter's public types — they are produced
+ * here and nowhere else. The tables below are TOTAL over core's own unions, so a
+ * pagination capability or a reducer added to core with no emission site is a
+ * compile error (C-855).
+ *
+ * # An absent argument and an `undefined` one are different arguments
+ *
+ * `take: undefined` is a present key with no value, and `"take" in args` is what
+ * a provider sees. Every key below is added only when its Aventara argument is
+ * present, which is also why `0` is carried through rather than tested for
+ * truthiness.
+ */
+/** An order or cursor the discovered model does not license. */
+export class PrismaOrderTranslationError extends Error {
+    name = "PrismaOrderTranslationError";
+}
+const PAGINATION_TOKENS = {
+    limit: "take",
+    offset: "skip",
+    cursor: "cursor",
+};
+/** The reducer vocabulary, on the ORDER side (`<M>OrderByRelationAggregateInput`). */
+const REDUCER_TOKENS = {
+    $count: "_count",
+};
+export function translatePagination(input) {
+    const emitted = {};
+    if (input.limit !== undefined) {
+        emitted[PAGINATION_TOKENS.limit] = input.limit;
+    }
+    if (input.offset !== undefined) {
+        emitted[PAGINATION_TOKENS.offset] = input.offset;
+    }
+    if (input.cursor !== undefined) {
+        emitted[PAGINATION_TOKENS.cursor] = addressCursor(input.cursor, input.identifiers);
+    }
+    return emitted;
+}
+/**
+ * The Aventara cursor carries the active ordered scalar fields; core guarantees
+ * that they include a complete identifier (`V1009` — *"orderBy must include a
+ * complete Resource identifier as an explicit tie-breaker"*). Prisma's `cursor`
+ * is an ADDRESS, so the identifier is what is emitted: the remaining ordered
+ * fields are the ordering, which `orderBy` already carries, and adding them as
+ * equality members of a where-unique would narrow the address rather than
+ * sharpen it.
+ */
+function addressCursor(cursor, identifiers) {
+    // `"subset"`: the cursor carries every active ordered scalar field, of which
+    // the identifier is one part (`validateCursor`), so extra keys are expected.
+    // The values are already Prisma-shaped, so the emitter is the identity.
+    const addressed = addressIdentifier({
+        addresses: identifiers,
+        values: cursor,
+        match: "subset",
+        emit: (_member, value) => value,
+    });
+    if (addressed === undefined) {
+        throw new PrismaOrderTranslationError(`cursor: no identifier is complete in { ${Object.keys(cursor).join(", ")} }, so it addresses no row`);
+    }
+    return addressed.where;
+}
+export function translateOrderBy(input) {
+    if (Array.isArray(input.orderBy)) {
+        // The precedence list keeps its shape: Prisma reads an array as precedence
+        // too, and collapsing it would reorder the request.
+        return input.orderBy.map((entry, index) => translateEntry(input.model, input.resource, entry, `orderBy[${index}]`));
+    }
+    return translateEntry(input.model, input.resource, input.orderBy, "orderBy");
+}
+function translateEntry(model, resourceKey, entry, path) {
+    const resource = model.resources[resourceKey];
+    if (resource === undefined) {
+        throw new PrismaOrderTranslationError(`${path}: Resource "${resourceKey}" is not in the discovered model`);
+    }
+    if (!isRecord(entry)) {
+        throw new PrismaOrderTranslationError(`${path} must be an object`);
+    }
+    const keys = Object.keys(entry);
+    // Core's rule, mirrored: one precedence entry is one field, because the order
+    // of keys in an object is not a precedence a caller can rely on.
+    if (keys.length !== 1) {
+        throw new PrismaOrderTranslationError(`${path} must contain exactly one field`);
+    }
+    const fieldName = keys[0];
+    const field = resource.fields[fieldName];
+    if (field === undefined) {
+        throw new PrismaOrderTranslationError(`${path}.${fieldName} is not a field of Resource "${resourceKey}"`);
+    }
+    if (field.capabilities.order !== true) {
+        throw new PrismaOrderTranslationError(`${path}.${fieldName}: ordering is not advertised on this field`);
+    }
+    const value = entry[fieldName];
+    return {
+        [fieldName]: field.kind === "scalar"
+            ? translateScalarOrder(field, value, `${path}.${fieldName}`)
+            : translateRelationOrder(model, field, value, `${path}.${fieldName}`),
+    };
+}
+function translateScalarOrder(field, value, path) {
+    if (value === "asc" || value === "desc") {
+        return value;
+    }
+    if (!isRecord(value)) {
+        throw new PrismaOrderTranslationError(`${path} must be "asc", "desc" or an explicit null order`);
+    }
+    // C-836: the extended form is `SortOrderInput`, and the deriver advertises
+    // `orderNulls` only where the generated types admit it for THIS field. Prisma's
+    // spelling is the same `{ sort, nulls }`, so the translation is the gate.
+    if (field.capabilities.orderNulls !== true) {
+        throw new PrismaOrderTranslationError(`${path}: explicit null ordering is not advertised on this field`);
+    }
+    const { sort, nulls } = value;
+    if (Object.keys(value).length !== 2 ||
+        (sort !== "asc" && sort !== "desc") ||
+        (nulls !== "first" && nulls !== "last")) {
+        throw new PrismaOrderTranslationError(`${path}: an explicit null order is { sort, nulls }`);
+    }
+    return { sort, nulls };
+}
+function translateRelationOrder(model, field, value, path) {
+    if (!isRecord(value)) {
+        throw new PrismaOrderTranslationError(`${path} must be an object`);
+    }
+    if (field.cardinality === "one") {
+        // A to-one edge orders by the target's own fields.
+        return translateEntry(model, field.target, value, path);
+    }
+    // A to-many edge orders by its advertised reducer and by nothing else:
+    // `<M>OrderByRelationAggregateInput` carries `_count` alone.
+    const keys = Object.keys(value);
+    const [reducer] = keys;
+    if (keys.length !== 1 || reducer === undefined || !isReducer(reducer)) {
+        throw new PrismaOrderTranslationError(`${path}: a to-many edge orders only by an advertised reducer`);
+    }
+    if (!(advertisedReducers(field.capabilities.reducers) ?? []).includes(reducer)) {
+        throw new PrismaOrderTranslationError(`${path}.${reducer} is not advertised on this edge`);
+    }
+    const direction = value[reducer];
+    if (direction !== "asc" && direction !== "desc") {
+        throw new PrismaOrderTranslationError(`${path}.${reducer} must be "asc" or "desc"`);
+    }
+    return { [REDUCER_TOKENS[reducer]]: direction };
+}
+function isReducer(key) {
+    return Object.hasOwn(REDUCER_TOKENS, key);
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/dist/translation/projection.translator.d.ts

@@ -0,0 +1,115 @@
+import type { RelationReducer } from "@aventara/core";
+/**
+ * Task 8 — the projection half of T-7: Aventara `select`/`include`/`$count` →
+ * Prisma `select`/`include`/`_count` (C-832, C-833).
+ *
+ * **What arrives here is core's plan, not a caller's request.** By the time an
+ * `AdapterOperation` reaches the adapter, `planReadOperation` has resolved
+ * `include` into `select`, expanded every relation it could resolve into object
+ * form, and dropped VIRTUAL scalars from the adapter's half while keeping them
+ * in the projection plan it validates against
+ * **[CORE, runtime/computed-read-runtime.ts]**. So this module reads one shape:
+ * `select` as an array whose entries are field-name strings, the reducer string
+ * `"$count"`, or single-key objects carrying a relation's own arguments beside a
+ * nested `select`.
+ *
+ * **Three translations are worth stating because they are not obvious:**
+ *
+ * 1. *The default projection emits nothing at all.* C-833's claim is that
+ *    Prisma's default read projection — every scalar, no relations — IS the
+ *    framework default (§10.1), so the honest translation of "no `select`" is
+ *    an empty argument fragment rather than a reconstructed scalar list. A
+ *    reconstructed list would have to be derived from the model and would drift
+ *    from it; this cannot.
+ * 2. *A string entry becomes `true`, whether it names a scalar or a relation.*
+ *    §10.2 says a relation string uses the target Resource's default
+ *    projection, and `posts: true` is exactly how Prisma spells that. Since the
+ *    two emissions coincide, the translator needs no model lookup to tell a
+ *    scalar from a relation — and therefore cannot get that lookup wrong.
+ * 3. *`$count` is lifted to the level that owns the edge.* Aventara writes the
+ *    reducer inside the relation's own `select` (§10.3); Prisma writes it in the
+ *    PARENT's `select`, under `_count`. The `where` placed in `_count` is the
+ *    relation's *translated* `where` and carries no pagination, which is what
+ *    makes `count` the total matching the nested `where` before
+ *    limit/offset/cursor (C-832).
+ *
+ * **One call, not two (D-822, measured 2026-10-02).** D-822 left open whether
+ * Prisma's relation `_count` is affected by a `take`/`skip` on the same relation
+ * in the same query, and required Task 8 to establish it before choosing a
+ * shape. Measured against real databases on both engines — `@prisma/client`
+ * 7.10.0, `_count: { select: { posts: { where } } }` beside
+ * `posts: { where, take, skip }` — the count was `3` in every case while the row
+ * set was `3`, `1`, `2`, `1` and `1` for no pagination, `take: 1`, `skip: 1`,
+ * `take: 1 + skip: 1` and `take: 2 + skip: 2`, and `3` again with
+ * `cursor + take: 1`. SQLite and PostgreSQL agreed exactly. The filtered-count
+ * claim ("since 4.3.0") was re-measured in the same run: `_count` of the same
+ * edge answered `5` unfiltered and `3` with the `where`. So the translation is
+ * one call and the two-call fallback D-822 allowed for is not needed.
+ *
+ * **The relation-argument translator is injected.** `where`, `orderBy`,
+ * `limit`, `offset` and `cursor` are Task 7's vocabulary
+ * (`where.translator.ts`, `order-pagination.translator.ts`); this module owns
+ * the projection and nothing else. Injecting the seam also makes the `_count`
+ * filter the *same* translated `where` the relation read uses, rather than a
+ * second translation of the same predicate that could drift from it.
+ */
+/** Core's own word for the reducer set, so the adapter cannot invent a second one. */
+export type PrismaRelationProjection = {
+    readonly field: string;
+    /** Non-empty exactly when the edge requested a reducer. */
+    readonly reducers: readonly RelationReducer[];
+    /** Whether any row field was requested beside the reducer (§10.3's third shape). */
+    readonly rows: boolean;
+    readonly projection: PrismaProjectionPlan;
+};
+/**
+ * What T-8 called `ReadProjectionPlanLike`, renamed because it is not a view of
+ * a plan: `AdapterOperation` carries only `{ family, variant, resource,
+ * arguments }` **[CORE]**, so the adapter *reconstructs* the reducer positions
+ * from the arguments core planned, and this module is their owner. It records
+ * only the edges that need reshaping — an edge with no reducer anywhere beneath
+ * it is absent, which is what lets the shaper return such a row untouched.
+ */
+export type PrismaProjectionPlan = {
+    readonly relations: readonly PrismaRelationProjection[];
+};
+/** Where in the projection a relation sits, for the injected translator's diagnostics. */
+export type PrismaProjectionContext = {
+    readonly path: readonly string[];
+};
+/**
+ * Task 7's `where`/`orderBy`/pagination translation, as this module's one
+ * dependency: Aventara relation arguments in, Prisma relation arguments out.
+ */
+export type PrismaRelationArgumentTranslator = (args: Readonly<Record<string, unknown>>, context: PrismaProjectionContext) => Readonly<Record<string, unknown>>;
+export type PrismaProjectionDependencies = {
+    readonly translateRelationArguments: PrismaRelationArgumentTranslator;
+};
+export type PrismaProjectionTranslation = {
+    /**
+     * The projection fragment of the Prisma call: `{}` for the default
+     * projection, `{ select: … }` otherwise. The operation translator merges it
+     * with the rest of the arguments.
+     */
+    readonly args: Readonly<Record<string, unknown>>;
+    readonly plan: PrismaProjectionPlan;
+};
+/**
+ * A projection the adapter will not translate.
+ *
+ * Every case is one core's validation should already have rejected, and each is
+ * raised rather than worked around: translating an `include` as "no relations",
+ * or an empty `select` as "every scalar", would answer a different question in
+ * silence, which is C-855's failure mode seen from the translation side.
+ */
+export declare class PrismaProjectionTranslationError extends Error {
+    constructor(reason: string, path: readonly string[]);
+}
+/**
+ * Translates core's planned projection into the Prisma projection arguments and
+ * the plan the result shaper needs to place every `$count` envelope.
+ *
+ * @throws {PrismaProjectionTranslationError} for a projection the adapter will
+ * not translate rather than silently reinterpret.
+ */
+export declare function translateProjection(args: Readonly<Record<string, unknown>>, dependencies: PrismaProjectionDependencies): PrismaProjectionTranslation;

package/dist/translation/projection.translator.js

@@ -0,0 +1,151 @@
+/**
+ * A projection the adapter will not translate.
+ *
+ * Every case is one core's validation should already have rejected, and each is
+ * raised rather than worked around: translating an `include` as "no relations",
+ * or an empty `select` as "every scalar", would answer a different question in
+ * silence, which is C-855's failure mode seen from the translation side.
+ */
+export class PrismaProjectionTranslationError extends Error {
+    constructor(reason, path) {
+        const where = path.length === 0 ? "the root projection" : path.join(".");
+        super(`${reason} (at ${where}).`);
+        this.name = "PrismaProjectionTranslationError";
+    }
+}
+/** Prisma's spelling of the reducer; the dictionary's `_count` → `$count` row, read backwards. */
+const PRISMA_COUNT_KEY = "_count";
+const AVENTARA_COUNT_REDUCER = "$count";
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/** The single-key `{ relation: { … } }` entry core emits for a customized edge. */
+function relationEntry(entry, path) {
+    const keys = Object.keys(entry);
+    const field = keys[0];
+    if (keys.length !== 1 || field === undefined) {
+        throw new PrismaProjectionTranslationError("A relation projection entry must carry exactly one relation name", path);
+    }
+    return [field, entry[field]];
+}
+function relationArguments(value) {
+    return Object.fromEntries(Object.entries(value).filter(([key]) => key !== "select" && key !== "include"));
+}
+function nestedSelect(value, path) {
+    if (value.include !== undefined) {
+        throw new PrismaProjectionTranslationError("A relation projection must use `select`; core resolves `include` before the adapter", path);
+    }
+    if (value.select === undefined) {
+        return undefined;
+    }
+    if (!Array.isArray(value.select)) {
+        throw new PrismaProjectionTranslationError("A relation `select` must be an array of projection entries", path);
+    }
+    return value.select;
+}
+function translateRelation(field, value, dependencies, path) {
+    const here = [...path, field];
+    if (!isRecord(value)) {
+        throw new PrismaProjectionTranslationError("A customized relation must use object form", here);
+    }
+    const entries = nestedSelect(value, here);
+    const reducerRequested = entries?.includes(AVENTARA_COUNT_REDUCER) === true;
+    const rowEntries = entries?.filter((entry) => entry !== AVENTARA_COUNT_REDUCER);
+    const translated = dependencies.translateRelationArguments(relationArguments(value), { path: here });
+    const nested = rowEntries === undefined || rowEntries.length === 0
+        ? undefined
+        : translateLevel(rowEntries, dependencies, here);
+    // An edge whose only requested entries were row fields keeps Prisma's own
+    // default projection when none were named at all (§10.2's relation string).
+    const rows = entries === undefined || (rowEntries?.length ?? 0) > 0;
+    const selected = rows
+        ? {
+            ...translated,
+            ...(nested === undefined ? {} : { select: nested.select }),
+        }
+        : undefined;
+    const node = reducerRequested || (nested?.plan.relations.length ?? 0) > 0
+        ? {
+            field,
+            reducers: reducerRequested ? [AVENTARA_COUNT_REDUCER] : [],
+            rows,
+            projection: nested?.plan ?? { relations: [] },
+        }
+        : undefined;
+    return {
+        // `true` rather than `{}`: an edge with neither arguments nor a nested
+        // projection is exactly "the target's default projection".
+        selected: selected === undefined
+            ? undefined
+            : Object.keys(selected).length === 0
+                ? true
+                : selected,
+        // The count carries the translated `where` and NOTHING else, which is what
+        // makes it the pre-pagination total (C-832).
+        counted: reducerRequested
+            ? translated.where === undefined
+                ? true
+                : { where: translated.where }
+            : undefined,
+        node,
+    };
+}
+function translateLevel(select, dependencies, path) {
+    if (select.length === 0) {
+        throw new PrismaProjectionTranslationError("A projection must request at least one field; Prisma cannot express an empty `select`", path);
+    }
+    const prismaSelect = {};
+    const counts = {};
+    const relations = [];
+    for (const entry of select) {
+        if (typeof entry === "string") {
+            if (entry === AVENTARA_COUNT_REDUCER) {
+                throw new PrismaProjectionTranslationError("`$count` is an edge reducer and is only valid inside a relation projection", path);
+            }
+            // A scalar and a relation string translate alike, and Prisma reads
+            // `relation: true` as the target's default projection (§10.2).
+            prismaSelect[entry] = true;
+            continue;
+        }
+        if (!isRecord(entry)) {
+            throw new PrismaProjectionTranslationError("A projection entry must be a field name or a single-key relation object", path);
+        }
+        const [field, value] = relationEntry(entry, path);
+        const relation = translateRelation(field, value, dependencies, path);
+        if (relation.selected !== undefined) {
+            prismaSelect[field] = relation.selected;
+        }
+        if (relation.counted !== undefined) {
+            counts[field] = relation.counted;
+        }
+        if (relation.node !== undefined) {
+            relations.push(relation.node);
+        }
+    }
+    if (Object.keys(counts).length > 0) {
+        prismaSelect[PRISMA_COUNT_KEY] = { select: counts };
+    }
+    return { select: prismaSelect, plan: { relations } };
+}
+/**
+ * Translates core's planned projection into the Prisma projection arguments and
+ * the plan the result shaper needs to place every `$count` envelope.
+ *
+ * @throws {PrismaProjectionTranslationError} for a projection the adapter will
+ * not translate rather than silently reinterpret.
+ */
+export function translateProjection(args, dependencies) {
+    if (args.include !== undefined) {
+        throw new PrismaProjectionTranslationError("An operation projection must arrive as `select`; core resolves `include` before the adapter", []);
+    }
+    if (args.select === undefined) {
+        // C-833: Prisma's default read projection is the framework default, so the
+        // translation is to request nothing.
+        return { args: {}, plan: { relations: [] } };
+    }
+    if (!Array.isArray(args.select)) {
+        throw new PrismaProjectionTranslationError("An operation `select` must be an array of projection entries", []);
+    }
+    const level = translateLevel(args.select, dependencies, []);
+    return { args: { select: level.select }, plan: level.plan };
+}

package/dist/translation/scalar.conversion.d.ts

@@ -0,0 +1,101 @@
+import { type AdapterField, type AdapterModel } from "@aventara/core";
+/**
+ * C-834 — the scalar value conversion, in **one** table and **both**
+ * directions.
+ *
+ * # Why this is a module and not three private helpers
+ *
+ * Three consumers cross the same boundary with the same values: a write's `data`
+ * (`mutation.translator.ts`), a filter operand (`where.translator.ts`) and a row
+ * coming back (`execution/result.shaper.ts`). The emission table was born inside
+ * the mutation translator, which is where the first of the three needed it; a
+ * copy in each consumer would be three places to answer "what does a `decimal`
+ * look like on the wire", and the second copy to drift would be the one nobody
+ * reads. {@link SCALAR_BOUNDARY_CROSSINGS} is therefore the single owner, and
+ * Task 10's `identifier.addressing.ts` is the precedent — extracted for exactly
+ * this reason.
+ *
+ * The table is TOTAL over core's `BuiltInScalar` by a mapped type, so a tenth
+ * scalar added to the protocol is a compile error here rather than a value that
+ * silently crosses unconverted in one direction only.
+ *
+ * # `decimal` is the one real conversion, and that is measured
+ *
+ * Eight of the nine scalars pass through in both directions, re-measured on both
+ * driver adapters at `@prisma/client` 7.10.0 (2026-10-02): a `bigint` primitive,
+ * a `Date` and a `Uint8Array` are what the generated input types accept and what
+ * a read returns (`Buffer.isBuffer(v) === false`, `v instanceof Uint8Array ===
+ * true`), `Json` is written and returned as a plain object (its prototype IS
+ * `Object.prototype`, which is what core's own `isPlainRecord` output check
+ * requires **[CORE, runtime/scalar-runtime.ts]**), and an enum member is its own
+ * name on both sides. Those are the same forms core's runtime scope requires
+ * (`normalizeScalarAtom`'s `"application"` branch), so a pass-through is a
+ * decision, not an omission.
+ *
+ * `decimal` is the exception §6.2 names: *the public `Decimal` MUST NOT be
+ * `Prisma.Decimal`*, and it is not — core's `Decimal` is a class with one
+ * private `#value` and a `toString`, while Prisma's is its bundled decimal.js,
+ * whose constructor is named `Decimal2`. Neither accepts the other, so the
+ * crossing is a real conversion both ways: out, the base-10 string; in, core's
+ * own `Decimal`.
+ *
+ * # Outbound: three different failures, none of them a type error
+ *
+ * Passing core's `Decimal` through unconverted fails *differently* depending on
+ * where it lands, and none of the three is a plain rejection (measured on both
+ * engines, 2026-10-02):
+ *
+ * - as a **write value**: refused at the wire — *"Invalid value for argument
+ *   `toString`: We could not serialize [object Function] value."*;
+ * - as a **comparison operand** (`gt`, `equals`, …): read as a **FieldRef**, not
+ *   as a value — *"PrismaClientValidationError: Argument `_ref` is missing."*;
+ * - as a **bare equality operand**: *accepted*, and silently wrong. Core's
+ *   `Decimal` keeps its digits in a private field, so `Object.keys` is empty and
+ *   Prisma reads the object as an **empty `DecimalFilter`** — `findMany` returned
+ *   **2 of 2** rows, byte-identical to passing no predicate at all, where the
+ *   string `"1"` returned 1. A misinterpretation that validates is the failure
+ *   this module exists to make impossible.
+ *
+ * # Inbound: the value core's output validator will accept
+ *
+ * Core validates adapter output in its `"runtime"` scope, which requires the
+ * *runtime* form of every scalar — `value instanceof Decimal` for a decimal
+ * **[CORE, runtime/output-validator.ts → normalizeScalarFieldValue]**. A
+ * `Decimal2` is not one, so an unconverted read fails core's own validation and
+ * the caller is told `A3000`. Converting here is therefore not a courtesy: it is
+ * the adapter's half of §6.2.
+ *
+ * # The scalar identity comes from the model, never from the value
+ *
+ * Both directions are keyed by the field's discovered scalar, never by the
+ * runtime shape of the value. A `Json` column holding `{ "x": 1 }` and a
+ * `Decimal` reaching Prisma are both "an object", and a `Json` column holding
+ * the string `"12.5"` is indistinguishable from a decimal string: shape-sniffing
+ * would convert one of those sooner or later, and silently. The discovered model
+ * already knows, so it is asked.
+ */
+/** A value this adapter will not convert rather than misrepresent. */
+export declare class PrismaScalarConversionError extends Error {
+    readonly name = "PrismaScalarConversionError";
+}
+/** Which way across the adapter boundary a value is travelling. */
+export type PrismaScalarDirection = "outbound" | "inbound";
+/** A scalar-shaped discovered field: the only thing that names a scalar. */
+export type PrismaScalarField = Extract<AdapterField<AdapterModel>, {
+    kind: "scalar";
+}>;
+/**
+ * One value out of Aventara and into a Prisma argument.
+ *
+ * @throws {PrismaScalarConversionError} for a value the adapter will not
+ * represent rather than let a provider misread.
+ */
+export declare function emitScalarValue(model: AdapterModel, field: PrismaScalarField, value: unknown, path: string): unknown;
+/**
+ * One value out of a Prisma result and into the runtime form core's output
+ * validator accepts.
+ *
+ * @throws {PrismaScalarConversionError} for a provider value the adapter cannot
+ * honestly read as that scalar.
+ */
+export declare function receiveScalarValue(model: AdapterModel, field: PrismaScalarField, value: unknown, path: string): unknown;