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

package/dist/discovery/identifier.mapper.js

@@ -1,42 +1,6 @@
-/**
- * The Prisma addressing key for a uniqueness criterion: the key a
- * `WhereUniqueInput` accepts, and the key the generated `AtLeast<…, K>` union
- * lists.
- *
- * Computed **once**, here, at generate time — the architect's decision on
- * 2026-09-29: *"store it, less processing and less room for drifting."* Runtime
- * matches the stored key and never re-derives it.
- *
- * The rule, measured at 7.10.0 (regenerated 2026-09-29 over five models):
- *
- * | criterion                          | key       | wraps |
- * | ---------------------------------- | --------- | ----- |
- * | `id String @id` / `@unique`        | `id`      | no    |
- * | `@@unique([b, a])`                 | `b_a`     | yes   |
- * | `@@id([a, b])`                     | `a_b`     | yes   |
- * | `@@unique([b, a], name: "altKey")` | `altKey`  | yes   |
- * | `@@id([a, b], name: "pk")`         | `pk`      | yes   |
- * | any of the above, `map: "…"`       | unchanged | —     |
- *
- * Two of those rows are why this is a function of the PSL facts and not of the
- * members alone. A custom `name:` **replaces** the positional alias rather than
- * adding to it, so `members.join("_")` is simply wrong for a named criterion —
- * which is precisely what made the cross-check refuse a schema Prisma accepts,
- * reporting a correctly-discovered identifier as an invented constraint (fixed
- * 2026-09-29; `map:` stays invisible and stays discarded).
- *
- * What this key is **not** is part of the identifier. `AdapterIdentifier` is a
- * tuple of field names with nowhere to put a name (C-814), and this key lives in
- * the artifact's translation table beside the model, never in it.
- */
 export function prismaUniqueInputKey(uniqueness) {
     return uniqueness.name ?? uniqueness.members.join("_");
 }
