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

package/dist/protocol/http-request.reader.d.ts

@@ -1,9 +1,11 @@
-import type { ClientProtocolIdentity } from "../runtime/operation-request.js";
+import type { AvRequestProtocol } from "../runtime/operation-request.js";
 import type { OperationRouteSegments } from "./absent-route.responder.js";
 import type { AvProtocolRequest } from "./http-request.decoder.js";
 import type { AvProtocolResponse } from "./http-response.encoder.js";
 /** `POST <api>/_transactions`. */
 export declare const TRANSACTIONS_ROUTE = "/_transactions";
+/** `POST <api>/_access/can`. */
+export declare const ACCESS_CAN_ROUTE = "/_access/can";
 /** `GET <api>/_contract`. */
 export declare const CONTRACT_ROUTE = "/_contract";
 /** The methods an operation or `/_transactions` route accepts: `POST`, only. */
@@ -25,10 +27,10 @@ export type ReadRequest = {
     /** Adopted from `Aventara-Request-Id`, else minted. */
     readonly requestId: string;
     /** `undefined` when either identity header is absent (`A2000`). */
-    readonly protocol: ClientProtocolIdentity | undefined;
+    readonly protocol: AvRequestProtocol | undefined;
 };
 /** What a value that is not an `AvProtocolRequest` reads as. */
-export type UnreadableRequest = {
+type UnreadableRequest = {
     readonly ok: false;
     readonly response: AvProtocolResponse;
     readonly requestId: string;
@@ -43,3 +45,4 @@ export declare function readRequest(received: unknown): ReadRequest | Unreadable
  * `undefined` when it is not one.
  */
 export declare function operationRouteSegments(path: string): OperationRouteSegments | undefined;
+export {};

package/dist/protocol/http-request.reader.js

@@ -3,6 +3,7 @@ import { transportFailure } from "./protocol-failure.js";
 import { adoptedRequestId, normalizeHeaders, protocolIdentityOf, } from "./protocol-headers.js";
 const OPERATION_ROUTE = /^\/_resources\/([^/]*)\/([^/]*)\/([^/]*)$/;
 export const TRANSACTIONS_ROUTE = "/_transactions";
+export const ACCESS_CAN_ROUTE = "/_access/can";
 export const CONTRACT_ROUTE = "/_contract";
 export const POST_ONLY = Object.freeze(["POST"]);
 export const GET_ONLY = Object.freeze(["GET"]);

package/dist/protocol/http-response.encoder.js

@@ -1,5 +1,5 @@
 import { encodeBase64, WIRE_SCALAR_PATTERNS, } from "../contracts/wire-scalar-format.js";
-import { AvDecimal } from "../runtime/decimal.js";
+import { isAvDecimal } from "../runtime/decimal.js";
 import { SERIALIZATION_FAILURE_MESSAGE } from "../runtime/error-boundary.js";
 import { operationFailure, } from "../runtime/operation-response.js";
 import { httpStatus } from "./http-status.table.js";
@@ -161,7 +161,7 @@ function scalarWireText(value) {
         }
         return JSON.stringify(wire);
     }
-    if (value instanceof AvDecimal) {
+    if (isAvDecimal(value)) {
         return JSON.stringify(value.toString());
     }
     if (value instanceof Uint8Array) {

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

@@ -1,4 +1,4 @@
-import type { ClientProtocolIdentity } from "../runtime/operation-request.js";
+import type { AvRequestProtocol } from "../runtime/operation-request.js";
 /** `AvProtocol.headers` — the header names the protocol owns, as passive data. */
 export declare const headers: Readonly<{
     readonly protocolVersion: "Aventara-Protocol-Version";
@@ -22,11 +22,11 @@ export declare function normalizeHeaders(received: ReceivedHeaders): Readonly<Re
  */
 export declare function headerValue(normalized: Readonly<Record<string, string>>, name: string): string | undefined;
 /**
- * The identity headers as the `ClientProtocolIdentity` core checks, or `undefined`
+ * The identity headers as the `AvRequestProtocol` core checks, or `undefined`
  * when either is ABSENT — a request without them is malformed: it does not say which
  * protocol and ClientContract it speaks, so there is nothing to compare.
  */
-export declare function protocolIdentityOf(normalized: Readonly<Record<string, string>>): ClientProtocolIdentity | undefined;
+export declare function protocolIdentityOf(normalized: Readonly<Record<string, string>>): AvRequestProtocol | undefined;
 /**
  * The identity headers a request did not send, in the order the framework sends them —
  * what the `A2000` answering it names. Empty exactly when {@link protocolIdentityOf}

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

@@ -17,11 +17,16 @@ export type SurfaceRoute = ({
     readonly kind: "transactions";
     readonly method: "POST";
     readonly path: "/_transactions";
+} | {
+    readonly kind: "can";
+    readonly method: "POST";
+    readonly path: "/_access/can";
 };
 /**
  * The route list of one ClientContract: every route a host mounts, from one list,
  * deep-frozen — exactly the advertised operation triples in the Contract's own key
  * order, then `GET /_contract`, then `POST /_transactions` when, and only when,
- * `transactions === "interactive"`.
+ * `transactions === "interactive"`, then `POST /_access/can` when, and only when,
+ * the Contract has its `access` section.
  */
 export declare function surfaceOf(client: AvContractClient): readonly SurfaceRoute[];

package/dist/protocol/protocol-surface.js

@@ -37,5 +37,12 @@ export function surfaceOf(client) {
             path: "/_transactions",
         }));
     }
+    if (client.access !== undefined) {
+        routes.push(Object.freeze({
+            kind: "can",
+            method: "POST",
+            path: "/_access/can",
+        }));
+    }
     return Object.freeze(routes);
 }

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

