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

package/dist/protocol/protocol-surface.d.ts

@@ -1,5 +1,5 @@
-import type { ClientContract } from "../contracts/contract.js";
-import { type OperationIdentity } from "../operations/operation-identity.js";
+import type { AvContractClient } from "../contracts/contract.js";
+import { type AvOperationIdentity } from "../operations/operation-identity.js";
 /**
  * One route of the protocol surface: a route a host mounts for the bound
  * ClientContract, tagged by `kind`.
@@ -9,7 +9,7 @@ export type SurfaceRoute = ({
     readonly method: "POST";
     readonly path: `/_resources/${string}`;
     readonly resource: string;
-} & OperationIdentity) | {
+} & AvOperationIdentity) | {
     readonly kind: "contract";
     readonly method: "GET";
     readonly path: "/_contract";
@@ -24,4 +24,4 @@ export type SurfaceRoute = ({
  * order, then `GET /_contract`, then `POST /_transactions` when, and only when,
  * `transactions === "interactive"`.
  */
-export declare function surfaceOf(client: ClientContract): readonly SurfaceRoute[];
+export declare function surfaceOf(client: AvContractClient): readonly SurfaceRoute[];

package/dist/protocol/protocol.binder.d.ts

@@ -1,6 +1,7 @@
-import type { Framework } from "../framework/framework.js";
-import type { OperationResponse } from "../runtime/operation-response.js";
-import type { TransactionResponse } from "../transactions/transaction-response.js";
+import type { AvFramework } from "../framework/framework.js";
+import type { AvOperationResponse } from "../runtime/operation-response.js";
+import type { AvState } from "../runtime/request-state.js";
+import type { AvTransactionResponse } from "../transactions/transaction-response.js";
 import { type AvProtocolRequest, type DecodedOperation, type DecodedOperationRequest, type DecodedTransaction } from "./http-request.decoder.js";
 import { type AvProtocolResponse } from "./http-response.encoder.js";
 import { transportFailure } from "./protocol-failure.js";