-/**
- * Every uniqueness criterion PSL states, in PSL's own order. A field spelled
- * `@id @unique` yields two criteria with the same key; the caller keeps the
- * first, so `@id` wins and one column does not become two identifiers.
- */
 function* uniquenessCriteria(model) {
     const criterion = (source, uniqueness) => ({
         source,
@@ -44,8 +8,6 @@ function* uniquenessCriteria(model) {
         key: prismaUniqueInputKey(uniqueness),
     });
     for (const field of model.fields) {
-        // A field-level criterion has no `name:` to carry: PSL gives `@id` and
-        // `@unique` no such argument, and Prisma keys them by the column.
         if (field.id) {
             yield criterion("@id", { members: [field.name], name: null });
         }
@@ -60,16 +22,7 @@ function* uniquenessCriteria(model) {
         yield criterion("@@unique", blockUnique);
     }
 }
-/**
- * One model's identity, read from PSL alone.
- *
- * A pure function of plain data: no generated client, no `@prisma/client`
- * import, and no TYPE input — which is what lets the cross-check be an
- * independent second opinion rather than a tautology.
- */
 export function mapPrismaIdentifiers(model) {
-    // The scalar columns this adapter can actually name: a relation field, a list
-    // and an `@ignore`d column are all keys no `AdapterFieldMap` will carry.
     const columns = new Map();
     for (const field of model.fields) {
         if (field.relation !== null || field.list || field.ignored) {
@@ -79,10 +32,6 @@ export function mapPrismaIdentifiers(model) {
     }
     const identifiers = [];
     const omitted = [];
-    // Deduplication is on the MEMBER TUPLE, not on the addressing key: the tuple
-    // is what `@id @unique` duplicates, and it identifies a criterion injectively,
-    // while a key does not — a custom `name:` can collide with a field name, and
-    // keying the seen-set would then silently drop a different criterion.
     const seen = new Set();
     for (const criterion of uniquenessCriteria(model)) {
         const tuple = JSON.stringify(criterion.members);
@@ -104,19 +53,6 @@ export function mapPrismaIdentifiers(model) {
             });
             continue;
         }
-        // C-815. SQL uniqueness does not constrain NULLs, so a criterion with any
-        // nullable participant does not guarantee AT MOST ONE row and is not an
-        // `Identifier`. Recorded, never dropped: the generator still emits an
-        // `AtLeast` key for it, and the TYPE cross-check needs the omission to
-        // explain that key.
-        //
-        // C-815 is typed a Derived Decision because no source states it. Prisma
-        // states the same rule from its own side, which is the nearest thing to a
-        // source there is: a model whose ONLY criterion has a nullable participant
-        // is rejected at validate time with P1012, "Each model must have at least
-        // one unique criteria that has only required fields … The following unique
-        // criterias were not considered as they contain fields that are not
-        // required: - a, b" (7.10.0, measured 2026-09-28).
         const nullableMembers = criterion.members.filter((member) => columns.get(member)?.optional === true);
         if (nullableMembers.length > 0) {
             omitted.push({

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

@@ -3,16 +3,8 @@ import type { PrismaComposedArtifact, PrismaModelComposer } from "../generate/pr
 import type { PrismaCapabilitySurface } from "./capability-surface.interface.js";
 import type { PrismaSchemaFacts } from "./schema-facts.interface.js";
 /**
- * Task 6 — **composition**: the one place the two readers' facts become the two
- * halves of the discovery artifact.
- *
- * Every rule it applies belongs to somebody else. That is the design, not a
- * shortcut: the scalar table is `scalar.mapper.ts`'s, the field projection and the
- * lifecycle traits are `field.mapper.ts`'s, identity is `identifier.mapper.ts`'s,
- * capabilities are `capability.deriver.ts`'s, the §8.3 variant gate is
- * `operations.deriver.ts`'s and nowhere else, and the enum comparison is
- * `enum.mapper.ts`'s. This module **orders and assembles**, and it owns exactly
- * two judgements of its own:
+ * Every rule it applies belongs to somebody else. This module **orders and
+ * assembles**, and it owns exactly two judgements of its own:
  *
  * 1. **Which diagnostics are fatal.** A mapper answers with a diagnostic; whether
  *    the build stops is composition's call, because only composition knows that a
@@ -49,31 +41,22 @@ import type { PrismaSchemaFacts } from "./schema-facts.interface.js";
  *
  * The composer is created with a {@link TransactionCapability} and nothing else.
  * `provider` is not a member anywhere on the path, so `if (provider === …)` is a
- * compile error rather than a convention (dictionary invariant 6, D-802). The
- * generate step keeps `provider` only to stamp the artifact, which is a recorded
- * fact and not a branch.
- *
- * `transactions` is a **driver** fact (T-2) and the driver is a runtime choice, so
- * it is declared to the composer at generate time. The two cannot silently
- * disagree: an artifact that says `"interactive"` loaded by an adapter whose
- * declared driver says `"none"` mounts no `transaction`, and core refuses
- * construction with `DISCOVERY_TRANSACTION_CAPABILITY_MISMATCH` **[CORE,
- * framework.factory.ts]** — a hard, legible failure rather than a silent one.
- *
- * # The C-818 conflict this header used to record is closed
+ * compile error rather than a convention. The generate step keeps `provider` only
+ * to stamp the artifact, which is a recorded fact and not a branch.
  *
- * It read: a relation carries create directives for `create.one` and none for
- * `create.many` **[DOC7]**, `AdapterRelationField.capabilities` is one record per
- * field with a single `create` member, so composition had to ask
- * `deriveRelationCapabilities` for the `"create.one"` answer — the permissive one —
- * and C-818's restriction was unrepresentable in the Contract.
+ * `transactions` is a **driver** fact and the driver is a runtime choice, so it is
+ * declared to the composer at generate time. The two cannot silently disagree: an
+ * artifact that says `"interactive"` loaded by an adapter whose declared driver
+ * says `"none"` mounts no `transaction`, and core refuses construction with
+ * `DISCOVERY_TRANSACTION_CAPABILITY_MISMATCH` **[CORE, framework.factory.ts]** — a
+ * hard, legible failure rather than a silent one.
  *
  * The capability members are **scope-qualified** now, so the one record holds both
- * answers: the create stage is advertised at the `nested` write scope and not at the
- * bulk one. Composition asks for no variant, passes no `operation`, and advertises
- * nothing it cannot honour. The mutation translator keeps its refusal — it is the
- * belt to core's braces, not the only guard (C-855) — but it is no longer the ONLY
- * place the restriction exists.
+ * answers: the create stage is advertised at the `nested` write scope and not at
+ * the bulk one. Composition asks for no variant, passes no `operation`, and
+ * advertises nothing it cannot honour. The mutation translator keeps its refusal —
+ * it is the belt to core's braces, not the only guard — but it is no longer the
+ * ONLY place the restriction exists.
  */
 /** Composition refuses: the collected diagnostics, named and reported together. */
 export declare class PrismaModelCompositionError extends Error {
@@ -83,9 +66,9 @@ export declare class PrismaModelCompositionError extends Error {
 }
 export type PrismaModelCompositionOptions = {
     /**
-     * The driver's transaction capability (T-2). The ONLY declared fact
-     * composition accepts, and deliberately not the whole profile: a
-     * `PrismaProviderProfile` carries `provider`.
+     * The driver's transaction capability. The ONLY declared fact composition accepts,
+     * and deliberately not the whole profile: a `PrismaProviderProfile` carries
+     * `provider`.
      */
     readonly transactions: TransactionCapability;
 };

package/dist/discovery/model.discoverer.js

@@ -4,80 +4,6 @@ import { mapPrismaEnum } from "./enum.mapper.js";
 import { crossCheckCreateOptional, projectPrismaField, } from "./field.mapper.js";
 import { mapPrismaIdentifiers } from "./identifier.mapper.js";
 import { deriveResourceOperations } from "./operations.deriver.js";
-/**
- * Task 6 — **composition**: the one place the two readers' facts become the two
- * halves of the discovery artifact.
- *
- * Every rule it applies belongs to somebody else. That is the design, not a
- * shortcut: the scalar table is `scalar.mapper.ts`'s, the field projection and the
- * lifecycle traits are `field.mapper.ts`'s, identity is `identifier.mapper.ts`'s,
- * capabilities are `capability.deriver.ts`'s, the §8.3 variant gate is
- * `operations.deriver.ts`'s and nowhere else, and the enum comparison is
- * `enum.mapper.ts`'s. This module **orders and assembles**, and it owns exactly
- * two judgements of its own:
- *
- * 1. **Which diagnostics are fatal.** A mapper answers with a diagnostic; whether
- *    the build stops is composition's call, because only composition knows that a
- *    model with an unmapped column cannot produce a Contract at all.
- * 2. **The scalar registry.** `ScalarRegistry` is the set of Aventara scalar
- *    identities the discovered fields actually use — a fact no single field can
- *    state and only the whole pass can.
- *
- * # Three halves, from one pass over one field list
- *
- * `model` is core's: canonicalized, hashed, compiled into the Contract.
- * `translation` is the adapter's Prisma addressing, and `referentialActions` is
- * what the resolved `@relation(onDelete:/onUpdate:)` arguments say. All three are
- * built from the SAME pass: the translation table from the same
- * `mapPrismaIdentifiers` answer the model's `identifiers` come from — `.members`
- * into the model, the whole address into the table — and the action table from the
- * same `projectPrismaField` answer the model's relation fields come from. Two
- * parallel passes would have to be kept in step; one pass cannot drift.
- *
- * `PrismaTranslationTable<M>` and `PrismaReferentialActionTable<M>` are mapped
- * types over the model's resources, so a resource this module adds to the model
- * and forgets to address — or forgets to answer the actions for — is a **compile
- * error** rather than a runtime `undefined` at the first unique read or the first
- * cascade question.
- *
- * The action table carries **only owning edges**, because only an owning edge has
- * an action: PSL forbids the back-reference from declaring one, so the
- * back-reference's answer is its partner's. Its direction is the one documented on
- * `PrismaReferentialEdge` and on `field.mapper.ts`'s `PrismaRelationEdge` —
- * *deleting a `target` does `onDelete` to rows of the enclosing resource* — and it
- * is carried out of field projection unchanged rather than re-derived here.
- *
- * # No provider reaches this module, and that is enforced by the input
- *
- * The composer is created with a {@link TransactionCapability} and nothing else.
- * `provider` is not a member anywhere on the path, so `if (provider === …)` is a
- * compile error rather than a convention (dictionary invariant 6, D-802). The
- * generate step keeps `provider` only to stamp the artifact, which is a recorded
- * fact and not a branch.
- *
- * `transactions` is a **driver** fact (T-2) and the driver is a runtime choice, so
- * it is declared to the composer at generate time. The two cannot silently
- * disagree: an artifact that says `"interactive"` loaded by an adapter whose
- * declared driver says `"none"` mounts no `transaction`, and core refuses
- * construction with `DISCOVERY_TRANSACTION_CAPABILITY_MISMATCH` **[CORE,
- * framework.factory.ts]** — a hard, legible failure rather than a silent one.
- *
- * # The C-818 conflict this header used to record is closed
- *
- * It read: a relation carries create directives for `create.one` and none for
- * `create.many` **[DOC7]**, `AdapterRelationField.capabilities` is one record per
- * field with a single `create` member, so composition had to ask
- * `deriveRelationCapabilities` for the `"create.one"` answer — the permissive one —
- * and C-818's restriction was unrepresentable in the Contract.
- *
- * The capability members are **scope-qualified** now, so the one record holds both
- * answers: the create stage is advertised at the `nested` write scope and not at the
- * bulk one. Composition asks for no variant, passes no `operation`, and advertises
- * nothing it cannot honour. The mutation translator keeps its refusal — it is the
- * belt to core's braces, not the only guard (C-855) — but it is no longer the ONLY
- * place the restriction exists.
- */
-/** Composition refuses: the collected diagnostics, named and reported together. */
 export class PrismaModelCompositionError extends Error {
     name = "PrismaModelCompositionError";
     diagnostics;
@@ -89,13 +15,6 @@ export class PrismaModelCompositionError extends Error {
         this.diagnostics = diagnostics;
     }
 }
-/**
- * The generate step's `composeModel` seam, filled.
- *
- * A factory rather than a bare function because the step's seam takes only the
- * readers' output — order and refusal over external effects is the step's job, and
- * the declared driver fact is the caller's.
- */
 export function createPrismaModelComposer(options) {
     return (input) => discoverPrismaModel({ ...input, ...options });
 }
@@ -113,8 +32,6 @@ export function discoverPrismaModel(input) {
         const model = declared.get(name);
         const exposed = input.surface.resources[name];
         if (model === undefined || exposed === undefined) {
-            // The existence gate admitted it, so both halves must be there. A
-            // diagnostic rather than a throw: the caller gets the whole list.
             diagnostics.push(`\`${name}\` was admitted by the existence gate and is absent from ${model === undefined ? "the PSL facts" : "the capability surface"}, which the gate cannot produce — this is a reader defect.`);
             continue;
         }
@@ -144,17 +61,77 @@ export function discoverPrismaModel(input) {
         },
         translation,
         referentialActions,
+        createRequirements: composeCreateRequirements(declared, input.surface, resources),
     };
 }
-/* ------------------------------------------------------------------ *
- * Enums                                                              *
- * ------------------------------------------------------------------ */
+function composeCreateRequirements(declared, surface, resources) {
+    const table = {};
+    for (const [name, resource] of Object.entries(resources)) {
+        const model = declared.get(name);
+        const exposed = surface.resources[name];
+        if (model === undefined || exposed === undefined) {
+            continue;
+        }
+        const requiredScalars = new Set(Object.entries(resource.fields)
+            .filter(([field, shape]) => {
+            const scalar = exposed.scalarFields[field];
+            return (shape.kind === "scalar" &&
+                scalar !== undefined &&
+                scalar.createOperations !== null &&
+                !scalar.createOptional);
+        })
+            .map(([field]) => field));
+        const requirements = [];
+        const references = new Set();
+        for (const field of model.fields) {
+            const shape = resource.fields[field.name];
+            if (shape?.kind !== "relation") {
+                continue;
+            }
+            const owned = field.relation?.fields ?? [];
+            for (const scalar of owned) {
+                references.add(scalar);
+            }
+            if (exposed.relationFields[field.name]?.createRequired !== true) {
+                continue;
+            }
+            const orFields = owned.filter((scalar) => requiredScalars.has(scalar));
+            if (orFields.length === 0) {
+                continue;
+            }
+            const inverse = inverseOf(declared, name, field);
+            requirements.push({
+                kind: "relation",
+                relation: field.name,
+                orFields,
+                ...(inverse === undefined ? {} : { inverse }),
+            });
+        }
+        const fields = model.fields
+            .map((field) => field.name)
+            .filter((field) => requiredScalars.has(field) && !references.has(field))
+            .map((field) => ({ kind: "field", field }));
+        table[name] = [...fields, ...requirements];
+    }
+    return table;
+}
+function inverseOf(declared, model, field) {
+    const target = declared.get(field.type);
+    if (target === undefined) {
+        return undefined;
+    }
+    const name = field.relation?.name ?? null;
+    const partners = target.fields.filter((candidate) => candidate.type === model &&
+        (candidate.relation?.name ?? null) === name &&
+        !(target.name === model && candidate.name === field.name));
+    const [partner] = partners;
+    return partners.length === 1 && partner !== undefined
+        ? { resource: target.name, relation: partner.name }
+        : undefined;
+}
 function composeEnums(input, diagnostics) {
     const enums = {};
     for (const declared of input.facts.enums) {
-        // The mapper's judgement, forwarded. Declaration order is semantic and
-        // enters the Contract hash, so "diverged" is fatal here for the same reason
-        // `reader-crosscheck.ts` reports it: the client is from another schema.
         const mapped = mapPrismaEnum({
             declared,
             exposed: input.surface.enums[declared.name],
@@ -166,24 +143,14 @@ function composeEnums(input, diagnostics) {
         if (mapped.outcome === "diverged") {
             diagnostics.push(mapped.diagnostic.message);
         }
-        // `excluded` is the existence rule applied to an enum: declared in PSL and
-        // absent from the generated `enums.ts`. It is NOT fatal, exactly as an
-        // `@ignore`d model is not: an enum the client cannot name has no place in a
-        // Contract, and any column typed by it is itself absent from the 🟢 surface
-        // and therefore already excluded by the field-level gate.
     }
     return enums;
 }
-/* ------------------------------------------------------------------ *
- * One resource                                                       *
- * ------------------------------------------------------------------ */
 function composeResource(input) {
     const { model, exposed, diagnostics } = input;
     const fields = {};
-    /** Owning edges only, in PSL field-declaration order (see this module's header). */
     const owningEdges = [];
     const unknowns = [];
-    /** What the create-optional cross-check consumes: PSL's own answers. */
     const projectedScalars = [];
     for (const field of model.fields) {
         const projection = projectPrismaField({
@@ -196,8 +163,6 @@ function composeResource(input) {
         });
         switch (projection.outcome) {
             case "excluded":
-                // The existence gate has already decided this absence is explained;
-                // re-deciding it here would be a second owner for C-808.
                 continue;
             case "unmapped":
                 diagnostics.push(projection.diagnostic.message);
@@ -211,9 +176,6 @@ function composeResource(input) {
                 }
                 const type = projection.field.type;
                 if ("scalar" in type) {
-                    // Narrowed by membership rather than asserted: `AdapterScalarField`'s
-                    // type ref is `keyof M["scalars"]`, which is `string` on the general
-                    // model, and the registry must carry built-in identities only.
                     const scalar = BUILT_IN_SCALARS.find((candidate) => candidate === type.scalar);
                     if (scalar === undefined) {
                         diagnostics.push(`\`${model.name}.${field.name}\` mapped to the scalar identity \`${type.scalar}\`, which is not one of Aventara's built-in scalars (${BUILT_IN_SCALARS.join(", ")}).`);
@@ -240,31 +202,19 @@ function composeResource(input) {
                     continue;
                 }
                 if (!input.admitted.has(projection.field.target)) {
-                    // An edge to a resource the model does not carry would compile into a
-                    // Contract that references a Resource that is not there.
                     diagnostics.push(`\`${model.name}.${field.name}\` targets \`${projection.field.target}\`, which the existence gate did not admit, so the edge would point at a Resource the model does not carry.`);
                     continue;
                 }
                 fields[projection.name] = {
                     ...projection.field,
-                    // No variant is named: the scope-qualified members carry both create
-                    // answers at once. See this module's header for the conflict that
-                    // closed.
                     capabilities: deriveRelationCapabilities({
                         surface: relationSurface,
                     }),
                 };
-                // The edge's resolved actions, carried out of the SAME projection the
-                // field above came from. Both members are non-null exactly on an owning
-                // edge, and PSL forbids a back-reference from declaring either — so the
-                // pair is tested together rather than one member at a time, and a
-                // back-reference contributes nothing instead of contributing two nulls.
                 if (projection.edge.onDelete !== null &&
                     projection.edge.onUpdate !== null) {
                     owningEdges.push({
                         field: projection.edge.field,
-                        // The PARENT. Deleting one of these does `onDelete` to rows of
-                        // `model.name`, which is the key this list hangs under.
                         target: projection.edge.target,
                         cardinality: projection.edge.cardinality,
                         onDelete: projection.edge.onDelete,
@@ -276,15 +226,10 @@ function composeResource(input) {
         }
     }
     if (unknowns.length > 0) {
-        // T-3.1 invariant 5: an unrecognised construct is a build stop, never a
-        // column Aventara quietly decides the client must supply.
         for (const unknown of unknowns) {
             diagnostics.push(`${unknown.spelling} (${unknown.kind}) in \`${unknown.block ?? "<top level>"}\` at ${unknown.site.file}:${unknown.site.line}: ${unknown.text} — the reader does not model it, and a silently dropped construct is how a grammar change becomes wrong output instead of a build stop.`);
         }
     }
-    // Task 4's cross-check, run from the SURFACE's own `createOptional` bit. The
-    // marker is one bit over several causes and is never read as a trait; this is
-    // the one direction it is read in.
     const createOptional = Object.entries(exposed.scalarFields)
         .filter(([, scalar]) => scalar.createOptional)
         .map(([name]) => name);
@@ -300,36 +245,16 @@ function composeResource(input) {
         resource: {
             fields,
             identifiers: members,
-            // The §8.3 gate's single home. Composition supplies its three inputs and
-            // omits nothing itself.
             operations: deriveResourceOperations({
                 operations: exposed.operations,
                 identifiers: members,
                 transactions: input.transactions,
             }),
         },
-        // The same list's other projection: `members` above, the whole address here.
         translation: { identifierKeys: identifiers.identifiers },
         referentialActions: { owningEdges },
     };
 }
-/* ------------------------------------------------------------------ *
- * The scalar registry                                                *
- * ------------------------------------------------------------------ */
-/**
- * The Aventara scalar identities the discovered fields actually use, in core's
- * own `BUILT_IN_SCALARS` declaration order.
- *
- * Ordered by the union rather than by field declaration order for the reason
- * `capability.deriver.ts` orders its lists that way: the canonical form must be a
- * property of the model and not of how a schema happened to be written. (The
- * emitted artifact is canonicalized again before hashing, so this order is for
- * readers of the model in memory; it costs nothing and removes a question.)
- *
- * An enum-backed column contributes NO scalar: C-810 makes it a ScalarField whose
- * type ref takes the `enum` arm, and the enum registry is where its identity
- * lives.
- */
 function composeScalarRegistry(used) {
     const scalars = {};
     for (const scalar of BUILT_IN_SCALARS) {

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

@@ -1,22 +1,11 @@
 import type { AdapterResource, ResourceOperations, TransactionCapability } from "@aventara/core";
 import type { PrismaAdapterModel } from "./discovery-artifact.interface.js";
 /**
- * T-6 — `deriveResourceOperations`, **the single home of the §8.3 gate**.
- *
- * §8.3: *"an adapter … MUST advertise the variant only when it can preserve
- * framework semantics atomically enough for the provider… If the provider cannot
- * guarantee the required semantics, the variant is omitted."* Every omission in
- * Phase 8 is decided here. No mapper, no discoverer, no emitter and no executor
- * may drop a variant, because an omission in two places is an omission nobody can
- * audit.
+ * No mapper, no discoverer, no emitter and no executor may drop a variant, because
+ * an omission in two places is an omission nobody can audit.
  *
  * # Three inputs, and `provider` is not one of them
  *
- * The available operation set is read from the client's own `<M>Delegate` (T-3) —
- * at 7.10.0, identically on both Phase 8 engines and on all six models (four
- * when this was first measured; re-measured over `User` and `Profile` too when
- * the one-to-one fixture landed, and the set is unchanged):
- *
  * ```text
  * findUnique, findUniqueOrThrow, findFirst, findFirstOrThrow, findMany, create,
  * createMany, createManyAndReturn, delete, update, deleteMany, updateMany,
@@ -29,46 +18,29 @@ import type { PrismaAdapterModel } from "./discovery-artifact.interface.js";
  * needs. The whole `PrismaProviderProfile` is deliberately NOT accepted: it
  * carries `provider`, and a module that cannot be handed a provider cannot branch
  * on one (dictionary invariant 6). `isolationLevels` is not a precondition of any
- * variant (C-830: Phase 8 escalates no isolation).
+ * variant.
  *
  * `supportsEmulatedFirstVariants` is **derived, exactly `transactions !== "none"`,
- * and stored nowhere** (T-2's amendment, D-824). A stored copy would be a second
- * source of truth for a one-line derivation.
+ * and stored nowhere**. A stored copy would be a second source of truth for a
+ * one-line derivation.
  *
  * # What is NOT gated here, and why that is deliberate
  *
- * `delete.many` is absent on **every** profile (C-829, D-826): 7.10.0 has no
- * `deleteManyAndReturn`, the architect ruled the variant omitted rather than
- * emulated, and the omission does **not** vary with `transactions`. Pairing it
- * with the emulation gate would re-teach the read-capability-depends-on-
- * transaction-capability coupling C-829 records as no longer existing.
- *
- * The first-style variants' preconditions are the **read**, an identifier, a
- * transaction — the three `emulatedFirst` carries, because all three are shared —
- * and then **the chosen route's own write call**, which each family contributes
- * itself. §14e's route is **Route A**: the read selects the identifier and the
- * write is Prisma's own `update`/`delete` narrowed to it with the caller's
- * predicate re-asserted under `AND`. Task 10 measured both routes on the real
- * 7.10.0 client on both engines, every row came out for Route A, and the choice is
- * propagated across the 21 rows of `translation/operation.translator.ts`'s table;
- * `FIRST_VARIANT_WRITE_ROUTE` there is the one cell that names it.
- *
  * So `update.first` reads `emulatedFirst && exposes("update")` and `delete.first`
  * reads `emulatedFirst && exposes("delete")`. Under Route B those cells would read
  * `updateManyAndReturn` and `deleteMany` instead — which is exactly why the write
- * call is NOT folded into `emulatedFirst`: a shared precondition naming one route's
- * call would assert a gate the other route does not have, an assertion that cannot
- * fail for the right reason (C-817, T-7.1.1). A reversal of §14e is an edit to
- * these two cells and to the translator's one, and to nothing else here.
+ * call is NOT folded into `emulatedFirst`: a shared precondition naming one
+ * route's call would assert a gate the other route does not have, an assertion
+ * that cannot fail for the right reason.
  */
 /** Core's own identifier tuples for a discovered Resource. */
 type DiscoveredIdentifiers = AdapterResource<PrismaAdapterModel>["identifiers"];
 export type ResourceOperationsInput = {
-    /** `<M>Delegate`'s own methods, as the types reader read them (T-3). */
+    /** `<M>Delegate`'s own methods, as the types reader read them. */
     readonly operations: readonly string[];
     /** The model's usable identifiers; empty means no unique addressing exists. */
     readonly identifiers: DiscoveredIdentifiers;
-    /** The one declared profile row this gate reads (T-2's amendment). */
+    /** The one declared profile row this gate reads. */
     readonly transactions: TransactionCapability;
 };
 export declare function deriveResourceOperations(input: ResourceOperationsInput): ResourceOperations;

package/dist/discovery/operations.deriver.js

@@ -1,50 +1,14 @@
-/* ------------------------------------------------------------------ *
- * The scopes each advertised variant qualifies its arguments with      *
- * ------------------------------------------------------------------ */
-/**
- * The scope follows the **Prisma call the gate below routes the variant to**, and
- * those calls fall into four argument shapes. The scope therefore sits beside the
- * gate that chose the call, where a reversal of §14e's route is visible as an edit
- * to one cell — not in a constant in core, which would be a tabulated provider fact
- * and wrong for the next adapter (D-802, §4 Q2).
- *
- * **The narrowest honest encoding (F-821).** Two of the four shapes are the
- * unrestricted positions — the `"record"` projection and the `"nested"` data
- * argument — which is exactly what core's readers (`projectionScopeOf`,
- * `writeScopeOf`) answer for `true`. A descriptor stating them carries no
- * information: core's canonicalizer collapsed it before any Contract value or
- * hash, but it lengthened the artifact and moved its `modelHash`. So those
- * variants are `true`, and a descriptor is stated only where it narrows: the two
- * bulk shapes. `true` also stays the answer for the variants with no
- * scope-qualified argument at all (`count` / `deleteMany` return a number, and the
- * delete family has no data argument) — `OperationVariantScopes` requires at least
- * one scope, so nothing else is representable there.
- */
-/**
- * A row-returning read (`findFirst`, `findUnique`, `findMany`), and a
- * row-returning write or delete of ONE addressed record (`create`, `update`,
- * `upsert`, `delete`, and the emulated first-style variants, whose §14e Route A
- * write is Prisma's own `update` / `delete` narrowed to the identifier): the
- * unrestricted projection and, for a write, the nested data argument — what
- * `true` already means.
- */
 const SINGLE_RECORD = true;
-/** `createManyAndReturn` / `updateManyAndReturn`: both axes are the bulk ones. */
 const WRITES_MANY_AND_RETURNS = {
     projection: "bulkWrite",
     write: "bulkWrite",
 };
-/** `createMany` / `updateMany`: the same flat data argument, and no projection. */
 const WRITES_MANY_AND_COUNTS = { write: "bulkWrite" };
-/** `count` / `deleteMany`: no projection argument and no data argument. */
 const QUALIFIES_NO_ARGUMENT = true;
 export function deriveResourceOperations(input) {
     const exposes = (method) => input.operations.includes(method);
     const addressable = input.identifiers.length > 0;
-    // Derived, never stored: the emulated read-then-write sequence runs inside one
-    // interactive transaction (D-807), so a driver without one cannot carry it.
     const emulates = input.transactions !== "none";
-    /** A first-style variant is a read, an identifier to write by, and a transaction. */
     const emulatedFirst = exposes("findFirst") && addressable && emulates;
     const find = {
         ...(exposes("findFirst") ? { first: SINGLE_RECORD } : {}),
@@ -54,7 +18,6 @@ export function deriveResourceOperations(input) {
     };
     const create = {
         ...(exposes("create") ? { one: SINGLE_RECORD } : {}),
-        // C-817: the row-returning bulk write is what `create.many` owes its caller.
         ...(exposes("createManyAndReturn")
             ? { many: WRITES_MANY_AND_RETURNS }
             : {}),
@@ -71,8 +34,6 @@ export function deriveResourceOperations(input) {
     const remove = {
         ...(emulatedFirst && exposes("delete") ? { first: SINGLE_RECORD } : {}),
         ...(exposes("delete") && addressable ? { unique: SINGLE_RECORD } : {}),
-        // `many` is ABSENT unconditionally (C-829). `delete.count` is the supported
-        // way to delete a filtered set.
         ...(exposes("deleteMany") ? { count: QUALIFIES_NO_ARGUMENT } : {}),
     };
     const upsert = {
@@ -86,7 +47,6 @@ export function deriveResourceOperations(input) {
         ...(nonEmpty(upsert) ? { upsert } : {}),
     };
 }
-/** A family with no available variant is absent, not an empty object. */
 function nonEmpty(family) {
     return Object.keys(family).length > 0;
 }