@@ -17,7 +17,8 @@ export type AvProtocolBinding = {
      * tagged by `kind`: one `POST` `operation` route per `(resource, family, variant)`
      * 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
+     * `transactions` is `"interactive"`, then the `can` route `POST /_access/can`
+     * exactly when it has its `access` section. Each path is relative to
      * `framework.api`. Read once at bind time: every call answers the same
      * deep-frozen list, which is passive data a host may serialize.
      */
@@ -88,6 +89,20 @@ export type AvProtocolBinding = {
         /** Seeds the plan's one `ctx.$state`, as for `handleOperation`. */
         readonly state?: () => AvState | Promise<AvState>;
     }) => Promise<AvProtocolResponse>;
+    /**
+     * The `POST /_access/can` shortcut: the request decoded, its `ctx.$state`
+     * seeded through `options.state`, its `{ questions }` answered by the bound
+     * Framework's policy engine under the principal `ctx.$state.me`, and the answer
+     * encoded: `200 A1000` with one boolean per question, in order. It only shapes
+     * a UI, so it refuses malformed input only, never `403`. Absent (`404 A2002`)
+     * unless the bound Contract has its `access` section, which it has exactly when
+     * the framework's `access` option is configured. Total over any value, as
+     * `handleOperation` is.
+     */
+    readonly handleCan: (request: AvProtocolRequest, options?: {
+        /** Seeds the request's `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

package/dist/protocol/protocol.binder.js

@@ -1,10 +1,11 @@
+import { accessQuestionsOf } from "../policy/access-question.registry.js";
 import { diagnosticsSinkOf } from "../runtime/diagnostics-reporter.js";
 import { ownedExecutionOf } from "../runtime/owned-execution.registry.js";
 import { answerAbsentRequest } from "./absent-route.responder.js";
 import { contractDocumentOf, encodeContractRequest, } from "./contract-document.responder.js";
 import { decodeOperationRequest, decodeTransactionRequest, } from "./http-request.decoder.js";
 import { encodeOperationResponse, encodeTransactionResponse, } from "./http-response.encoder.js";
-import { handleOperationRequest, handleTransactionRequest, operationUnencodableReport, planUnencodableReport, } from "./protocol.handler.js";
+import { handleCanRequest, handleOperationRequest, handleTransactionRequest, operationUnencodableReport, planUnencodableReport, } from "./protocol.handler.js";
 import { transportFailure } from "./protocol-failure.js";
 import { surfaceOf } from "./protocol-surface.js";
 export function bind(framework, options) {
@@ -21,6 +22,7 @@ export function bind(framework, options) {
         executeTransaction: (request) => framework.executeTransaction(request),
         owned: ownedExecutionOf(framework),
         sink,
+        can: accessQuestionsOf(framework),
     };
     return Object.freeze({
         surface: () => surface,
@@ -33,6 +35,7 @@ export function bind(framework, options) {
         failure: transportFailure,
         handleOperation: (request, options) => handleOperationRequest(handler, request, options),
         handleTransaction: (request, options) => handleTransactionRequest(handler, request, options),
+        handleCan: (request, options) => handleCanRequest(handler, request, options),
         encodeContract: (request) => encodeContractRequest(document, request),
         answerAbsent: (request) => answerAbsentRequest(contracts, request, sink, origin),
     });

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

@@ -1,6 +1,7 @@
 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 { AccessQuestionsAnswerer } from "../policy/access-question.runtime.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";
@@ -13,7 +14,7 @@ import { type AvProtocolResponse, type UnencodableReport } from "./http-response
  * decoder parsed without copying it again (absent for anything but a
  * constructed Framework) — and its configured diagnostics sink.
  */
-export type HandlerContext = {
+type HandlerContext = {
     readonly contracts: AvContracts;
     /** The origin every request the binding decodes runs under. */
     readonly origin: RemoteRequestOrigin;
@@ -21,6 +22,8 @@ export type HandlerContext = {
     readonly executeTransaction: AvFramework["executeTransaction"];
     readonly owned: OwnedExecution | undefined;
     readonly sink: AvDiagnosticsSink | undefined;
+    /** The Framework's `can` answerer: absent for one without `access`, or anything `createFramework` did not return. */
+    readonly can: AccessQuestionsAnswerer | undefined;
 };
 /** What a host passes beside one protocol request. */
 export type ProtocolCallOptions = {
@@ -62,3 +65,11 @@ export declare function handleOperationRequest(context: HandlerContext, request:
  * planUnencodableReport}.
  */
 export declare function handleTransactionRequest(context: HandlerContext, request: AvProtocolRequest, options?: ProtocolCallOptions): Promise<AvProtocolResponse>;
+/**
+ * `protocol.handleCan(request)`: the `/_access/can` request decoded, its state
+ * seeded, its questions answered by the bound Framework, and the answer encoded —
+ * `200 A1000` with one boolean per question, in order, or the refusal. Total over
+ * any value, as {@link handleOperationRequest} is.
+ */
+export declare function handleCanRequest(context: HandlerContext, request: AvProtocolRequest, options?: ProtocolCallOptions): Promise<AvProtocolResponse>;
+export {};

package/dist/protocol/protocol.handler.js

@@ -1,16 +1,54 @@
+import { copyAtDoor } from "../runtime/caller-data.door.js";
 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 { internalFailure, } from "../runtime/operation-response.js";
+import { capturePlanAtCall } from "../transactions/transaction-plan-validator.js";
+import { decodeCanRequest, 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 transactionEntry(context, request) {
-    return context.owned !== undefined && isParsedByDecoder(request.plan)
-        ? context.owned.executeTransaction
-        : context.executeTransaction;
+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),
+    };
 }
 async function seededState(options, report, view) {
     if (options?.state === undefined) {
@@ -48,11 +86,12 @@ export async function handleOperationRequest(context, request, options) {
     if (!decoded.ok) {
         return decoded.response;
     }
-    const seeded = await seededState(options, createDiagnosticsReporter(context.sink, decoded.request), { path: ["arguments"], arguments: decoded.request.arguments });
+    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 operationEntry(context, decoded.request)(seeded.state === undefined
-            ? decoded.request
-            : { ...decoded.request, state: seeded.state })
+        ? 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));
 }
@@ -61,15 +100,45 @@ export async function handleTransactionRequest(context, request, options) {
     if (!decoded.ok) {
         return decoded.response;
     }
+    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: decoded.request.plan });
+    }), { path: ["plan"], arguments: admitted.request.plan });
     const response = seeded.ok
