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

package/dist/runtime/operation-code.guidance.js

@@ -0,0 +1,167 @@
+export const OPERATION_CODE_GUIDANCE = {
+    A1000: {
+        message: "Success.",
+        cause: "A read, a count or another operation without a more specific success code succeeded.",
+        fix: "Nothing: the call succeeded.",
+    },
+    A1001: {
+        message: "No match.",
+        cause: "A first-style operation (find.first, update.first, delete.first) matched no row; data is null and the generated client resolves null.",
+        fix: "Nothing: handle the null result. A unique operation answers A2003 instead.",
+    },
+    A1002: {
+        message: "Created.",
+        cause: "create.one created a row.",
+        fix: "Nothing: the call succeeded.",
+    },
+    A1003: {
+        message: "Created many.",
+        cause: "create.many or create.count created rows.",
+        fix: "Nothing: the call succeeded.",
+    },
+    A1004: {
+        message: "Updated.",
+        cause: "update.first or update.unique updated a row.",
+        fix: "Nothing: the call succeeded.",
+    },
+    A1005: {
+        message: "Updated many.",
+        cause: "update.many or update.count updated rows.",
+        fix: "Nothing: the call succeeded.",
+    },
+    A1006: {
+        message: "Deleted.",
+        cause: "delete.first or delete.unique deleted a row.",
+        fix: "Nothing: the call succeeded.",
+    },
+    A1007: {
+        message: "Deleted many.",
+        cause: "delete.count deleted rows.",
+        fix: "Nothing: the call succeeded.",
+    },
+    A1008: {
+        message: "Upserted.",
+        cause: "upsert.unique created or updated a row.",
+        fix: "Nothing: the call succeeded.",
+    },
+    A1009: {
+        message: "Transaction committed.",
+        cause: "A whole transaction plan committed; data holds one result per step.",
+        fix: "Nothing: the plan committed.",
+    },
+    A2000: {
+        message: "Invalid request.",
+        cause: "The HTTP request cannot be interpreted: malformed JSON, a body that is not a JSON object, an unknown `/_*` path, a body that does not decode in its Content-Encoding, or a missing Aventara-Protocol-Version or Aventara-Contract-Hash header (the message names it).",
+        fix: "Send a JSON object with both identity headers. The generated client does this for you.",
+    },
+    A2001: {
+        message: "Unknown Resource.",
+        cause: 'The Resource is not in the caller\'s contract: misspelt, hidden by exposure, or added to the schema after aventara:prepare last ran. cause.message is "The requested Resource is not available." and the issue is V1005 at `["resource"]`.',
+        fix: "Use the model's exact name. After a schema change run the adapter's generate step (`npm run aventara:prepare` in a scaffolded project), restart, and regenerate the client. A Resource hidden on purpose is reached from server code (framework.application).",
+    },
+    A2002: {
+        message: "Unknown operation.",
+        cause: 'The operation is not available on that Resource: a typo, removed by exposure, an operation the adapter does not offer (such as delete.many), or a ctx.$sql, appTx.$sql or ctx.$transaction the adapter or the layer cannot run. The issue is V1006 at `["family"]` or `["variant"]`.',
+        fix: "Call an operation the contract lists (`GET <api>/_contract`), regenerate a stale client, and check the layer's exemptions and transactionsStyle.",
+    },
+    A2003: {
+        message: "Not found.",
+        cause: "A unique operation (find.unique, update.unique, delete.unique) matched no row, or a $connect names a record that does not exist. The operation fails, so no after hook runs.",
+        fix: "Catch AvNotFoundError, or use a first-style operation, which answers A1001 with null. Check the $connect identifier.",
+    },
+    A2004: {
+        message: "Validation failed.",
+        cause: 'The arguments break a contract rule or a field validator. cause.issues lists each problem by V-code and path; a validator\'s issue also has check and params. The validators judge the values after the pipes and write compute, so a computed value they refuse is here too, at its field. A required create field left out is here (V1000). So is a value the database itself refused: too long for its column or out of its range (V1004), or holding a character it cannot store or a pattern it cannot read (V1001), with the issue at `["arguments"]` and its message saying what the database refused. So is a record written through a relation that writes that relation, or a field holding its reference, back (V1012, at that field), where the adapter admits no such write.',
+        fix: "Fix the argument each issue's path points at, as its V-code says. A field the server must fill takes a compute.create stage. For a value the database refused, send one its column holds. For a nested write that writes its relation back, leave that field out: the parent supplies it.",
+    },
+    A2005: {
+        message: "Contract mismatch.",
+        cause: "The caller's Aventara-Contract-Hash is not the server's current one: the schema, the configuration, the limits or the exposure changed, or the client targets another deployment.",
+        fix: "Regenerate the client against the running server: `npm run avclient:generate`.",
+    },
+    A2006: {
+        message: "Protocol mismatch.",
+        cause: "Aventara-Protocol-Version is not 1.",
+        fix: "Send `Aventara-Protocol-Version: 1`, or upgrade the client.",
+    },
+    A2007: {
+        message: "Invalid transaction reference.",
+        cause: "A transaction $ref or fingerprint is invalid: the issues are V1010, V1011, V1016, V1017 or V1018, and cause.operation is the step. A $ref with no fingerprint is A2004 / V1000.",
+        fix: "Let the generated client or framework.appTx build plans; check the $ref path and that the referenced step comes earlier.",
+    },
+    A2008: {
+        message: "Conflict.",
+        cause: "A uniqueness or reference constraint failed: a duplicate value, a missing parent, or a $disconnect or $set that would orphan a required child (also through update.first or a developer SQL statement). Sending it again unchanged fails the same way.",
+        fix: "Change the data. For a duplicate, update the existing row or use upsert.unique.",
+    },
+    A2009: {
+        message: "Limit exceeded.",
+        cause: "A contract limit was crossed: nesting depth (V1013), list or plan size (V1014), boolean nodes (V1015) or Json value depth (V1021).",
+        fix: "Ask for less (paginate, split the plan), or raise the limit under `limits`.",
+    },
+    A2010: {
+        message: "Payload too large.",
+        cause: "The decoded request body exceeds maxRequestBytes (default 1048576).",
+        fix: "Send less, or raise limits.maxRequestBytes.",
+    },
+    A2011: {
+        message: "Unsupported media type.",
+        cause: "The body is not application/json, or its Content-Encoding is not gzip, deflate or br.",
+        fix: "Send `Content-Type: application/json`.",
+    },
+    A2012: {
+        message: "Method not allowed.",
+        cause: "The HTTP method does not fit the route; the Allow header names the right one (`POST` on operations and `/_transactions`, `GET` on `/_contract`).",
+        fix: "Use the method the Allow header names.",
+    },
+    A2013: {
+        message: "Concurrent modification.",
+        cause: "A competing writer reached the state first; nothing was written.",
+        fix: "Retry. No retry is automatic.",
+    },
+    A2014: {
+        message: "Stale selection.",
+        cause: "The selected state changed before the write; nothing was written.",
+        fix: "Read again, then retry.",
+    },
+    A3000: {
+        message: "Internal error.",
+        cause: 'An unexpected failure on the server: a stage threw an error that is not an AvError, an interceptor called next() twice, a compute stage reached a write through its read-only ctx, a compute stage returned a value of the wrong type, or a compute.create returned undefined for a required field. cause.message is always "Internal framework error."',
+        fix: "Read the real error in the diagnostics sink (the root `diagnostics` key) or the server log line for the request id, and fix that stage. To answer with a code of your choice, throw an AvError.",
+    },
+    A3001: {
+        message: "Adapter error.",
+        cause: 'A database or ORM failure that is not something the caller can fix. cause.message is always "Adapter execution failed."',
+        fix: "Read the raw error in the diagnostics sink; check the database, its connection and the migration state.",
+    },
+    A3002: {
+        message: "Transaction error.",
+        cause: "Transaction infrastructure failed (commit or rollback, or the transaction expired or was closed under a step), or a Resource transaction interceptor called next() twice or resolved without calling it.",
+        fix: "Read the diagnostics sink. Call next() exactly once in a transaction interceptor; retry an infrastructure failure.",
+    },
+    A3003: {
+        message: "Serialization error.",
+        cause: "A result could not be encoded for transport.",
+        fix: "Read the diagnostics sink; make compute.read stages and Json values return plain data of the field's type.",
+    },
+    A3004: {
+        message: "Pipe output invalid.",
+        cause: 'A server pipe, field pipe or transaction pipe (or write compute) returned arguments the server\'s own contract refuses: a field the Resource does not have, a wrong type, a dropped required field, a reference written together with its relation (V1012), or a changed plan. cause.message is always "A server pipeline produced invalid arguments."',
+        fix: "Read the server log line, which names the pipe, the operation and the path, and fix the pipe. A pipe returns a new object of the same shape, or undefined to keep the arguments.",
+    },
+    A4000: {
+        message: "Unauthenticated.",
+        cause: 'A guard threw new AvError("A4000", ...): authentication is required or failed. The framework never authenticates by itself.',
+        fix: "Send the credentials your guards expect, such as the Authorization header.",
+    },
+    A4001: {
+        message: "Forbidden.",
+        cause: 'A guard returned false ("Operation denied by a framework guard."), a field write guard or a nested write\'s target guard included, or a stage threw A4001.',
+        fix: "Call as a caller the guard admits, or stop sending the guarded field. To answer another code, throw an AvError from the guard.",
+    },
+    A4002: {
+        message: "Policy denied.",
+        cause: 'A guard or hook threw new AvError("A4002", ...) with a policy reason of your own.',
+        fix: "Read cause.message for the policy's reason.",
+    },
+};

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

