@aventara/core 1.0.0-rc.0 → 1.0.0-rc.10

package/dist/runtime/operation-runtime.js

@@ -1,38 +1,173 @@
+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";
+import { enforceReadPolicy, } from "../policy/policy-read.runtime.js";
+import { admitRequestPolicy, openRequestPolicy, } from "../policy/policy-request.js";
+import { enforceWritePolicy, writeNeedsTransaction, } from "../policy/policy-write.runtime.js";
+import { transactionInfrastructureFailure } from "../transactions/transaction-response.js";
+import { settleTransaction } from "../transactions/transaction-settlement.runtime.js";
+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 { createRequirementIssues, recordWriteFactsOf, } from "./create-requirement.js";
+import { AvComputedValueError } from "./computed-value.error.js";
+import { createContextExecutor, } from "./context-executor.runtime.js";
+import { computedRequirementGapsOf, createRequirementIssues, 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, 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";
 import { createMisuseReporter, } from "./misuse-reporter.js";
-import { applyWriteFieldBehaviors, stripVirtualMutationInput, } from "./mutation-planner.js";
+import { applyNestedWriteCompute, applyWriteCompute, stripVirtualMutationInput, } from "./mutation-planner.js";
+import { nestedWriteTargetsOf, } from "./nested-write.walker.js";
 import { internalFailure, operationFailure } from "./operation-response.js";
-import { mapOperationOutcome, mapValidationOutcome } from "./outcome-mapper.js";
-import { OutputValidationError, validateOperationOutput, } from "./output-validator.js";
-import { refusePipeOutput } from "./pipe-output.validator.js";
+import { mapOperationOutcome, mapValidationOutcome, uniqueMissFailure, } from "./outcome-mapper.js";
+import { AvOutputValidationError, validateOperationOutput, } from "./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,
+        transaction: binding?.kind === "transaction" ? binding.executor : undefined,
+        state: request.state,
+    };
+}
+export function withRequestState(request) {
+    return { ...request, state: requestStateOf(request.state) };
+}
+function withRequestPolicy(dependencies, request, caller, report) {
+    const failed = (error) => {
+        report(error, "A3000");
+        return internalFailure();
+    };
+    const withPolicy = (policy) => policy === undefined ? request : { ...request, policy };
+    try {
+        const policy = openRequestPolicy(dependencies.config.policy, dependencies.contracts.core, request, caller, dependencies.adapter);
+        return policy instanceof Promise
+            ? policy.then(withPolicy, failed)
+            : withPolicy(policy);
+    }
+    catch (error) {
+        return failed(error);
+    }
+}
+export function createPipelineDependencies(dependencies, model) {
+    const misuse = createMisuseReporter(dependencies.config.misuse);
+    const recordWrites = recordWriteFactsOf({
+        ...(dependencies.adapter.referentialActions === undefined
+            ? {}
+            : { referentialActions: dependencies.adapter.referentialActions }),
+        model,
+    });
+    const contexts = createContextExecutor({
+        model,
+        adapter: dependencies.adapter,
+        application: dependencies.contracts.application,
+        diagnostics: dependencies.config.diagnostics,
+        misuse,
+        run: (request, transaction) => executeContextCall(raw, dependencies, request, transaction, misuse),
+    });
+    const { contracts, config } = dependencies;
+    const pipeline = {
+        contracts,
+        config,
+        recordWrites,
+        contexts,
+        fieldStages: {
+            application: planFieldStages(config.application.pipelines, contracts.application),
+            client: planFieldStages(config.client.pipelines, contracts.client),
+            agent: planFieldStages(config.agent.pipelines, contracts.agent),
+        },
+    };
+    const rawTree = rawPipelineTree(config.application.pipelines);
+    const raw = {
+        ...pipeline,
+        config: {
+            ...config,
+            application: { ...config.application, pipelines: rawTree },
+        },
+        fieldStages: {
+            ...pipeline.fieldStages,
+            application: planFieldStages(rawTree, contracts.application),
+        },
+    };
+    return pipeline;
+}
+async function executeContextCall(raw, dependencies, request, transaction, misuse) {
+    const report = createDiagnosticsReporter(dependencies.config.diagnostics, request);
+    try {
+        let validated;
+        try {
+            validated = validateOperation(dependencies, request, "caller", misuse);
+        }
+        catch (error) {
+            return sanitizeOperationFailure(error, "runtime", report, {
+                path: OPERATION_ARGUMENTS_PATH,
+                arguments: request.arguments,
+            });
+        }
+        if (!validated.ok) {
+            return validated.response;
+        }
+        const stateful = withRequestState(request);
+        const admitted = await admitOperation(raw, stateful, validated.contract, validated.arguments, OPERATION_ARGUMENTS_PATH, report, {
+            requestId: request.requestId,
+            transaction,
+            state: stateful.state,
+        });
+        if (!admitted.ok) {
+            return admitted.response;
+        }
+        return await executeAdmittedOperation(raw, stateful, validated.contract, admitted.args, OPERATION_ARGUMENTS_PATH, transaction === undefined
+            ? { kind: "standalone", executor: dependencies.adapter }
+            : { kind: "transaction", executor: transaction }, report);
+    }
+    catch (error) {
+        report(error, "A3000");
+        return internalFailure();
+    }
+}
 export function activeContract(contracts, request) {
-    return request.origin === "application"
-        ? contracts.application
-        : contracts.client;
+    return contracts[request.origin];
 }
 function activeScopeConfig(config, request) {
-    return request.origin === "application" ? config.application : config.client;
+    return config[request.origin];
 }
