@aventara/core 0.1.0-pilot.4 → 1.0.0-rc.0

package/dist/runtime/scalar-runtime.js

@@ -1,6 +1,7 @@
-import { lookupField, lookupResource } from "../contracts/contract-lookup.js";
+import { lookupField, lookupOwn, lookupResource, } from "../contracts/contract-lookup.js";
 import { decodeBase64, WIRE_SCALAR_PATTERNS, } from "../contracts/wire-scalar-format.js";
-import { routeTransactionReferenceCandidate } from "../transactions/transaction-reference.js";
+import { shapeOfField } from "../json/json-shape.registry.js";
+import { routeTransactionReferenceCandidate, } from "../transactions/transaction-reference.js";
 import { Decimal } from "./decimal.js";
 const INT_MIN = -(2 ** 31);
 const INT_MAX = 2 ** 31 - 1;
@@ -26,8 +27,9 @@ function typeIssue(path, expected) {
 function formatIssue(path, expected) {
     return issue("V1003", path, `Value must use ${expected}.`);
 }
+let writeInPlace = false;
 function cloneRecord(value) {
-    return { ...value };
+    return writeInPlace ? value : { ...value };
 }
 function materializeJsonPath(root, link) {
     const segments = [];
@@ -125,7 +127,7 @@ function normalizeJsonValue(value, path, seen) {
     }
     return issues.length > 0 ? { ok: false, issues } : { ok: true, value: root };
 }
-function normalizeScalarAtom(contract, field, value, scope, path, allowNull) {
+function normalizeScalarAtom(contract, field, value, origin, path, allowNull) {
     if (value === null) {
         return allowNull
             ? { ok: true, value: null }
@@ -195,7 +197,7 @@ function normalizeScalarAtom(contract, field, value, scope, path, allowNull) {
             }
             break;
         case "bigint":
-            if (scope === "application") {
+            if (origin === "application") {
                 normalized =
                     typeof value === "bigint"
                         ? { ok: true, value }
@@ -228,7 +230,7 @@ function normalizeScalarAtom(contract, field, value, scope, path, allowNull) {
             }
             break;
         case "decimal":
-            if (scope === "application") {
+            if (origin === "application") {
                 normalized =
                     value instanceof Decimal
                         ? { ok: true, value }
@@ -253,7 +255,7 @@ function normalizeScalarAtom(contract, field, value, scope, path, allowNull) {
             }
             break;
         case "datetime":
-            if (scope === "application") {
+            if (origin === "application") {
                 if (!(value instanceof Date)) {
                     normalized = { ok: false, issues: [typeIssue(path, "a Date")] };
                 }
@@ -289,7 +291,7 @@ function normalizeScalarAtom(contract, field, value, scope, path, allowNull) {
             }
             break;
         case "bytes":
-            if (scope === "application") {
+            if (origin === "application") {
                 normalized =
                     value instanceof Uint8Array
                         ? { ok: true, value }
@@ -334,7 +336,7 @@ function normalizeScalarAtom(contract, field, value, scope, path, allowNull) {
     }
     return normalized;
 }
-export function normalizeScalarFieldValue(contract, field, value, scope, path) {
+export function normalizeScalarFieldValue(contract, field, value, origin, path) {
     if (value === null) {
         return field.nullable
             ? { ok: true, value: null }
@@ -347,7 +349,7 @@ export function normalizeScalarFieldValue(contract, field, value, scope, path) {
         const normalized = [];
         const issues = [];
         value.forEach((entry, index) => {
-            const result = normalizeScalarAtom(contract, field, entry, scope === "runtime" ? "application" : scope, [...path, index], false);
+            const result = normalizeScalarAtom(contract, field, entry, origin === "runtime" ? "application" : origin, [...path, index], false);
             if (result.ok) {
                 normalized.push(result.value);
             }
@@ -359,7 +361,41 @@ export function normalizeScalarFieldValue(contract, field, value, scope, path) {
             ? { ok: false, issues }
             : { ok: true, value: normalized };
     }
-    return normalizeScalarAtom(contract, field, value, scope === "runtime" ? "application" : scope, path, field.nullable);
+    return normalizeScalarAtom(contract, field, value, origin === "runtime" ? "application" : origin, path, field.nullable);
+}
+export function jsonShapeIssues(field, value, path, position = "value") {
+    if (field.json === undefined || value === null || value === undefined) {
+        return [];
+    }
+    const shape = shapeOfField(field);
+    if (shape === undefined) {
+        throw new Error("a shaped Json field reached validation with no shape bound to it");
+    }
+    const at = (entry, entryPath) => shape.validate(entry).map((found) => ({
+        ...found,
+        path: [...entryPath, ...(found.path ?? [])],
+    }));
+    return field.list && position === "value" && Array.isArray(value)
+        ? value.flatMap((entry, index) => at(entry, [...path, index]))
+        : at(value, path);
+}
+function normalizeWrittenValue(contract, field, value, origin, path, issues) {
+    const result = normalizeScalarFieldValue(contract, field, value, origin, path);
+    if (!result.ok) {
+        issues.push(...result.issues);
+        return undefined;
+    }
+    issues.push(...jsonShapeIssues(field, result.value, path));
+    return result.value;
+}
+function normalizeWrittenElement(contract, field, value, origin, path, issues) {
+    const result = normalizeListElement(contract, field, value, origin, path);
+    if (!result.ok) {
+        issues.push(...result.issues);
+        return undefined;
+    }
+    issues.push(...jsonShapeIssues(field, result.value, path, "entry"));
+    return result.value;
 }
 const SCALAR_ATOM_COPIERS = {
     string: (value) => value,
@@ -390,8 +426,8 @@ export function copyScalarFieldValue(field, value) {
     }
     return items;
 }
-function normalizeListElement(contract, field, value, scope, path) {
-    return normalizeScalarAtom(contract, field, value, scope, path, false);
+function normalizeListElement(contract, field, value, origin, path) {
+    return normalizeScalarAtom(contract, field, value, origin, path, false);
 }
 function mergeResult(result, issues) {
     if (result.ok) {
@@ -400,9 +436,41 @@ function mergeResult(result, issues) {
     issues.push(...result.issues);
     return undefined;
 }
-function normalizeScalarFilter(contract, field, value, scope, path, issues) {
+export const REFERENCE_OPERANDS = Object.freeze({
+    equals: "value",
+    not: "value",
+    lt: "nonNullValue",
+    lte: "nonNullValue",
+    gt: "nonNullValue",
+    gte: "nonNullValue",
+    contains: "nonNullValue",
+    startsWith: "nonNullValue",
+    endsWith: "nonNullValue",
+    has: "entry",
+    in: "entries",
+    notIn: "entries",
+    hasEvery: "entries",
+    hasSome: "entries",
+});
+export function referenceOperandShape(operator) {
+    return lookupOwn(REFERENCE_OPERANDS, operator);
+}
+function acceptsNullOperand(operator) {
+    return NULL_OPERAND_OPERATORS.has(operator);
+}
+const NULL_OPERAND_OPERATORS = new Set([
+    "equals",
+    "not",
+    "arrayContains",
+    "arrayStartsWith",
+    "arrayEndsWith",
+]);
+function normalizeScalarFilter(contract, field, value, origin, path, issues, references = false) {
+    if (isKeptReference(references, value)) {
+        return value;
+    }
     if (!isPlainRecord(value)) {
-        return mergeResult(normalizeScalarFieldValue(contract, field, value, scope, path), issues);
+        return mergeResult(normalizeScalarFieldValue(contract, field, value, origin, path), issues);
     }
     const keys = Object.keys(value);
     if (keys.length === 0 || !keys.some((key) => key in value)) {
@@ -411,11 +479,19 @@ function normalizeScalarFilter(contract, field, value, scope, path, issues) {
     const normalized = cloneRecord(value);
     for (const [operator, operand] of Object.entries(value)) {
         const operandPath = [...path, operator];
+        if (operand === null && !acceptsNullOperand(operator)) {
+            issues.push(typeIssue(operandPath, "non-null"));
+            continue;
+        }
         if (operator === "mode" || operator === "isEmpty" || operator === "path") {
             continue;
         }
+        if (referenceOperandShape(operator) !== undefined &&
+            isKeptReference(references, operand)) {
+            continue;
+        }
         if (operator === "not" && isPlainRecord(operand)) {
-            normalized[operator] = normalizeScalarFilter(contract, field, operand, scope, operandPath, issues);
+            normalized[operator] = normalizeScalarFilter(contract, field, operand, origin, operandPath, issues, references);
             continue;
         }
         if (operator === "in" || operator === "notIn") {
@@ -423,14 +499,14 @@ function normalizeScalarFilter(contract, field, value, scope, path, issues) {
                 issues.push(typeIssue(operandPath, "an array"));
                 continue;
             }
-            normalized[operator] = operand.map((entry, index) => mergeResult(normalizeListElement(contract, field, entry, scope, [
+            normalized[operator] = operand.map((entry, index) => mergeResult(normalizeListElement(contract, field, entry, origin, [
                 ...operandPath,
                 index,
             ]), issues));
             continue;
         }
         if (operator === "has") {
-            normalized[operator] = mergeResult(normalizeListElement(contract, field, operand, scope, operandPath), issues);
+            normalized[operator] = mergeResult(normalizeListElement(contract, field, operand, origin, operandPath), issues);
             continue;
         }
         if (operator === "hasEvery" || operator === "hasSome") {
@@ -438,7 +514,7 @@ function normalizeScalarFilter(contract, field, value, scope, path, issues) {
                 issues.push(typeIssue(operandPath, "an array"));
                 continue;
             }
-            normalized[operator] = operand.map((entry, index) => mergeResult(normalizeListElement(contract, field, entry, scope, [
+            normalized[operator] = operand.map((entry, index) => mergeResult(normalizeListElement(contract, field, entry, origin, [
                 ...operandPath,
                 index,
             ]), issues));
@@ -451,11 +527,11 @@ function normalizeScalarFilter(contract, field, value, scope, path, issues) {
             normalized[operator] = mergeResult(jsonResult, issues);
             continue;
         }
-        normalized[operator] = mergeResult(normalizeScalarFieldValue(contract, field, operand, scope, operandPath), issues);
+        normalized[operator] = mergeResult(normalizeScalarFieldValue(contract, field, operand, origin, operandPath), issues);
     }
     return normalized;
 }
-function normalizeWhere(contract, resourceName, where, scope, path, issues) {
+function normalizeWhere(contract, resourceName, where, origin, path, issues, references = false) {
     if (!isPlainRecord(where)) {
         return where;
     }
@@ -467,28 +543,28 @@ function normalizeWhere(contract, resourceName, where, scope, path, issues) {
     for (const [key, value] of Object.entries(where)) {
         if (key === "AND" || key === "OR") {
             if (Array.isArray(value)) {
-                normalized[key] = value.map((entry, index) => normalizeWhere(contract, resourceName, entry, scope, [...path, key, index], issues));
+                normalized[key] = value.map((entry, index) => normalizeWhere(contract, resourceName, entry, origin, [...path, key, index], issues, references));
             }
             continue;
         }
         if (key === "NOT") {
-            normalized[key] = normalizeWhere(contract, resourceName, value, scope, [...path, key], issues);
+            normalized[key] = normalizeWhere(contract, resourceName, value, origin, [...path, key], issues, references);
             continue;
         }
         const field = lookupField(resource, key);
         if (field?.kind === "scalar") {
-            normalized[key] = normalizeScalarFilter(contract, field, value, scope, [...path, key], issues);
+            normalized[key] = normalizeScalarFilter(contract, field, value, origin, [...path, key], issues, references);
             continue;
         }
         if (field?.kind === "relation" && isPlainRecord(value)) {
             if (field.cardinality === "one") {
-                normalized[key] = normalizeWhere(contract, field.target, value, scope, [...path, key], issues);
+                normalized[key] = normalizeWhere(contract, field.target, value, origin, [...path, key], issues, references);
             }
             else {
                 const relationValue = cloneRecord(value);
                 for (const relationOperator of ["some", "every", "none"]) {
                     if (relationOperator in value) {
-                        relationValue[relationOperator] = normalizeWhere(contract, field.target, value[relationOperator], scope, [...path, key, relationOperator], issues);
+                        relationValue[relationOperator] = normalizeWhere(contract, field.target, value[relationOperator], origin, [...path, key, relationOperator], issues, references);
                     }
                 }
                 normalized[key] = relationValue;
@@ -497,7 +573,10 @@ function normalizeWhere(contract, resourceName, where, scope, path, issues) {
     }
     return normalized;
 }
-function normalizeUniqueSelector(contract, resourceName, selector, scope, path, issues) {
+function isKeptReference(references, value) {
+    return (references && routeTransactionReferenceCandidate(value).kind !== "ordinary");
+}
+function normalizeUniqueSelector(contract, resourceName, selector, origin, path, issues, references = false) {
     if (!isPlainRecord(selector)) {
         return selector;
     }
@@ -508,8 +587,8 @@ function normalizeUniqueSelector(contract, resourceName, selector, scope, path,
     const normalized = cloneRecord(selector);
     for (const [fieldName, value] of Object.entries(selector)) {
         const field = lookupField(resource, fieldName);
-        if (field?.kind === "scalar") {
-            normalized[fieldName] = mergeResult(normalizeScalarFieldValue(contract, field, value, scope, [
+        if (field?.kind === "scalar" && !isKeptReference(references, value)) {
+            normalized[fieldName] = mergeResult(normalizeScalarFieldValue(contract, field, value, origin, [
                 ...path,
                 fieldName,
             ]), issues);
@@ -517,28 +596,28 @@ function normalizeUniqueSelector(contract, resourceName, selector, scope, path,
     }
     return normalized;
 }
-function normalizeCursor(contract, resourceName, cursor, scope, path, issues) {
-    return normalizeUniqueSelector(contract, resourceName, cursor, scope, path, issues);
+function normalizeCursor(contract, resourceName, cursor, origin, path, issues, references = false) {
+    return normalizeUniqueSelector(contract, resourceName, cursor, origin, path, issues, references);
 }
-function normalizeRelationProjection(contract, edge, value, scope, path, issues) {
+function normalizeRelationProjection(contract, edge, value, origin, path, issues) {
     if (!isPlainRecord(value)) {
         return value;
     }
     const normalized = cloneRecord(value);
     if ("where" in value) {
-        normalized.where = normalizeWhere(contract, edge.target, value.where, scope, [...path, "where"], issues);
+        normalized.where = normalizeWhere(contract, edge.target, value.where, origin, [...path, "where"], issues);
     }
     if ("cursor" in value) {
-        normalized.cursor = normalizeCursor(contract, edge.target, value.cursor, scope, [...path, "cursor"], issues);
+        normalized.cursor = normalizeCursor(contract, edge.target, value.cursor, origin, [...path, "cursor"], issues);
     }
     for (const mode of ["select", "include"]) {
         if (mode in value) {
-            normalized[mode] = normalizeProjection(contract, edge.target, value[mode], scope, [...path, mode], issues);
+            normalized[mode] = normalizeProjection(contract, edge.target, value[mode], origin, [...path, mode], issues);
         }
     }
     return normalized;
 }
-function normalizeProjection(contract, resourceName, projection, scope, path, issues) {
+function normalizeProjection(contract, resourceName, projection, origin, path, issues) {
     if (!Array.isArray(projection)) {
         return projection;
     }
@@ -559,23 +638,20 @@ function normalizeProjection(contract, resourceName, projection, scope, path, is
             return entry;
         }
         return {
-            [relationName]: normalizeRelationProjection(contract, edge, entry[relationName], scope, [...path, index, relationName], issues),
+            [relationName]: normalizeRelationProjection(contract, edge, entry[relationName], origin, [...path, index, relationName], issues),
         };
     });
 }
-function normalizeScalarMutation(contract, field, value, scope, path, issues, transactionReferences = false) {
-    if (transactionReferences) {
-        const route = routeTransactionReferenceCandidate(value);
-        if (route.kind !== "ordinary") {
-            return value;
-        }
+function normalizeScalarMutation(contract, field, value, origin, path, issues, transactionReferences = false) {
+    if (isKeptReference(transactionReferences, value)) {
+        return value;
     }
     if (!isPlainRecord(value)) {
-        return mergeResult(normalizeScalarFieldValue(contract, field, value, scope, path), issues);
+        return normalizeWrittenValue(contract, field, value, origin, path, issues);
     }
     const directiveKeys = Object.keys(value).filter((key) => key.startsWith("$"));
     if (directiveKeys.length === 0) {
-        return mergeResult(normalizeScalarFieldValue(contract, field, value, scope, path), issues);
+        return normalizeWrittenValue(contract, field, value, origin, path, issues);
     }
     const normalized = cloneRecord(value);
     for (const [directive, operand] of Object.entries(value)) {
@@ -585,21 +661,18 @@ function normalizeScalarMutation(contract, field, value, scope, path, issues, tr
         }
         if (directive === "$push" && field.list) {
             if (Array.isArray(operand)) {
-                normalized[directive] = operand.map((entry, index) => mergeResult(normalizeListElement(contract, field, entry, scope, [
-                    ...operandPath,
-                    index,
-                ]), issues));
+                normalized[directive] = operand.map((entry, index) => normalizeWrittenElement(contract, field, entry, origin, [...operandPath, index], issues));
             }
             else {
-                normalized[directive] = mergeResult(normalizeListElement(contract, field, operand, scope, operandPath), issues);
+                normalized[directive] = normalizeWrittenElement(contract, field, operand, origin, operandPath, issues);
             }
             continue;
         }
-        normalized[directive] = mergeResult(normalizeListElement(contract, field, operand, scope, operandPath), issues);
+        normalized[directive] = mergeResult(normalizeListElement(contract, field, operand, origin, operandPath), issues);
     }
     return normalized;
 }
-function normalizeRelationMutation(contract, edge, value, scope, path, issues) {
+function normalizeRelationMutation(contract, edge, value, origin, path, issues, references = false) {
     if (!isPlainRecord(value)) {
         return value;
     }
@@ -612,8 +685,8 @@ function normalizeRelationMutation(contract, edge, value, scope, path, issues) {
         if (directive === "$create") {
             normalized[directive] =
                 edge.cardinality === "many" && Array.isArray(operand)
-                    ? entries.map((entry, index) => normalizeMutationData(contract, edge.target, entry, scope, [...directivePath, index], issues))
-                    : normalizeMutationData(contract, edge.target, operand, scope, directivePath, issues);
+                    ? entries.map((entry, index) => normalizeMutationData(contract, edge.target, entry, origin, [...directivePath, index], issues, references))
+                    : normalizeMutationData(contract, edge.target, operand, origin, directivePath, issues, references);
             continue;
         }
         if (directive === "$connect" || directive === "$set") {
@@ -621,8 +694,8 @@ function normalizeRelationMutation(contract, edge, value, scope, path, issues) {
                 continue;
             }
             normalized[directive] = Array.isArray(operand)
-                ? operand.map((entry, index) => normalizeUniqueSelector(contract, edge.target, entry, scope, [...directivePath, index], issues))
-                : normalizeUniqueSelector(contract, edge.target, operand, scope, directivePath, issues);
+                ? operand.map((entry, index) => normalizeUniqueSelector(contract, edge.target, entry, origin, [...directivePath, index], issues, references))
+                : normalizeUniqueSelector(contract, edge.target, operand, origin, directivePath, issues, references);
             continue;
         }
         if (directive === "$disconnect") {
@@ -630,8 +703,8 @@ function normalizeRelationMutation(contract, edge, value, scope, path, issues) {
                 continue;
             }
             normalized[directive] = Array.isArray(operand)
-                ? operand.map((entry, index) => normalizeUniqueSelector(contract, edge.target, entry, scope, [...directivePath, index], issues))
-                : normalizeUniqueSelector(contract, edge.target, operand, scope, directivePath, issues);
+                ? operand.map((entry, index) => normalizeUniqueSelector(contract, edge.target, entry, origin, [...directivePath, index], issues, references))
+                : normalizeUniqueSelector(contract, edge.target, operand, origin, directivePath, issues, references);
             continue;
         }
         if (directive === "$connectOrCreate") {
@@ -641,8 +714,8 @@ function normalizeRelationMutation(contract, edge, value, scope, path, issues) {
                 }
                 return {
                     ...entry,
-                    where: normalizeUniqueSelector(contract, edge.target, entry.where, scope, [...directivePath, index, "where"], issues),
-                    create: normalizeMutationData(contract, edge.target, entry.create, scope, [...directivePath, index, "create"], issues),
+                    where: normalizeUniqueSelector(contract, edge.target, entry.where, origin, [...directivePath, index, "where"], issues, references),
+                    create: normalizeMutationData(contract, edge.target, entry.create, origin, [...directivePath, index, "create"], issues, references),
                 };
             });
             normalized[directive] =
@@ -660,10 +733,10 @@ function normalizeRelationMutation(contract, edge, value, scope, path, issues) {
                     ...entry,
                     ...(entry.where !== undefined
                         ? {
-                            where: normalizeWhere(contract, edge.target, entry.where, scope, [...directivePath, index, "where"], issues),
+                            where: normalizeWhere(contract, edge.target, entry.where, origin, [...directivePath, index, "where"], issues, references),
                         }
                         : {}),
-                    data: normalizeMutationData(contract, edge.target, entry.data, scope, [...directivePath, index, "data"], issues),
+                    data: normalizeMutationData(contract, edge.target, entry.data, origin, [...directivePath, index, "data"], issues, references),
                 };
             });
             normalized[directive] =
@@ -679,7 +752,7 @@ function normalizeRelationMutation(contract, edge, value, scope, path, issues) {
                 }
                 return {
                     ...entry,
-                    where: normalizeWhere(contract, edge.target, entry.where, scope, [...directivePath, index, "where"], issues),
+                    where: normalizeWhere(contract, edge.target, entry.where, origin, [...directivePath, index, "where"], issues, references),
                 };
             });
             normalized[directive] =
@@ -697,11 +770,11 @@ function normalizeRelationMutation(contract, edge, value, scope, path, issues) {
                     ...entry,
                     ...(entry.where !== undefined
                         ? {
-                            where: normalizeUniqueSelector(contract, edge.target, entry.where, scope, [...directivePath, index, "where"], issues),
+                            where: normalizeUniqueSelector(contract, edge.target, entry.where, origin, [...directivePath, index, "where"], issues, references),
                         }
                         : {}),
-                    create: normalizeMutationData(contract, edge.target, entry.create, scope, [...directivePath, index, "create"], issues),
-                    update: normalizeMutationData(contract, edge.target, entry.update, scope, [...directivePath, index, "update"], issues),
+                    create: normalizeMutationData(contract, edge.target, entry.create, origin, [...directivePath, index, "create"], issues, references),
+                    update: normalizeMutationData(contract, edge.target, entry.update, origin, [...directivePath, index, "update"], issues, references),
                 };
             });
             normalized[directive] =
@@ -712,7 +785,7 @@ function normalizeRelationMutation(contract, edge, value, scope, path, issues) {
     }
     return normalized;
 }
-function normalizeMutationData(contract, resourceName, data, scope, path, issues, transactionReferences = false) {
+function normalizeMutationData(contract, resourceName, data, origin, path, issues, transactionReferences = false) {
     if (!isPlainRecord(data)) {
         return data;
     }
@@ -724,10 +797,10 @@ function normalizeMutationData(contract, resourceName, data, scope, path, issues
     for (const [fieldName, value] of Object.entries(data)) {
         const field = lookupField(resource, fieldName);
         if (field?.kind === "scalar") {
-            normalized[fieldName] = normalizeScalarMutation(contract, field, value, scope, [...path, fieldName], issues, transactionReferences);
+            normalized[fieldName] = normalizeScalarMutation(contract, field, value, origin, [...path, fieldName], issues, transactionReferences);
         }
         else if (field?.kind === "relation") {
-            normalized[fieldName] = normalizeRelationMutation(contract, field, value, scope, [...path, fieldName], issues);
+            normalized[fieldName] = normalizeRelationMutation(contract, field, value, origin, [...path, fieldName], issues, transactionReferences);
         }
     }
     return normalized;
@@ -739,36 +812,46 @@ function isUniqueOperation(request) {
             request.family === "delete" ||
             request.family === "upsert"));
 }
-export function normalizeOperationScalarValues(contract, request, scope, options) {
+export function normalizeOperationScalarValues(contract, request, origin, options, write = "copy") {
+    const previous = writeInPlace;
+    writeInPlace = write === "in-place";
+    try {
+        return normalizeArguments(contract, request, origin, options);
+    }
+    finally {
+        writeInPlace = previous;
+    }
+}
+function normalizeArguments(contract, request, origin, options) {
     const issues = [];
     const args = cloneRecord(request.arguments);
     if ("where" in args) {
         args.where = isUniqueOperation(request)
-            ? normalizeUniqueSelector(contract, request.resource, args.where, scope, ["arguments", "where"], issues)
-            : normalizeWhere(contract, request.resource, args.where, scope, ["arguments", "where"], issues);
+            ? normalizeUniqueSelector(contract, request.resource, args.where, origin, ["arguments", "where"], issues, options?.transactionReferences === true)
+            : normalizeWhere(contract, request.resource, args.where, origin, ["arguments", "where"], issues, options?.transactionReferences === true);
     }
     if ("cursor" in args) {
-        args.cursor = normalizeCursor(contract, request.resource, args.cursor, scope, ["arguments", "cursor"], issues);
+        args.cursor = normalizeCursor(contract, request.resource, args.cursor, origin, ["arguments", "cursor"], issues, options?.transactionReferences === true);
     }
     for (const mode of ["select", "include"]) {
         if (mode in args) {
-            args[mode] = normalizeProjection(contract, request.resource, args[mode], scope, ["arguments", mode], issues);
+            args[mode] = normalizeProjection(contract, request.resource, args[mode], origin, ["arguments", mode], issues);
         }
     }
     if (request.family === "create" && "data" in args) {
         args.data = Array.isArray(args.data)
-            ? args.data.map((entry, index) => normalizeMutationData(contract, request.resource, entry, scope, ["arguments", "data", index], issues, options?.transactionReferences === true))
-            : normalizeMutationData(contract, request.resource, args.data, scope, ["arguments", "data"], issues, options?.transactionReferences === true);
+            ? args.data.map((entry, index) => normalizeMutationData(contract, request.resource, entry, origin, ["arguments", "data", index], issues, options?.transactionReferences === true))
+            : normalizeMutationData(contract, request.resource, args.data, origin, ["arguments", "data"], issues, options?.transactionReferences === true);
     }
     if (request.family === "update" && "data" in args) {
-        args.data = normalizeMutationData(contract, request.resource, args.data, scope, ["arguments", "data"], issues, options?.transactionReferences === true);
+        args.data = normalizeMutationData(contract, request.resource, args.data, origin, ["arguments", "data"], issues, options?.transactionReferences === true);
     }
     if (request.family === "upsert") {
         if ("create" in args) {
-            args.create = normalizeMutationData(contract, request.resource, args.create, scope, ["arguments", "create"], issues, options?.transactionReferences === true);
+            args.create = normalizeMutationData(contract, request.resource, args.create, origin, ["arguments", "create"], issues, options?.transactionReferences === true);
         }
         if ("update" in args) {
-            args.update = normalizeMutationData(contract, request.resource, args.update, scope, ["arguments", "update"], issues, options?.transactionReferences === true);
+            args.update = normalizeMutationData(contract, request.resource, args.update, origin, ["arguments", "update"], issues, options?.transactionReferences === true);
         }
     }
     return issues.length > 0

package/dist/transactions/transaction-plan-assembler.d.ts

@@ -1,6 +1,8 @@
 import type { FrameworkContracts } from "../compiler/contract.compiler.js";
 import type { RequestOrigin } from "../config/config-layer.js";
 import type { OperationIdentity } from "../operations/operation-identity.js";
+import type { CallerDataError } from "../runtime/caller-data.copier.js";
+import type { MisuseReporter } from "../runtime/misuse-reporter.js";
 import type { ClientProtocolIdentity } from "../runtime/operation-request.js";
 import type { OperationFailureResponse } from "../runtime/operation-response.js";
 import type { Operation, OperationFingerprint } from "./deferred-operation.js";
@@ -20,6 +22,8 @@ export type AssembledTransactionPlan = {
     };
     /** Each operation's own origin, by index (mixed plans). */
     readonly origins: readonly TransactionOperationOrigin[];
+    /** The steps whose arguments their builder could not copy, by index. */
+    readonly refused: ReadonlyMap<number, CallerDataError>;
 } | {
     readonly ok: false;
     readonly response: OperationFailureResponse;
@@ -35,5 +39,5 @@ export type TransactionPlanAssembler = {
  * handle, so a handle another instance built — typed against another model,
  * bound to other Contracts — is refused rather than run.
  */
-export declare function createTransactionPlanAssembler(contracts: FrameworkContracts, protocol: ClientProtocolIdentity): TransactionPlanAssembler;
+export declare function createTransactionPlanAssembler(contracts: FrameworkContracts, protocol: ClientProtocolIdentity, misuse: MisuseReporter): TransactionPlanAssembler;
 export {};