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

package/dist/transactions/transaction-request.d.ts

@@ -1,26 +1,39 @@
 import type { ClientProtocolIdentity } from "../runtime/operation-request.js";
-import type { PipelineTransportContext } from "../runtime/pipeline.js";
+import type { AvTransportContext } from "../runtime/pipeline.js";
+import type { AvState } from "../runtime/request-state.js";
 type TransactionRequestBase = {
     readonly requestId: string;
     readonly plan: unknown;
+    /**
+     * The run's `ctx.$state`: every step's stages and the transaction stages share
+     * this one object. Omitted, it is a fresh `{}`.
+     */
+    readonly state?: AvState;
 };
 /** An in-process transaction request, run under the Application Contract. */
 export type ApplicationTransactionRequest = TransactionRequestBase & {
-    readonly scope: "application";
+    readonly origin: "application";
     readonly protocol?: never;
     readonly transport?: never;
 };
 /** A remote transaction request, run under the Client Contract. */
 export type ClientTransactionRequest = TransactionRequestBase & {
-    readonly scope: "client";
+    readonly origin: "client";
     readonly protocol: ClientProtocolIdentity;
-    readonly transport?: PipelineTransportContext;
+    readonly transport?: AvTransportContext;
+};
+/** An AI agent's transaction request, run under the Agent Contract. */
+export type AgentTransactionRequest = TransactionRequestBase & {
+    readonly origin: "agent";
+    readonly protocol: ClientProtocolIdentity;
+    readonly transport?: AvTransportContext;
 };
 /** One transaction request, as `framework.executeTransaction` takes it. */
-export type FrameworkTransactionRequest = ApplicationTransactionRequest | ClientTransactionRequest;
+export type FrameworkTransactionRequest = ApplicationTransactionRequest | ClientTransactionRequest | AgentTransactionRequest;
 /**
  * The origin one plan operation runs under: its own layer's Contract, its own
- * pipelines, and — for a client step — the protocol identity it is accepted with.
+ * pipelines, and — for a client or agent step — the protocol identity it is
+ * accepted with.
  */
-export type TransactionOperationOrigin = Pick<ApplicationTransactionRequest, "scope"> | Pick<ClientTransactionRequest, "scope" | "protocol" | "transport">;
+export type TransactionOperationOrigin = Pick<ApplicationTransactionRequest, "origin"> | Pick<ClientTransactionRequest, "origin" | "protocol" | "transport"> | Pick<AgentTransactionRequest, "origin" | "protocol" | "transport">;
 export {};

package/dist/transactions/transaction-response.d.ts

@@ -1,15 +1,20 @@
-import type { OperationFailureResponse } from "../runtime/operation-response.js";
+import type { AvOperationFailureResponse } from "../runtime/operation-response.js";
 /** A committed plan: each operation's final `data`, in plan order. */