@@ -104,7 +104,13 @@ export type ValidatedOperationArguments = {
 };
 /** Validates one operation's arguments through the Framework Validation Layer. */
 export declare function validateOperationRequest(contract: AvContract, request: FrameworkOperationRequest, options?: OperationValidationOptions, write?: NormalizationWrite): ValidatedOperationArguments;
-/** Every sent field's path: a single call's arguments hold no `$ref`. */
+/** The subject a refused output of an operation's pipes is reported under at a plan step. */
+export declare const STEP_PIPES = "Pipes";
+/**
+ * Every sent field's path. A `$ref` is an object of `$`-keys, which no field
+ * pipe or validator takes, so a plan step's literal values before BEGIN are
+ * every field too, wherever a pipe left a reference or a literal.
+ */
 export declare const EVERY_FIELD: () => boolean;
 /**
  * What admission leaves: the deep-frozen arguments every later stage reads, and
@@ -123,16 +129,24 @@ export type AdmittedOperation = {
 export type AdmissionScope = {
     /**
      * The sent values the field pipes and validators take: every one for a single
-     * call, a plan step's literal values before BEGIN, its resolved `$ref` values
-     * at the step.
+     * call and for a plan step before BEGIN (an unresolved `$ref` is an object of
+     * `$`-keys, which they never take), its resolved `$ref` values at the step.
      */
     readonly select: (path: readonly (string | number)[]) => boolean;
     /** Before BEGIN a plan step's `$ref` slots are unresolved: these admit them. */
     readonly validation?: OperationValidationOptions;
