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

package/dist/runtime/operation-runtime.js

@@ -1,4 +1,5 @@
 import { hasFieldValidators } from "../compiler/field-validator.compiler.js";
+import { createComputedFields } from "../config/field-compute.resolver.js";
 import { fieldStagesOf, isForcedOperation, nestedTargetLevels, operationLevels, rawPipelineTree, transactionLevelsOf, } from "../config/pipeline-tree.resolver.js";
 import { AVENTARA_PROTOCOL_VERSION } from "../contracts/contract-protocol.js";
 import { findOperationAvailabilityIssue, validateOperationArguments, } from "../operations/operation-validator.js";
@@ -7,13 +8,14 @@ import { settleTransaction } from "../transactions/transaction-settlement.runtim
 import { TRANSACTION_PIPES, transactionFacts, } from "../transactions/transaction-stage.runtime.js";
 import { copyAtDoor, misuseIdentityOf, refuseCallerData, } from "./caller-data.door.js";
 import { materializeReadOperation, planReadOperation, } from "./computed-read-runtime.js";
+import { AvComputedValueError } from "./computed-value.error.js";
 import { createContextExecutor, } from "./context-executor.runtime.js";
-import { createRequirementIssues, recordWriteFactsOf, } from "./create-requirement.js";
+import { computedRequirementGapsOf, createRequirementIssues, preliminaryRecordIssues, recordWriteFactsOf, } from "./create-requirement.js";
 import { createDiagnosticsReporter, } from "./diagnostics-reporter.js";
 import { AdapterBoundary, OPERATION_ARGUMENTS_PATH, resolveOperationFailure, sanitizeOperationFailure, } from "./error-boundary.js";
 import { planFieldStages } from "./field-stage.plan.js";
 import { guardSentFields, pipeSentFields, valueAt, writeRecordPathsOf, } from "./field-stage.runtime.js";
-import { fieldValidatorIssues } from "./field-validator.runtime.js";
+import { fieldValidatorIssues, hiddenFieldRefusal, } from "./field-validator.runtime.js";
 import { thrownFailure } from "./framework-error.factory.js";
 import { AvInterceptorNextError } from "./interceptor-next.error.js";
 import { runLevelLifecycle, } from "./level-lifecycle.runtime.js";
@@ -23,10 +25,11 @@ import { nestedWriteTargetsOf, } from "./nested-write.walker.js";
 import { internalFailure, operationFailure } from "./operation-response.js";
 import { mapOperationOutcome, mapValidationOutcome, uniqueMissFailure, } from "./outcome-mapper.js";
 import { AvOutputValidationError, validateOperationOutput, } from "./output-validator.js";
-import { refusePipeOutput, refuseStageOutput, } from "./pipe-output.validator.js";
+import { AvPipeOutputError, PIPE_OUTPUT_FAILURE_MESSAGE, refusePipeOutput, refuseStageOutput, } from "./pipe-output.validator.js";
 import { deepFreeze, frozenCopy } from "./readonly-value.js";
 import { requestStateOf } from "./request-state.resolver.js";
 import { normalizeOperationScalarValues, } from "./scalar-runtime.js";
