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

package/dist/runtime/level-lifecycle.runtime.js

@@ -0,0 +1,42 @@
+import { frozenCopy } from "./readonly-value.js";
+export async function runLevelLifecycle(levels, context, inner, settle, reuse, refuse) {
+    const once = (run) => {
+        let called = false;
+        return () => {
+            if (called) {
+                const refusal = refuse();
+                reuse.refusal ??= refusal;
+                return Promise.reject(refusal);
+            }
+            called = true;
+            return run();
+        };
+    };
+    const hooked = async () => {
+        for (const level of levels) {
+            for (const hook of level.hooks.before) {
+                await hook(context());
+            }
+        }
+        const result = await settle(await inner());
+        const after = [...levels].reverse().flatMap((level) => level.hooks.after);
+        if (after.length > 0) {
+            const told = frozenCopy(result);
+            for (const hook of after) {
+                await hook(told, context());
+            }
+        }
+        return result;
+    };
+    const interceptors = levels.flatMap((level) => level.interceptors);
+    let next = hooked;
+    for (let index = interceptors.length - 1; index >= 0; index -= 1) {
+        const interceptor = interceptors[index];
+        if (interceptor === undefined) {
+            continue;
+        }
+        const continuation = once(next);
+        next = () => interceptor(context(), async () => settle(await continuation()));
+    }
+    return next();
+}

package/dist/runtime/misuse-reporter.d.ts

@@ -1,32 +1,32 @@
-import type { RequestOrigin } from "../config/config-layer.js";
-import type { OperationFamily } from "../operations/operation-identity.js";
+import type { AvRequestOrigin } from "../config/config-layer.js";
+import type { AvOperationFamily } from "../operations/operation-identity.js";
 /**
  * One caller value the framework refused because it could not be read
  * (`"unreadable-value"`: a revoked Proxy, a throwing getter or trap) or is not plain
- * data (`"non-plain-value"`: a class instance other than `Date`, `Decimal` or
+ * data (`"non-plain-value"`: a class instance other than `Date`, `AvDecimal` or
  * `Uint8Array`). The caller received `A2004` with one `V1001` at `path`.
  *
- * The operation's identity is present when the framework could read it — absent for
- * a request whose own envelope could not be read — and `operation` is the step's
+ * The operation's identity is present when the framework could read it (absent for
+ * a request whose own envelope could not be read), and `operation` is the step's
  * index in a transaction plan.
  */