-export type TransactionCommittedResponse<T = readonly unknown[]> = {
+export type AvTransactionCommittedResponse<T = readonly unknown[]> = {
     readonly data: T;
     readonly code: "A1009";
     readonly cause: null;
 };
 /** What a transaction answers: committed (`A1009`) or a failure. */
-export type TransactionResponse = TransactionCommittedResponse | OperationFailureResponse;
+export type AvTransactionResponse = AvTransactionCommittedResponse | AvOperationFailureResponse;
 /** Builds the committed response. */
-export declare function transactionCommitted(results: readonly unknown[]): TransactionCommittedResponse;
-/** Builds the failure response of a plan step, naming the step in `cause.operation`. */
-export declare function transactionOperationFailure(failure: OperationFailureResponse, operation: number): OperationFailureResponse;
+export declare function transactionCommitted(results: readonly unknown[]): AvTransactionCommittedResponse;
+/**
+ * Builds the failure response of a plan step: the step named in
+ * `cause.operation`, and each issue at its full plan location —
+ * `["operations", operation, "args", …]` for the step's arguments,
+ * `["operations", operation, …]` for the step itself.
+ */
+export declare function transactionOperationFailure(failure: AvOperationFailureResponse, operation: number): AvOperationFailureResponse;
 /** Builds the `A3002` response for a transaction that itself failed. */
-export declare function transactionInfrastructureFailure(operation?: number): OperationFailureResponse;
+export declare function transactionInfrastructureFailure(operation?: number): AvOperationFailureResponse;

package/dist/transactions/transaction-response.js

@@ -1,13 +1,36 @@
+import { OPERATION_ARGUMENTS_PATH, planOperationArgumentsPath, planStepPath, } from "../runtime/error-boundary.js";
 import { operationFailure } from "../runtime/operation-response.js";
 export function transactionCommitted(results) {
     return { data: results, code: "A1009", cause: null };
 }
 export function transactionOperationFailure(failure, operation) {
+    const { issues, ...cause } = failure.cause;
     return operationFailure(failure.code, {
-        ...failure.cause,
+        ...cause,
+        ...(issues === undefined
+            ? {}
+            : { issues: issues.map((issue) => atPlanLocation(issue, operation)) }),
         operation,
     });
 }
+function isPlanLocated(path) {
+    return path[0] === "operations" && typeof path[1] === "number";
+}
+function atPlanLocation(issue, operation) {
+    const { path } = issue;
+    if (path === undefined || isPlanLocated(path)) {
+        return issue;
+    }
+    return {
+        ...issue,
+        path: path[0] === OPERATION_ARGUMENTS_PATH[0]
+            ? [
+                ...planOperationArgumentsPath(operation),
+                ...path.slice(OPERATION_ARGUMENTS_PATH.length),
+            ]
+            : [...planStepPath(operation), ...path],
+    };
+}
 export function transactionInfrastructureFailure(operation) {
     return operationFailure("A3002", {
         message: "Transaction failed.",

package/dist/transactions/transaction-runtime.d.ts

@@ -1,20 +1,23 @@
-import type { AdapterModel } from "../adapters/adapter-model.js";
+import type { AvAdapterModel } from "../adapters/adapter-model.js";
 import type { TransactionDiagnosticsChannel } from "../runtime/diagnostics-reporter.js";
-import type { OperationRuntimeDependencies } from "../runtime/operation-runtime.js";
+import type { OperationPipelineDependencies, OperationRuntimeDependencies } from "../runtime/operation-runtime.js";
+import type { PlanArguments } from "./transaction-plan-validator.js";
 import type { FrameworkTransactionRequest, TransactionOperationOrigin } from "./transaction-request.js";
-import type { TransactionResponse } from "./transaction-response.js";
+import type { AvTransactionResponse } from "./transaction-response.js";
 /**
  * The transaction executor core. Like the operation executor it owns no
  * diagnostics channel: the framework factory binds one to the request and
  * hands it in, so every report of a plan travels the same route.
  *
  * `origins`, when given, states each operation's own origin (the typed
- * runner's mixed plans); see `validateTransactionPlan`.
+ * runner's mixed plans), and `planArguments` whether the steps' arguments are
+ * copied at the door; see `validateTransactionPlan`.
  */
-export type FrameworkTransactionExecutor = (request: FrameworkTransactionRequest, diagnostics: TransactionDiagnosticsChannel, origins?: readonly TransactionOperationOrigin[]) => Promise<TransactionResponse>;
+export type FrameworkTransactionExecutor = (request: FrameworkTransactionRequest, diagnostics: TransactionDiagnosticsChannel, origins: readonly TransactionOperationOrigin[] | undefined, planArguments: PlanArguments) => Promise<AvTransactionResponse>;
 /**
  * Validates a whole plan through the Framework Validation Layer, then runs it inside
- * exactly one Adapter transaction. Guards, pipes, hooks and interceptors of every plan
- * operation run while the provider transaction is open.
+ * exactly one Adapter transaction. The touched Resources' transaction stages and
+ * every plan operation's guards, pipes, hooks and interceptors run while the
+ * provider transaction is open.
  */
-export declare function createTransactionRuntime<M extends AdapterModel>(dependencies: OperationRuntimeDependencies<M>): FrameworkTransactionExecutor;
+export declare function createTransactionRuntime<M extends AvAdapterModel>(dependencies: OperationRuntimeDependencies<M>, pipelineDependencies: OperationPipelineDependencies<M>): FrameworkTransactionExecutor;

package/dist/transactions/transaction-runtime.js

@@ -1,80 +1,197 @@
-import { planOperationArgumentsPath } from "../runtime/error-boundary.js";
-import { internalFailure } from "../runtime/operation-response.js";
-import { executeValidatedOperation } from "../runtime/operation-runtime.js";
+import { transactionLevelsOf } from "../config/pipeline-tree.resolver.js";
+import { AdapterBoundary, planOperationArgumentsPath, planStepPath, sanitizeOperationFailure, } from "../runtime/error-boundary.js";
+import { isPlainRecord, valueAt } from "../runtime/field-stage.runtime.js";
+import { internalFailure, operationSuccess, } from "../runtime/operation-response.js";
+import { admitOperation, executeAdmittedOperation, prepareStep, withRequestState, } from "../runtime/operation-runtime.js";
 import { mapValidationOutcome } from "../runtime/outcome-mapper.js";
 import { resolveCascadeClosure } from "../runtime/referential-action.js";
-import { TransactionIntegrityError } from "./transaction-integrity-error.js";
+import { AvTransactionIntegrityError } from "./transaction-integrity-error.js";
 import { validateTransactionPlan } from "./transaction-plan-validator.js";
-import { resolveTransactionReferences } from "./transaction-reference-resolver.js";
+import { resolveSqlStatement, resolveTransactionReferences, } from "./transaction-reference-resolver.js";
 import { transactionCommitted, transactionInfrastructureFailure, transactionOperationFailure, } from "./transaction-response.js";
-const TRANSACTION_ABORT = Object.freeze({ reason: "aventara-transaction-abort" });
-export function createTransactionRuntime(dependencies) {
-    const { adapter, ...runtimeDependencies } = dependencies;
-    const pipelineDependencies = {
-        ...runtimeDependencies,
-        createRequirements: adapter.createRequirements ?? {},
-    };
+import { settleTransaction } from "./transaction-settlement.runtime.js";
+import { touchedTransactionLevels, transactionFacts, } from "./transaction-stage.runtime.js";
+export function createTransactionRuntime(dependencies, pipelineDependencies) {
+    const { adapter } = dependencies;
     const planDependencies = {
         ...pipelineDependencies,
         cascades: resolveCascadeClosure(adapter.referentialActions),
+        sqlStatements: adapter.sqlStatements === true,
     };
-    return async (request, diagnostics, origins) => {
-        const validation = await validateTransactionPlan(planDependencies, request, origins);
+    return async (seeded, diagnostics, origins, planArguments) => {
+        const request = withRequestState(seeded);
+        const validation = await validateTransactionPlan(planDependencies, request, origins, planArguments);
         if (!validation.ok) {
             return validation.response;
         }
-        return executeTransactionPlan(adapter, pipelineDependencies, validation.plan, diagnostics);
+        return executeTransactionPlan(adapter, pipelineDependencies, request, validation.plan, request.state, diagnostics);
     };
 }
-async function executeTransactionPlan(adapter, dependencies, plan, diagnostics) {
-    const ledger = { results: [], failure: undefined };
-    const infrastructureFailure = (error) => {
-        const operation = ledger.failure?.operation;
-        diagnostics.transaction(operation)(error, "A3002");
-        return transactionInfrastructureFailure(operation);
+function planOrigin(request, plan) {
+    for (const step of plan.operations) {
+        if (step.kind === "operation") {
+            return step.request;
+        }
+    }
+    return request;
+}
+function stepView(step, args) {
+    if (step.kind === "sql") {
+        return {
+            sql: {
+                strings: step.strings,
+                values: step.values.map((value) => value.kind === "value"
+                    ? value.value
+                    : { $ref: { operation: value.operation, path: [value.field] } }),
+            },
+        };
+    }
+    return {
+        resource: step.request.resource,
+        family: step.request.family,
+        variant: step.request.variant,
+        args,
     };
-    if (typeof adapter.transaction !== "function") {
-        return infrastructureFailure(new TransactionIntegrityError("transaction-unavailable"));
+}
+function pathKey(path) {
+    return JSON.stringify(path);
+}
+function relativeSlotPath(operation, path) {
+    return path.slice(planOperationArgumentsPath(operation.index).length);
+}
+function standsAt(args, path, slot) {
+    const value = valueAt(args, path);
+    if (value === slot.reference) {
+        return true;
     }
-    const runPlanOperation = async (operation, executor) => {
+    const reference = isPlainRecord(value) ? value.$ref : undefined;
+    if (!isPlainRecord(reference) || !Array.isArray(reference.path)) {
+        return false;
+    }
+    const expected = slot.reference.$ref;
+    return (reference.operation === expected.operation &&
+        reference.path.length === 1 &&
+        reference.path[0] === expected.path[0]);
+}
+function slotKeys(operation) {
+    return new Set(operation.references.map((slot) => pathKey(relativeSlotPath(operation, slot.path))));
+}
+async function executeTransactionPlan(adapter, dependencies, request, plan, state, diagnostics) {
+    const stateful = (operation) => ({ ...operation.request, state });
+    const admitted = [];
+    for (const step of plan.operations) {
+        if (step.kind === "sql") {
+            admitted.push({ ok: true, args: undefined, piped: false });
+            continue;
+        }
+        const references = slotKeys(step);
+        const admission = await admitOperation(dependencies, stateful(step), step.contract, step.arguments, planOperationArgumentsPath(step.index), diagnostics.operation(step.request, step.index), { requestId: request.requestId, transaction: undefined, state }, {
+            select: (path) => !references.has(pathKey(path)),
+            validation: { transactionReferences: true },
+        });
+        if (!admission.ok) {
+            return transactionOperationFailure(admission.response, step.index);
+        }
+        admitted.push(admission);
+    }
+    const origin = planOrigin(request, plan);
+    const contract = dependencies.contracts[origin.origin];
+    const tree = dependencies.config[origin.origin].pipelines;
+    const view = plan.operations.map((step, index) => stepView(step, admitted[index]?.args));
+    const runPlanOperation = async (operation, args, transactionPiped, executor, results, outer) => {
         const report = diagnostics.operation(operation.request, operation.index);
+        const argumentsPath = planOperationArgumentsPath(operation.index);
+        const stepRequest = stateful(operation);
         try {
-            const resolved = resolveTransactionReferences(operation, ledger.results);
+            const live = operation.references.filter((slot) => standsAt(args, relativeSlotPath(operation, slot.path), slot));
+            const resolved = resolveTransactionReferences({
+                ...operation,
+                arguments: args,
+                references: live,
+            }, results);
             if (!resolved.ok) {
                 return mapValidationOutcome(resolved.issues);
             }
-            return await executeValidatedOperation(dependencies, operation.request, operation.contract, resolved.arguments, planOperationArgumentsPath(operation.index), executor, report);
+            const written = new Set(live
+                .filter((slot) => slot.written)
+                .map((slot) => pathKey(relativeSlotPath(operation, slot.path))));
+            const prepared = await prepareStep(dependencies, stepRequest, operation.contract, resolved.arguments, argumentsPath, report, executor, {
+                written: (path) => written.has(pathKey(path)),
+                transactionPiped,
+                pipedAroundReferences: admitted[operation.index]?.piped === true &&
+                    operation.references.length > 0,
+            }, outer);
+            if (!prepared.ok) {
+                return prepared.response;
+            }
+            return await executeAdmittedOperation(dependencies, stepRequest, operation.contract, prepared.args, argumentsPath, { kind: "transaction", executor, outer }, report);
         }
         catch (error) {
             report(error, "A3000");
             return internalFailure();
         }
     };
-    try {
-        await adapter.transaction(async (executor) => {
-            for (const operation of plan.operations) {
-                const response = await runPlanOperation(operation, executor);
-                if (response.cause !== null) {
-                    ledger.failure = { response, operation: operation.index };
-                    throw TRANSACTION_ABORT;
-                }
-                ledger.results.push(response.data);
+    const runSqlStatement = async (step, executor, results) => {
+        const report = diagnostics.transaction(step.index);
+        const boundary = new AdapterBoundary();
+        try {
+            const resolved = resolveSqlStatement(step, results);
+            if (!resolved.ok) {
+                return mapValidationOutcome(resolved.issues);
+            }
+            if (typeof executor.executeSql !== "function") {
+                report(new AvTransactionIntegrityError("statement-unavailable"), "A3002");
+                return transactionInfrastructureFailure();
+            }
+            const executeSql = executor.executeSql.bind(executor);
+            try {
+                const rows = await boundary.execute(async () => {
+                    const answer = await executeSql(resolved.statement);
+                    if (!Array.isArray(answer)) {
+                        throw new TypeError("Adapter executeSql must resolve the statement's rows as an array.");
+                    }
+                    return answer;
+                });
+                return operationSuccess([...rows], "A1000");
+            }
+            catch (error) {
+                return sanitizeOperationFailure(error, boundary.originOf(error), report, {
+                    path: [...planStepPath(step.index), "values"],
+                    arguments: resolved.statement.values,
+                });
             }
-        });
-    }
-    catch (error) {
-        if (error !== TRANSACTION_ABORT) {
-            return infrastructureFailure(error);
         }
-        return ledger.failure === undefined
-            ? infrastructureFailure(new TransactionIntegrityError("foreign-abort"))
-            : transactionOperationFailure(ledger.failure.response, ledger.failure.operation);
-    }
-    if (ledger.failure !== undefined) {
-        return infrastructureFailure(new TransactionIntegrityError("resolved-after-abort"));
-    }
-    if (ledger.results.length !== plan.operations.length) {
-        return infrastructureFailure(new TransactionIntegrityError("resolved-incomplete"));
+        catch (error) {
+            report(error, "A3000");
+            return internalFailure();
+        }
+    };
+    const settled = await settleTransaction({
+        adapter,
+        levels: touchedTransactionLevels(view, (resource) => transactionLevelsOf(tree, resource)),
+        plan: view,
+        contextOf: (current, executor) => dependencies.contexts.transaction({ requestId: origin.requestId, transaction: executor, state }, transactionFacts(contract, origin, current)),
+        failureView: { path: ["operations"], arguments: view },
+        report: diagnostics.transaction(),
+        runStep: (index, step, piped, executor, results, outer) => {
+            const operation = plan.operations[index];
+            if (operation === undefined) {
+                throw new TypeError(`Transaction step ${index} is not in the plan.`);
+            }
+            return operation.kind === "sql"
+                ? runSqlStatement(operation, executor, results)
+                : runPlanOperation(operation, step.args, piped, executor, results, outer);
+        },
+    });
+    switch (settled.kind) {
+        case "committed":
+            return transactionCommitted(settled.responses.map((response) => response.data));
+        case "rolled-back":
+            return settled.operation === undefined
+                ? settled.response
+                : transactionOperationFailure(settled.response, settled.operation);
+        case "broken":
+            diagnostics.transaction(settled.operation)(settled.error, "A3002");
+            return transactionInfrastructureFailure(settled.operation);
     }
-    return transactionCommitted([...ledger.results]);
 }

package/dist/transactions/transaction-settlement.runtime.d.ts

@@ -0,0 +1,51 @@
+import type { AvAdapter } from "../adapters/adapter.interface.js";
+import type { AvAdapterModel } from "../adapters/adapter-model.js";
+import type { AvAdapterTransactionExecutor } from "../adapters/adapter-transaction-executor.interface.js";
+import type { ResolvedTransactionPipelineConfig } from "../config/pipeline-config.js";
+import type { DiagnosticsReporter } from "../runtime/diagnostics-reporter.js";
+import { type CallerArgumentsView, type OuterFailureLayer } from "../runtime/error-boundary.js";
+import type { AvOperationFailureResponse, AvOperationResponse } from "../runtime/operation-response.js";
+import type { AvTransactionContext } from "../runtime/pipeline.js";
+import { type TransactionStepView } from "./transaction-stage.runtime.js";
+/**
+ * Runs one step inside the open transaction: `step` as the transaction pipes
+ * left it, `piped` whether one ran, `results` the completed steps' data in plan
+ * order, `outer` where an error the step's own filters leave unhandled is handed:
+ * the touched Resources' transaction filters answer it once the transaction
+ * interceptors have unwound. Its answer is the step's own outcome.
+ */
+export type TransactionStepRunner<M extends AvAdapterModel> = (index: number, step: TransactionStepView, piped: boolean, executor: AvAdapterTransactionExecutor<M>, results: readonly unknown[], outer: OuterFailureLayer) => Promise<AvOperationResponse>;
+/** How one transaction settled. */
+export type TransactionSettlement = 
+/** Committed: every step's own outcome, in plan order. */
+{
+    readonly kind: "committed";
+    readonly responses: readonly AvOperationResponse[];
+}
+/** Rolled back on a deliberate outcome: a step's (with its index) or a stage's. */
+ | {
+    readonly kind: "rolled-back";
+    readonly response: AvOperationFailureResponse;
+    readonly operation: number | undefined;
+}
+/** The transaction contract broke: `A3002`, the error for diagnostics. */
+ | {
+    readonly kind: "broken";
+    readonly error: unknown;
+    readonly operation: number | undefined;
+};
+export type TransactionSettlementInput<M extends AvAdapterModel> = {
+    readonly adapter: AvAdapter<M>;
+    /** The touched Resources' transaction levels, outer to inner. */
+    readonly levels: readonly ResolvedTransactionPipelineConfig[];
+    readonly plan: readonly TransactionStepView[];
+    /** The ctx a transaction stage is told, bound to the open transaction. */
+    readonly contextOf: (plan: readonly TransactionStepView[], executor: AvAdapterTransactionExecutor<M>) => AvTransactionContext;
+    /** What a stage failure's filters may read as the caller's arguments. */
+    readonly failureView: CallerArgumentsView;
+    /** The channel a transaction stage's own failure is reported on. */
+    readonly report: DiagnosticsReporter;
+    readonly runStep: TransactionStepRunner<M>;
+};
+/** Runs `plan` inside one Adapter transaction, its stages around its steps, and settles it. */
+export declare function settleTransaction<M extends AvAdapterModel>(input: TransactionSettlementInput<M>): Promise<TransactionSettlement>;

package/dist/transactions/transaction-settlement.runtime.js

@@ -0,0 +1,120 @@
+import { filterChain, resolveUnhandledFailure, sanitizeOperationFailure, } from "../runtime/error-boundary.js";
+import { thrownFailure } from "../runtime/framework-error.factory.js";
+import { operationFailure } from "../runtime/operation-response.js";
+import { AvTransactionIntegrityError } from "./transaction-integrity-error.js";
+import { resolveTransactionStageFailure, runTransactionStages, TRANSACTION_ABORT, } from "./transaction-stage.runtime.js";
+export async function settleTransaction(input) {
+    const { adapter, levels, plan, contextOf } = input;
+    if (typeof adapter.transaction !== "function") {
+        return {
+            kind: "broken",
+            error: new AvTransactionIntegrityError("transaction-unavailable"),
+            operation: undefined,
+        };
+    }
+    const ledger = { results: [], responses: [], failure: undefined, deferred: undefined };
+    const { results, responses } = ledger;
+    const failedOperation = () => ledger.failure?.kind === "rolled-back"
+        ? ledger.failure.operation
+        : undefined;
+    try {
+        await adapter.transaction(async (executor) => {
+            const staged = await runTransactionStages(levels, plan, (current) => contextOf(current, executor), async ({ plan: current, piped }) => {
+                const outer = {
+                    defer: (failure) => {
+                        ledger.deferred = { failure, plan: current };
+                        return sanitizeOperationFailure(failure.error, failure.boundary.originOf(failure.error), () => { }, failure.view);
+                    },
+                };
+                for (const [index, step] of current.entries()) {
+                    const response = await input.runStep(index, step, piped, executor, results, outer);
+                    if (response.cause !== null) {
+                        ledger.failure = {
+                            kind: "rolled-back",
+                            response,
+                            operation: index,
+                        };
+                        throw thrownFailure(response);
+                    }
+                    results.push(response.data);
+                    responses.push(response);
+                }
+                return [...results];
+            });
+            if (staged.kind === "broken") {
+                ledger.failure = { kind: "broken", error: staged.error };
+                throw TRANSACTION_ABORT;
+            }
+            const deferred = ledger.deferred;
+            if (deferred !== undefined && ledger.failure?.kind === "rolled-back") {
+                ledger.failure = {
+                    ...ledger.failure,
+                    response: await resolveUnhandledFailure(deferred.failure, filterChain(levels.flatMap((level) => level.filters), contextOf(deferred.plan, executor))),
+                };
+            }
+            if (staged.kind === "ran") {
+                if (ledger.failure === undefined && results.length !== plan.length) {
+                    ledger.failure = {
+                        kind: "broken",
+                        error: new AvTransactionIntegrityError("steps-not-run"),
+                    };
+                }
+                if (ledger.failure !== undefined) {
+                    throw TRANSACTION_ABORT;
+                }
+                return;
+            }
+            if (ledger.failure === undefined) {
+                let response;
+                if (staged.kind === "denied") {
+                    response = operationFailure("A4001", {
+                        message: "Operation denied by a framework guard.",
+                    });
+                }
+                else if (staged.kind === "refused") {
+                    input.report(staged.refusal.error, "A3004");
+                    response = staged.refusal.response;
+                }
+                else {
+                    response = await resolveTransactionStageFailure(staged.error, levels, contextOf(plan, executor), input.report, input.failureView);
+                }
+                ledger.failure = {
+                    kind: "rolled-back",
+                    response,
+                    operation: undefined,
+                };
+            }
+            throw TRANSACTION_ABORT;
+        });
+    }
+    catch (error) {
+        if (error !== TRANSACTION_ABORT) {
+            return { kind: "broken", error, operation: failedOperation() };
+        }
+        if (ledger.failure === undefined) {
+            return {
+                kind: "broken",
+                error: new AvTransactionIntegrityError("foreign-abort"),
+                operation: undefined,
+            };
+        }
+        return ledger.failure.kind === "broken"
+            ? { kind: "broken", error: ledger.failure.error, operation: undefined }
+            : ledger.failure;
+    }
+    if (ledger.failure !== undefined) {
+        return {
+            kind: "broken",
+            error: new AvTransactionIntegrityError("resolved-after-abort"),
+            operation: failedOperation(),
+        };
+    }
+    if (responses.length !== plan.length) {
+        return {
+            kind: "broken",
+            error: new AvTransactionIntegrityError("resolved-incomplete"),
+            operation: undefined,
+        };
+    }
+    return { kind: "committed", responses };
+}

package/dist/transactions/transaction-slot-path-error.d.ts

@@ -2,13 +2,13 @@
  * The ways a transaction slot path can fail to name a member of its argument
  * view. Each is a framework defect, not a caller error.
  */
-export type TransactionSlotPathViolation = "slot-prefix" | "absent-member" | "non-object-ancestor";
+export type AvTransactionSlotPathViolation = "slot-prefix" | "absent-member" | "non-object-ancestor";
 /**
  * Thrown internally when a slot path does not name a member of its argument
  * view; the caller receives `A3000`, and the diagnostics sink receives this
  * error.
  */
-export declare class TransactionSlotPathError extends Error {
-    readonly violation: TransactionSlotPathViolation;
-    constructor(violation: TransactionSlotPathViolation);
+export declare class AvTransactionSlotPathError extends Error {
+    readonly violation: AvTransactionSlotPathViolation;
+    constructor(violation: AvTransactionSlotPathViolation);
 }

package/dist/transactions/transaction-slot-path-error.js

@@ -3,11 +3,11 @@ const TRANSACTION_SLOT_PATH_MESSAGES = {
     "absent-member": "Transaction slot path names an absent member of the operation arguments.",
     "non-object-ancestor": "Transaction slot path descends through a non-object value.",
 };
-export class TransactionSlotPathError extends Error {
+export class AvTransactionSlotPathError extends Error {
     violation;
     constructor(violation) {
         super(TRANSACTION_SLOT_PATH_MESSAGES[violation]);
-        this.name = "TransactionSlotPathError";
+        this.name = "AvTransactionSlotPathError";
         this.violation = violation;
     }
 }

package/dist/transactions/transaction-slot-writer.js

@@ -1,6 +1,6 @@
-import { TransactionSlotPathError } from "./transaction-slot-path-error.js";
+import { AvTransactionSlotPathError } from "./transaction-slot-path-error.js";
 function slotPathMismatch(violation) {
-    throw new TransactionSlotPathError(violation);
+    throw new AvTransactionSlotPathError(violation);
 }
 function cloneContainerWithReplacement(container, property, replacement) {
     const array = Array.isArray(container);