+import { withoutUnsentWriteValues } from "./unsent-value.normalizer.js";
 function scopeOf(request, binding) {
     return {
         requestId: request.requestId,
@@ -39,7 +42,12 @@ export function withRequestState(request) {
 }
 export function createPipelineDependencies(dependencies, model) {
     const misuse = createMisuseReporter(dependencies.config.misuse);
-    const recordWrites = recordWriteFactsOf(dependencies.adapter);
+    const recordWrites = recordWriteFactsOf({
+        ...(dependencies.adapter.referentialActions === undefined
+            ? {}
+            : { referentialActions: dependencies.adapter.referentialActions }),
+        model,
+    });
     const contexts = createContextExecutor({
         model,
         adapter: dependencies.adapter,
@@ -121,7 +129,7 @@ function operationFacts(contract, request, args) {
             family: request.family,
             variant: request.variant,
         },
-        $args: args,
+        $args: frozenCopy(args),
         $origin: request.origin,
         $requestId: request.requestId,
         $contract: contract,
@@ -177,15 +185,16 @@ export function createOperationRuntime(dependencies, pipelineDependencies) {
             return validated.response;
         }
         const stateful = withRequestState(request);
+        const forced = isForcedOperation(activeScopeConfig(dependencies.config, request).pipelines, request);
         const admitted = await admitOperation(pipelineDependencies, stateful, validated.contract, validated.arguments, OPERATION_ARGUMENTS_PATH, report, {
             requestId: request.requestId,
             transaction: undefined,
             state: stateful.state,
-        });
+        }, forced ? FORCED_CALL : SINGLE_CALL);
         if (!admitted.ok) {
             return admitted.response;
         }
-        if (isForcedOperation(activeScopeConfig(dependencies.config, request).pipelines, request)) {
+        if (forced) {
             return executeForcedOperation(pipelineDependencies, dependencies.adapter, stateful, validated.contract, admitted.args, report);
         }
         return executeAdmittedOperation(pipelineDependencies, stateful, validated.contract, admitted.args, OPERATION_ARGUMENTS_PATH, { kind: "standalone", executor: dependencies.adapter }, report);
@@ -198,9 +207,11 @@ function validateOperation(dependencies, request, source, misuse) {
     }
     const contract = activeContract(dependencies.contracts, request);
     let owned = request;
-    if (source === "caller" &&
+    if (source !== "owned" &&
         findOperationAvailabilityIssue(contract, request) === undefined) {
-        const copy = copyAtDoor(request.arguments);
+        const copy = source === "caller"
+            ? copyAtDoor(request.arguments)
+            : { ok: false, error: source.refused };
         if (!copy.ok) {
             return rejected(mapValidationOutcome([
                 refuseCallerData(copy.error, OPERATION_ARGUMENTS_PATH, misuseIdentityOf(request), misuse),
@@ -235,6 +246,12 @@ export function protocolIdentityFailure(contracts, protocol, origin) {
     return undefined;
 }
 export function validateOperationRequest(contract, request, options, write = "copy") {
+    if (findOperationAvailabilityIssue(contract, request) === undefined) {
+        const sent = withoutUnsentWriteValues(contract, request, request.arguments);
+        if (sent !== request.arguments) {
+            request = { ...request, arguments: sent };
+        }
+    }
     const validation = validateOperationArguments(contract, request, options);
     if (!validation.ok) {
         return { ok: false, response: mapValidationOutcome(validation.issues) };
@@ -251,12 +268,13 @@ function rejected(response) {
     return { ok: false, response };
 }
 const FIELD_PIPES = "Field pipes";
-const STEP_PIPES = "Pipes";
+export const STEP_PIPES = "Pipes";
 export const EVERY_FIELD = () => true;
 function filtersOf(levels) {
     return levels.flatMap((level) => level.filters);
 }
 const SINGLE_CALL = { select: EVERY_FIELD };
+const FORCED_CALL = { select: EVERY_FIELD, beforeBegin: true };
 export async function admitOperation(dependencies, request, contract, args, argumentsPath, report, scope, admission = SINGLE_CALL) {
     const contexts = dependencies.contexts;
     const tree = activeScopeConfig(dependencies.config, request).pipelines;
@@ -299,8 +317,10 @@ export async function admitOperation(dependencies, request, contract, args, argu
         let pipeIndex = 0;
         for (const level of levels) {
             for (const pipe of level.pipes) {
-                const returned = await pipe(current, context());
-                if (returned !== undefined && returned !== current) {
+                const told = frozenCopy(current);
+                const output = await pipe(told, context());
+                if (output !== undefined && output !== told && output !== current) {
+                    const returned = withoutUnsentWriteValues(dependencies.contracts.core, request, output);
                     const refused = refusePipeOutput(contracts, request, returned, pipe, pipeIndex, admission.validation);
                     if (refused !== undefined) {
                         report(refused.error, "A3004");
@@ -322,6 +342,10 @@ export async function admitOperation(dependencies, request, contract, args, argu
             piped: piped || fields.piped,
         };
     };
+    const absent = preliminaryRecordIssues(contract, dependencies.recordWrites, request, current, argumentsPath);
+    if (absent.length > 0) {
+        return { ok: false, response: mapValidationOutcome(absent) };
+    }
     try {
         return await admit();
     }
@@ -333,10 +357,12 @@ export async function admitOperation(dependencies, request, contract, args, argu
     }
 }
 async function runFieldInputStages(dependencies, request, contract, args, argumentsPath, report, admission) {
-    const tree = activeScopeConfig(dependencies.config, request).pipelines;
+    const scopeConfig = activeScopeConfig(dependencies.config, request);
+    const tree = scopeConfig.pipelines;
     const planned = dependencies.fieldStages[request.origin];
     const pipes = planned.anyPipes;
-    if (!pipes && !hasFieldValidators(contract)) {
+    const judge = admission.beforeBegin === true && hasFieldValidators(contract);
+    if (!pipes && !judge) {
         return { ok: true, args, piped: false };
     }
     let current = args;
@@ -364,14 +390,25 @@ async function runFieldInputStages(dependencies, request, contract, args, argume
             }
         }
     }
-    const broken = fieldValidatorIssues(contract, dependencies.recordWrites.references, request, current, argumentsPath, admission.select);
-    if (broken.length > 0) {
-        return { ok: false, response: mapValidationOutcome(broken) };
+    if (judge) {
+        const compute = scopeConfig.compute;
+        const broken = fieldValidatorIssues(contract, dependencies.recordWrites.references, request, current, argumentsPath, admission.select, (resource, stage, field) => {
+            const fields = compute !== undefined && Object.hasOwn(compute, resource)
+                ? compute[resource]
+                : undefined;
+            const phases = fields !== undefined && Object.hasOwn(fields, field)
+                ? fields[field]
+                : undefined;
+            return phases?.[stage] !== undefined;
+        });
+        if (broken.length > 0) {
+            return { ok: false, response: mapValidationOutcome(broken) };
+        }
     }
     return { ok: true, args: current, piped: changed };
 }
 export async function prepareStep(dependencies, request, contract, args, argumentsPath, report, executor, changes, outer) {
-    let current = deepFreeze(args);
+    let current = deepFreeze(withoutUnsentWriteValues(dependencies.contracts.core, request, args));
     const scope = {
         requestId: request.requestId,
         transaction: executor,
@@ -395,12 +432,6 @@ export async function prepareStep(dependencies, request, contract, args, argumen
                 return { ok: false, response: refused.response };
             }
         }
-        if (changes.transactionPiped) {
-            const broken = fieldValidatorIssues(contract, dependencies.recordWrites.references, request, current, argumentsPath, EVERY_FIELD);
-            if (broken.length > 0) {
-                return { ok: false, response: mapValidationOutcome(broken) };
-            }
-        }
         return { ok: true, args: deepFreeze(current), piped: resolved.piped };
     }
     catch (error) {
@@ -465,15 +496,8 @@ export async function executeAdmittedOperation(dependencies, request, contract,
     const adapterBoundary = new AdapterBoundary();
     const contracts = { core: dependencies.contracts.core, active: contract };
     let args = deepFreeze(admittedArguments);
-    let told;
-    const view = () => {
-        if (told === undefined || told.of !== args) {
-            told = { of: args, view: frozenCopy(args) };
-        }
-        return told.view;
-    };
-    const context = () => contexts.operation(scope, operationFacts(contract, request, view()));
-    const computeContext = () => contexts.compute(scope, operationFacts(contract, request, view()));
+    const context = () => contexts.operation(scope, operationFacts(contract, request, args));
+    const computeContext = () => contexts.compute(scope, operationFacts(contract, request, args));
     const reuse = { refusal: undefined };
     const refusedReuse = (refusal) => {
         report(refusal, "A3000");
@@ -493,9 +517,31 @@ export async function executeAdmittedOperation(dependencies, request, contract,
     async function runLifecycle() {
         let computed = await applyWriteCompute(contracts, scopeConfig.compute, request, args, computeContext);
         computed = await applyNestedWriteCompute(contracts, scopeConfig.compute, computed, nestedWriteTargetsOf(contract, dependencies.recordWrites.references, request, computed), (target, payload) => contexts.compute(scope, nestedFacts(contract, request, target, payload)));
-        const missing = createRequirementIssues(contract, dependencies.recordWrites, request, computed, argumentsPath);
-        if (missing.length > 0) {
-            return mapValidationOutcome(missing);
+        const broken = createRequirementIssues(contract, dependencies.recordWrites, request, computed, argumentsPath);
+        const [firstBroken] = broken;
+        if (firstBroken !== undefined) {
+            const what = firstBroken.code === "V1000"
+                ? "dropped a required field"
+                : "wrote a reference twice";
+            report(new AvPipeOutputError(`Pipes or write compute ${what} of ${request.resource}.${request.family}.${request.variant} at "${(firstBroken.path ?? []).join(".")}" (${firstBroken.code}: ${firstBroken.message})`, broken), "A3004");
+            return operationFailure("A3004", {
+                message: PIPE_OUTPUT_FAILURE_MESSAGE,
+            });
+        }
+        const unfilled = computedRequirementGapsOf(contract, dependencies.recordWrites, request, computed, argumentsPath, (resource) => createComputedFields(scopeConfig.compute, resource));
+        const [firstUnfilled] = unfilled;
+        if (firstUnfilled !== undefined) {
+            throw new AvComputedValueError(firstUnfilled.resource, firstUnfilled.field, "create", unfilled.map((gap) => gap.issue), `compute.create on ${firstUnfilled.resource}.${firstUnfilled.field} returned undefined for a required field`);
+        }
+        if (hasFieldValidators(contract)) {
+            const refused = fieldValidatorIssues(contract, dependencies.recordWrites.references, request, computed, argumentsPath, EVERY_FIELD);
+            if (refused.length > 0) {
+                return mapValidationOutcome(refused);
+            }
+        }
+        const hiddenRefusal = hiddenFieldRefusal({ core: dependencies.contracts.core, active: contract }, dependencies.recordWrites.references, request, computed, argumentsPath);
+        if (hiddenRefusal !== undefined) {
+            throw hiddenRefusal;
         }
         args = deepFreeze(computed);
         let readMaterialized = false;

package/dist/runtime/owned-execution.registry.d.ts

@@ -1,11 +1,21 @@
 import type { AgentTransactionRequest, ClientTransactionRequest } from "../transactions/transaction-request.js";
 import type { AvTransactionResponse } from "../transactions/transaction-response.js";
+import type { AvCallerDataError } from "./caller-data.copier.js";
 import type { RemoteOperationRequest } from "./operation-request.js";
 import type { AvOperationResponse } from "./operation-response.js";
 /** The two entries that run a request the protocol decoded itself, uncopied. */
 export type OwnedExecution = {
-    readonly execute: (request: RemoteOperationRequest) => Promise<AvOperationResponse>;
-    readonly executeTransaction: (request: ClientTransactionRequest | AgentTransactionRequest) => Promise<AvTransactionResponse>;
+    /**
+     * Runs `request` uncopied; with `refused`, its arguments are a host's parsed body
+     * whose copy at the call failed, answered as the door answers that failure.
+     */
+    readonly execute: (request: RemoteOperationRequest, refused?: AvCallerDataError) => Promise<AvOperationResponse>;
+    /**
+     * Runs `request` uncopied; with `refused`, its plan is a host's parsed plan taken
+     * at the call, and these steps' arguments could not be copied there: each is
+     * answered at its turn as the door answers that failure.
+     */
+    readonly executeTransaction: (request: ClientTransactionRequest | AgentTransactionRequest, refused?: ReadonlyMap<number, AvCallerDataError>) => Promise<AvTransactionResponse>;
 };
 /** Records `framework`'s owned entries; called once, at construction. */
 export declare function recordOwnedExecution(framework: object, execution: OwnedExecution): void;

package/dist/runtime/pipe-output.validator.d.ts

@@ -24,6 +24,8 @@ import type { AvOperationFailureResponse } from "./operation-response.js";
  */
 /** The one text every `A3004` carries on the wire. */
 export declare const PIPE_OUTPUT_FAILURE_MESSAGE = "A server pipeline produced invalid arguments.";
+/** The Contract a stage's output is held to: Core's Resources plus what `active` adds. */
+export declare function serverContractFor(core: AvContractCore, active: AvContract): AvContract;
 /** The error the diagnostics channel receives for a refused pipe output. */
 export declare class AvPipeOutputError extends Error {
     readonly issues: readonly AvValidationIssue[];
@@ -61,3 +63,11 @@ export declare function refuseStageOutput(contracts: {
 }, request: AvOperationIdentity & {
     readonly resource: string;
 }, args: unknown, subject: string, options?: OperationValidationOptions): RefusedStageOutput | undefined;
+/**
+ * The `A3004` for a stage output the server's rules raised `issues` against
+ * (paths under `["arguments", …]`), the first named in the diagnostic;
+ * `undefined` when there are none.
+ */
+export declare function refusedStageOutput(request: AvOperationIdentity & {
+    readonly resource: string;
+}, issues: readonly AvValidationIssue[], subject: string): RefusedStageOutput | undefined;

package/dist/runtime/pipe-output.validator.js

@@ -19,7 +19,7 @@ function serverContract(core, active) {
     return { ...core, resources };
 }
 const SERVER_VIEWS = new WeakMap();
-function serverContractFor(core, active) {
+export function serverContractFor(core, active) {
     let view = SERVER_VIEWS.get(active);
     if (view === undefined) {
         view = serverContract(core, active);
@@ -64,7 +64,9 @@ export function refusePipeOutput(contracts, request, args, pipe, index, options)
     return refuseStageOutput(contracts, request, args, `Pipe ${pipeLabel(pipe, index)}`, options);
 }
 export function refuseStageOutput(contracts, request, args, subject, options) {
-    const issues = serverIssues(serverContractFor(contracts.core, contracts.active), request, args, options);
+    return refusedStageOutput(request, serverIssues(serverContractFor(contracts.core, contracts.active), request, args, options), subject);
+}
+export function refusedStageOutput(request, issues, subject) {
     const [first] = issues;
     if (first === undefined) {
         return undefined;

package/dist/runtime/pipeline.d.ts

@@ -1,16 +1,17 @@
 import type { AvAdapterModel } from "../adapters/adapter-model.js";
 import type { AvAdapterSqlValue } from "../adapters/adapter-sql-statement.js";
+import type { AvPreComputeLift } from "../config/computed-fields.js";
 import type { AvRequestOrigin } from "../config/config-layer.js";
 import type { AvConfigResourceKey } from "../config/framework-field-definition.js";
 import type { AvContract } from "../contracts/contract.js";
 import type { AvApplicationScalarForms } from "../contracts/scalar-value-type.js";
-import type { AvContractApplicationView } from "../framework/contract-view.js";
+import type { AvContractApplicationView, RequirementsLessComputed } from "../framework/contract-view.js";
 import type { AvContextOperations } from "../framework/operation-facade.js";
 import type { AvOperationArgumentsFor, AvResourceKey } from "../operations/operation-arguments.js";
 import type { AvOperationFamily, AvOperationIdentity } from "../operations/operation-identity.js";
 import type { AvTransactionReference } from "../transactions/transaction-reference.js";
 import type { AvError } from "./framework-error.js";
-import type { AvDeepReadonly, AvDeepReadonlyLeaf } from "./readonly-value.js";
+import type { ArrayForm, AvDeepReadonly, AvDeepReadonlyLeaf } from "./readonly-value.js";
 import type { AvState } from "./request-state.js";
 /**
  * What a pipeline is told about the HTTP request a client-origin operation arrived on.
@@ -50,10 +51,32 @@ export type AvContextSql = <Row = unknown>(strings: TemplateStringsArray, ...val
  * position admitting an unresolved `$ref`. `unknown` for a model whose Resource
  * names are not literal.
  */
-export type AvStageArguments<M extends AvAdapterModel, R extends string, F extends AvOperationFamily, V extends string> = string extends R ? unknown : R extends AvResourceKey<AvContractApplicationView<M>> ? AvOperationArgumentsFor<AvContractApplicationView<M>, R, Extract<AvOperationIdentity, {
+export type AvStageArguments<M extends AvAdapterModel, R extends string, F extends AvOperationFamily, V extends string> = StageArgumentsOf<AvContractApplicationView<M>, R, F, V>;
+/** The arguments of operation `F`.`V` on `R` under the Contract view `C`. */
+type StageArgumentsOf<C extends AvContract, R extends string, F extends AvOperationFamily, V extends string> = string extends R ? unknown : R extends AvResourceKey<C> ? AvOperationArgumentsFor<C, R, Extract<AvOperationIdentity, {
     readonly family: F;
     readonly variant: V;
 }>, AvApplicationScalarForms, AvApplicationScalarForms> : unknown;
+/**
+ * The arguments a variant's guards, pipes and filters are told: the operation's
+ * arguments before write compute has run, so a create need not hold a field
+ * `compute.create` fills (`Lift`, as `"<Resource>.<field>"`; `string`: any).
+ */
+export type AvPreComputeStageArguments<M extends AvAdapterModel, R extends string, F extends AvOperationFamily, V extends string, Lift extends string = AvPreComputeLift<M, "root">> = F extends "find" | "delete" ? AvStageArguments<M, R, F, V> : [Lift] extends [never] ? AvStageArguments<M, R, F, V> : StageArgumentsOf<PreComputeView<AvContractApplicationView<M>, Lift>, R, F, V>;
+/** A Contract view with the create requirements `Lift` names lifted. */
+type PreComputeView<C, Lift extends string> = Extract<{
+    readonly [P in keyof C]: P extends "resources" ? string extends Lift ? {
+        readonly [R in keyof C[P]]: Omit<C[P][R], "createRequirements">;
+    } : {
+        readonly [R in keyof C[P]]: LiftedResource<C[P][R], LiftedFieldOf<Lift, R>>;
+    } : C[P];
+}, AvContract>;
+/** The fields of Resource `R` that `Lift` names. */
+type LiftedFieldOf<Lift extends string, R> = Lift extends `${R & string}.${infer Field}` ? Field : never;
+/** One Resource with the create requirements on `Fields` lifted; itself when none. */
+type LiftedResource<Resource, Fields> = [Fields] extends [never] ? Resource : {
+    readonly [P in keyof Resource]: P extends "createRequirements" ? RequirementsLessComputed<Exclude<Resource[P], undefined>, Fields> : Resource[P];
+};
 /**
  * What a pipeline callback is told about the operation it is wrapping, and the
  * framework's executor: `ctx.<Resource>.<family>.<variant>(args)`, `ctx.$sql` and
@@ -83,8 +106,9 @@ export type AvContext<M extends AvAdapterModel = AvAdapterModel, R extends strin
      * returned them in a pipe, and the validated arguments the operation executes in
      * an interceptor, a hook or a filter. Only a pipe changes them, by returning new
      * ones; writing to them throws a `TypeError`. At a variant, typed as that
-     * operation's arguments ({@link AvStageArguments}), deep read-only; above it,
-     * `unknown`.
+     * operation's arguments ({@link AvStageArguments}), deep read-only; in a guard or
+     * a filter a create may lack the fields `compute.create` fills ({@link
+     * AvPreComputeStageArguments}: write compute has not run); above it, `unknown`.
      */
     readonly $args: AvDeepReadonly<A>;
     readonly $sql: AvContextSql;
@@ -103,8 +127,9 @@ export type AvGuard<M extends AvAdapterModel = AvAdapterModel, R extends string
  * Transforms the arguments before the validators judge them: the only stage
  * that changes them. `args` is deep-frozen, so a pipe returns new arguments;
  * returning `undefined` keeps them as they are. At a variant, `args` and the
- * return are typed as that operation's arguments ({@link AvStageArguments}),
- * `args` deep read-only.
+ * return are typed as that operation's arguments before write compute runs
+ * ({@link AvPreComputeStageArguments}: a create may lack the fields
+ * `compute.create` fills), `args` deep read-only.
  */
 export type AvPipe<M extends AvAdapterModel = AvAdapterModel, R extends string = AvConfigResourceKey<M>, F extends AvOperationFamily = AvOperationFamily, V extends string = string, A = unknown> = {
     pipe(args: PipeArguments<A>, context: AvContext<M, R, F, V, A>): PipeResult<PipeArguments<A>>;
@@ -113,7 +138,9 @@ export type AvPipe<M extends AvAdapterModel = AvAdapterModel, R extends string =
  * A variant pipe's arguments and return: the operation's arguments, deep
  * read-only, each member closed to inference.
  */
-type PipeArguments<T> = T extends AvDeepReadonlyLeaf | AvTransactionReference ? T : T extends object ? {
+type PipeArguments<T> = T extends AvDeepReadonlyLeaf | AvTransactionReference ? T : T extends readonly unknown[] ? ArrayForm<T> extends "array" ? readonly NoInfer<PipeArguments<Exclude<T[number], undefined>>>[] : {
+    readonly [K in keyof T]: NoInfer<PipeArguments<Exclude<T[K], undefined>>>;
+} : T extends object ? {
     readonly [K in keyof T]: NoInfer<PipeArguments<Exclude<T[K], undefined>>>;
 } : T;
 /** What a pipe returns: arguments of type `A`, or `undefined` to keep them. */

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