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

package/dist/contracts/contract-limits.d.ts

@@ -12,6 +12,10 @@ export type AvContractLimits = {
     readonly maxBooleanNodes: number;
     /** How deeply a `json` field's value may nest: its arrays and objects, counted from the value. */
     readonly maxJsonDepth: number;
+    /** The most operations one Operation Set (`POST /_all`) may hold. */
+    readonly maxAll: number;
+    /** The most entries of one Operation Set that run at once; at least 1. */
+    readonly maxAllConcurrency: number;
 };
 /** The limits in force when the configuration sets none. */
 export declare const DEFAULT_CONTRACT_LIMITS: {
@@ -21,4 +25,6 @@ export declare const DEFAULT_CONTRACT_LIMITS: {
     readonly maxTransactionOperations: 20;
     readonly maxBooleanNodes: 50;
     readonly maxJsonDepth: 64;
+    readonly maxAll: 10;
+    readonly maxAllConcurrency: 4;
 };

package/dist/contracts/contract-limits.js

@@ -5,4 +5,6 @@ export const DEFAULT_CONTRACT_LIMITS = {
     maxTransactionOperations: 20,
     maxBooleanNodes: 50,
     maxJsonDepth: 64,
+    maxAll: 10,
+    maxAllConcurrency: 4,
 };

package/dist/contracts/contract.d.ts

@@ -56,6 +56,21 @@ export interface AvContractApplication extends AvContract {
  * identified by its hash.
  */
 export interface AvContractClient extends AvContract {
+    /**
+     * The Resources, by name. One with a cached read carries `cache`, by `find`
+     * variant: that read is also served as
+     * `GET /_resources/<resource>/find/<variant>?q=…&v=…`, which a browser
+     * (`for: "user"`), a CDN for anonymous callers (`"anonymous"`) or a CDN for
+     * everyone (`"everyone"`) may keep for `maxAge` seconds.
+     */
+    readonly resources: Readonly<Record<string, AvResource<this> & {
+        readonly cache?: {
+            readonly [variant in "first" | "unique" | "many" | "count"]?: {
+                readonly for: "user" | "anonymous" | "everyone";
+                readonly maxAge: number;
+            };
+        };
+    }>>;
     /** The protocol version and this Contract's hash. */
     readonly protocol: AvContractClientProtocol;
     /**

package/dist/contracts/json-schema.projector.js

@@ -1,6 +1,4 @@
-function isRecord(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}
+import { isRecord } from "../runtime/record.guard.js";
 function memberSchema(schema) {
     if (!isRecord(schema)) {
         throw new TypeError("the schema is not one of the forms a ClientContract states");

package/dist/framework/access-facade.js

@@ -1,6 +1,7 @@
 import { projectJsonValue } from "../contracts/json-schema.projector.js";
 import { ACCESS_VERB_NAMES, ACCESS_VERBS, providerVerb, } from "../policy/access-verb.table.js";
 import { copyAtDoor } from "../runtime/caller-data.door.js";
+import { isRecord } from "../runtime/record.guard.js";
 import { requestIdOf } from "../runtime/request-id.js";
 import { stateOptionOf } from "../runtime/request-state.resolver.js";
 import { encodeOperationArgumentsForWire } from "../transactions/operation-arguments-encoder.js";
@@ -63,9 +64,6 @@ function stateOf(options) {
     const state = stateOptionOf(options);
     return state === undefined ? {} : { state };
 }
-function isRecord(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}
 function wireQuestions(contract, questions) {
     const copy = copyAtDoor({ questions });
     if (!copy.ok) {

package/dist/framework/framework.factory.js

@@ -9,7 +9,7 @@ import { recordAccessProvider } from "../policy/access-provider.registry.js";
 import { recordAccessQuestions } from "../policy/access-question.registry.js";
 import { createAccessQuestionAnswerer } from "../policy/access-question.runtime.js";
 import { heldTargetsOf } from "../policy/policy-reference-write.runtime.js";
-import { callerOf } from "../policy/policy-request.js";
+import { callerOf, derivePolicyCaller, } from "../policy/policy-request.js";
 import { policyStartupDiagnostics } from "../policy/policy-startup.validator.js";
 import { loadPrebuiltContracts, warnStalePrebuilt, } from "../prebuilt/prebuilt-contracts.loader.js";
 import { copyAtDoor, copyEnvelopeAtDoor, refuseCallerData, } from "../runtime/caller-data.door.js";
@@ -26,7 +26,8 @@ import { createTransactionPlanAssembler } from "../transactions/transaction-plan
 import { createTransactionRuntime } from "../transactions/transaction-runtime.js";
 import { createServerClientAccess } from "./access-facade.js";
 import { AvConstructionError } from "./framework-construction.error.js";
-import { createOperationFacade, createOperationTree, settleOperation, } from "./operation-facade.js";
+import { createAbortableOperationFacade, createOperationFacade, createOperationTree, settleOperation, } from "./operation-facade.js";
+import { runOperationSet } from "./operation-set.runner.js";
 const APPLICATION_SQL_BUILDER = "$sql";
 export async function createFramework(config) {
     const configDiagnostics = validateFrameworkConfig(config);
@@ -55,6 +56,10 @@ export async function createFramework(config) {
     if (!compilation.ok) {
         throw new AvConstructionError("contract-compilation", compilation.diagnostics);
     }
+    const clashes = serverClientClashes(compilation.contracts);
+    if (clashes.length > 0) {
+        throw new AvConstructionError("contract-compilation", clashes);
+    }
     const forcing = validateForcedOperations(config, compilation.contracts);
     if (forcing.length > 0) {
         throw new AvConstructionError("configuration", forcing);
@@ -79,7 +84,7 @@ export async function createFramework(config) {
     const executeTransaction = createTransactionRuntime(runtimeDependencies, pipelineDependencies);
     const misuse = createMisuseReporter(resolvedConfig.misuse);
     const executeOperation = (request, caller) => executeTotally(execute, request, resolvedConfig.diagnostics, "caller", caller);
-    const executeApplicationValues = (request, caller) => executeTotally(encodingApplicationValues(execute, compilation.contracts.client), request, resolvedConfig.diagnostics, "caller", caller);
+    const prepareApplicationValues = (request, caller) => ((copy) => () => executeTotally(encodingApplicationValues(execute, compilation.contracts.client, copy), request, resolvedConfig.diagnostics, "caller", caller))(copyArgumentsNow(request.arguments));
     const protocol = {
         version: AVENTARA_PROTOCOL_VERSION,
         hash: compilation.contracts.client.protocol.hash,
@@ -116,7 +121,7 @@ export async function createFramework(config) {
             arguments: args,
         }), executeOperation),
         client: createOperationFacade(model, clientRequest, executeOperation),
-        serverClient: withServerClientAccess(createOperationFacade(model, clientRequest, executeApplicationValues), accessAnswerer === undefined
+        serverClient: withServerClientMembers(createAbortableOperationFacade(model, clientRequest, prepareApplicationValues), (entries, options) => runOperationSet(entries, options, compilation.contracts.client.limits), accessAnswerer === undefined
             ? undefined
             : createServerClientAccess({
                 contract: compilation.contracts.client,
@@ -140,7 +145,8 @@ export async function createFramework(config) {
         recordAccessQuestions(framework, accessAnswerer);
     }
     recordOwnedExecution(framework, {
-        execute: (request, refused) => executeTotally(execute, request, resolvedConfig.diagnostics, refused === undefined ? "owned" : { refused }),
+        execute: (request, refused, member) => executeTotally(execute, request, resolvedConfig.diagnostics, refused === undefined ? "owned" : { refused }, member?.caller, member?.key),
+        caller: (request) => derivePolicyCaller(resolvedConfig.policy, request),
         executeTransaction: (request, refused) => executeTransactionTotally(executeTransaction, request, resolvedConfig.diagnostics, undefined, refused === undefined
             ? { source: "owned" }
             : { source: "owned", refused }),
@@ -169,9 +175,19 @@ async function prebuiltCompilation(prebuilt, model, config, resolved) {
     }
     return { ok: true, contracts: loaded.contracts };
 }
-function encodingApplicationValues(execute, contract) {
+function copyArgumentsNow(args) {
+    try {
+        return copyAtDoor(args);
+    }
+    catch (thrown) {
+        return { thrown };
+    }
+}
+function encodingApplicationValues(execute, contract, copy) {
     return (request, report, _source, caller) => {
-        const copy = copyAtDoor(request.arguments);
+        if ("thrown" in copy) {
+            throw copy.thrown;
+        }
         if (!copy.ok) {
             return execute(request, report, { refused: copy.error }, caller);
         }
@@ -181,8 +197,8 @@ function encodingApplicationValues(execute, contract) {
         }, report, "owned", caller);
     };
 }
-async function executeTotally(execute, request, diagnostics, source, caller) {
-    const report = createDiagnosticsReporter(diagnostics, request);
+async function executeTotally(execute, request, diagnostics, source, caller, key) {
+    const report = createDiagnosticsReporter(diagnostics, request, undefined, key);
     try {
         return await execute(request, report, source, caller);
     }
@@ -263,8 +279,21 @@ async function runTransactionTotally(execute, assembler, operations, requestId,
         statements: assembled.statements,
     }, caller);
 }
-function withServerClientAccess(facade, access) {
-    return access === undefined
-        ? facade
-        : Object.freeze({ ...facade, $access: access });
+function withServerClientMembers(facade, all, access) {
+    return Object.freeze({
+        ...facade,
+        all,
+        ...(access === undefined ? {} : { $access: access }),
+    });
+}
+function serverClientClashes(contracts) {
+    return Object.hasOwn(contracts.client.resources, "all")
+        ? [
+            {
+                code: "COMPILER_RESERVED_RESOURCE_NAME",
+                path: "adapter.model.resources.all",
+                message: 'resource "all" clashes with serverClient.all; rename the Resource or expose it under another name',
+            },
+        ]
+        : [];
 }

package/dist/framework/operation-facade.d.ts

@@ -39,13 +39,29 @@ export type AvAppTxPlainCall<in out C extends AvContract, in out R extends AvRes
 export type AvClientTxProjectingCall<in out C extends AvContract, in out R extends AvResourceKey<C>, in out I extends AvOperationIdentity> = DeferredProjectingCall<C, R, I, DeferredArguments<C, R, I, AvWireScalarForms, AvApplicationScalarForms>, AvApplicationScalarForms, "client">;
 /** `framework.clientTx.<Resource>.<family>.<variant>` when it does not. */
 export type AvClientTxPlainCall<in out C extends AvContract, in out R extends AvResourceKey<C>, in out I extends AvOperationIdentity> = DeferredPlainCall<C, R, I, DeferredArguments<C, R, I, AvWireScalarForms, AvApplicationScalarForms>, AvApplicationScalarForms, "client">;
+/** A `serverClient` call's options: {@link AvExecutionOptions}, and the call's own abort signal. */
+type AvServerClientCallOptions = AvExecutionOptions & {
+    /**
+     * Aborts this call only. Aborted before the call runs, it never runs;
+     * while it runs, it rejects with the signal's reason at once, and the
+     * database finishes what it started. Any platform's `AbortSignal` is one.
+     */
+    readonly signal?: {
+        readonly aborted: boolean;
+        readonly reason: unknown;
+        addEventListener(type: "abort", listener: () => void, options?: {
+            readonly once?: boolean;
+        }): void;
+        removeEventListener(type: "abort", listener: () => void): void;
+    };
+};
 /**
  * `framework.serverClient.<Resource>.<family>.<variant>` when the variant takes a `select` or `include`:
  * the Client Contract's view, application forms in.
  */
-export type AvServerClientProjectingCall<in out C extends AvContract, in out R extends AvResourceKey<C>, in out I extends AvOperationIdentity> = ProjectingCall<C, R, I, AvOperationArgumentsFor<C, R, I, AvApplicationScalarForms>, AvApplicationScalarForms, AvExecutionOptions>;
+export type AvServerClientProjectingCall<in out C extends AvContract, in out R extends AvResourceKey<C>, in out I extends AvOperationIdentity> = ProjectingCall<C, R, I, AvOperationArgumentsFor<C, R, I, AvApplicationScalarForms>, AvApplicationScalarForms, AvServerClientCallOptions>;
 /** `framework.serverClient.<Resource>.<family>.<variant>` when it does not. */
-export type AvServerClientPlainCall<in out C extends AvContract, in out R extends AvResourceKey<C>, in out I extends AvOperationIdentity> = PlainCall<C, R, I, AvOperationArgumentsFor<C, R, I, AvApplicationScalarForms>, AvApplicationScalarForms, AvExecutionOptions>;
+export type AvServerClientPlainCall<in out C extends AvContract, in out R extends AvResourceKey<C>, in out I extends AvOperationIdentity> = PlainCall<C, R, I, AvOperationArgumentsFor<C, R, I, AvApplicationScalarForms>, AvApplicationScalarForms, AvServerClientCallOptions>;
 /**
  * `framework.serverClientTx.<Resource>.<family>.<variant>` when the variant takes a `select` or `include`:
  * the Client Contract's view, application forms in, a client-origin handle out.
@@ -117,13 +133,50 @@ export type AvApplicationFacade<C extends AvContract> = {
 export type AvClientFacade<C extends AvContract> = {
     readonly [R in AvResourceKey<C>]: AvClientResourceFacade<C, R>;
 };
+/** `framework.serverClient.all`: its own member beside the Resources. */
+type ServerClientAll = {
+    /**
+     * Awaits an object of calls together, in process (any number of them:
+     * `limits.maxAll` guards the HTTP door only), and resolves one value per key. A call already runs when it is made;
+     * an `avLazy(() => call)` entry is started by `all`, at most
+     * `limits.maxAllConcurrency` at once. Strict: the first failure rejects it
+     * and its `avLazy` entries not yet started never start (fail-fast, not
+     * atomic: what already ran stays done). With `settle: true` every key settles as `{ status, value }`
+     * or `{ status, reason }`. Its `signal` aborts each of its calls and no other.
+     */
+    readonly all: <E extends {
+        readonly [key: string]: PromiseLike<unknown>;
+    }, S extends boolean = false>(entries: E, options?: {
+        /** Aborts every call of this `all`, and no other. Any platform's `AbortSignal` is one. */
+        readonly signal?: {
+            readonly aborted: boolean;
+            readonly reason: unknown;
+            addEventListener(type: "abort", listener: () => void, options?: {
+                readonly once?: boolean;
+            }): void;
+            removeEventListener(type: "abort", listener: () => void): void;
+        };
+        /** true settles every key on its own and never rejects for one; strict otherwise. */
+        readonly settle?: S;
+    }) => Promise<S extends true ? {
+        -readonly [K in keyof E]: {
+            readonly status: "fulfilled";
+            readonly value: Awaited<E[K]>;
+        } | {
+            readonly status: "rejected";
+            readonly reason: unknown;
+        };
+    } : {
+        -readonly [K in keyof E]: Awaited<E[K]>;
+    }>;
+};
 /**
  * `framework.serverClient`: one {@link AvServerClientResourceFacade} per Resource
- * of `C`, the Client Contract's view, taking application forms.
+ * of `C`, the Client Contract's view, taking application forms, and `all`.
  */
 export type AvServerClientFacade<C extends AvContract> = {
     readonly [R in AvResourceKey<C>]: AvServerClientResourceFacade<C, R>;
-};
+} & ServerClientAll;
 /** `framework.appTx.$sql`: the developer SQL step only an application transaction has. */
 type ApplicationSqlStep = {
     /**
@@ -156,7 +209,7 @@ export type AvServerClientTxFacade<C extends AvContract> = {
 };
 type ApplicationSurface<C> = C extends AvContract ? string extends AvResourceKey<C> ? OpaqueSurface : AvApplicationFacade<C> : never;
 type ClientSurface<C> = C extends AvContract ? string extends AvResourceKey<C> ? OpaqueSurface : AvClientFacade<C> : never;
-type ServerClientSurface<C> = C extends AvContract ? string extends AvResourceKey<C> ? OpaqueSurface : AvServerClientFacade<C> : never;
+type ServerClientSurface<C> = C extends AvContract ? string extends AvResourceKey<C> ? OpaqueSurface & ServerClientAll : AvServerClientFacade<C> : never;
 type ApplicationDeferredSurface<C> = C extends AvContract ? string extends AvResourceKey<C> ? OpaqueSurface & ApplicationSqlStep : AvAppTxFacade<C> : never;
 type ClientDeferredSurface<C> = C extends AvContract ? string extends AvResourceKey<C> ? OpaqueSurface : AvClientTxFacade<C> : never;
 type ServerClientDeferredSurface<C> = C extends AvContract ? string extends AvResourceKey<C> ? OpaqueSurface : AvServerClientTxFacade<C> : never;
@@ -164,7 +217,7 @@ type ServerClientDeferredSurface<C> = C extends AvContract ? string extends AvRe
 export type ApplicationOperations<M extends AvAdapterModel, Cfg> = ApplicationSurface<AvContractApplicationView<M, Cfg>>;
 /** `framework.client`'s type: {@link AvClientFacade}, or opaque. */
 export type ClientOperations<M extends AvAdapterModel, Cfg> = ClientSurface<ClientContractView<M, Cfg>>;
-/** `framework.serverClient`'s type: {@link AvServerClientFacade}, or opaque, and `$access`. */
+/** `framework.serverClient`'s type: {@link AvServerClientFacade}, or opaque with `all`, and `$access`. */
 export type ServerClientOperations<M extends AvAdapterModel, Cfg> = ServerClientSurface<ClientContractView<M, Cfg>> & ServerClientAccess<ClientContractView<M, Cfg>, AccessProviderOf<Cfg>>;
 /** `framework.appTx`'s type: {@link AvAppTxFacade}, or opaque with `$sql`. */
 export type ApplicationTransactionBuilders<M extends AvAdapterModel, Cfg> = ApplicationDeferredSurface<AvContractApplicationView<M, Cfg>>;
@@ -217,6 +270,14 @@ export declare function createOperationFacade<Facade>(model: AvAdapterModel, req
  * the response's data, or its failure thrown.
  */
 export declare function settleOperation(response: AvOperationResponse | AvTransactionResponse): unknown;
+/** Prepares one call's run: its arguments are read when the call is made. */
+type FacadePreparer = (request: AvOperationRequest, caller: PolicyCaller | undefined) => () => Promise<AvOperationResponse>;
+/**
+ * {@link createOperationFacade}'s twin for `framework.serverClient`: a call
+ * builds its request and runs at once, and the caller's `signal` aborts it
+ * (already aborted, it never runs; aborted while it runs, it rejects at once).
+ */
+export declare function createAbortableOperationFacade<Facade>(model: AvAdapterModel, request: FacadeRequest, prepare: FacadePreparer): Facade;
 /**
  * One leaf of an operation tree: the callable for one advertised variant. The
  * second parameter is a façade call's options; a builder leaf ignores it.

package/dist/framework/operation-facade.js

@@ -4,6 +4,7 @@ import { callerOf } from "../policy/policy-request.js";
 import { thrownFailure } from "../runtime/framework-error.factory.js";
 import { requestIdOf } from "../runtime/request-id.js";
 import { stateOptionOf } from "../runtime/request-state.resolver.js";
+import { runAbortable, signalOptionOf } from "./operation-set.runner.js";
 export function createOperationFacade(model, request, execute) {
     return createOperationTree(model, (resource, identity) => async (args, options) => settleOperation(await execute(request(resource, identity, args === undefined ? {} : args, requestIdOf(options), stateOptionOf(options)), callerOf(options))));
 }
@@ -13,6 +14,12 @@ export function settleOperation(response) {
     }
     return response.data;
 }
+export function createAbortableOperationFacade(model, request, prepare) {
+    return createOperationTree(model, (resource, identity) => (args, options) => {
+        const run = prepare(request(resource, identity, args === undefined ? {} : args, requestIdOf(options), stateOptionOf(options)), callerOf(options));
+        return runAbortable(async () => settleOperation(await run()), signalOptionOf(options));
+    });
+}
 export function createOperationTree(model, leaf) {
     const resources = Object.entries(model.resources).map(([resource, { operations }]) => {
         const families = Object.entries(operations).map(([family, variants]) => [family, variantLeaves(leaf, resource, family, variants)]);

package/dist/framework/operation-set.runner.d.ts

@@ -0,0 +1,47 @@
+import type { AvContractLimits } from "../contracts/contract-limits.js";
+/**
+ * What core reads of an abort signal: the platform's `AbortSignal` (DOM's,
+ * Node's, any runtime's) is one, structurally. Core runs in any JS runtime, so
+ * its declarations name no platform global (rc.11): a consumer with neither
+ * DOM's lib nor Node's types type-checks them. The public signatures spell this
+ * shape inline (`serverClient` calls, `serverClient.all`, the protocol's
+ * `handleAll`): no new public name.
+ */
+export type AbortSignalShape = {
+    readonly aborted: boolean;
+    readonly reason: unknown;
+    addEventListener(type: "abort", listener: () => void, options?: {
+        readonly once?: boolean;
+    }): void;
+    removeEventListener(type: "abort", listener: () => void): void;
+};
+/** `options.signal` when it is an abort signal; anything else is ignored. */
+export declare function signalOptionOf(options: unknown): AbortSignalShape | undefined;
+/**
+ * Runs `run` now under `signal`: an eager call's own abort. Already aborted, it
+ * never runs; aborted while it runs, it rejects at once with the signal's reason.
+ */
+export declare function runAbortable(run: () => Promise<unknown>, signal: AbortSignalShape | undefined): Promise<unknown>;
+/**
+ * A call made later: `avLazy(() => avClient.Post.find.many(args))` makes the
+ * call on each `then`, `catch` or `finally`, never before the first, and
+ * answers what that call answers. It keeps no answer: awaited again (by another
+ * request, say), it makes the call again, in the context awaiting it. Given to
+ * `all`, it is started by `all`, at most `limits.maxAllConcurrency` at once,
+ * and never when `all` has already failed (strict) or been aborted.
+ */
+export declare function avLazy<T>(make: () => PromiseLike<T>): Promise<T>;
+/**
+ * The Contract's `limits.maxAllConcurrency`, for `all` here and for `POST /_all`
+ * (`protocol/operation-set.handler.ts`). A compiled Contract always holds a
+ * whole number of at least 1; a hand-built one that does not runs its entries
+ * one at a time, never none.
+ */
+export declare function maxAllConcurrencyOf(limits: AvContractLimits): number;
+/**
+ * `all(entries, options?)` over `limits` (the Client Contract's): see the module
+ * comment. Rejects with a `TypeError`, before anything runs, when `entries` is not
+ * an object whose every value is a promise. Any number of entries is accepted:
+ * `limits.maxAll` guards the HTTP door only.
+ */
+export declare function runOperationSet(entries: unknown, options: unknown, limits: AvContractLimits): Promise<unknown>;

package/dist/framework/operation-set.runner.js

@@ -0,0 +1,168 @@
+import { isThenable } from "../runtime/thenable.guard.js";
+const LAZY_CALLS = new WeakMap();
+const ignore = () => undefined;
+export function signalOptionOf(options) {
+    if (typeof options !== "object" || options === null) {
+        return undefined;
+    }
+    const signal = options.signal;
+    return typeof signal === "object" &&
+        signal !== null &&
+        typeof signal.aborted === "boolean" &&
+        typeof signal.addEventListener === "function"
+        ? signal
+        : undefined;
+}
+function start(run, signal) {
+    if (signal?.aborted === true) {
+        return { result: Promise.reject(signal.reason), done: Promise.resolve() };
+    }
+    let running;
+    try {
+        running = run();
+    }
+    catch (error) {
+        running = Promise.reject(error);
+    }
+    const done = running.then(ignore, ignore);
+    if (signal === undefined) {
+        return { result: running, done };
+    }
+    const result = new Promise((resolve, reject) => {
+        const aborted = () => reject(signal.reason);
+        signal.addEventListener("abort", aborted, { once: true });
+        running.then((value) => {
+            signal.removeEventListener("abort", aborted);
+            resolve(value);
+        }, (error) => {
+            signal.removeEventListener("abort", aborted);
+            reject(error);
+        });
+    });
+    return { result, done };
+}
+export function runAbortable(run, signal) {
+    return start(run, signal).result;
+}
+export function avLazy(make) {
+    const run = () => Promise.resolve(make());
+    const record = {
+        begin: (signal) => start(run, signal),
+    };
+    const result = () => record.begin().result;
+    const lazy = Object.freeze({
+        then: (onFulfilled, onRejected) => result().then(onFulfilled, onRejected),
+        catch: (onRejected) => result().catch(onRejected),
+        finally: (onFinally) => result().finally(onFinally),
+        [Symbol.toStringTag]: "Promise",
+    });
+    LAZY_CALLS.set(lazy, record);
+    return lazy;
+}
+export function maxAllConcurrencyOf(limits) {
+    const limit = limits.maxAllConcurrency;
+    return typeof limit === "number" && Number.isSafeInteger(limit) && limit >= 1
+        ? limit
+        : 1;
+}
+export function runOperationSet(entries, options, limits) {
+    if (typeof entries !== "object" ||
+        entries === null ||
+        Array.isArray(entries)) {
+        return Promise.reject(new TypeError("all takes an object of calls: { key: avClient.Resource.find.many(…), … }."));
+    }
+    const keyed = [];
+    for (const key of Object.keys(entries)) {
+        const value = entries[key];
+        if (!isThenable(value)) {
+            return Promise.reject(new TypeError(`all's entry ${JSON.stringify(key)} is not a call.`));
+        }
+        keyed.push([key, value]);
+    }
+    const settle = typeof options === "object" &&
+        options !== null &&
+        options.settle === true;
+    const outer = signalOptionOf(options);
+    const group = new AbortController();
+    const forward = () => {
+        group.abort(outer?.reason);
+    };
+    if (outer?.aborted === true) {
+        forward();
+    }
+    else {
+        outer?.addEventListener("abort", forward, { once: true });
+    }
+    const list = keyed.map(([key, value]) => {
+        const record = LAZY_CALLS.get(value);
+        let resolve = ignore;
+        let reject = ignore;
+        const outcome = new Promise((onResolve, onReject) => {
+            resolve = onResolve;
+            reject = onReject;
+        });
+        return {
+            key,
+            value,
+            record,
+            outcome,
+            resolve,
+            reject,
+        };
+    });
+    const answer = (entry, result) => {
+        result.then((value) => entry.resolve(value), (reason) => {
+            entry.reject(reason);
+            if (!settle) {
+                group.abort();
+            }
+        });
+    };
+    const follow = (entry, result) => {
+        const aborted = () => entry.reject(group.signal.reason);
+        if (group.signal.aborted) {
+            aborted();
+        }
+        else {
+            group.signal.addEventListener("abort", aborted, { once: true });
+        }
+        answer(entry, result);
+    };
+    for (const entry of list) {
+        if (entry.record === undefined) {
+            follow(entry, entry.value);
+        }
+    }
+    const queued = list.filter((entry) => entry.record !== undefined);
+    const cap = maxAllConcurrencyOf(limits);
+    let next = 0;
+    let running = 0;
+    const launch = () => {
+        while (next < queued.length && (running < cap || group.signal.aborted)) {
+            const entry = queued[next];
+            const record = entry.record;
+            next += 1;
+            const call = record.begin(group.signal);
+            running += 1;
+            answer(entry, call.result);
+            void Promise.all([call.done, entry.outcome.then(ignore, ignore)]).then(() => {
+                running -= 1;
+                launch();
+            });
+        }
+    };
+    group.signal.addEventListener("abort", launch, { once: true });
+    launch();
+    const done = (result) => {
+        outer?.removeEventListener("abort", forward);
+        return result;
+    };
+    const byKey = (values) => Object.fromEntries(list.map(({ key }, index) => [key, values[index]]));
+    if (settle) {
+        return Promise.all(list.map(({ outcome }) => outcome.then((value) => ({ status: "fulfilled", value }), (reason) => ({ status: "rejected", reason })))).then((settled) => done(byKey(settled)));
+    }
+    return Promise.all(list.map(({ outcome }) => outcome)).then((values) => done(byKey(values)), (error) => {
+        group.abort();
+        throw done(error);
+    });
+}

package/dist/index.d.ts

@@ -3,6 +3,7 @@ export type { AvAdapterDiscoveryDiagnostic, AvAdapterDiscoveryDiagnosticCode, }
 export type { AvAdapterModel } from "./adapters/adapter-model.js";
 export type { AvContracts } from "./compiler/contract.compiler.js";
 export type { AvContractCompilerDiagnostic, AvContractCompilerDiagnosticCode, } from "./compiler/contract-compiler-diagnostic.js";
+export { cache } from "./config/cache-stage.factory.js";
 export type { AvConfigComputedFields } from "./config/computed-fields.js";
 export type { AvMcpEndpoint } from "./config/config.resolver.js";
 export type { AvConfigDiagnostic, AvConfigDiagnosticCode, } from "./config/config-diagnostic.js";
@@ -34,6 +35,7 @@ export type { AvFramework } from "./framework/framework.js";
 export type { AvConstructionDiagnostic, AvConstructionStage, } from "./framework/framework-construction.error.js";
 export { AvConstructionError } from "./framework/framework-construction.error.js";
 export type { AvApplicationFacade, AvApplicationFamilyFacade, AvApplicationPlainCall, AvApplicationProjectingCall, AvApplicationResourceFacade, AvAppTxFacade, AvAppTxFamilyFacade, AvAppTxPlainCall, AvAppTxProjectingCall, AvAppTxResourceFacade, AvClientFacade, AvClientFamilyFacade, AvClientPlainCall, AvClientProjectingCall, AvClientResourceFacade, AvClientTxFacade, AvClientTxFamilyFacade, AvClientTxPlainCall, AvClientTxProjectingCall, AvClientTxResourceFacade, AvServerClientFacade, AvServerClientFamilyFacade, AvServerClientPlainCall, AvServerClientProjectingCall, AvServerClientResourceFacade, AvServerClientTxFacade, AvServerClientTxFamilyFacade, AvServerClientTxPlainCall, AvServerClientTxProjectingCall, AvServerClientTxResourceFacade, } from "./framework/operation-facade.js";
+export { avLazy } from "./framework/operation-set.runner.js";
 export type { AvCreateDataInput, AvCursorInput, AvFieldKey, AvIncludeInput, AvNoAdvertisedMember, AvNullsOrder, AvOperationArgumentMap, AvOperationArgumentsFor, AvOrderByEntry, AvOrderByInput, AvProjectionEntry, AvRelationProjectionInput, AvResourceKey, AvScalarFilterOperands, AvScalarOrderInput, AvScalarWhereInput, AvSelectInput, AvSortDirection, AvUniqueWhereInput, AvUpdateDataInput, AvWhereInput, } from "./operations/operation-arguments.js";
 export type { AvDeferredOperationCall, AvOperationCall, AvOperationGrammar, AvOperationSlot, } from "./operations/operation-call.js";
 export type { AvOperationFamily, AvOperationIdentity, AvOperationVariant, } from "./operations/operation-identity.js";

package/dist/index.js

@@ -1,6 +1,8 @@
+export { cache } from "./config/cache-stage.factory.js";
 export { defineResource, } from "./config/define-resource.js";
 export { createFramework } from "./framework/framework.factory.js";
 export { AvConstructionError } from "./framework/framework-construction.error.js";
+export { avLazy } from "./framework/operation-set.runner.js";
 export { AvDecimal } from "./runtime/decimal.js";
 export { AvErrorCatalog, } from "./runtime/error.catalog.js";
 export { AvAuthError, AvConflictError, AvContractMismatchError, AvError, AvInternalError, AvNotFoundError, AvProtocolError, AvValidationError, } from "./runtime/framework-error.js";

package/dist/internal.d.ts

@@ -15,6 +15,7 @@ export type { AvAdapterSqlStatement, AvAdapterSqlValue, } from "./adapters/adapt
 export type { AvAdapterTransactionExecutor } from "./adapters/adapter-transaction-executor.interface.js";
 export { compileContracts } from "./compiler/contract.compiler.js";
 export { resolveFrameworkConfig } from "./config/config.resolver.js";
+export { canonicalJson } from "./contracts/canonical-json.writer.js";
 export { PROJECTION_SCOPES, WRITE_SCOPES } from "./contracts/capability.js";
 export { validateClientContractStructure } from "./contracts/client-contract-structure.validator.js";
 export { AvCanonicalJsonError, canonicalizeContract, canonicalizeJson, } from "./contracts/contract-canonicalizer.js";
@@ -35,6 +36,7 @@ export type { SemanticOperationArguments } from "./operations/operation-validato
 export { VALIDATION_CODES } from "./operations/validation-code.js";
 export { accessProviderOf } from "./policy/access-provider.registry.js";
 export { ACCESS_VERB_NAMES, ACCESS_VERBS, providerVerb, } from "./policy/access-verb.table.js";
+export { holdRequestPrincipal } from "./policy/policy-request.js";
 export { prebuiltFileChanges } from "./prebuilt/prebuilt-changes.js";
 export { emitPrebuiltContracts, prebuiltContractsOf, } from "./prebuilt/prebuilt-contracts.emitter.js";
 export { mcpFailureReporterOf } from "./runtime/diagnostics-reporter.js";

package/dist/internal.js

@@ -1,5 +1,6 @@
 export { compileContracts } from "./compiler/contract.compiler.js";
 export { resolveFrameworkConfig } from "./config/config.resolver.js";
+export { canonicalJson } from "./contracts/canonical-json.writer.js";
 export { PROJECTION_SCOPES, WRITE_SCOPES } from "./contracts/capability.js";
 export { validateClientContractStructure } from "./contracts/client-contract-structure.validator.js";
 export { AvCanonicalJsonError, canonicalizeContract, canonicalizeJson, } from "./contracts/contract-canonicalizer.js";
@@ -16,6 +17,7 @@ export { DATABASE_REFUSALS } from "./operations/database-refusal.js";
 export { VALIDATION_CODES } from "./operations/validation-code.js";
 export { accessProviderOf } from "./policy/access-provider.registry.js";
 export { ACCESS_VERB_NAMES, ACCESS_VERBS, providerVerb, } from "./policy/access-verb.table.js";
+export { holdRequestPrincipal } from "./policy/policy-request.js";
 export { prebuiltFileChanges } from "./prebuilt/prebuilt-changes.js";
 export { emitPrebuiltContracts, prebuiltContractsOf, } from "./prebuilt/prebuilt-contracts.emitter.js";
 export { mcpFailureReporterOf } from "./runtime/diagnostics-reporter.js";

package/dist/operations/operation-validator-core.js

@@ -1,7 +1,8 @@
 import { FILTER_MODES, toOneRelinkWithRewrite, } from "../contracts/capability.js";
 import { lookupField, lookupResource } from "../contracts/contract-lookup.js";
 import { advertisedDirectivesAt, advertisedReducers, advertisedReducersAt, holdsAt, } from "../contracts/field.js";
-import { isPlainRecord, unsentReadValueIssue, } from "../runtime/scalar-runtime.js";
+import { isPlainRecord, isRecord } from "../runtime/record.guard.js";
+import { unsentReadValueIssue } from "../runtime/scalar-runtime.js";
 import { routeTransactionReferenceCandidate } from "../transactions/transaction-reference.js";
 import { isOperationFamily, } from "./operation-identity.js";
 import { NESTED_PROJECTION_SCOPE, resolveProjectionScope, } from "./projection-scope.resolver.js";
@@ -96,9 +97,6 @@ const OPERATION_ARGUMENT_RULES = {
         projection: true,
     },
 };
-function isRecord(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}
 function includes(values, value) {
     return values?.includes(value) ?? false;
 }

package/dist/operations/structural-limits.walker.js

@@ -1,5 +1,6 @@
 import { lookupField, lookupResource } from "../contracts/contract-lookup.js";
 import { advertisedDirectives, holdsAt, } from "../contracts/field.js";
+import { isRecord } from "../runtime/record.guard.js";
 import { NESTED_PROJECTION_SCOPE, resolveProjectionScope, } from "./projection-scope.resolver.js";
 const UNTRACKED = [];
 const RELATION_FILTER_OPERATORS = ["some", "every", "none"];
@@ -15,9 +16,6 @@ const DIRECTIVE_PAYLOADS = new Map([
     ],
 ]);
 const NO_PAYLOADS = [];
-function isRecord(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}
 function extend(state, path, segment) {
     return state.tracking ? [...path, segment] : UNTRACKED;
 }