+    /**
+     * A plan step or a forced call, admitted before BEGIN: the validators judge
+     * there the sent values no later stage can change (a field with no write
+     * compute stage of its record's phase), so a caller's refusal opens no
+     * transaction. Everything is judged again after write compute.
+     */
+    readonly beforeBegin?: boolean;
 };
 /**
- * Runs an operation's admission — its guards, pipes and validators — and answers
- * the deep-frozen arguments the rest of the operation reads, or the refusal.
+ * Runs an operation's admission — its guards and pipes, and before BEGIN the
+ * validators of the values nothing after it changes — and answers the
+ * deep-frozen arguments the rest of the operation reads, or the refusal.
  */
 export declare function admitOperation<M extends AvAdapterModel>(dependencies: OperationPipelineDependencies<M>, request: StatefulOperationRequest, contract: AvContract, args: unknown, argumentsPath: readonly (string | number)[], report: DiagnosticsReporter, scope: ExecutorScope<M>, admission?: AdmissionScope): Promise<AdmittedOperation>;
 /** How a plan step's arguments were changed between their admission and the step. */
@@ -146,7 +160,7 @@ export type StepChanges = {
 };
 /**
  * A plan step's (or a forced call's) arguments at the step: resolved values
- * through their field stages, and re-checked when a stage changed them.
+ * through their field pipes, and re-checked when a stage changed them.
  */
 export declare function prepareStep<M extends AvAdapterModel>(dependencies: OperationPipelineDependencies<M>, request: StatefulOperationRequest, contract: AvContract, args: unknown, argumentsPath: readonly (string | number)[], report: DiagnosticsReporter, executor: AvAdapterTransactionExecutor<M>, changes: StepChanges, outer: OuterFailureLayer): Promise<AdmittedOperation>;
 /**

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,8 +8,9 @@ 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";
@@ -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,27 @@ 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);
+            }
         }
         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. */