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

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,20 +1,78 @@
+import { copyAtDoor } from "../runtime/caller-data.door.js";
 import { createDiagnosticsReporter, createReporter, } from "../runtime/diagnostics-reporter.js";
+import { sanitizeOperationFailure } from "../runtime/error-boundary.js";
+import { capturePlanAtCall } from "../transactions/transaction-plan-validator.js";
 import { decodeOperationRequest, decodeTransactionRequest, isParsedByDecoder, } from "./http-request.decoder.js";
 import { encodeOperationResponse, encodeTransactionResponse, } from "./http-response.encoder.js";
-function operationEntry(context, request) {
-    return context.owned !== undefined && isParsedByDecoder(request.arguments)
-        ? context.owned.execute
-        : context.execute;
+function admitOperation(context, request) {
+    const owned = context.owned;
+    if (isParsedByDecoder(request.arguments)) {
+        return { request, run: owned?.execute ?? context.execute };
+    }
+    const copy = copyAtDoor(request.arguments);
+    if (owned === undefined) {
+        return {
+            request: copy.ok ? { ...request, arguments: copy.value } : request,
+            run: context.execute,
+        };
+    }
+    if (copy.ok) {
+        return {
+            request: { ...request, arguments: copy.value },
+            run: (admitted) => owned.execute(admitted),
+        };
+    }
+    return {
+        request: { ...request, arguments: {} },
+        run: (admitted) => owned.execute(admitted, copy.error),
+    };
+}
+function admitTransaction(context, request) {
+    const owned = context.owned;
+    if (isParsedByDecoder(request.plan)) {
+        return {
+            request,
+            run: owned?.executeTransaction ?? context.executeTransaction,
+        };
+    }
+    const captured = capturePlanAtCall(request.plan);
+    if (owned === undefined) {
+        return {
+            request: captured.refused.size === 0
+                ? { ...request, plan: captured.plan }
+                : request,
+            run: context.executeTransaction,
+        };
+    }
+    return {
+        request: { ...request, plan: captured.plan },
+        run: (admitted) => owned.executeTransaction(admitted, captured.refused.size === 0 ? undefined : captured.refused),
+    };
 }
-function transactionEntry(context, request) {
-    return context.owned !== undefined && isParsedByDecoder(request.plan)
-        ? context.owned.executeTransaction
-        : context.executeTransaction;
+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) {
+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 +80,35 @@ 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 admitted = admitOperation(context, decoded.request);
+    const seeded = await seededState(options, createDiagnosticsReporter(context.sink, admitted.request), { path: ["arguments"], arguments: admitted.request.arguments });
+    const response = seeded.ok
+        ? await admitted.run(seeded.state === undefined
+            ? admitted.request
+            : { ...admitted.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 admitted = admitTransaction(context, decoded.request);
+    const seeded = await seededState(options, createReporter(context.sink, {
+        kind: "transaction",
+        origin: context.origin,
+        requestId: decoded.requestId,
+    }), { path: ["plan"], arguments: admitted.request.plan });
+    const response = seeded.ok
+        ? await admitted.run(seeded.state === undefined
+            ? admitted.request
+            : { ...admitted.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
@@ -41,19 +41,36 @@ export type CallerDataPolicy = {
     readonly keep?: CallerDataKeep;
     readonly mirror?: CallerDataMirror;
 };
+/** The members a structural mirror copies by value rather than mirroring. */
+type MirrorMembers = {
+    /** The policy a member at `path` (from the mirror's root) is copied by, or `undefined`. */
+    readonly copyAt: (path: CallerDataPath) => CallerDataPolicy | undefined;
+    /** Receives a member whose copy failed; the mirror holds `undefined` for it. */
+    readonly refused: (path: CallerDataPath, error: AvCallerDataError) => void;
+};
+/**
+ * Mirrors `value` by its descriptors, as a `$ref` control object is mirrored (no
+ * getter runs, an accessor stays a tripwire), except the members `members.copyAt`
+ * names by their path: each is copied by value under the policy it returns, and one
+ * whose copy fails is reported to `members.refused` and held as `undefined`.
+ *
+ * @throws {@link AvCallerDataError} at `[]` when `value` itself cannot be reflected.
+ */
+export declare function mirrorCallerData(value: object, members: MirrorMembers): unknown;
 /**
  * Places a mirror tripwire's failure in the value the door copied: its path from the
  * 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;
+export {};

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;
@@ -268,14 +268,14 @@ function pathSegment(array, key) {
     }
     return key;
 }
-function mirrorControlData(value) {
+function mirrorControlData(value, members) {
     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 = [
@@ -375,6 +375,20 @@ function mirrorControlData(value) {
                 continue;
             }
             const memberLink = childLink(link, pathSegment(shape.array, key));
+            const byValue = members?.copyAt(pathOf(memberLink));
+            if (byValue !== undefined) {
+                try {
+                    store(copyCallerData(member, byValue));
+                }
+                catch (error) {
+                    if (!(error instanceof AvCallerDataError)) {
+                        throw error;
+                    }
+                    members?.refused(pathOf(memberLink), error);
+                    store(undefined);
+                }
+                continue;
+            }
             const memberShape = reflectNode(member);
             if (memberShape === undefined) {
                 store(UNREADABLE);
@@ -408,6 +422,9 @@ function mirrorControlData(value) {
     }
     return root;
 }
+export function mirrorCallerData(value, members) {
+    return mirrorControlData(value, members);
+}
 export function locateCallerDataError(error, copy) {
     const within = error.within;
     if (within === undefined) {
@@ -416,7 +433,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,20 +1,26 @@
-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.
  *
  * - `"caller"`: a server-side caller's own objects — copied at the door.
  * - `"owned"`: data no caller holds a reference to — a body the protocol decoder
- *   parsed with `JSON.parse` for this request alone, or a plan the typed runner
- *   assembled from copies its builders took. It is never copied again.
+ *   parsed with `JSON.parse` for this request alone, a host's parsed body the
+ *   protocol's shortcut copied at the call, or a plan the typed runner assembled
+ *   from copies its builders took. It is never copied again.
  *
- * Only core's own modules choose `"owned"`: the public `framework.execute` and
- * `executeTransaction` always pass `"caller"`.
+ * - `{ refused }`: a body the protocol's shortcut copied at the call, whose copy
+ *   failed — answered at the door as `"caller"` would answer it, never read again.
+ *
+ * Only core's own modules choose anything but `"caller"`: the public
+ * `framework.execute` and `executeTransaction` always pass `"caller"`.
  */
-export type ArgumentsSource = "caller" | "owned";
+export type ArgumentsSource = "caller" | "owned" | {
+    readonly refused: AvCallerDataError;
+};
 /** 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 +36,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 +47,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 {};