-export type FrameworkMisuseEvent = {
+export type AvMisuseEvent = {
     readonly kind: "unreadable-value" | "non-plain-value";
     /** The issue path the caller received. */
     readonly path: readonly (string | number)[];
-    readonly origin?: RequestOrigin;
+    readonly origin?: AvRequestOrigin;
     readonly resource?: string;
-    readonly family?: OperationFamily;
+    readonly family?: AvOperationFamily;
     readonly variant?: string;
     readonly operation?: number;
 };
 /**
- * Receives a {@link FrameworkMisuseEvent} for every caller value the framework
+ * Receives a {@link AvMisuseEvent} for every caller value the framework
  * refused as unreadable or not plain data. Set once, as the root configuration's
  * `misuse`. What it returns, throws or rejects with never reaches the response.
  */
-export type FrameworkMisuseSink = (event: FrameworkMisuseEvent) => void | Promise<void>;
+export type AvMisuseSink = (event: AvMisuseEvent) => void | Promise<void>;
 /** The channel as the runtime holds it: total, never awaited. */
-export type MisuseReporter = (event: FrameworkMisuseEvent) => void;
+export type MisuseReporter = (event: AvMisuseEvent) => void;
 /** Binds the configured sink; without one, nothing is observed. */
-export declare function createMisuseReporter(sink: FrameworkMisuseSink | undefined): MisuseReporter;
+export declare function createMisuseReporter(sink: AvMisuseSink | undefined): MisuseReporter;

package/dist/runtime/mutation-planner.d.ts

@@ -1,8 +1,9 @@
-import type { FrameworkBehaviorsConfig } from "../config/framework-behaviors-config.js";
-import type { RelationMutationDirective } from "../contracts/capability.js";
-import type { Contract, CoreContract } from "../contracts/contract.js";
+import type { ResolvedComputeConfig } from "../config/field-compute.resolver.js";
+import type { AvRelationMutationDirective } from "../contracts/capability.js";
+import type { AvContract, AvContractCore } from "../contracts/contract.js";
+import type { AvComputeContext } from "./field-compute.js";
+import type { NestedWriteTarget } from "./nested-write.walker.js";
 import type { OperationExecutionRequest } from "./operation-request.js";
-import type { PipelineContext } from "./pipeline.js";
 /**
  * The two Contracts a write reads. The Core Contract decides what the Adapter is asked
  * to store; the active Contract adds the fields its scope declared under
@@ -10,11 +11,11 @@ import type { PipelineContext } from "./pipeline.js";
  * virtual: its behaviours run and its value is stripped before the Adapter call.
  */
 export type WriteContracts = {
-    readonly core: CoreContract;
-    readonly active: Contract;
+    readonly core: AvContractCore;
+    readonly active: AvContract;
 };
 type WriteStage = "create" | "update";
-type ContextFactory = (args: unknown) => PipelineContext;
+type ContextFactory = (args: unknown) => AvComputeContext;
 export type RelationRecordSite = {
     readonly key: string | undefined;
     readonly stage: WriteStage;
@@ -53,9 +54,17 @@ export declare const RELATION_MUTATION_RECORD_SITES: {
  * membership, not an assertion: `Object.prototype` members resolve through the
  * prototype chain and would otherwise reach a site loop with a non-iterable.
  */
-export declare function isRelationMutationDirective(key: string): key is RelationMutationDirective;
-/** Apply effective computed create/update field behavior to post-pipe logical args. */
-export declare function applyWriteFieldBehaviors(contracts: WriteContracts, behaviors: FrameworkBehaviorsConfig | undefined, request: OperationExecutionRequest, args: unknown, contextFactory: ContextFactory): Promise<unknown>;
+export declare function isRelationMutationDirective(key: string): key is AvRelationMutationDirective;
+/** Apply the effective create/update compute stages to the post-pipe logical args. */
+export declare function applyWriteCompute(contracts: WriteContracts, compute: ResolvedComputeConfig | undefined, request: OperationExecutionRequest, args: unknown, contextFactory: ContextFactory): Promise<unknown>;
+/**
+ * Applies each nested target's write compute, in the targets' order, to its
+ * records: `compute.create` on a created row (an `$upsert`'s `create` branch
+ * too), `compute.update` on an updated one. Each target's stages are told
+ * `context(target, payload)`, the nested target's own context. The arguments
+ * are copied where a record changes, never written.
+ */
+export declare function applyNestedWriteCompute(contracts: WriteContracts, compute: ResolvedComputeConfig | undefined, args: unknown, targets: readonly NestedWriteTarget[], context: (target: NestedWriteTarget, payload: unknown) => AvComputeContext): Promise<unknown>;
 /** Strip VIRTUAL scalar input only at the persistence boundary. */
 export declare function stripVirtualMutationInput(contracts: WriteContracts, request: OperationExecutionRequest, args: unknown): Promise<unknown>;
 export {};

package/dist/runtime/mutation-planner.js

@@ -1,5 +1,6 @@
 import { lookupField, lookupResource } from "../contracts/contract-lookup.js";
-import { ComputedValueError } from "./computed-value.error.js";
+import { AvComputedValueError } from "./computed-value.error.js";
+import { replaceAt, valueAt } from "./field-stage.runtime.js";
 import { jsonShapeIssues, normalizeScalarFieldValue, } from "./scalar-runtime.js";
 function writeScalarField(contracts, resourceName, fieldName) {
     const field = lookupField(lookupResource(contracts.core, resourceName), fieldName) ??
@@ -33,7 +34,7 @@ function cloneRecord(value) {
 function relationEntries(value) {
     return Array.isArray(value) ? value : [value];
 }
-async function computeRecord(contracts, behaviors, request, resourceName, stage, data, contextFactory) {
+async function computeRecord(contracts, compute, resourceName, stage, data, contextFactory) {
     if (!isRecord(data)) {
         return data;
     }
@@ -42,13 +43,13 @@ async function computeRecord(contracts, behaviors, request, resourceName, stage,
         return data;
     }
     const logicalData = cloneRecord(data);
-    const resourceBehaviors = behaviors[resourceName]?.fields;
-    if (resourceBehaviors !== undefined) {
-        for (const [fieldName, fieldBehavior] of Object.entries(resourceBehaviors)) {
-            if (fieldBehavior === undefined) {
+    const resourceCompute = compute[resourceName];
+    if (resourceCompute !== undefined) {
+        for (const [fieldName, fieldCompute] of Object.entries(resourceCompute)) {
+            if (fieldCompute === undefined) {
                 continue;
             }
-            const callback = fieldBehavior[stage];
+            const callback = fieldCompute[stage];
             if (typeof callback !== "function") {
                 continue;
             }
@@ -56,40 +57,43 @@ async function computeRecord(contracts, behaviors, request, resourceName, stage,
             if (field === undefined) {
                 continue;
             }
+            const snapshot = Object.freeze({ ...logicalData });
             const computed = await callback({
-                origin: request.origin,
-                resource: resourceName,
                 field: fieldName,
-                value: logicalData[fieldName],
-                data: logicalData,
-                operation: contextFactory(logicalData),
+                value: snapshot[fieldName],
+                data: snapshot,
+                ctx: contextFactory(snapshot),
             });
             if (computed === undefined) {
                 continue;
             }
-            const validation = normalizeScalarFieldValue(contracts.core, field, computed, "runtime", ["behaviors", resourceName, fieldName, stage]);
+            const validation = normalizeScalarFieldValue(contracts.core, field, computed, "runtime", [
+                "resources",
+                resourceName,
+                "fields",
+                fieldName,
+                "pipelines",
+                "compute",
+                stage,
+            ]);
             if (!validation.ok) {
-                throw new ComputedValueError(resourceName, fieldName, stage, validation.issues);
+                throw new AvComputedValueError(resourceName, fieldName, stage, validation.issues);
             }
             const shapeIssues = jsonShapeIssues(field, validation.value, [
-                "behaviors",
+                "resources",
                 resourceName,
+                "fields",
                 fieldName,
+                "pipelines",
+                "compute",
                 stage,
             ]);
             if (shapeIssues.length > 0) {
-                throw new ComputedValueError(resourceName, fieldName, stage, shapeIssues);
+                throw new AvComputedValueError(resourceName, fieldName, stage, shapeIssues);
             }
             logicalData[fieldName] = validation.value;
         }
     }
-    for (const [fieldName, value] of Object.entries(logicalData)) {
-        const field = lookupField(resource, fieldName);
-        if (field?.kind !== "relation") {
-            continue;
-        }
-        logicalData[fieldName] = await mapRelationMutationRecords(field, value, (targetResource, nestedStage, record) => computeRecord(contracts, behaviors, request, targetResource, nestedStage, record, contextFactory));
-    }
     return logicalData;
 }
 async function mapRelationMutationRecords(relation, value, leaf) {
@@ -125,29 +129,49 @@ async function mapRelationMutationRecords(relation, value, leaf) {
     }
     return normalized;
 }
-export async function applyWriteFieldBehaviors(contracts, behaviors, request, args, contextFactory) {
-    if (behaviors === undefined || !isRecord(args)) {
+export async function applyWriteCompute(contracts, compute, request, args, contextFactory) {
+    if (compute === undefined || !isRecord(args)) {
         return args;
     }
     const logicalArgs = cloneRecord(args);
     if (request.family === "create" && "data" in logicalArgs) {
         logicalArgs.data = Array.isArray(logicalArgs.data)
-            ? await Promise.all(logicalArgs.data.map((entry) => computeRecord(contracts, behaviors, request, request.resource, "create", entry, contextFactory)))
-            : await computeRecord(contracts, behaviors, request, request.resource, "create", logicalArgs.data, contextFactory);
+            ? await Promise.all(logicalArgs.data.map((entry) => computeRecord(contracts, compute, request.resource, "create", entry, contextFactory)))
+            : await computeRecord(contracts, compute, request.resource, "create", logicalArgs.data, contextFactory);
     }
     if (request.family === "update" && "data" in logicalArgs) {
-        logicalArgs.data = await computeRecord(contracts, behaviors, request, request.resource, "update", logicalArgs.data, contextFactory);
+        logicalArgs.data = await computeRecord(contracts, compute, request.resource, "update", logicalArgs.data, contextFactory);
     }
     if (request.family === "upsert") {
         if ("create" in logicalArgs) {
-            logicalArgs.create = await computeRecord(contracts, behaviors, request, request.resource, "create", logicalArgs.create, contextFactory);
+            logicalArgs.create = await computeRecord(contracts, compute, request.resource, "create", logicalArgs.create, contextFactory);
         }
         if ("update" in logicalArgs) {
-            logicalArgs.update = await computeRecord(contracts, behaviors, request, request.resource, "update", logicalArgs.update, contextFactory);
+            logicalArgs.update = await computeRecord(contracts, compute, request.resource, "update", logicalArgs.update, contextFactory);
         }
     }
     return logicalArgs;
 }
+export async function applyNestedWriteCompute(contracts, compute, args, targets, context) {
+    if (compute === undefined) {
+        return args;
+    }
+    let current = args;
+    for (const target of targets) {
+        if (!Object.hasOwn(compute, target.resource)) {
+            continue;
+        }
+        for (const site of target.records) {
+            const record = valueAt(current, site.path);
+            if (!isRecord(record)) {
+                continue;
+            }
+            const computed = await computeRecord(contracts, compute, target.resource, site.stage, record, () => context(target, valueAt(current, target.path)));
+            current = replaceAt(current, site.path, computed);
+        }
+    }
+    return current;
+}
 async function stripVirtualRecord(contracts, resourceName, data) {
     if (!isRecord(data)) {
         return data;

package/dist/runtime/nested-write.walker.d.ts

@@ -0,0 +1,32 @@
+import type { AvContract } from "../contracts/contract.js";
+import type { AvOperationIdentity } from "../operations/operation-identity.js";
+import { type Path } from "./field-stage.runtime.js";
+import type { ReferentialActionTable } from "./referential-action.js";
+/** The family a nested target's stages are told, and its guards are drawn from. */
+export type NestedTargetFamily = "create" | "update" | "delete";
+/** One record of a nested target's data, and the write phase it is. */
+export type NestedRecordSite = {
+    /** Where the record sits in the operation's arguments. */
+    readonly path: Path;
+    /** `create` for a created row (an `$upsert`'s `create` branch too), `update` otherwise. */
+    readonly stage: "create" | "update";
+};
+/** One nested write's target, in data order. */
+export type NestedWriteTarget = {
+    /** The target Resource. */
+    readonly resource: string;
+    readonly family: NestedTargetFamily;
+    /** Where the directive's entry — the nested payload — sits in the arguments. */
+    readonly path: Path;
+    /** The entry's data records the target's field stages run on. */
+    readonly records: readonly NestedRecordSite[];
+};
+/**
+ * Every nested write target in an operation's arguments, depth first in data
+ * order: a target comes before the targets inside its own data, and before the
+ * next directive's. Empty for an operation with no write data. Total over
+ * malformed input.
+ */
+export declare function nestedWriteTargetsOf(contract: AvContract, references: ReferentialActionTable, request: AvOperationIdentity & {
+    readonly resource: string;
+}, args: unknown): readonly NestedWriteTarget[];

package/dist/runtime/nested-write.walker.js

@@ -0,0 +1,73 @@
+import { lookupField, lookupResource } from "../contracts/contract-lookup.js";
+import { isPlainRecord, valueAt, writeRecordPathsOf, } from "./field-stage.runtime.js";
+import { isRelationMutationDirective, RELATION_MUTATION_RECORD_SITES, } from "./mutation-planner.js";
+const DIRECTIVE_FAMILY = {
+    $create: "create",
+    $connectOrCreate: "create",
+    $update: "update",
+    $upsert: "update",
+    $delete: "delete",
+    $connect: "relation",
+    $disconnect: "relation",
+    $set: "relation",
+};
+function holdsReference(references, resource, relation) {
+    const edges = Object.hasOwn(references, resource)
+        ? references[resource]
+        : undefined;
+    return (Array.isArray(edges) &&
+        edges.some((edge) => edge.field === relation));
+}
+function walkRecord(context, resource, path, record) {
+    if (!isPlainRecord(record)) {
+        return;
+    }
+    const owner = lookupResource(context.contract, resource);
+    for (const [key, value] of Object.entries(record)) {
+        const field = lookupField(owner, key);
+        if (field?.kind !== "relation" || !isPlainRecord(value)) {
+            continue;
+        }
+        for (const [directive, operand] of Object.entries(value)) {
+            if (!isRelationMutationDirective(directive)) {
+                continue;
+            }
+            const mapped = DIRECTIVE_FAMILY[directive];
+            if (mapped === "relation" &&
+                field.cardinality === "one" &&
+                holdsReference(context.references, resource, key)) {
+                continue;
+            }
+            const family = mapped === "relation" ? "update" : mapped;
+            const entries = directive !== "$set" && Array.isArray(operand)
+                ? operand.map((_entry, index) => [index])
+                : [[]];
+            for (const at of entries) {
+                const entryPath = [...path, key, directive, ...at];
+                const records = [];
+                for (const site of RELATION_MUTATION_RECORD_SITES[directive]) {
+                    const sitePath = site.key === undefined ? entryPath : [...entryPath, site.key];
+                    if (isPlainRecord(valueAt(record, sitePath.slice(path.length)))) {
+                        records.push({ path: sitePath, stage: site.stage });
+                    }
+                }
+                context.targets.push({
+                    resource: field.target,
+                    family,
+                    path: entryPath,
+                    records,
+                });
+                for (const site of records) {
+                    walkRecord(context, field.target, site.path, valueAt(record, site.path.slice(path.length)));
+                }
+            }
+        }
+    }
+}
+export function nestedWriteTargetsOf(contract, references, request, args) {
+    const context = { contract, references, targets: [] };
+    for (const path of writeRecordPathsOf(request.family, args)) {
+        walkRecord(context, request.resource, path, valueAt(args, path));
+    }
+    return context.targets;
+}

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

@@ -1,14 +1,23 @@
-import type { OperationIdentity } from "../operations/operation-identity.js";
-import type { PipelineTransportContext } from "./pipeline.js";
-/** The protocol version and ClientContract hash a client says it was built for. */
+import type { AvOperationIdentity } from "../operations/operation-identity.js";
+import type { AvTransportContext } from "./pipeline.js";
+import type { AvState } from "./request-state.js";
+/**
+ * The protocol version and Contract hash a remote caller says it was built for:
+ * the Client Contract's for a client, the Agent Contract's for an agent.
+ */
 export type ClientProtocolIdentity = {
     readonly version: number;
     readonly hash: string;
 };
-type RuntimeOperationBase = OperationIdentity & {
+type RuntimeOperationBase = AvOperationIdentity & {
     readonly resource: string;
     readonly arguments: unknown;
     readonly requestId: string;
+    /**
+     * The request's `ctx.$state`: every stage of it, and every ctx call they make,
+     * shares this one object. Omitted, it is a fresh `{}`.
+     */
+    readonly state?: AvState;
 };
 /** An in-process request, run under the Application Contract. */
 export type ApplicationOperationRequest = RuntimeOperationBase & {
@@ -23,10 +32,21 @@ export type ApplicationOperationRequest = RuntimeOperationBase & {
 export type ClientOperationRequest = RuntimeOperationBase & {
     readonly origin: "client";
     readonly protocol: ClientProtocolIdentity;
-    readonly transport?: PipelineTransportContext;
+    readonly transport?: AvTransportContext;
 };
+/**
+ * An AI agent's request, run under the Agent Contract; `protocol` is the
+ * identity of the Agent Contract the caller (an MCP server) was built from.
+ */
+export type AgentOperationRequest = RuntimeOperationBase & {
+    readonly origin: "agent";
+    readonly protocol: ClientProtocolIdentity;
+    readonly transport?: AvTransportContext;
+};
+/** A request from outside the server: a client's or an agent's. */
+export type RemoteOperationRequest = ClientOperationRequest | AgentOperationRequest;
 /** One operation request, as `framework.execute` takes it. */
-export type FrameworkOperationRequest = ApplicationOperationRequest | ClientOperationRequest;
+export type FrameworkOperationRequest = ApplicationOperationRequest | ClientOperationRequest | AgentOperationRequest;
 type WithoutArguments<Request> = Request extends unknown ? Omit<Request, "arguments"> : never;
 /**
  * A request as every stage after the Framework Validation Layer sees it:
@@ -37,4 +57,11 @@ type WithoutArguments<Request> = Request extends unknown ? Omit<Request, "argume
  * correlations survive the omission.
  */
 export type OperationExecutionRequest = WithoutArguments<FrameworkOperationRequest>;
+/**
+ * A request whose stages run: its `state` settled once, the seed or the `{}`
+ * the runtime made for it, so every stage is told the same object.
+ */
+export type StatefulOperationRequest = OperationExecutionRequest & {
+    readonly state: AvState;
+};
 export {};

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

@@ -1,50 +1,50 @@
-import type { ValidationIssue } from "../operations/validation-code.js";
+import type { AvValidationIssue } from "../operations/validation-code.js";
 /** Every outcome code, as a runtime list. */
 export declare const OPERATION_CODES: readonly ["A1000", "A1001", "A1002", "A1003", "A1004", "A1005", "A1006", "A1007", "A1008", "A1009", "A2000", "A2001", "A2002", "A2003", "A2004", "A2005", "A2006", "A2007", "A2008", "A2009", "A2010", "A2011", "A2012", "A2013", "A2014", "A3000", "A3001", "A3002", "A3003", "A3004", "A4000", "A4001", "A4002"];
 /**
  * Every outcome code: `A1xxx` success, `A2xxx` caller error, `A3xxx` internal
  * failure, `A4xxx` authentication or permission denial.
  */
-export type OperationCode = (typeof OPERATION_CODES)[number];
+export type AvOperationCode = (typeof OPERATION_CODES)[number];
 /** The success codes, `A1xxx`. */
-export type OperationSuccessCode = Extract<OperationCode, `A1${string}`>;
+export type AvOperationSuccessCode = Extract<AvOperationCode, `A1${string}`>;
 /** Every outcome code that is not a success. */
-export type OperationErrorCode = Exclude<OperationCode, OperationSuccessCode>;
+export type AvOperationErrorCode = Exclude<AvOperationCode, AvOperationSuccessCode>;
 /** Internal-failure family: nothing in the cause is caller-actionable. */
-export type OperationInternalErrorCode = Extract<OperationErrorCode, `A3${string}`>;
+export type OperationInternalErrorCode = Extract<AvOperationErrorCode, `A3${string}`>;
 /** Why a request failed: a message, and the validation issues when there are any. */
-export type Cause = {
+export type AvCause = {
     readonly message: string;
-    readonly issues?: readonly ValidationIssue[];
+    readonly issues?: readonly AvValidationIssue[];
     readonly operation?: number;
 };
 /** The response envelope: `{ data, code, cause }`. */
-type OperationResponseEnvelope<TData, TCode extends OperationCode, TCause extends Cause | null> = {
+type OperationResponseEnvelope<TData, TCode extends AvOperationCode, TCause extends AvCause | null> = {
     readonly data: TData;
     readonly code: TCode;
     readonly cause: TCause;
 };
 /** Success codes that carry response data (every success code but A1001). */
-export type OperationSuccessDataCode = Exclude<OperationSuccessCode, "A1001">;
+export type AvOperationSuccessDataCode = Exclude<AvOperationSuccessCode, "A1001">;
 /** A success with data: `cause` is `null`. */
-export type OperationSuccessResponse<T> = OperationResponseEnvelope<T, OperationSuccessDataCode, null>;
+export type AvOperationSuccessResponse<T> = OperationResponseEnvelope<T, AvOperationSuccessDataCode, null>;
 /** A success with no matching row (`A1001`): `data` and `cause` are `null`. */
-export type OperationNoMatchResponse = OperationResponseEnvelope<null, "A1001", null>;
+export type AvOperationNoMatchResponse = OperationResponseEnvelope<null, "A1001", null>;
 /** A failure: `data` is `null` and `cause` says why. */
-export type OperationFailureResponse = OperationResponseEnvelope<null, OperationErrorCode, Cause>;
+export type AvOperationFailureResponse = OperationResponseEnvelope<null, AvOperationErrorCode, AvCause>;
 /**
  * What an operation answers: success with data, a no-match success (`A1001`),
  * or a failure with a cause.
  */
-export type OperationResponse<T = unknown> = OperationSuccessResponse<T> | OperationNoMatchResponse | OperationFailureResponse;
+export type AvOperationResponse<T = unknown> = AvOperationSuccessResponse<T> | AvOperationNoMatchResponse | AvOperationFailureResponse;
 /** Builds a success response with data. */
-export declare function operationSuccess<T>(data: T, code: OperationSuccessDataCode): OperationSuccessResponse<T>;
+export declare function operationSuccess<T>(data: T, code: AvOperationSuccessDataCode): AvOperationSuccessResponse<T>;
 /** Builds the no-match success arm (A1001). */
-export declare function operationNoMatch(): OperationNoMatchResponse;
+export declare function operationNoMatch(): AvOperationNoMatchResponse;
 /** Builds a failure response. */
-export declare function operationFailure(code: OperationErrorCode, cause: Cause): OperationFailureResponse;
+export declare function operationFailure(code: AvOperationErrorCode, cause: AvCause): AvOperationFailureResponse;
 /** The one generic internal-failure text; every A3000 carries it. */
 export declare const INTERNAL_FAILURE_MESSAGE = "Internal framework error.";
 /** The response every internal failure (`A3000`) answers with. */
-export declare function internalFailure(): OperationFailureResponse;
+export declare function internalFailure(): AvOperationFailureResponse;
 export {};