@aventara/core 1.0.0-rc.1 → 1.0.0-rc.2

package/dist/runtime/readonly-value.d.ts

@@ -1,12 +1,23 @@
 import { AvDecimal } from "./decimal.js";
 /** A value `AvDeepReadonly` leaves as it is: a primitive, a function, or a scalar instance. */
 export type AvDeepReadonlyLeaf = string | number | boolean | bigint | symbol | null | undefined | Date | Uint8Array | AvDecimal | ((...args: never[]) => unknown);
+/**
+ * Whether array type `T` is an open array (every length: `"array"`) or a tuple
+ * (`"tuple"`). A tuple whose only fixed positions are optional ones before a rest
+ * element (`[a?, ...b[]]`) has every length too and reads as an array.
+ */
+export type ArrayForm<T extends readonly unknown[]> = T extends readonly [] | readonly [unknown, ...unknown[]] | readonly [...unknown[], unknown] ? "tuple" : T extends {
+    readonly length: infer Length;
+} ? number extends Length ? "array" : "tuple" : "tuple";
 /**
  * `T` with every property, element and nested property read-only: what a stage
- * that only reads is told. Arrays become read-only arrays; a `Date`, a
- * `Uint8Array`, an `AvDecimal` and functions are left as they are.
+ * that only reads is told. Arrays become read-only arrays, tuples read-only
+ * tuples; a `Date`, a `Uint8Array`, an `AvDecimal` and functions are left as
+ * they are.
  */