-        ? await transactionEntry(context, decoded.request)(seeded.state === undefined
-            ? decoded.request
-            : { ...decoded.request, state: seeded.state })
+        ? 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));
 }
+export async function handleCanRequest(context, request, options) {
+    const decoded = decodeCanRequest(context.contracts, request, context.origin);
+    if (!decoded.ok) {
+        return decoded.response;
+    }
+    const { requestId, body } = decoded.request;
+    const report = createReporter(context.sink, {
+        kind: "can",
+        origin: "client",
+        requestId,
+    });
+    if (context.can === undefined) {
+        report(new Error("The bound Framework has no answerer for /_access/can."), "A3000");
+        return encodeOperationResponse(internalFailure(), requestId);
+    }
+    const seeded = await seededState(options, report, {
+        path: ["questions"],
+        arguments: body,
+    });
+    const response = seeded.ok
+        ? await context.can({
+            origin: context.origin,
+            requestId,
+            ...(seeded.state === undefined ? {} : { state: seeded.state }),
+            body,
+        })
+        : seeded.response;
+    return encodeOperationResponse(response, requestId);
+}

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

@@ -1,5 +1,5 @@
 /** Why a caller value could not be copied. */
-export type CallerDataFailureKind = "unreadable-value" | "non-plain-value";
+type CallerDataFailureKind = "unreadable-value" | "non-plain-value";
 /** A data location inside the copied value, from its root. */
 export type CallerDataPath = readonly (string | number)[];
 /**
@@ -41,6 +41,22 @@ 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
@@ -55,5 +71,4 @@ export declare function locateCallerDataError(error: AvCallerDataError, copy: un
  *   naming its path from `value`.
  */
 export declare function copyCallerData(value: unknown, policy?: CallerDataPolicy): unknown;