@@ -11,49 +12,51 @@ import { type SurfaceRoute } from "./protocol-surface.js";
  */
 export type AvProtocolBinding = {
     /**
-     * Every route a host mounts for the bound ClientContract, from one list, each
+     * Every route a host mounts for the bound Contract (the Client Contract, or the
+     * Agent Contract under `{ origin: "agent" }`), from one list, each
      * tagged by `kind`: one `POST` `operation` route per `(resource, family, variant)`
-     * it advertises — nothing it does not — then the `contract` route `GET /_contract`
+     * it advertises and no other, then the `contract` route `GET /_contract`
      * (always), then the `transactions` route `POST /_transactions` exactly when its
      * `transactions` is `"interactive"`. Each path is relative to
-     * `framework.entrypoint`. Read once at bind time: every call answers the same
+     * `framework.api`. Read once at bind time: every call answers the same
      * deep-frozen list, which is passive data a host may serialize.
      */
     readonly surface: () => readonly SurfaceRoute[];
     /**
-     * An operation route's HTTP request → the client-origin request
+     * An operation route's HTTP request → the client-origin (or the binding's
+     * agent-origin) request
      * `framework.execute` takes, or the framework response that answers it instead,
      * with the request id either way. Answers absence for an unadvertised triple
      * without executing it, so a catch-all host is safe. Raw body: size, content type,
-     * JSON and shape enforced; parsed body: shape only — the rest was the host's
-     * parser's.
+     * JSON and shape enforced; parsed body: shape only, since the rest was the
+     * host's parser's job.
      */
     readonly decodeOperation: (request: AvProtocolRequest) => DecodedOperation;
     /**
-     * The same for `/_transactions` → the client-origin plan request
-     * `framework.executeTransaction` takes; absent unless the ClientContract's
+     * The same for `/_transactions` → the binding's origin's plan request
+     * `framework.executeTransaction` takes; absent unless the bound Contract's
      * transactions are `"interactive"`.
      */
     readonly decodeTransaction: (request: AvProtocolRequest) => DecodedTransaction;
     /**
-     * One operation's framework response — what `framework.execute` answered — as the
+     * One operation's framework response (what `framework.execute` answered) as the
      * HTTP response a host writes: the code's status, `data` in wire forms, `Aventara-
      * Request-Id` echoed. A result with no wire form answers `A3003` → 500. A
      * diagnostic of one operation names it (`resource`, `family`, `variant`), so the
-     * `A3003` reaches the diagnostics sink only when the host passes `decoded` —
-     * `decodeOperation`'s success value — as `handleOperation` does; without it the
+     * `A3003` reaches the diagnostics sink only when the host passes `decoded`
+     * (`decodeOperation`'s success value), as `handleOperation` does; without it the
      * answer is the same and nothing is reported.
      */
-    readonly encodeOperation: (response: OperationResponse, requestId: string, decoded?: DecodedOperationRequest) => AvProtocolResponse;
+    readonly encodeOperation: (response: AvOperationResponse, requestId: string, decoded?: DecodedOperationRequest) => AvProtocolResponse;
     /**
-     * The same for `/_transactions` — what `framework.executeTransaction` answered. An
+     * The same for `/_transactions`: what `framework.executeTransaction` answered. An
      * `A3003` is reported to the Framework's diagnostics sink as a `"transaction"`
-     * diagnostic — client origin, this `requestId`, the step it blames as `operation` —
+     * diagnostic (client origin, this `requestId`, the step it blames as `operation`)
      * with the value that had no wire form (or what its getter threw) as `error`.
      */
-    readonly encodeTransaction: (response: TransactionResponse, requestId: string) => AvProtocolResponse;
+    readonly encodeTransaction: (response: AvTransactionResponse, requestId: string) => AvProtocolResponse;
     /**
-     * A transport code — `A2000`, `A2010`, `A2011` or `A2012` — as the complete
+     * A transport code (`A2000`, `A2010`, `A2011` or `A2012`) as the complete
      * framework response. For a host that parses the body itself and must answer
      * its parser's failure. `A2012` requires the methods its route allows, so
      * every 405 carries `Allow`.
@@ -67,20 +70,30 @@ export type AvProtocolBinding = {
      * host hands it: one that is not an `AvProtocolRequest` answers `400 A2000`; it
      * never rejects.
      */
-    readonly handleOperation: (request: AvProtocolRequest) => Promise<AvProtocolResponse>;
+    readonly handleOperation: (request: AvProtocolRequest, options?: {
+        /**
+         * Seeds the request's `ctx.$state` (a host reads its platform request
+         * here, Passport's `req.user`, say). Called once, after decoding; a
+         * throw is answered like any developer failure. Omitted, the state is `{}`.
+         */
+        readonly state?: () => AvState | Promise<AvState>;
+    }) => Promise<AvProtocolResponse>;
     /**
      * The same for `/_transactions`: `decodeTransaction` →
      * `framework.executeTransaction` → `encodeTransaction`. Every step runs under
      * ClientContract rules; a committed plan is `200 A1009`, a rolled-back one its
      * failing step's own status.
      */
-    readonly handleTransaction: (request: AvProtocolRequest) => Promise<AvProtocolResponse>;
+    readonly handleTransaction: (request: AvProtocolRequest, options?: {
+        /** Seeds the plan's one `ctx.$state`, as for `handleOperation`. */
+        readonly state?: () => AvState | Promise<AvState>;
+    }) => Promise<AvProtocolResponse>;
     /**
      * The `GET /_contract` responder: the bound ClientContract's JCS-canonical bytes,
      * `ETag` its quoted hash, `Cache-Control: no-cache`, and `304` with no body when
      * `If-None-Match` matches (weak comparison, a list, `*`). Requires no identity
-     * header; any other method is `405 A2012` with `Allow: GET`. The bytes are written
-     * once, at bind time.
+     * header; any other method is `405 A2012` with `Allow: GET`. The bytes are the ones
+     * the Contract's hash was taken over, written once, at construction.
      */
     readonly encodeContract: (request: AvProtocolRequest) => AvProtocolResponse;
     /**
@@ -91,12 +104,22 @@ export type AvProtocolBinding = {
      * `undefined` for a path outside the protocol's namespace, which the host
      * answers itself. An operation or `/_transactions` route answered `500 A3000`
      * is also reported once to the Framework's diagnostics sink, as an
-     * `UnmountedRouteError` naming the route the host did not mount.
+     * `AvUnmountedRouteError` naming the route the host did not mount.
      */
     readonly answerAbsent: (request: AvProtocolRequest) => AvProtocolResponse | undefined;
 };
 /**
- * `AvProtocol.bind(framework)`: reads the instance's compiled ClientContract
- * once and returns the bound members, frozen.
+ * `AvProtocol.bind(framework, options?)`: reads the instance's compiled Client
+ * Contract (or, with `{ origin: "agent" }`, its Agent Contract) once and returns
+ * the bound members, frozen. Every request decoded through it runs under that
+ * origin.
  */