-export type AvDeepReadonly<T> = T extends AvDeepReadonlyLeaf ? T : T extends object ? {
+export type AvDeepReadonly<T> = T extends AvDeepReadonlyLeaf ? T : T extends readonly unknown[] ? ArrayForm<T> extends "array" ? readonly AvDeepReadonly<T[number]>[] : {
+    readonly [K in keyof T]: AvDeepReadonly<T[K]>;
+} : T extends object ? {
     readonly [K in keyof T]: AvDeepReadonly<T[K]>;
 } : T;
 /**

package/dist/runtime/readonly-value.js

@@ -36,20 +36,25 @@ function scalarCopy(value) {
     }
     return undefined;
 }
+const SCALAR_FREE = new WeakSet();
 export function frozenCopy(value) {
     const copies = new Map();
+    const walking = new Set();
+    let cycled = false;
     const copy = (current) => {
         const scalar = scalarCopy(current);
         if (scalar !== undefined) {
             return scalar;
         }
-        if (!isContainer(current)) {
+        if (!isContainer(current) || SCALAR_FREE.has(current)) {
             return current;
         }
         if (copies.has(current)) {
+            cycled ||= walking.has(current);
             return copies.get(current);
         }
         copies.set(current, current);
+        walking.add(current);
         const entries = [];
         let changed = !DEEP_FROZEN.has(current);
         for (const key of Reflect.ownKeys(current)) {
@@ -63,8 +68,12 @@ export function frozenCopy(value) {
             changed ||= next !== descriptor.value;
             entries.push([key, descriptor, next]);
         }
+        walking.delete(current);
         if (!changed) {
             copies.set(current, current);
+            if (!cycled) {
+                SCALAR_FREE.add(current);
+            }
             return current;
         }
         const target = Array.isArray(current)

package/dist/runtime/scalar-runtime.d.ts

@@ -1,5 +1,5 @@
 import type { AvRequestOrigin } from "../config/config-layer.js";
-import type { AvScalarFilterOperator } from "../contracts/capability.js";
+import { type AvScalarFilterOperator } from "../contracts/capability.js";
 import type { AvContract } from "../contracts/contract.js";
 import type { AvScalarField } from "../contracts/field.js";
 import type { AvOperationIdentity } from "../operations/operation-identity.js";
@@ -31,6 +31,10 @@ type Path = readonly (string | number)[];
  * one reader and a value to another.
  */
 export declare function isPlainRecord(value: unknown): value is Readonly<Record<string, unknown>>;
+/** What a refused `undefined` the request reads with is told. */
+export declare const UNSENT_READ_VALUE_MESSAGE = "Value must not be undefined: it would be left out, and the request would reach more rows.";
+/** The `V1001` of an `undefined` the request reads with. */
+export declare function unsentReadValueIssue(path: Path): AvValidationIssue;
 /**
  * An operation argument's JSON value is bounded by `maxJsonDepth`, which the
  * structural walk enforces before this runs; a `$sql` step's parameter is not

package/dist/runtime/scalar-runtime.js

@@ -1,13 +1,20 @@
 import { shapeOfField } from "../avz/json-shape.registry.js";
+import { AVZ_FORMATS } from "../config/framework-field-definition.js";
+import { FILTER_MODES, } from "../contracts/capability.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 { AvDecimal } from "./decimal.js";
+import { fieldCheckIssues } from "./field-check.evaluator.js";
 const INT_MIN = -(2 ** 31);
 const INT_MAX = 2 ** 31 - 1;
 const BIGINT_MIN = -(2n ** 63n);
 const BIGINT_MAX = 2n ** 63n - 1n;
 const UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+const NAMED_FORMATS = new Set(AVZ_FORMATS);
+function isNamedFormat(format) {
+    return NAMED_FORMATS.has(format);
+}
 function isRecord(value) {
     return value !== null && typeof value === "object" && !Array.isArray(value);
 }
@@ -24,6 +31,10 @@ function issue(code, path, message) {
 function typeIssue(path, expected) {
     return issue("V1001", path, `Value must be ${expected}.`);
 }
+export const UNSENT_READ_VALUE_MESSAGE = "Value must not be undefined: it would be left out, and the request would reach more rows.";
+export function unsentReadValueIssue(path) {
+    return issue("V1001", path, UNSENT_READ_VALUE_MESSAGE);
+}
 function formatIssue(path, expected) {
     return issue("V1003", path, `Value must use ${expected}.`);
 }
@@ -83,18 +94,14 @@ export function normalizeJsonValue(value, path, seen) {
             const normalized = [];
             task.emit(normalized);
             stack.push({ kind: "leave", container: current });
-            const entries = [];
-            current.forEach((entry, index) => {
-                entries.push([index, entry]);
-            });
-            for (let cursor = entries.length - 1; cursor >= 0; cursor -= 1) {
-                const entry = entries[cursor];
+            for (let index = current.length - 1; index >= 0; index -= 1) {
+                const entry = current[index];
                 stack.push({
                     kind: "visit",
-                    value: entry[1],
-                    link: { parent: task.link, segment: entry[0] },
+                    value: entry === undefined ? null : entry,
+                    link: { parent: task.link, segment: index },
                     emit: (child) => {
-                        normalized.push(child);
+                        normalized[index] = child;
                     },
                 });
             }
@@ -112,7 +119,7 @@ export function normalizeJsonValue(value, path, seen) {
         const normalized = {};
         task.emit(normalized);
         stack.push({ kind: "leave", container: current });
-        const entries = Object.entries(current);
+        const entries = Object.entries(current).filter((entry) => entry[1] !== undefined);
         for (let cursor = entries.length - 1; cursor >= 0; cursor -= 1) {
             const entry = entries[cursor];
             stack.push({
@@ -359,9 +366,21 @@ export function normalizeScalarFieldValue(contract, field, value, origin, path)
         });
         return issues.length > 0
             ? { ok: false, issues }
-            : { ok: true, value: normalized };
+            : heldToFormat(field, { ok: true, value: normalized }, origin, path);
+    }
+    return heldToFormat(field, normalizeScalarAtom(contract, field, value, origin === "runtime" ? "application" : origin, path, field.nullable), origin, path);
+}
+function heldToFormat(field, normalized, origin, path) {
+    const format = field.format;
+    if (origin !== "runtime" ||
+        !normalized.ok ||
+        format === undefined ||
+        format === "uuid" ||
+        !isNamedFormat(format)) {
+        return normalized;
     }
-    return normalizeScalarAtom(contract, field, value, origin === "runtime" ? "application" : origin, path, field.nullable);
+    const issues = fieldCheckIssues([{ check: "string_format", format }], normalized.value, "string", path, field.list);
+    return issues.length === 0 ? normalized : { ok: false, issues };
 }
 export function jsonShapeIssues(field, value, path, position = "value") {
     if (field.json === undefined || value === null || value === undefined) {
@@ -427,6 +446,11 @@ export function copyScalarFieldValue(field, value) {
 function normalizeListElement(contract, field, value, origin, path) {
     return normalizeScalarAtom(contract, field, value, origin, path, false);
 }
+function normalizeFilterEntry(contract, field, value, origin, path) {
+    return value === undefined
+        ? { ok: false, issues: [unsentReadValueIssue(path)] }
+        : normalizeListElement(contract, field, value, origin, path);
+}
 function mergeResult(result, issues) {
     if (result.ok) {
         return result.value;
@@ -463,10 +487,40 @@ const NULL_OPERAND_OPERATORS = new Set([
     "arrayStartsWith",
     "arrayEndsWith",
 ]);
+const KEYWORD_OPERANDS = Object.freeze({
+    mode: (operand, path, issues) => {
+        if (!FILTER_MODES.includes(operand)) {
+            issues.push(typeIssue(path, '"default", "sensitive" or "insensitive"'));
+        }
+    },
+    isEmpty: (operand, path, issues) => {
+        if (typeof operand !== "boolean") {
+            issues.push(typeIssue(path, "a boolean"));
+        }
+    },
+    path: (operand, path, issues) => {
+        if (!Array.isArray(operand)) {
+            issues.push(typeIssue(path, "an array of strings"));
+            return;
+        }
+        for (let index = 0; index < operand.length; index += 1) {
+            if (operand[index] === undefined) {
+                issues.push(unsentReadValueIssue([...path, index]));
+            }
+            else if (typeof operand[index] !== "string") {
+                issues.push(typeIssue([...path, index], "a string"));
+            }
+        }
+    },
+});
 function normalizeScalarFilter(contract, field, value, origin, path, issues, references = false) {
     if (isKeptReference(references, value)) {
         return value;
     }
+    if (value === undefined) {
+        issues.push(unsentReadValueIssue(path));
+        return value;
+    }
     if (!isPlainRecord(value)) {
         return mergeResult(normalizeScalarFieldValue(contract, field, value, origin, path), issues);
     }
@@ -477,11 +531,17 @@ function normalizeScalarFilter(contract, field, value, origin, path, issues, ref
     const normalized = cloneRecord(value);
     for (const [operator, operand] of Object.entries(value)) {
         const operandPath = [...path, operator];
+        if (operand === undefined) {
+            issues.push(unsentReadValueIssue(operandPath));
+            continue;
+        }
         if (operand === null && !acceptsNullOperand(operator)) {
             issues.push(typeIssue(operandPath, "non-null"));
             continue;
         }
-        if (operator === "mode" || operator === "isEmpty" || operator === "path") {
+        const keyword = lookupOwn(KEYWORD_OPERANDS, operator);
+        if (keyword !== undefined) {
+            keyword(operand, operandPath, issues);
             continue;
         }
         if (referenceOperandShape(operator) !== undefined &&
@@ -497,14 +557,14 @@ function normalizeScalarFilter(contract, field, value, origin, path, issues, ref
                 issues.push(typeIssue(operandPath, "an array"));
                 continue;
             }
-            normalized[operator] = operand.map((entry, index) => mergeResult(normalizeListElement(contract, field, entry, origin, [
+            normalized[operator] = operand.map((entry, index) => mergeResult(normalizeFilterEntry(contract, field, entry, origin, [
                 ...operandPath,
                 index,
             ]), issues));
             continue;
         }
         if (operator === "has") {
-            normalized[operator] = mergeResult(normalizeListElement(contract, field, operand, origin, operandPath), issues);
+            normalized[operator] = mergeResult(normalizeFilterEntry(contract, field, operand, origin, operandPath), issues);
             continue;
         }
         if (operator === "hasEvery" || operator === "hasSome") {
@@ -512,7 +572,7 @@ function normalizeScalarFilter(contract, field, value, origin, path, issues, ref
                 issues.push(typeIssue(operandPath, "an array"));
                 continue;
             }
-            normalized[operator] = operand.map((entry, index) => mergeResult(normalizeListElement(contract, field, entry, origin, [
+            normalized[operator] = operand.map((entry, index) => mergeResult(normalizeFilterEntry(contract, field, entry, origin, [
                 ...operandPath,
                 index,
             ]), issues));
@@ -521,6 +581,12 @@ function normalizeScalarFilter(contract, field, value, origin, path, issues, ref
         if ("scalar" in field.type &&
             field.type.scalar === "json" &&
             (operator.startsWith("string") || operator.startsWith("array"))) {
+            if (operator.startsWith("string")) {
+                if (typeof operand !== "string") {
+                    issues.push(typeIssue(operandPath, "a string"));
+                }
+                continue;
+            }
             const jsonResult = normalizeJsonValue(operand, operandPath, new Set());
             normalized[operator] = mergeResult(jsonResult, issues);
             continue;
@@ -585,6 +651,10 @@ function normalizeUniqueSelector(contract, resourceName, selector, origin, path,
     const normalized = cloneRecord(selector);
     for (const [fieldName, value] of Object.entries(selector)) {
         const field = lookupField(resource, fieldName);
+        if (field?.kind === "scalar" && value === undefined) {
+            issues.push(unsentReadValueIssue([...path, fieldName]));
+            continue;
+        }
         if (field?.kind === "scalar" && !isKeptReference(references, value)) {
             normalized[fieldName] = mergeResult(normalizeScalarFieldValue(contract, field, value, origin, [
                 ...path,

package/dist/runtime/unsent-value.normalizer.d.ts

@@ -0,0 +1,15 @@
+import type { AvContract } from "../contracts/contract.js";
+import type { AvOperationFamily } from "../operations/operation-identity.js";
+/**
+ * One operation's arguments with every write record's unsent fields removed — a
+ * field whose value is `undefined`, at any depth of nested write data the
+ * Contract's `maxNestingDepth` admits — and
+ * nothing else changed (see the module note): `where`, selectors and every other
+ * member are left as they are. The same object when nothing was unsent; otherwise
+ * a copy of each container on the way, never a write into `args`. Total over
+ * malformed input.
+ */
+export declare function withoutUnsentWriteValues(contract: AvContract, request: {
+    readonly resource: string;
+    readonly family: AvOperationFamily;
+}, args: unknown): unknown;

package/dist/runtime/unsent-value.normalizer.js

@@ -0,0 +1,128 @@
+import { lookupField, lookupResource } from "../contracts/contract-lookup.js";
+import { isPlainRecord, WRITE_KEYS } from "./field-stage.runtime.js";
+import { isRelationMutationDirective, RELATION_MUTATION_RECORD_SITES, } from "./mutation-planner.js";
+const REMOVE = Symbol("remove");
+const DEPTH_CEILING = 256;
+function rebuilt(record, changes) {
+    const copy = Object.getPrototypeOf(record) === null ? Object.create(null) : {};
+    for (const key of Object.keys(record)) {
+        const value = changes.has(key) ? changes.get(key) : record[key];
+        if (value === REMOVE) {
+            continue;
+        }
+        Object.defineProperty(copy, key, {
+            value,
+            writable: true,
+            enumerable: true,
+            configurable: true,
+        });
+    }
+    return copy;
+}
+function eachEntry(value, strip) {
+    if (!Array.isArray(value)) {
+        return strip(value);
+    }
+    let copy;
+    for (let index = 0; index < value.length; index += 1) {
+        if (!(index in value)) {
+            continue;
+        }
+        const entry = value[index];
+        const stripped = strip(entry);
+        if (stripped !== entry) {
+            copy ??= value.slice();
+            copy[index] = stripped;
+        }
+    }
+    return copy ?? value;
+}
+function stripRecord(walk, resourceName, record, depth) {
+    if (depth > walk.depth || !isPlainRecord(record)) {
+        return record;
+    }
+    const resource = lookupResource(walk.contract, resourceName);
+    let changes;
+    for (const key of Object.keys(record)) {
+        const value = record[key];
+        if (value === undefined) {
+            changes ??= new Map();
+            changes.set(key, REMOVE);
+            continue;
+        }
+        const field = lookupField(resource, key);
+        if (field?.kind !== "relation") {
+            continue;
+        }
+        const stripped = stripRelationWrite(walk, field.target, value, depth + 1);
+        if (stripped !== value) {
+            changes ??= new Map();
+            changes.set(key, stripped);
+        }
+    }
+    return changes === undefined ? record : rebuilt(record, changes);
+}
+function stripRelationWrite(walk, target, value, depth) {
+    if (!isPlainRecord(value)) {
+        return value;
+    }
+    let changes;
+    for (const directive of Object.keys(value)) {
+        if (!isRelationMutationDirective(directive)) {
+            continue;
+        }
+        const sites = RELATION_MUTATION_RECORD_SITES[directive];
+        if (sites.length === 0) {
+            continue;
+        }
+        const operand = value[directive];
+        const next = eachEntry(operand, (entry) => {
+            let stripped = entry;
+            for (const site of sites) {
+                if (site.key === undefined) {
+                    stripped = stripRecord(walk, target, stripped, depth);
+                    continue;
+                }
+                if (!isPlainRecord(stripped) || !Object.hasOwn(stripped, site.key)) {
+                    continue;
+                }
+                const inner = stripped[site.key];
+                const record = stripRecord(walk, target, inner, depth);
+                if (record !== inner) {
+                    stripped = rebuilt(stripped, new Map([[site.key, record]]));
+                }
+            }
+            return stripped;
+        });
+        if (next !== operand) {
+            changes ??= new Map();
+            changes.set(directive, next);
+        }
+    }
+    return changes === undefined ? value : rebuilt(value, changes);
+}
+export function withoutUnsentWriteValues(contract, request, args) {
+    const keys = Object.hasOwn(WRITE_KEYS, request.family)
+        ? WRITE_KEYS[request.family]
+        : undefined;
+    if (keys === undefined || !isPlainRecord(args)) {
+        return args;
+    }
+    const walk = {
+        contract,
+        depth: Math.min(contract.limits.maxNestingDepth, DEPTH_CEILING),
+    };
+    let changes;
+    for (const key of keys) {
+        if (!Object.hasOwn(args, key)) {
+            continue;
+        }
+        const value = args[key];
+        const next = eachEntry(value, (entry) => stripRecord(walk, request.resource, entry, 0));
+        if (next !== value) {
+            changes ??= new Map();
+            changes.set(key, next);
+        }
+    }
+    return changes === undefined ? args : rebuilt(args, changes);
+}

package/dist/transactions/operation-fingerprint.js

@@ -1,4 +1,4 @@
-import { canonicalizeJson } from "../contracts/contract-canonicalizer.js";
+import { canonicalizeWireJson } from "../contracts/contract-canonicalizer.js";
 const OPERATION_FINGERPRINT_PATTERN = /^fp1:[A-Za-z0-9_-]{22}$/;
 function encodeBase64Url(bytes) {
     let binary = "";
@@ -14,7 +14,7 @@ export function isOperationFingerprint(value) {
     return typeof value === "string" && OPERATION_FINGERPRINT_PATTERN.test(value);
 }
 export async function computeOperationFingerprint(node) {
-    const canonical = canonicalizeJson({
+    const canonical = canonicalizeWireJson({
         resource: node.resource,
         family: node.family,
         variant: node.variant,

package/dist/transactions/sql-statement.d.ts

@@ -35,6 +35,14 @@ export type PlannedSqlValue = {
     readonly operation: number;
     readonly field: string;
 }
+/**
+ * A whole value that is a `$ref` control object the caller wrote, mirrored at
+ * the builder: validated as an operation step's reference is.
+ */
+ | {
+    readonly kind: "candidate";
+    readonly candidate: unknown;
+}
 /** A `$ref` placeholder found inside a value, at `path` within it: refused. */
  | {
     readonly kind: "misplaced-reference";

package/dist/transactions/sql-statement.validator.js

@@ -1,11 +1,12 @@
 import { validationIssue } from "../operations/validation-code.js";
+import { AvCallerDataError, locateCallerDataError, } from "../runtime/caller-data.copier.js";
 import { refuseCallerData } from "../runtime/caller-data.door.js";
 import { AvDecimal } from "../runtime/decimal.js";
 import { planStepPath } from "../runtime/error-boundary.js";
 import { operationFailure } from "../runtime/operation-response.js";
 import { mapValidationOutcome } from "../runtime/outcome-mapper.js";
 import { isPlainRecord, normalizeJsonValue, } from "../runtime/scalar-runtime.js";
-import { invalidSourceIndexIssue, referenceSourceAt, referenceSourceField, } from "./transaction-reference-validator.js";
+import { inspectReferenceCandidate, invalidSourceIndexIssue, referenceSourceAt, referenceSourceField, } from "./transaction-reference-validator.js";
 import { transactionOperationFailure } from "./transaction-response.js";
 function refused(issue, index) {
     return {
@@ -56,7 +57,7 @@ export function normalizeSqlValue(value, path) {
     };
 }
 export function validateSqlStatement(statement, context) {
-    const { index, earlier } = context;
+    const { index } = context;
     if (!context.available) {
         const message = "SQL statements are not available on this Adapter.";
         return {
@@ -73,6 +74,22 @@ export function validateSqlStatement(statement, context) {
     if (statement.refused !== undefined) {
         return refused(refuseCallerData(statement.refused, [...planStepPath(index), "values"], { origin: "application", operation: index }, context.misuse), index);
     }
+    try {
+        return validateSqlValues(statement, statement.strings, context);
+    }
+    catch (error) {
+        if (!(error instanceof AvCallerDataError)) {
+            throw error;
+        }
+        return refused(refuseCallerData(locateCallerDataError(error, statement.values.map((planned) => planned.kind === "value"
+            ? planned.value
+            : planned.kind === "candidate"
+                ? planned.candidate
+                : undefined)), [...planStepPath(index), "values"], { origin: "application", operation: index }, context.misuse), index);
+    }
+}
+function validateSqlValues(statement, strings, context) {
+    const { index, earlier } = context;
     const values = [];
     const issues = [];
     for (const [position, planned] of statement.values.entries()) {
@@ -80,6 +97,22 @@ export function validateSqlStatement(statement, context) {
         switch (planned.kind) {
             case "misplaced-reference":
                 return refused(validationIssue("V1010", [...path, ...planned.path, "$ref"], "A transaction reference in a SQL step must be a whole value."), index);
+            case "candidate": {
+                const inspection = inspectReferenceCandidate(planned.candidate, path, earlier, index);
+                if (!inspection.ok) {
+                    return refused(inspection.issue, index);
+                }
+                if (inspection.field.kind !== "scalar" || inspection.field.list) {
+                    return refused(validationIssue("V1011", inspection.pathPath, "Transaction reference source is not a single scalar field."), index);
+                }
+                values.push({
+                    kind: "reference",
+                    operation: inspection.source.index,
+                    field: inspection.segment,
+                    source: inspection.field,
+                });
+                break;
+            }
             case "reference": {
                 const source = referenceSourceAt(earlier, planned.operation, index);
                 if (source === undefined) {
@@ -127,7 +160,7 @@ export function validateSqlStatement(statement, context) {
         statement: {
             kind: "sql",
             index,
-            strings: statement.strings,
+            strings,
             values,
         },
     };

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

@@ -1,6 +1,6 @@
 import type { AvContracts } from "../compiler/contract.compiler.js";
 import type { AvOperationIdentity } from "../operations/operation-identity.js";
-import type { AvCallerDataError } from "../runtime/caller-data.copier.js";
+import { AvCallerDataError } from "../runtime/caller-data.copier.js";
 import type { MisuseReporter } from "../runtime/misuse-reporter.js";
 import type { ClientProtocolIdentity } from "../runtime/operation-request.js";
 import type { AvOperationFailureResponse } from "../runtime/operation-response.js";

package/dist/transactions/transaction-plan-assembler.js

@@ -1,10 +1,13 @@
 import { VALIDATION_CODE_MESSAGES, validationIssue, } from "../operations/validation-code.js";
+import { AvCallerDataError, } from "../runtime/caller-data.copier.js";
 import { copyAtDoor, refuseCallerData } from "../runtime/caller-data.door.js";
 import { operationFailure } from "../runtime/operation-response.js";
 import { mapValidationOutcome } from "../runtime/outcome-mapper.js";
+import { withoutUnsentWriteValues } from "../runtime/unsent-value.normalizer.js";
 import { encodeOperationArgumentsForWire } from "./operation-arguments-encoder.js";
 import { computeOperationFingerprint } from "./operation-fingerprint.js";
 import { readSqlTemplate } from "./sql-statement.js";
+import { routeTransactionReferenceCandidate } from "./transaction-reference.js";
 import { transactionOperationFailure } from "./transaction-response.js";
 const SQL_STEP_NODE = Object.freeze({ fingerprint: null });
 function isPlainRecord(value) {
@@ -46,6 +49,9 @@ function rebuildArguments(root, leaf) {
         if (!Array.isArray(value) && !isPlainRecord(value)) {
             return { value };
         }
+        if (Object.hasOwn(value, "$ref")) {
+            return { value };
+        }
         if (ancestors.has(value)) {
             return { value };
         }
@@ -92,15 +98,17 @@ function operationEntryFailure(operation, message) {
 function referenceFailure(issue, operation) {
     return transactionOperationFailure(mapValidationOutcome([issue]), operation);
 }
+const STEP_REFERENCE_MIRROR = (value) => Object.hasOwn(value, "$ref");
 export function createTransactionPlanAssembler(contracts, protocol, misuse) {
     const handles = new WeakMap();
     const placeholders = new WeakMap();
     const originOf = (origin) => origin === "application"
         ? { origin: "application" }
         : { origin: "client", protocol };
-    const snapshot = (args) => {
+    const snapshot = (args, mirror) => {
         const copy = copyAtDoor(args, {
             keep: (value) => placeholders.has(value),
+            ...(mirror === undefined ? {} : { mirror }),
         });
         return copy.ok ? { args: copy.value } : { args: {}, refused: copy.error };
     };
@@ -131,15 +139,28 @@ export function createTransactionPlanAssembler(contracts, protocol, misuse) {
         handles.set(handle, record);
         return handle;
     };
-    const defer = (origin, resource, identity, args) => createHandle({
-        kind: "operation",
-        origin,
-        resource,
-        identity,
-        ...snapshot(args),
-    });
+    const defer = (origin, resource, identity, args) => {
+        const copy = snapshot(args, STEP_REFERENCE_MIRROR);
+        let sent = copy.args;
+        try {
+            sent = withoutUnsentWriteValues(origin === "application" ? contracts.application : contracts.client, { resource, family: identity.family }, copy.args);
+        }
+        catch (error) {
+            if (!(error instanceof AvCallerDataError)) {
+                throw error;
+            }
+        }
+        return createHandle({
+            kind: "operation",
+            origin,
+            resource,
+            identity,
+            ...copy,
+            args: sent,
+        });
+    };
     const deferSql = (strings, values) => {
-        const copy = snapshot(values);
+        const copy = snapshot(values, STEP_REFERENCE_MIRROR);
         return createHandle({
             kind: "sql",
             strings: readSqlTemplate(strings, values.length),
@@ -153,7 +174,9 @@ export function createTransactionPlanAssembler(contracts, protocol, misuse) {
             const sites = placeholderSites(value);
             const [site] = sites;
             if (site === undefined) {
-                return { kind: "value", value };
+                return routeTransactionReferenceCandidate(value).kind === "ordinary"
+                    ? { kind: "value", value }
+                    : { kind: "candidate", candidate: value };
             }
             if (site.path.length > 0) {
                 return { kind: "misplaced-reference", path: site.path };