-/** 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,4 +1,4 @@
-import { AvDecimal } from "./decimal.js";
+import { AvDecimal, decimalDigitsOf, isAvDecimal } from "./decimal.js";
 const FAILURE_MESSAGES = {
     "unreadable-value": "Value could not be read.",
     "non-plain-value": "Value must be plain data.",
@@ -19,7 +19,6 @@ const NO_POLICY = {};
 const OBJECT_PROTOTYPE = Object.prototype;
 const DATE_PROTOTYPE = Date.prototype;
 const dateValueOf = Date.prototype.getTime;
-const decimalValueOf = AvDecimal.prototype.toString;
 const FAST_WALK_DEPTH = 256;
 const SLOW_WALK = Symbol("slow walk");
 class FastWalkFailure {
@@ -33,8 +32,8 @@ function copyValueType(value, prototype) {
     if (prototype === DATE_PROTOTYPE || value instanceof Date) {
         return new Date(dateValueOf.call(value));
     }
-    if (value instanceof AvDecimal) {
-        return new AvDecimal(decimalValueOf.call(value));
+    if (isAvDecimal(value)) {
+        return new AvDecimal(decimalDigitsOf(value));
     }
     if (value instanceof Uint8Array) {
         return new Uint8Array(value);
@@ -268,7 +267,7 @@ function pathSegment(array, key) {
     }
     return key;
 }
-function mirrorControlData(value) {
+function mirrorControlData(value, members) {
     const shape = reflectNode(value);
     if (shape === undefined) {
         throw new AvCallerDataError("unreadable-value", []);
@@ -375,6 +374,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 +421,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) {
@@ -465,6 +481,3 @@ export function copyCallerData(value, policy = NO_POLICY) {
     }
     return guardNative(() => copyFast(value, 0, policy), (failure) => copySlow(value, policy, failure instanceof FastWalkFailure ? failure.at : undefined));
 }
-export function callerDataFailureMessage(kind) {
-    return FAILURE_MESSAGES[kind];
-}

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

@@ -6,15 +6,21 @@ import type { AvMisuseEvent, MisuseReporter } from "./misuse-reporter.js";
  *
  * - `"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<AvMisuseEvent, "kind" | "path">;
+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
@@ -54,3 +60,4 @@ export declare function copyAtDoor(value: unknown, policy?: CallerDataPolicy): C
  * plan validator inspects and copies step by step.
  */
 export declare function copyEnvelopeAtDoor(request: unknown, members: readonly string[]): CallerDataCopy;
+export {};

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

@@ -21,6 +21,11 @@ export type PlannedReadOperation = {
     readonly projection: ReadProjectionPlan | undefined;
     readonly materialize: boolean;
 };
+/**
+ * The fields a level returns when it states no projection: every scalar of the
+ * active Contract whose `select` is `true` and that is not governed.
+ */
+export declare function defaultProjectionFields(active: AvContract, resourceName: string): readonly string[];
 /**
  * Clone the caller projection into the internal Adapter projection: the read
  * set the Adapter is asked for, always explicit for a projecting variant, plus
@@ -33,5 +38,5 @@ export declare function planReadOperation(core: AvContractCore, model: AvAdapter
  * Materialize computed scalar reads and remove internal dependency fields,
  * against `active` — the Contract `planReadOperation` was given as `active`.
  */
-export declare function materializeReadOperation(active: AvContract, compute: ResolvedComputeConfig | 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 {};