-export declare function bind(framework: Framework): AvProtocolBinding;
+export declare function bind(framework: AvFramework, options?: {
+    /**
+     * The origin every request through this binding runs under: `"client"`
+     * (the default: the Client Contract, `/_contract`'s document) or `"agent"`
+     * (the Agent Contract, its hash and its layer's pipelines), for a host
+     * that serves an AI agent — an MCP server.
+     */
+    readonly origin?: "client" | "agent";
+}): AvProtocolBinding;

package/dist/protocol/protocol.binder.js

@@ -7,13 +7,16 @@ import { encodeOperationResponse, encodeTransactionResponse, } from "./http-resp
 import { handleOperationRequest, handleTransactionRequest, operationUnencodableReport, planUnencodableReport, } from "./protocol.handler.js";
 import { transportFailure } from "./protocol-failure.js";
 import { surfaceOf } from "./protocol-surface.js";
-export function bind(framework) {
+export function bind(framework, options) {
     const { contracts } = framework;
-    const surface = surfaceOf(contracts.client);
-    const document = contractDocumentOf(contracts.client);
+    const origin = options?.origin === "agent" ? "agent" : "client";
+    const contract = contracts[origin];
+    const surface = surfaceOf(contract);
+    const document = contractDocumentOf(contract);
     const sink = diagnosticsSinkOf(framework);
     const handler = {
         contracts,
+        origin,
         execute: (request) => framework.execute(request),
         executeTransaction: (request) => framework.executeTransaction(request),
         owned: ownedExecutionOf(framework),
@@ -21,16 +24,16 @@ export function bind(framework) {
     };
     return Object.freeze({
         surface: () => surface,
-        decodeOperation: (request) => decodeOperationRequest(contracts, request),
-        decodeTransaction: (request) => decodeTransactionRequest(contracts, request),
+        decodeOperation: (request) => decodeOperationRequest(contracts, request, origin),
+        decodeTransaction: (request) => decodeTransactionRequest(contracts, request, origin),
         encodeOperation: (response, requestId, decoded) => encodeOperationResponse(response, requestId, decoded === undefined
             ? undefined
             : operationUnencodableReport(sink, decoded.request)),
-        encodeTransaction: (response, requestId) => encodeTransactionResponse(response, requestId, planUnencodableReport(sink, requestId)),
+        encodeTransaction: (response, requestId) => encodeTransactionResponse(response, requestId, planUnencodableReport(sink, requestId, origin)),
         failure: transportFailure,
-        handleOperation: (request) => handleOperationRequest(handler, request),
-        handleTransaction: (request) => handleTransactionRequest(handler, request),
+        handleOperation: (request, options) => handleOperationRequest(handler, request, options),
+        handleTransaction: (request, options) => handleTransactionRequest(handler, request, options),
         encodeContract: (request) => encodeContractRequest(document, request),
-        answerAbsent: (request) => answerAbsentRequest(contracts, request, sink),
+        answerAbsent: (request) => answerAbsentRequest(contracts, request, sink, origin),
     });
 }

package/dist/protocol/protocol.handler.d.ts

@@ -1,8 +1,10 @@
-import type { FrameworkContracts } from "../compiler/contract.compiler.js";
-import type { Framework } from "../framework/framework.js";
-import { type FrameworkDiagnosticsSink } from "../runtime/diagnostics-reporter.js";
-import type { ClientOperationRequest } from "../runtime/operation-request.js";
+import type { AvContracts } from "../compiler/contract.compiler.js";
+import type { RemoteRequestOrigin } from "../config/config-layer.js";
+import type { AvFramework } from "../framework/framework.js";
+import { type AvDiagnosticsSink } from "../runtime/diagnostics-reporter.js";
+import type { RemoteOperationRequest } from "../runtime/operation-request.js";
 import type { OwnedExecution } from "../runtime/owned-execution.registry.js";
+import type { AvState } from "../runtime/request-state.js";
 import { type AvProtocolRequest } from "./http-request.decoder.js";
 import { type AvProtocolResponse, type UnencodableReport } from "./http-response.encoder.js";
 /**
@@ -12,11 +14,18 @@ import { type AvProtocolResponse, type UnencodableReport } from "./http-response
  * constructed Framework) — and its configured diagnostics sink.
  */
 export type HandlerContext = {
-    readonly contracts: FrameworkContracts;
-    readonly execute: Framework["execute"];
-    readonly executeTransaction: Framework["executeTransaction"];
+    readonly contracts: AvContracts;
+    /** The origin every request the binding decodes runs under. */
+    readonly origin: RemoteRequestOrigin;
+    readonly execute: AvFramework["execute"];
+    readonly executeTransaction: AvFramework["executeTransaction"];
     readonly owned: OwnedExecution | undefined;
-    readonly sink: FrameworkDiagnosticsSink | undefined;
+    readonly sink: AvDiagnosticsSink | undefined;
+};
+/** What a host passes beside one protocol request. */
+export type ProtocolCallOptions = {
+    /** Seeds the request's `ctx.$state`; called once, after decoding. Omitted, the state is `{}`. */
+    readonly state?: () => AvState | Promise<AvState>;
 };
 /**
  * Where a plan's `A3003` goes: the Framework's diagnostics sink, as a `"transaction"`
@@ -24,15 +33,15 @@ export type HandlerContext = {
  * encoder blames as `operation` when it blames one. One spelling for both
  * `protocol.encodeTransaction` and `protocol.handleTransaction`.
  */
-export declare function planUnencodableReport(sink: FrameworkDiagnosticsSink | undefined, requestId: string): UnencodableReport;
+export declare function planUnencodableReport(sink: AvDiagnosticsSink | undefined, requestId: string, origin?: RemoteRequestOrigin): UnencodableReport;
 /**
  * Where one operation's `A3003` goes: the Framework's diagnostics sink, as an
  * `"operation"` diagnostic carrying the decoded request's identity and id — the shape
- * the public `OperationDiagnostic` already has. One spelling for
+ * the public `AvOperationDiagnostic` already has. One spelling for
  * `protocol.handleOperation` and for `protocol.encodeOperation` given the decoded
  * request.
  */
-export declare function operationUnencodableReport(sink: FrameworkDiagnosticsSink | undefined, request: ClientOperationRequest): UnencodableReport;
+export declare function operationUnencodableReport(sink: AvDiagnosticsSink | undefined, request: RemoteOperationRequest): UnencodableReport;
 /**
  * `protocol.handleOperation(request)`: the three steps a host would otherwise spell
  * out — `decodeOperation` → `framework.execute` → `encodeOperation` — in one call,
@@ -40,7 +49,7 @@ export declare function operationUnencodableReport(sink: FrameworkDiagnosticsSin
  * itself (a transport failure, an identity mismatch, an unadvertised route) is
  * answered without executing.
  */
-export declare function handleOperationRequest(context: HandlerContext, request: AvProtocolRequest): Promise<AvProtocolResponse>;
+export declare function handleOperationRequest(context: HandlerContext, request: AvProtocolRequest, options?: ProtocolCallOptions): Promise<AvProtocolResponse>;
 /**
  * `protocol.handleTransaction(request)`: the same shortcut for `/_transactions` —
  * `decodeTransaction` → `framework.executeTransaction` → `encodeTransaction`. The
@@ -52,4 +61,4 @@ export declare function handleOperationRequest(context: HandlerContext, request:
  * handleOperationRequest} is; an `A3003` is reported through {@link
  * planUnencodableReport}.
  */
-export declare function handleTransactionRequest(context: HandlerContext, request: AvProtocolRequest): Promise<AvProtocolResponse>;
+export declare function handleTransactionRequest(context: HandlerContext, request: AvProtocolRequest, options?: ProtocolCallOptions): Promise<AvProtocolResponse>;

package/dist/protocol/protocol.handler.js

@@ -1,4 +1,5 @@
 import { createDiagnosticsReporter, createReporter, } from "../runtime/diagnostics-reporter.js";
+import { sanitizeOperationFailure } from "../runtime/error-boundary.js";
 import { decodeOperationRequest, decodeTransactionRequest, isParsedByDecoder, } from "./http-request.decoder.js";
 import { encodeOperationResponse, encodeTransactionResponse, } from "./http-response.encoder.js";
 function operationEntry(context, request) {
@@ -11,10 +12,30 @@ function transactionEntry(context, request) {
         ? context.owned.executeTransaction
         : context.executeTransaction;
 }
-export function planUnencodableReport(sink, requestId) {
+async function seededState(options, report, view) {
+    if (options?.state === undefined) {
+        return { ok: true, state: undefined };
+    }
+    try {
+        const state = await options.state();
+        return {
+            ok: true,
+            state: typeof state === "object" && state !== null && !Array.isArray(state)
+                ? state
+                : undefined,
+        };
+    }
+    catch (error) {
+        return {
+            ok: false,
+            response: sanitizeOperationFailure(error, "runtime", report, view),
+        };
+    }
+}
+export function planUnencodableReport(sink, requestId, origin = "client") {
     return (error, operation) => createReporter(sink, {
         kind: "transaction",
-        origin: "client",
+        origin,
         requestId,
         ...(operation === undefined ? {} : { operation }),
     })(error, "A3003");
@@ -22,19 +43,33 @@ export function planUnencodableReport(sink, requestId) {
 export function operationUnencodableReport(sink, request) {
     return (error) => createDiagnosticsReporter(sink, request)(error, "A3003");
 }
-export async function handleOperationRequest(context, request) {
-    const decoded = decodeOperationRequest(context.contracts, request);
+export async function handleOperationRequest(context, request, options) {
+    const decoded = decodeOperationRequest(context.contracts, request, context.origin);
     if (!decoded.ok) {
         return decoded.response;
     }
-    const response = await operationEntry(context, decoded.request)(decoded.request);
+    const seeded = await seededState(options, createDiagnosticsReporter(context.sink, decoded.request), { path: ["arguments"], arguments: decoded.request.arguments });
+    const response = seeded.ok
+        ? await operationEntry(context, decoded.request)(seeded.state === undefined
+            ? decoded.request
+            : { ...decoded.request, state: seeded.state })
+        : seeded.response;
     return encodeOperationResponse(response, decoded.requestId, operationUnencodableReport(context.sink, decoded.request));
 }
-export async function handleTransactionRequest(context, request) {
-    const decoded = decodeTransactionRequest(context.contracts, request);
+export async function handleTransactionRequest(context, request, options) {
+    const decoded = decodeTransactionRequest(context.contracts, request, context.origin);
     if (!decoded.ok) {
         return decoded.response;
     }
-    const response = await transactionEntry(context, decoded.request)(decoded.request);
-    return encodeTransactionResponse(response, decoded.requestId, planUnencodableReport(context.sink, decoded.requestId));
+    const seeded = await seededState(options, createReporter(context.sink, {
+        kind: "transaction",
+        origin: context.origin,
+        requestId: decoded.requestId,
+    }), { path: ["plan"], arguments: decoded.request.plan });
+    const response = seeded.ok
+        ? await transactionEntry(context, decoded.request)(seeded.state === undefined
+            ? decoded.request
+            : { ...decoded.request, state: seeded.state })
+        : seeded.response;
+    return encodeTransactionResponse(response, decoded.requestId, planUnencodableReport(context.sink, decoded.requestId, context.origin));
 }

package/dist/protocol/unmounted-route.error.d.ts

@@ -5,15 +5,15 @@
  * `500 A3000` is unchanged; this error names the route the host left out, so the
  * server's diagnostics show it too. It is never sent to the caller.
  */
-export declare class UnmountedRouteError extends Error {
+export declare class AvUnmountedRouteError extends Error {
     /** What the ClientContract advertises: `resource.family.variant`, or `transactions`. */
     readonly advertised: string;
-    /** The route as the request reached it: method and entrypoint-relative path. */
+    /** The route as the request reached it: method and api-relative path. */
     readonly route: string;
-    readonly name = "UnmountedRouteError";
+    readonly name = "AvUnmountedRouteError";
     constructor(
     /** What the ClientContract advertises: `resource.family.variant`, or `transactions`. */
     advertised: string, 
-    /** The route as the request reached it: method and entrypoint-relative path. */
+    /** The route as the request reached it: method and api-relative path. */
     route: string);
 }

package/dist/protocol/unmounted-route.error.js

@@ -1,7 +1,7 @@
-export class UnmountedRouteError extends Error {
+export class AvUnmountedRouteError extends Error {
     advertised;
     route;
-    name = "UnmountedRouteError";
+    name = "AvUnmountedRouteError";
     constructor(advertised, route) {
         super(`The ClientContract advertises ${advertised}, but the host mounted no route for ${route}, so protocol.answerAbsent answered it 500 A3000. Mount every protocol.surface() entry.`);
         this.advertised = advertised;

package/dist/runtime/caller-data.copier.d.ts

@@ -7,7 +7,7 @@ export type CallerDataPath = readonly (string | number)[];
  * root. Thrown by {@link copyCallerData} and caught by every door, which answers it as
  * the caller's `A2004`/`V1001` at its own address. It never carries the value.
  */
-export declare class CallerDataError extends Error {
+export declare class AvCallerDataError extends Error {
     readonly kind: CallerDataFailureKind;
     readonly path: CallerDataPath;
     /**
@@ -15,7 +15,7 @@ export declare class CallerDataError extends Error {
      * tripwire read after the door; {@link locateCallerDataError} resolves it.
      */
     readonly within?: object | undefined;
-    readonly name = "CallerDataError";
+    readonly name = "AvCallerDataError";
     constructor(kind: CallerDataFailureKind, path: CallerDataPath, 
     /**
      * The control mirror `path` starts from, when the failure is a mirror's
@@ -46,14 +46,14 @@ export type CallerDataPolicy = {
  * copy's root, where `error.path` started from the mirror. A failure that is not a
  * tripwire's, or a mirror the copy does not hold, is returned as it is.
  */
-export declare function locateCallerDataError(error: CallerDataError, copy: unknown): CallerDataError;
+export declare function locateCallerDataError(error: AvCallerDataError, copy: unknown): AvCallerDataError;
 /**
  * Copies a caller's value into fresh plain data (see the module note), reading the
  * caller's objects exactly once.
  *
- * @throws {@link CallerDataError} when a value cannot be read or is not plain data,
+ * @throws {@link AvCallerDataError} when a value cannot be read or is not plain data,
  *   naming its path from `value`.
  */
 export declare function copyCallerData(value: unknown, policy?: CallerDataPolicy): unknown;
-/** The `V1001` message a door answers a {@link CallerDataError} with. */
+/** The `V1001` message a door answers a {@link AvCallerDataError} with. */
 export declare function callerDataFailureMessage(kind: CallerDataFailureKind): string;

package/dist/runtime/caller-data.copier.js

@@ -1,13 +1,13 @@
-import { Decimal } from "./decimal.js";
+import { AvDecimal } from "./decimal.js";
 const FAILURE_MESSAGES = {
     "unreadable-value": "Value could not be read.",
     "non-plain-value": "Value must be plain data.",
 };
-export class CallerDataError extends Error {
+export class AvCallerDataError extends Error {
     kind;
     path;
     within;
-    name = "CallerDataError";
+    name = "AvCallerDataError";
     constructor(kind, path, within) {
         super(FAILURE_MESSAGES[kind]);
         this.kind = kind;
@@ -19,7 +19,7 @@ const NO_POLICY = {};
 const OBJECT_PROTOTYPE = Object.prototype;
 const DATE_PROTOTYPE = Date.prototype;
 const dateValueOf = Date.prototype.getTime;
-const decimalValueOf = Decimal.prototype.toString;
+const decimalValueOf = AvDecimal.prototype.toString;
 const FAST_WALK_DEPTH = 256;
 const SLOW_WALK = Symbol("slow walk");
 class FastWalkFailure {
@@ -33,8 +33,8 @@ function copyValueType(value, prototype) {
     if (prototype === DATE_PROTOTYPE || value instanceof Date) {
         return new Date(dateValueOf.call(value));
     }
-    if (value instanceof Decimal) {
-        return new Decimal(decimalValueOf.call(value));
+    if (value instanceof AvDecimal) {
+        return new AvDecimal(decimalValueOf.call(value));
     }
     if (value instanceof Uint8Array) {
         return new Uint8Array(value);
@@ -134,7 +134,7 @@ function readAt(link, read) {
         return read();
     }
     catch {
-        throw new CallerDataError("unreadable-value", pathOf(link));
+        throw new AvCallerDataError("unreadable-value", pathOf(link));
     }
 }
 function copySlow(value, policy, failedAt) {
@@ -154,7 +154,7 @@ function copySlow(value, policy, failedAt) {
         const task = stack.pop();
         if (task.kind === "leave") {
             if (task.refuse !== false) {
-                throw new CallerDataError("unreadable-value", pathOf(task.refuse));
+                throw new AvCallerDataError("unreadable-value", pathOf(task.refuse));
             }
             ancestors.delete(task.container);
             continue;
@@ -172,7 +172,7 @@ function copySlow(value, policy, failedAt) {
         const refuse = current === failedAt ? link : false;
         const settle = (copy) => {
             if (refuse !== false) {
-                throw new CallerDataError("unreadable-value", pathOf(refuse));
+                throw new AvCallerDataError("unreadable-value", pathOf(refuse));
             }
             task.assign(copy);
         };
@@ -209,7 +209,7 @@ function copySlow(value, policy, failedAt) {
         if (!isPlainPrototype(prototype)) {
             const copied = readAt(link, () => copyValueType(current, prototype));
             if (copied === undefined) {
-                throw new CallerDataError("non-plain-value", pathOf(link));
+                throw new AvCallerDataError("non-plain-value", pathOf(link));
             }
             settle(copied);
             continue;
@@ -271,11 +271,11 @@ function pathSegment(array, key) {
 function mirrorControlData(value) {
     const shape = reflectNode(value);
     if (shape === undefined) {
-        throw new CallerDataError("unreadable-value", []);
+        throw new AvCallerDataError("unreadable-value", []);
     }
     let root;
     const refuse = (kind, path) => {
-        throw new CallerDataError(kind, path, root);
+        throw new AvCallerDataError(kind, path, root);
     };
     const mirrors = new Map();
     const stack = [
@@ -416,7 +416,7 @@ export function locateCallerDataError(error, copy) {
     const at = pathTo(copy, within);
     return at === undefined
         ? error
-        : new CallerDataError(error.kind, [...at, ...error.path]);
+        : new AvCallerDataError(error.kind, [...at, ...error.path]);
 }
 function pathTo(copy, target) {
     const seen = new Set();

package/dist/runtime/caller-data.door.d.ts

@@ -1,6 +1,6 @@
-import type { ValidationIssue } from "../operations/validation-code.js";
-import { CallerDataError, type CallerDataPath, type CallerDataPolicy } from "./caller-data.copier.js";
-import type { FrameworkMisuseEvent, MisuseReporter } from "./misuse-reporter.js";
+import type { AvValidationIssue } from "../operations/validation-code.js";
+import { AvCallerDataError, type CallerDataPath, type CallerDataPolicy } from "./caller-data.copier.js";
+import type { AvMisuseEvent, MisuseReporter } from "./misuse-reporter.js";
 /**
  * Where the arguments an execution entry receives came from.
  *
@@ -14,7 +14,7 @@ import type { FrameworkMisuseEvent, MisuseReporter } from "./misuse-reporter.js"
  */
 export type ArgumentsSource = "caller" | "owned";
 /** The operation identity a misuse event may name, as far as it could be read. */
-export type MisuseIdentity = Omit<FrameworkMisuseEvent, "kind" | "path">;
+export type MisuseIdentity = Omit<AvMisuseEvent, "kind" | "path">;
 /**
  * The identity of a request the framework holds a copy of, keeping only what is
  * identity: an origin, a Resource name and a standard operation, each present only
@@ -30,7 +30,7 @@ export declare function misuseIdentityOf(request: {
  * The caller's `V1001` for a refused value at `address` (the door's own spelling of
  * where the copied value stands), reported once to the misuse hook.
  */
-export declare function refuseCallerData(error: CallerDataError, address: CallerDataPath, identity: MisuseIdentity, misuse: MisuseReporter): ValidationIssue;
+export declare function refuseCallerData(error: AvCallerDataError, address: CallerDataPath, identity: MisuseIdentity, misuse: MisuseReporter): AvValidationIssue;
 /**
  * A door's copy of one caller value, or the failure it met. The door holds it until
  * its answer is due — a plan answers its steps in order — so the failure is a value
@@ -41,7 +41,7 @@ export type CallerDataCopy = {
     readonly value: unknown;
 } | {
     readonly ok: false;
-    readonly error: CallerDataError;
+    readonly error: AvCallerDataError;
 };
 /** Copies `value` at a door, keeping {@link copyCallerData}'s refusal as a value. */
 export declare function copyAtDoor(value: unknown, policy?: CallerDataPolicy): CallerDataCopy;

package/dist/runtime/caller-data.door.js

@@ -1,8 +1,10 @@
 import { parseOperationIdentity } from "../operations/operation-identity.js";
 import { validationIssue } from "../operations/validation-code.js";
-import { CallerDataError, copyCallerData, } from "./caller-data.copier.js";
+import { AvCallerDataError, copyCallerData, } from "./caller-data.copier.js";
 export function misuseIdentityOf(request) {
-    const origin = request.origin === "application" || request.origin === "client"
+    const origin = request.origin === "application" ||
+        request.origin === "client" ||
+        request.origin === "agent"
         ? request.origin
         : undefined;
     const identity = typeof request.family === "string" && typeof request.variant === "string"
@@ -28,7 +30,7 @@ export function copyAtDoor(value, policy) {
         return { ok: true, value: copyCallerData(value, policy) };
     }
     catch (error) {
-        if (error instanceof CallerDataError) {
+        if (error instanceof AvCallerDataError) {
             return { ok: false, error };
         }
         throw error;
@@ -53,7 +55,7 @@ export function copyEnvelopeAtDoor(request, members) {
         if (!copy.ok) {
             return {
                 ok: false,
-                error: new CallerDataError(copy.error.kind, [
+                error: new AvCallerDataError(copy.error.kind, [
                     member,
                     ...copy.error.path,
                 ]),

package/dist/runtime/computed-read-runtime.d.ts

@@ -1,8 +1,9 @@
-import type { FrameworkBehaviorsConfig } from "../config/framework-behaviors-config.js";
-import type { Contract, CoreContract } from "../contracts/contract.js";
+import type { AvAdapterModel } from "../adapters/adapter-model.js";
+import type { ResolvedComputeConfig } from "../config/field-compute.resolver.js";
+import type { AvContract, AvContractCore } from "../contracts/contract.js";
+import type { AvComputeContext } from "./field-compute.js";
 import type { OperationExecutionRequest } from "./operation-request.js";
-import type { PipelineContext } from "./pipeline.js";
-type ContextFactory = () => PipelineContext;
+type ContextFactory = () => AvComputeContext;
 export type RelationReadPlan = {
     readonly field: string;
     readonly cardinality: "one" | "many";
@@ -27,10 +28,10 @@ export type PlannedReadOperation = {
  * are never mutated and hidden dependencies are resolved through the Core
  * Contract.
  */
-export declare function planReadOperation(core: CoreContract, active: Contract, behaviors: FrameworkBehaviorsConfig | undefined, request: OperationExecutionRequest, args: unknown): PlannedReadOperation;
+export declare function planReadOperation(core: AvContractCore, model: AvAdapterModel, active: AvContract, compute: ResolvedComputeConfig | undefined, request: OperationExecutionRequest, args: unknown): PlannedReadOperation;
 /**
  * Materialize computed scalar reads and remove internal dependency fields,
  * against `active` — the Contract `planReadOperation` was given as `active`.
  */
-export declare function materializeReadOperation(active: Contract, behaviors: FrameworkBehaviorsConfig | undefined, request: OperationExecutionRequest, plan: PlannedReadOperation, value: unknown, contextFactory: ContextFactory): Promise<unknown>;
+export declare function materializeReadOperation(active: AvContract, compute: ResolvedComputeConfig | undefined, request: OperationExecutionRequest, plan: PlannedReadOperation, value: unknown, contextFactory: ContextFactory): Promise<unknown>;
 export {};