-function pipelineContext(contract, request, args) {
+function operationFacts(contract, request, args) {
     return {
-        contract,
-        origin: request.origin,
-        resource: request.resource,
-        family: request.family,
-        variant: request.variant,
-        args,
-        requestId: request.requestId,
-        ...(request.origin === "client" && request.transport !== undefined
-            ? { transport: request.transport }
+        $operation: {
+            resource: request.resource,
+            family: request.family,
+            variant: request.variant,
+        },
+        $args: frozenCopy(args),
+        $origin: request.origin,
+        $requestId: request.requestId,
+        $contract: contract,
+        ...(request.origin !== "application" && request.transport !== undefined
+            ? { $transport: request.transport }
             : {}),
     };
 }
+function nestedFacts(contract, request, target, payload) {
+    return {
+        ...operationFacts(contract, request, payload),
+        $operation: {
+            resource: target.resource,
+            family: target.family,
+            variant: "one",
+            nested: true,
+        },
+    };
+}
 function forbidden() {
     return operationFailure("A4001", {
         message: "Operation denied by a framework guard.",
@@ -48,18 +183,13 @@ function outputAccepted(contract, request, projection, data, report) {
         return false;
     }
     if (!validation.ok) {
-        report(new OutputValidationError(request, validation.issues), "A3000");
+        report(new AvOutputValidationError(request, validation.issues), "A3000");
     }
     return validation.ok;
 }
-export function createOperationRuntime(dependencies) {
-    const pipelineDependencies = {
-        contracts: dependencies.contracts,
-        config: dependencies.config,
-        recordWrites: recordWriteFactsOf(dependencies.adapter),
-    };
+export function createOperationRuntime(dependencies, pipelineDependencies) {
     const misuse = createMisuseReporter(dependencies.config.misuse);
-    return async (request, report, source) => {
+    return async (request, report, source, caller) => {
         let validated;
         try {
             validated = validateOperation(dependencies, request, source, misuse);
@@ -73,7 +203,36 @@ export function createOperationRuntime(dependencies) {
         if (!validated.ok) {
             return validated.response;
         }
-        return executeValidatedOperation(pipelineDependencies, request, validated.contract, validated.arguments, OPERATION_ARGUMENTS_PATH, dependencies.adapter, report);
+        const opened = withRequestPolicy(dependencies, withRequestState(request), caller, report);
+        const stateful = opened instanceof Promise ? await opened : opened;
+        if (!("state" in stateful)) {
+            return stateful;
+        }
+        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;
+        }
+        let checkedWrite = false;
+        if (stateful.policy !== undefined &&
+            request.family !== "find" &&
+            validated.contract.transactions === "interactive" &&
+            !forced) {
+            try {
+                checkedWrite = await writeNeedsTransaction(stateful.policy, dependencies.contracts.core, stateful, () => planReadOperation(dependencies.contracts.core, dependencies.config.adapter.model, validated.contract, activeScopeConfig(dependencies.config, request).compute, stateful, admitted.args), admitted.args);
+            }
+            catch (error) {
+                return sanitizeOperationFailure(error, stateful.policy.execution.boundary.originOf(error), report, { path: OPERATION_ARGUMENTS_PATH, arguments: admitted.args });
+            }
+        }
+        if (forced || checkedWrite) {
+            return executeForcedOperation(pipelineDependencies, dependencies.adapter, stateful, validated.contract, admitted.args, report, forced);
+        }
+        return executeAdmittedOperation(pipelineDependencies, stateful, validated.contract, admitted.args, OPERATION_ARGUMENTS_PATH, { kind: "standalone", executor: dependencies.adapter }, report);
     };
 }
 function validateOperation(dependencies, request, source, misuse) {
@@ -83,9 +242,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),
@@ -100,24 +261,32 @@ function validateOperation(dependencies, request, source, misuse) {
     return { ok: true, contract, arguments: validation.arguments };
 }
 export function validateProtocolIdentity(contracts, request) {
-    return request.origin === "client"
-        ? protocolIdentityFailure(contracts, request.protocol)
-        : undefined;
+    return request.origin === "application"
+        ? undefined
+        : protocolIdentityFailure(contracts, request.protocol, request.origin);
 }
-export function protocolIdentityFailure(contracts, protocol) {
+export function protocolIdentityFailure(contracts, protocol, origin) {
     if (protocol.version !== AVENTARA_PROTOCOL_VERSION) {
         return operationFailure("A2006", {
             message: "Aventara protocol version does not match the server.",
         });
     }
-    if (protocol.hash !== contracts.client.protocol.hash) {
+    if (protocol.hash !== contracts[origin].protocol.hash) {
         return operationFailure("A2005", {
-            message: "Generated client contract does not match the server. Regenerate the client.",
+            message: origin === "client"
+                ? "Generated client contract does not match the server. Regenerate the client."
+                : "Agent contract does not match the server. Rebuild the agent's tools from the current Agent Contract.",
         });
     }
     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) };
@@ -133,75 +302,398 @@ export function validateOperationRequest(contract, request, options, write = "co
 function rejected(response) {
     return { ok: false, response };
 }
-export async function executeValidatedOperation(dependencies, request, contract, validatedArguments, argumentsPath, executor, report) {
-    const scopeConfig = activeScopeConfig(dependencies.config, request);
-    const pipelines = scopeConfig.pipelines;
-    const adapterBoundary = new AdapterBoundary();
-    let args = validatedArguments;
+const FIELD_PIPES = "Field 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;
+    const levels = operationLevels(tree, request);
+    const planned = dependencies.fieldStages[request.origin];
+    const guarded = planned.guarded(request.resource);
+    const contracts = { core: dependencies.contracts.core, active: contract };
+    let current = deepFreeze(args);
+    const context = () => contexts.operation(scope, operationFacts(contract, request, current));
+    const admit = async () => {
+        for (const level of levels) {
+            for (const guard of level.guards) {
+                if ((await guard(context())) === false) {
+                    return { ok: false, response: forbidden() };
+                }
+            }
+        }
+        if (guarded.length > 0 &&
+            !(await guardSentFields(fieldStagesOf(tree, request.resource), guarded, writeRecordPathsOf(request.family, current), current, context))) {
+            return { ok: false, response: forbidden() };
+        }
+        for (const target of planned.nestedGuards
+            ? nestedWriteTargetsOf(contract, dependencies.recordWrites.references, request, current)
+            : []) {
+            const told = () => contexts.operation(scope, nestedFacts(contract, request, target, valueAt(current, target.path)));
+            for (const level of nestedTargetLevels(tree, target.resource, target.family)) {
+                for (const guard of level.guards) {
+                    if ((await guard(told())) === false) {
+                        return { ok: false, response: forbidden() };
+                    }
+                }
+            }
+            const targetGuarded = planned.guarded(target.resource);
+            if (targetGuarded.length > 0 &&
+                !(await guardSentFields(fieldStagesOf(tree, target.resource), targetGuarded, target.records.map((site) => site.path), current, told))) {
+                return { ok: false, response: forbidden() };
+            }
+        }
+        let piped = false;
+        let pipeIndex = 0;
+        for (const level of levels) {
+            for (const pipe of level.pipes) {
+                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");
+                        return { ok: false, response: refused.response };
+                    }
+                    current = deepFreeze(returned);
+                    piped = true;
+                }
+                pipeIndex += 1;
+            }
+        }
+        const fields = await runFieldInputStages(dependencies, request, contract, current, argumentsPath, report, admission);
+        if (!fields.ok) {
+            return fields;
+        }
+        return {
+            ok: true,
+            args: deepFreeze(fields.args),
+            piped: piped || fields.piped,
+        };
+    };
+    const absent = createRequirementIssues(contract, dependencies.recordWrites, request, current, argumentsPath);
+    if (absent.length > 0) {
+        return { ok: false, response: mapValidationOutcome(absent) };
+    }
+    if (request.policy !== undefined) {
+        const refused = await admitRequestPolicy(request.policy, dependencies.contracts.core, contract, request, current, report, { path: argumentsPath, arguments: current });
+        if (refused !== undefined) {
+            return { ok: false, response: refused };
+        }
+    }
     try {
-        return await runLifecycle();
+        return await admit();
     }
     catch (error) {
-        return resolveOperationFailure(error, pipelines.filters, pipelineContext(contract, request, args), adapterBoundary, report, { path: argumentsPath, arguments: args });
+        return {
+            ok: false,
+            response: await resolveOperationFailure(error, filtersOf(levels), context(), new AdapterBoundary(), report, { path: argumentsPath, arguments: current }),
+        };
     }
-    async function runLifecycle() {
-        for (const guard of pipelines.guards) {
-            const allowed = await guard(pipelineContext(contract, request, args));
-            if (allowed === false) {
-                return forbidden();
+}
+async function runFieldInputStages(dependencies, request, contract, args, argumentsPath, report, admission) {
+    const scopeConfig = activeScopeConfig(dependencies.config, request);
+    const tree = scopeConfig.pipelines;
+    const planned = dependencies.fieldStages[request.origin];
+    const pipes = planned.anyPipes;
+    const judge = admission.beforeBegin === true && hasFieldValidators(contract);
+    if (!pipes && !judge) {
+        return { ok: true, args, piped: false };
+    }
+    let current = args;
+    let changed = false;
+    if (pipes) {
+        const pipedFields = planned.piped(request.resource);
+        let piped = pipedFields.length === 0
+            ? { args: current, changed: false }
+            : await pipeSentFields(fieldStagesOf(tree, request.resource), pipedFields, writeRecordPathsOf(request.family, current), current, admission.select);
+        changed = piped.changed;
+        for (const target of nestedWriteTargetsOf(contract, dependencies.recordWrites.references, request, piped.args)) {
+            const targetPiped = planned.piped(target.resource);
+            if (targetPiped.length === 0) {
+                continue;
             }
+            piped = await pipeSentFields(fieldStagesOf(tree, target.resource), targetPiped, target.records.map((site) => site.path), piped.args, admission.select);
+            changed ||= piped.changed;
         }
-        for (const [index, pipe] of pipelines.pipes.entries()) {
-            const nextArgs = await pipe(args, pipelineContext(contract, request, args));
-            if (nextArgs !== undefined) {
-                args = nextArgs;
+        current = piped.args;
+        if (changed) {
+            const refused = refuseStageOutput({ core: dependencies.contracts.core, active: contract }, request, current, FIELD_PIPES, admission.validation);
+            if (refused !== undefined) {
+                report(refused.error, "A3004");
+                return { ok: false, response: refused.response };
             }
-            const refused = refusePipeOutput({ core: dependencies.contracts.core, active: contract }, request, args, pipe, index);
+        }
+    }
+    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(withoutUnsentWriteValues(dependencies.contracts.core, request, args));
+    const scope = {
+        requestId: request.requestId,
+        transaction: executor,
+        state: request.state,
+    };
+    try {
+        const resolved = await runFieldInputStages(dependencies, request, contract, current, argumentsPath, report, { select: changes.written });
+        if (!resolved.ok) {
+            return resolved;
+        }
+        current = resolved.args;
+        const subject = changes.transactionPiped
+            ? TRANSACTION_PIPES
+            : changes.pipedAroundReferences
+                ? STEP_PIPES
+                : undefined;
+        if (subject !== undefined) {
+            const refused = refuseStageOutput({ core: dependencies.contracts.core, active: contract }, request, current, subject);
             if (refused !== undefined) {
                 report(refused.error, "A3004");
-                return refused.response;
+                return { ok: false, response: refused.response };
+            }
+        }
+        return { ok: true, args: deepFreeze(current), piped: resolved.piped };
+    }
+    catch (error) {
+        return {
+            ok: false,
+            response: await resolveOperationFailure(error, filtersOf(operationLevels(activeScopeConfig(dependencies.config, request).pipelines, request)), dependencies.contexts.operation(scope, operationFacts(contract, request, current)), new AdapterBoundary(), report, { path: argumentsPath, arguments: current }, outer),
+        };
+    }
+}
+async function executeForcedOperation(dependencies, adapter, request, contract, args, report, forced) {
+    const plan = [
+        {
+            resource: request.resource,
+            family: request.family,
+            variant: request.variant,
+            args,
+        },
+    ];
+    const settled = await settleTransaction({
+        adapter,
+        levels: forced
+            ? transactionLevelsOf(activeScopeConfig(dependencies.config, request).pipelines, request.resource)
+            : [],
+        plan,
+        contextOf: (current, executor) => dependencies.contexts.transaction({
+            requestId: request.requestId,
+            transaction: executor,
+            state: request.state,
+        }, transactionFacts(contract, request, current)),
+        failureView: { path: OPERATION_ARGUMENTS_PATH, arguments: args },
+        report,
+        runStep: async (_index, step, piped, executor, _results, outer) => {
+            let stepArguments = step.args;
+            if (piped) {
+                const prepared = await prepareStep(dependencies, request, contract, stepArguments, OPERATION_ARGUMENTS_PATH, report, executor, {
+                    written: () => false,
+                    transactionPiped: true,
+                    pipedAroundReferences: false,
+                }, outer);
+                if (!prepared.ok) {
+                    return prepared.response;
+                }
+                stepArguments = prepared.args;
+            }
+            return executeAdmittedOperation(dependencies, request, contract, stepArguments, OPERATION_ARGUMENTS_PATH, { kind: "transaction", executor, outer }, report);
+        },
+    });
+    switch (settled.kind) {
+        case "committed":
+            return settled.responses[0] ?? internalFailure();
+        case "rolled-back":
+            return settled.response;
+        case "broken":
+            report(settled.error, "A3002");
+            return transactionInfrastructureFailure();
+    }
+}
+export async function executeAdmittedOperation(dependencies, request, contract, admittedArguments, argumentsPath, binding, report) {
+    const { executor } = binding;
+    const scope = scopeOf(request, binding);
+    const contexts = dependencies.contexts;
+    const scopeConfig = activeScopeConfig(dependencies.config, request);
+    const levels = operationLevels(scopeConfig.pipelines, request);
+    const adapterBoundary = new AdapterBoundary();
+    const contracts = { core: dependencies.contracts.core, active: contract };
+    let args = deepFreeze(admittedArguments);
+    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");
+        return internalFailure();
+    };
+    let response;
+    try {
+        response = await runLifecycle();
+    }
+    catch (error) {
+        if (reuse.refusal !== undefined) {
+            return refusedReuse(reuse.refusal);
+        }
+        return resolveOperationFailure(error, filtersOf(levels), context(), adapterBoundary, report, { path: argumentsPath, arguments: args }, binding.kind === "transaction" ? binding.outer : undefined);
+    }
+    return reuse.refusal === undefined ? response : refusedReuse(reuse.refusal);
+    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 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 = await applyWriteFieldBehaviors({ core: dependencies.contracts.core, active: contract }, scopeConfig.behaviors, request, args, () => pipelineContext(contract, request, args));
-        const missing = createRequirementIssues(contract, dependencies.recordWrites, request, args, argumentsPath);
-        if (missing.length > 0) {
-            return mapValidationOutcome(missing);
+        const hiddenRefusal = hiddenFieldRefusal({ core: dependencies.contracts.core, active: contract }, dependencies.recordWrites.references, request, computed, argumentsPath);
+        if (hiddenRefusal !== undefined) {
+            throw hiddenRefusal;
         }
-        for (const hook of pipelines.hooks.before) {
-            await hook(pipelineContext(contract, request, args));
+        args = deepFreeze(computed);
+        let policyWrite;
+        if (request.policy !== undefined && request.family !== "find") {
+            const planned = planReadOperation(dependencies.contracts.core, dependencies.config.adapter.model, contract, scopeConfig.compute, request, args);
+            const plannedArguments = await stripVirtualMutationInput(contracts, request, planned.arguments);
+            try {
+                policyWrite = await enforceWritePolicy(request.policy.on({ executor, boundary: adapterBoundary }), dependencies.contracts.core, dependencies.config.adapter.model, request, planned, plannedArguments, binding.kind === "transaction");
+            }
+            catch (error) {
+                return sanitizeOperationFailure(error, adapterBoundary.originOf(error), report, { path: argumentsPath, arguments: args });
+            }
+            if (policyWrite.kind === "refused") {
+                return policyWrite.response;
+            }
         }
+        let policyFailure;
+        const refuseWrite = (response) => {
+            policyFailure = response;
+            throw thrownFailure(response);
+        };
         let readMaterialized = false;
         let executedReadPlan;
         const materialize = async (data, plan) => {
             readMaterialized = true;
             executedReadPlan = plan;
-            return materializeReadOperation(contract, scopeConfig.behaviors, request, plan, data, () => pipelineContext(contract, request, args));
+            return materializeReadOperation(contract, scopeConfig.compute, request, plan, data, computeContext);
         };
-        let invoke = async () => {
-            const readPlan = planReadOperation(dependencies.contracts.core, contract, scopeConfig.behaviors, request, args);
-            const adapterArguments = await stripVirtualMutationInput({ core: dependencies.contracts.core, active: contract }, request, readPlan.arguments);
-            const identity = request;
-            const adapterData = await adapterBoundary.execute(() => executor.execute({
-                ...identity,
-                resource: request.resource,
-                arguments: adapterArguments,
-            }));
+        const invoke = async () => {
+            let readPlan = planReadOperation(dependencies.contracts.core, dependencies.config.adapter.model, contract, scopeConfig.compute, request, args);
+            let adapterArguments = await stripVirtualMutationInput(contracts, request, readPlan.arguments);
+            let operation = request;
+            let settle;
+            let writeMiss;
+            let failedWrite;
+            if (policyWrite !== undefined && policyWrite.kind !== "refused") {
+                writeMiss = policyWrite.miss;
+                failedWrite = policyWrite.failed;
+                if (policyWrite.kind === "empty") {
+                    if (writeMiss !== undefined && policyWrite.data === null) {
+                        refuseWrite(await writeMiss());
+                    }
+                    return materialize(policyWrite.data, readPlan);
+                }
+                operation = policyWrite.identity;
+                adapterArguments = policyWrite.arguments;
+                readPlan = policyWrite.plan;
+                settle = policyWrite.settle;
+            }
+            else if (request.policy !== undefined && request.family === "find") {
+                const read = await enforceReadPolicy(request.policy.on({ executor, boundary: adapterBoundary }), dependencies.contracts.core, dependencies.config.adapter.model, request, readPlan, adapterArguments);
+                if (read.kind === "refused") {
+                    throw thrownFailure(read.response);
+                }
+                if (read.kind === "empty") {
+                    const miss = uniqueMissFailure(request, read.data);
+                    if (miss !== undefined) {
+                        throw thrownFailure(miss);
+                    }
+                    return materialize(read.data, readPlan);
+                }
+                operation = read.identity;
+                adapterArguments = read.arguments;
+                readPlan = read.plan;
+                settle = read.settle;
+            }
+            const { policy: _session, ...identity } = operation;
+            let adapterData;
+            try {
+                adapterData = await adapterBoundary.execute(() => executor.execute({
+                    ...identity,
+                    resource: request.resource,
+                    arguments: adapterArguments,
+                }));
+            }
+            catch (error) {
+                const missed = failedWrite === undefined
+                    ? undefined
+                    : await failedWrite(error).catch(() => undefined);
+                if (missed !== undefined) {
+                    refuseWrite(missed);
+                }
+                throw error;
+            }
+            if (writeMiss !== undefined && adapterData === null) {
+                refuseWrite(await writeMiss());
+            }
+            const miss = uniqueMissFailure(request, adapterData);
+            if (miss !== undefined) {
+                throw thrownFailure(miss);
+            }
+            if (settle !== undefined) {
+                const settled = await settle(adapterData);
+                if (!settled.ok) {
+                    if (policyWrite !== undefined) {
+                        refuseWrite(settled.response);
+                    }
+                    throw thrownFailure(settled.response);
+                }
+                adapterData = settled.data;
+            }
             return materialize(adapterData, readPlan);
         };
-        for (let index = pipelines.interceptors.length - 1; index >= 0; index -= 1) {
-            const interceptor = pipelines.interceptors[index];
-            if (interceptor === undefined) {
-                continue;
-            }
-            const next = invoke;
-            invoke = () => interceptor(pipelineContext(contract, request, args), next);
-        }
-        let data = await invoke();
-        if (!readMaterialized) {
-            data = await materialize(data, planReadOperation(dependencies.contracts.core, contract, scopeConfig.behaviors, request, args));
-        }
-        for (const hook of pipelines.hooks.after) {
-            await hook(data, pipelineContext(contract, request, args));
+        const materialized = async (data) => readMaterialized
+            ? data
+            : materialize(data, planReadOperation(dependencies.contracts.core, dependencies.config.adapter.model, contract, scopeConfig.compute, request, args));
+        const data = await materialized(await runLevelLifecycle(levels, context, invoke, materialized, reuse, () => new AvInterceptorNextError()));
+        if (policyFailure !== undefined) {
+            return policyFailure;
         }
         if (!outputAccepted(contract, request, executedReadPlan?.projection, data, report)) {
             return internalFailure();