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

package/dist/protocol/protocol.handler.js

@@ -3,29 +3,40 @@ import { createDiagnosticsReporter, createReporter, } from "../runtime/diagnosti
 import { sanitizeOperationFailure } from "../runtime/error-boundary.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 { checkOperationRoute } from "./absent-route.responder.js";
+import { adoptParsedBody, decodeCanRequest, decodeOperationRead, decodeTransactionRequest, isParsedByDecoder, transportOf, } from "./http-request.decoder.js";
+import { readRequest } from "./http-request.reader.js";
 import { encodeOperationResponse, encodeTransactionResponse, } from "./http-response.encoder.js";
-function admitOperation(context, request) {
+import { transportFailure } from "./protocol-failure.js";
+import { headerValue } from "./protocol-headers.js";
+import { cachedReadAnswer, uncachedAnswer } from "./read-cache.responder.js";
+import { readArgumentsOf } from "./read-query.codec.js";
+export function admitOperation(context, request) {
     const owned = context.owned;
     if (isParsedByDecoder(request.arguments)) {
-        return { request, run: owned?.execute ?? context.execute };
+        return {
+            request,
+            run: owned === undefined
+                ? (admitted) => context.execute(admitted)
+                : (admitted, member) => owned.execute(admitted, undefined, member),
+        };
     }
     const copy = copyAtDoor(request.arguments);
     if (owned === undefined) {
         return {
             request: copy.ok ? { ...request, arguments: copy.value } : request,
-            run: context.execute,
+            run: (admitted) => context.execute(admitted),
         };
     }
     if (copy.ok) {
         return {
             request: { ...request, arguments: copy.value },
-            run: (admitted) => owned.execute(admitted),
+            run: (admitted, member) => owned.execute(admitted, undefined, member),
         };
     }
     return {
         request: { ...request, arguments: {} },
-        run: (admitted) => owned.execute(admitted, copy.error),
+        run: (admitted, member) => owned.execute(admitted, copy.error, member),
     };
 }
 function admitTransaction(context, request) {
@@ -50,7 +61,7 @@ function admitTransaction(context, request) {
         run: (admitted) => owned.executeTransaction(admitted, captured.refused.size === 0 ? undefined : captured.refused),
     };
 }
-async function seededState(options, report, view) {
+export async function seededState(options, report, view) {
     if (options?.state === undefined) {
         return { ok: true, state: undefined };
     }
@@ -82,10 +93,20 @@ export function operationUnencodableReport(sink, request) {
     return (error) => createDiagnosticsReporter(sink, request)(error, "A3003");
 }
 export async function handleOperationRequest(context, request, options) {
-    const decoded = decodeOperationRequest(context.contracts, request, context.origin);
+    const read = readRequest(request);
+    if (!read.ok) {
+        return read.response;
+    }
+    if (read.request.method === "GET") {
+        return handleCachedRead(context, read, options);
+    }
+    const decoded = decodeOperationRead(context.contracts, read, context.origin);
     if (!decoded.ok) {
         return decoded.response;
     }
+    return runOperation(context, decoded, options);
+}
+async function runOperation(context, decoded, options) {
     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
@@ -95,6 +116,61 @@ export async function handleOperationRequest(context, request, options) {
         : seeded.response;
     return encodeOperationResponse(response, decoded.requestId, operationUnencodableReport(context.sink, decoded.request));
 }
+async function handleCachedRead(context, read, options) {
+    const route = checkOperationRoute(context.contracts, read, context.origin);
+    if (!route.ok) {
+        return uncachedAnswer(route.response);
+    }
+    const { cache, query } = route;
+    if (cache === undefined || query === undefined) {
+        return uncachedAnswer(transportFailure("A2000", read.requestId));
+    }
+    const args = await readArgumentsOf(query.q, context.contracts[context.origin].limits.maxRequestBytes);
+    if (!args.ok) {
+        return uncachedAnswer(transportFailure(args.code, read.requestId));
+    }
+    adoptParsedBody(args.value);
+    const request = {
+        origin: context.origin,
+        requestId: read.requestId,
+        resource: route.resource,
+        ...route.operation,
+        protocol: route.protocol,
+        transport: transportOf(read),
+        arguments: args.value,
+    };
+    const ifNoneMatch = headerValue(read.headers, "if-none-match");
+    const owned = context.owned;
+    if (cache.for !== "anonymous" || owned === undefined) {
+        const answer = await runOperation(context, { ok: true, request, requestId: read.requestId }, options);
+        return cachedReadAnswer(answer, cache, ifNoneMatch, false);
+    }
+    const report = createDiagnosticsReporter(context.sink, request);
+    const seeded = await seededState(options, report, {
+        path: ["arguments"],
+        arguments: request.arguments,
+    });
+    if (!seeded.ok) {
+        return uncachedAnswer(encodeOperationResponse(seeded.response, read.requestId));
+    }
+    const state = seeded.state ?? {};
+    let caller;
+    try {
+        caller = await owned.caller({ origin: context.origin, state });
+    }
+    catch (error) {
+        report(error, "A3000");
+        return uncachedAnswer(encodeOperationResponse(internalFailure(), read.requestId));
+    }
+    const response = await owned.execute({ ...request, state }, undefined, caller === undefined ? undefined : { caller });
+    return cachedReadAnswer(encodeOperationResponse(response, read.requestId, operationUnencodableReport(context.sink, request)), cache, ifNoneMatch, isAnonymous(caller, read.headers));
+}
+function isAnonymous(caller, headers) {
+    return caller === undefined
+        ? headerValue(headers, "cookie") === undefined &&
+            headerValue(headers, "authorization") === undefined
+        : caller.principal === null || caller.principal === undefined;
+}
 export async function handleTransactionRequest(context, request, options) {
     const decoded = decodeTransactionRequest(context.contracts, request, context.origin);
     if (!decoded.ok) {

package/dist/protocol/read-cache.responder.d.ts

@@ -0,0 +1,26 @@
+import type { AvContractClient } from "../contracts/contract.js";
+import type { AvProtocolResponse } from "./http-response.encoder.js";
+/** A cached read's mark, as the Client Contract states it. */
+type ReadCacheMark = NonNullable<NonNullable<AvContractClient["resources"][string]["cache"]>["first" | "unique" | "many" | "count"]>;
+/**
+ * A `GET`'s answer that must not be kept: `Cache-Control: no-store` (with
+ * `Referrer-Policy: no-referrer` and `X-Content-Type-Options: nosniff`). Every
+ * refusal, a stale client's `A2005` included, and every answer but `200`.
+ */
+export declare function uncachedAnswer(response: AvProtocolResponse): AvProtocolResponse;
+/**
+ * A cached read's answer. A `200` gets, by the mark's `for`:
+ *
+ * - `"everyone"`: `Cache-Control: public, max-age=<n>`;
+ * - `"anonymous"`: `public` to an `anonymous` caller, `private` otherwise, both
+ *   with `Vary: Authorization, Cookie`;
+ * - `"user"`: `Cache-Control: private, max-age=<n>`, `Vary: Authorization,
+ *   Cookie`;
+ *
+ * and `Referrer-Policy: no-referrer`, `X-Content-Type-Options: nosniff` and an
+ * `ETag` over its body; it is `304` with no body when `ifNoneMatch` names that
+ * tag. A public answer echoes no `Aventara-Request-Id`. Any other status is
+ * {@link uncachedAnswer}.
+ */
+export declare function cachedReadAnswer(response: AvProtocolResponse, cache: ReadCacheMark, ifNoneMatch: string | undefined, anonymous: boolean): Promise<AvProtocolResponse>;
+export {};

package/dist/protocol/read-cache.responder.js

@@ -0,0 +1,47 @@
+import { noneMatchHolds } from "./contract-document.responder.js";
+import { headers, NO_SNIFF } from "./protocol-headers.js";
+const CALLER_VARY = "Authorization, Cookie";
+export function uncachedAnswer(response) {
+    return {
+        ...response,
+        headers: {
+            ...response.headers,
+            "Cache-Control": "no-store",
+            "Referrer-Policy": "no-referrer",
+            ...NO_SNIFF,
+        },
+    };
+}
+export async function cachedReadAnswer(response, cache, ifNoneMatch, anonymous) {
+    if (response.status !== 200) {
+        return uncachedAnswer(response);
+    }
+    const shared = cache.for === "everyone" || (cache.for === "anonymous" && anonymous);
+    const validators = {
+        "Cache-Control": `${shared ? "public" : "private"}, max-age=${cache.maxAge}`,
+        ...(cache.for === "everyone" ? {} : { Vary: CALLER_VARY }),
+        "Referrer-Policy": "no-referrer",
+        ...NO_SNIFF,
+        ETag: `"${await bodyDigest(response.body)}"`,
+    };
+    const kept = { ...response.headers };
+    if (shared) {
+        delete kept[headers.requestId];
+    }
+    if (noneMatchHolds(ifNoneMatch, validators.ETag)) {
+        delete kept["Content-Type"];
+        return { status: 304, headers: { ...kept, ...validators }, body: "" };
+    }
+    return { ...response, headers: { ...kept, ...validators } };
+}
+async function bodyDigest(body) {
+    const digest = new Uint8Array(await globalThis.crypto.subtle.digest("SHA-256", new TextEncoder().encode(body)));
+    let binary = "";
+    for (const byte of digest) {
+        binary += String.fromCharCode(byte);
+    }
+    return btoa(binary)
+        .replace(/\+/g, "-")
+        .replace(/\//g, "_")
+        .replace(/=+$/, "");
+}

package/dist/protocol/read-query.codec.d.ts

@@ -0,0 +1,34 @@
+/** A cached read's query: its two parameters, each percent-decoded once. */
+export type ReadQuery = {
+    /** The arguments, in either form. */
+    readonly q: string;
+    /** The Client Contract hash the client was generated against. */
+    readonly v: string;
+};
+/**
+ * The query's `q` and `v`, or `undefined` when it is anything else: absent,
+ * either parameter missing or repeated, another parameter, or a percent-escape
+ * that does not decode.
+ */
+export declare function readQueryOf(query: string | undefined): ReadQuery | undefined;
+/** What reading `q` answers: the arguments object, or the transport code refusing it. */
+type ReadArguments = {
+    readonly ok: true;
+    readonly value: object;
+} | {
+    readonly ok: false;
+    readonly code: "A2000" | "A2010";
+};
+/**
+ * `q` as the arguments object: plain JSON when it starts with `{`, otherwise
+ * base64url(deflate-raw(JSON)). More than `maxBytes` bytes of JSON, or of
+ * compressed input, is `A2010`; anything that is not base64url, deflate-raw,
+ * UTF-8 or a JSON object is `A2000`.
+ */
+export declare function readArgumentsOf(q: string, maxBytes: number): Promise<ReadArguments>;
+/**
+ * A read's `q`: its arguments' canonical JSON, percent-encoded, or that JSON
+ * deflate-raw'd and base64url'd when that is shorter.
+ */
+export declare function readQueryArgumentOf(args: object): Promise<string>;
+export {};

package/dist/protocol/read-query.codec.js

@@ -0,0 +1,125 @@
+import { canonicalJson } from "../contracts/canonical-json.writer.js";
+const BASE64URL = /^[A-Za-z0-9_-]*$/;
+export function readQueryOf(query) {
+    if (query === undefined || query === "") {
+        return undefined;
+    }
+    const found = new Map();
+    for (const pair of query.split("&")) {
+        const equals = pair.indexOf("=");
+        const name = equals === -1 ? pair : pair.slice(0, equals);
+        if ((name !== "q" && name !== "v") || found.has(name) || equals === -1) {
+            return undefined;
+        }
+        const value = percentDecoded(pair.slice(equals + 1));
+        if (value === undefined) {
+            return undefined;
+        }
+        found.set(name, value);
+    }
+    const q = found.get("q");
+    const v = found.get("v");
+    return q === undefined || v === undefined ? undefined : { q, v };
+}
+function percentDecoded(text) {
+    try {
+        return decodeURIComponent(text);
+    }
+    catch {
+        return undefined;
+    }
+}
+export async function readArgumentsOf(q, maxBytes) {
+    if (q.startsWith("{")) {
+        const bytes = new TextEncoder().encode(q);
+        return bytes.byteLength > maxBytes
+            ? { ok: false, code: "A2010" }
+            : parsedObject(q);
+    }
+    if (!BASE64URL.test(q) || q.length % 4 === 1) {
+        return { ok: false, code: "A2000" };
+    }
+    if (Math.floor((q.length * 3) / 4) > maxBytes) {
+        return { ok: false, code: "A2010" };
+    }
+    const compressed = base64urlBytes(q);
+    const inflated = await inflatedWithin(compressed, maxBytes);
+    if (inflated.ok === false) {
+        return inflated;
+    }
+    let text;
+    try {
+        text = new TextDecoder("utf-8", { fatal: true }).decode(inflated.bytes);
+    }
+    catch {
+        return { ok: false, code: "A2000" };
+    }
+    return parsedObject(text);
+}
+function parsedObject(text) {
+    let value;
+    try {
+        value = JSON.parse(text);
+    }
+    catch {
+        return { ok: false, code: "A2000" };
+    }
+    return typeof value === "object" && value !== null && !Array.isArray(value)
+        ? { ok: true, value }
+        : { ok: false, code: "A2000" };
+}
+function base64urlBytes(text) {
+    const binary = atob(text.replace(/-/g, "+").replace(/_/g, "/") +
+        "=".repeat((4 - (text.length % 4)) % 4));
+    const bytes = new Uint8Array(binary.length);
+    for (let index = 0; index < binary.length; index += 1) {
+        bytes[index] = binary.charCodeAt(index);
+    }
+    return bytes;
+}
+async function inflatedWithin(compressed, maxBytes) {
+    const stream = new Blob([compressed])
+        .stream()
+        .pipeThrough(new DecompressionStream("deflate-raw"));
+    const reader = stream.getReader();
+    const chunks = [];
+    let total = 0;
+    try {
+        for (;;) {
+            const { done, value } = await reader.read();
+            if (done) {
+                break;
+            }
+            total += value.byteLength;
+            if (total > maxBytes) {
+                await reader.cancel().catch(() => undefined);
+                return { ok: false, code: "A2010" };
+            }
+            chunks.push(value);
+        }
+    }
+    catch {
+        return { ok: false, code: "A2000" };
+    }
+    const bytes = new Uint8Array(total);
+    let offset = 0;
+    for (const chunk of chunks) {
+        bytes.set(chunk, offset);
+        offset += chunk.byteLength;
+    }
+    return { ok: true, bytes };
+}
+export async function readQueryArgumentOf(args) {
+    const json = canonicalJson(args);
+    const plain = encodeURIComponent(json);
+    const deflated = await new Response(new Blob([json]).stream().pipeThrough(new CompressionStream("deflate-raw"))).arrayBuffer();
+    let binary = "";
+    for (const byte of new Uint8Array(deflated)) {
+        binary += String.fromCharCode(byte);
+    }
+    const compressed = btoa(binary)
+        .replace(/\+/g, "-")
+        .replace(/\//g, "_")
+        .replace(/=+$/, "");
+    return compressed.length < plain.length ? compressed : plain;
+}

package/dist/runtime/computed-read-runtime.js

@@ -2,10 +2,9 @@ import { adapterPrimaryIdentifier } from "../adapters/adapter-identifier.js";
 import { lookupField, lookupResource } from "../contracts/contract-lookup.js";
 import { AvComputedValueError } from "./computed-value.error.js";
 import { frozenCopy } from "./readonly-value.js";
+import { isRecord } from "./record.guard.js";
 import { normalizeScalarFieldValue } from "./scalar-runtime.js";
-function isRecord(value) {
-    return value !== null && typeof value === "object" && !Array.isArray(value);
-}
+import { isThenable } from "./thenable.guard.js";
 function readCompute(value) {
     if (typeof value === "function") {
         return { compute: value, dependsOn: [] };
@@ -342,11 +341,6 @@ function isNestedContainer(value) {
         !(value instanceof Date) &&
         !(value instanceof Uint8Array));
 }
-function isThenable(value) {
-    return (value !== null &&
-        (typeof value === "object" || typeof value === "function") &&
-        typeof value.then === "function");
-}
 function setOwn(target, key, value) {
     if (key in target) {
         Object.defineProperty(target, key, {

package/dist/runtime/create-requirement.js

@@ -2,9 +2,7 @@ import { lookupField, lookupResource } from "../contracts/contract-lookup.js";
 import { advertisedDirectivesAt } from "../contracts/field.js";
 import { LOOPBACK_WRITE_SCOPE, NESTED_WRITE_SCOPE, resolveWriteScope, } from "../operations/write-scope.resolver.js";
 import { isRelationMutationDirective, RELATION_MUTATION_RECORD_SITES, } from "./mutation-planner.js";
-function isRecord(value) {
-    return value !== null && typeof value === "object" && !Array.isArray(value);
-}
+import { isRecord } from "./record.guard.js";
 function written(record, key) {
     return Object.hasOwn(record, key) && record[key] !== undefined;
 }

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

@@ -19,6 +19,11 @@ export type AvOperationDiagnostic = {
     readonly variant: string;
     readonly requestId: string;
     readonly operation?: number;
+    /**
+     * The key of the Operation Set entry (`POST /_all`) the failure met; absent
+     * for an operation that ran alone or as a transaction step.
+     */
+    readonly key?: string;
     /**
      * `true` when `error` is an `AvError` its thrower (a pipeline
      * callback, a compute stage, a filter or an Adapter) raised deliberately with an
@@ -134,7 +139,7 @@ export declare function diagnosticsSinkOf(framework: object): AvDiagnosticsSink
  * Binds the configured sink to one operation request. The sink is not awaited,
  * and nothing it throws or rejects with reaches the response.
  */
-export declare function createDiagnosticsReporter(sink: AvDiagnosticsSink | undefined, request: AvOperationRequest, operation?: number): DiagnosticsReporter;
+export declare function createDiagnosticsReporter(sink: AvDiagnosticsSink | undefined, request: AvOperationRequest, operation?: number, key?: string): DiagnosticsReporter;
 /** The diagnostics channel of one transaction request. */
 export type TransactionDiagnosticsChannel = {
     /** A plan-level report; `operation` attributes it to a recorded failing index. */

package/dist/runtime/diagnostics-reporter.js

@@ -1,14 +1,8 @@
 import { coreBrandOf } from "./core-class.brand.js";
 import { internalFailure, } from "./operation-response.js";
 import { requestIdOf } from "./request-id.js";
+import { isThenable } from "./thenable.guard.js";
 const IGNORE_DIAGNOSTIC = () => undefined;
-function isThenable(value) {
-    if ((typeof value !== "object" || value === null) &&
-        typeof value !== "function") {
-        return false;
-    }
-    return typeof value.then === "function";
-}
 export function createReporter(sink, identity) {
     if (sink === undefined) {
         return IGNORE_DIAGNOSTIC;
@@ -74,7 +68,7 @@ export function recordDiagnosticsSink(framework, sink) {
 export function diagnosticsSinkOf(framework) {
     return CONFIGURED_SINKS.get(framework);
 }
-export function createDiagnosticsReporter(sink, request, operation) {
+export function createDiagnosticsReporter(sink, request, operation, key) {
     let identity;
     try {
         identity = {
@@ -85,6 +79,7 @@ export function createDiagnosticsReporter(sink, request, operation) {
             variant: request.variant,
             requestId: request.requestId,
             ...(operation === undefined ? {} : { operation }),
+            ...(key === undefined ? {} : { key }),
         };
     }
     catch {

package/dist/runtime/error.catalog.d.ts

@@ -8,7 +8,7 @@ import { type AvOperationCode } from "./operation-response.js";
  * The documentation page every catalog entry links into. Each code has its own
  * anchor there: the code in lower case (`#a2004`, `#config_required`).
  */
-export declare const ERROR_CODES_DOCS_URL = "https://aventara-framework.vercel.app/docs/error-codes";
+export declare const ERROR_CODES_DOCS_URL = "https://aventara.razor34.dev/framework/docs/error-codes";
 /**
  * What kind of code an entry is: an outcome code's family (`success` `A1xxx`,
  * `request` `A2xxx`, `internal` `A3xxx`, `auth` `A4xxx`), a `validation` issue
@@ -43,7 +43,7 @@ export declare function errorDocsUrl(code: AvErrorCatalogCode): string;
  *
  * ```ts
  * AvErrorCatalog[error.code].fix;
- * AvErrorCatalog.V1000.docs; // https://aventara-framework.vercel.app/docs/error-codes#v1000
+ * AvErrorCatalog.V1000.docs; // https://aventara.razor34.dev/framework/docs/error-codes#v1000
  * ```
  */
 export declare const AvErrorCatalog: AvErrorCatalog;

package/dist/runtime/error.catalog.js

@@ -5,7 +5,7 @@ import { VALIDATION_CODE_GUIDANCE } from "../operations/validation-code.guidance
 import { VALIDATION_CODE_MESSAGES, VALIDATION_CODES, } from "../operations/validation-code.js";
 import { OPERATION_CODE_GUIDANCE } from "./operation-code.guidance.js";
 import { OPERATION_CODES } from "./operation-response.js";
-export const ERROR_CODES_DOCS_URL = "https://aventara-framework.vercel.app/docs/error-codes";
+export const ERROR_CODES_DOCS_URL = "https://aventara.razor34.dev/framework/docs/error-codes";
 export function errorDocsUrl(code) {
     return `${ERROR_CODES_DOCS_URL}#${code.toLowerCase()}`;
 }

package/dist/runtime/field-stage.runtime.d.ts

@@ -4,8 +4,6 @@ import type { AvOperationFamily } from "../operations/operation-identity.js";
 import type { AvContext } from "./pipeline.js";
 export type Path = readonly (string | number)[];
 type UnknownRecord = Readonly<Record<string, unknown>>;
-/** A plain object: what a write record, or a directive's operand, is. */
-export declare function isPlainRecord(value: unknown): value is UnknownRecord;
 /** The containers a family writes, by argument key. */
 export declare const WRITE_KEYS: Readonly<Partial<Record<AvOperationFamily, readonly string[]>>>;
 /** The fields of `resource` with stages, in the Resource's field order. */

package/dist/runtime/field-stage.runtime.js

@@ -1,11 +1,5 @@
 import { frozenCopy } from "./readonly-value.js";
-export function isPlainRecord(value) {
-    if (value === null || typeof value !== "object" || Array.isArray(value)) {
-        return false;
-    }
-    const prototype = Object.getPrototypeOf(value);
-    return prototype === Object.prototype || prototype === null;
-}
+import { isPlainRecord } from "./record.guard.js";
 export const WRITE_KEYS = {
     create: ["data"],
     update: ["data"],

package/dist/runtime/field-validator.runtime.js

@@ -1,8 +1,9 @@
 import { hasFieldValidators, validatedFieldsOf, } from "../compiler/field-validator.compiler.js";
 import { AvComputedValueError } from "./computed-value.error.js";
 import { entryCheckIssues, fieldCheckIssues } from "./field-check.evaluator.js";
-import { isPlainRecord, valueAt, writeRecordPathsOf, } from "./field-stage.runtime.js";
+import { valueAt, writeRecordPathsOf, } from "./field-stage.runtime.js";
 import { nestedWriteTargetsOf } from "./nested-write.walker.js";
+import { isPlainRecord } from "./record.guard.js";
 import { jsonShapeIssues } from "./scalar-runtime.js";
 function isDirective(value) {
     return (isPlainRecord(value) &&

package/dist/runtime/mutation-planner.js

@@ -2,6 +2,7 @@ import { lookupField, lookupResource } from "../contracts/contract-lookup.js";
 import { AvComputedValueError } from "./computed-value.error.js";
 import { replaceAt, valueAt } from "./field-stage.runtime.js";
 import { frozenCopy } from "./readonly-value.js";
+import { isRecord } from "./record.guard.js";
 import { normalizeScalarFieldValue } from "./scalar-runtime.js";
 function writeScalarField(contracts, resourceName, fieldName) {
     const field = lookupField(lookupResource(contracts.core, resourceName), fieldName) ??
@@ -26,9 +27,6 @@ export const RELATION_MUTATION_RECORD_SITES = {
 export function isRelationMutationDirective(key) {
     return Object.hasOwn(RELATION_MUTATION_RECORD_SITES, key);
 }
-function isRecord(value) {
-    return value !== null && typeof value === "object" && !Array.isArray(value);
-}
 function cloneRecord(value) {
     return { ...value };
 }

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

@@ -1,6 +1,7 @@
 import { lookupField, lookupResource } from "../contracts/contract-lookup.js";
-import { isPlainRecord, valueAt, writeRecordPathsOf, } from "./field-stage.runtime.js";
+import { valueAt, writeRecordPathsOf, } from "./field-stage.runtime.js";
 import { isRelationMutationDirective, RELATION_MUTATION_RECORD_SITES, } from "./mutation-planner.js";
+import { isPlainRecord } from "./record.guard.js";
 const DIRECTIVE_FAMILY = {
     $create: "create",
     $connectOrCreate: "create",

package/dist/runtime/output-validator.js

@@ -1,12 +1,10 @@
 import { lookupField, lookupResource } from "../contracts/contract-lookup.js";
 import { advertisedReducers, } from "../contracts/field.js";
+import { isRecord } from "./record.guard.js";
 import { normalizeScalarFieldValue } from "./scalar-runtime.js";
 function issue(message, path = ["data"]) {
     return { ok: false, issues: [{ path, code: "V1001", message }] };
 }
-function isRecord(value) {
-    return value !== null && typeof value === "object" && !Array.isArray(value);
-}
 function validatesRecordOrNull(value) {
     return value === null || isRecord(value);
 }

package/dist/runtime/owned-execution.registry.d.ts

@@ -1,15 +1,35 @@
+import type { RemoteRequestOrigin } from "../config/config-layer.js";
+import type { PolicyCaller } from "../policy/policy-request.js";
 import type { AvAgentTransactionRequest, AvClientTransactionRequest } from "../transactions/transaction-request.js";
 import type { AvTransactionResponse } from "../transactions/transaction-response.js";
 import type { AvCallerDataError } from "./caller-data.copier.js";
 import type { RemoteOperationRequest } from "./operation-request.js";
 import type { AvOperationResponse } from "./operation-response.js";
-/** The two entries that run a request the protocol decoded itself, uncopied. */
+import type { AvState } from "./request-state.js";
+/**
+ * The entries that run a request the protocol decoded itself, uncopied, and
+ * what an Operation Set reads off the Framework besides.
+ */
 export type OwnedExecution = {
     /**
      * Runs `request` uncopied; with `refused`, its arguments are a host's parsed body
      * whose copy at the call failed, answered as the door answers that failure.
+     * `member` is an Operation Set entry's: the principal derived once for the
+     * set, and the entry's key, which its diagnostics name.
      */
-    readonly execute: (request: RemoteOperationRequest, refused?: AvCallerDataError) => Promise<AvOperationResponse>;
+    readonly execute: (request: RemoteOperationRequest, refused?: AvCallerDataError, member?: {
+        readonly caller?: PolicyCaller;
+        readonly key?: string;
+    }) => Promise<AvOperationResponse>;
+    /**
+     * The principal a remote request with this state runs as, derived once, or
+     * `undefined` when no policy checks it. Throws or rejects as
+     * `policy.principal` does.
+     */
+    readonly caller: (request: {
+        readonly origin: RemoteRequestOrigin;
+        readonly state: AvState;
+    }) => PolicyCaller | undefined | Promise<PolicyCaller>;
     /**
      * Runs `request` uncopied; with `refused`, its plan is a host's parsed plan taken
      * at the call, and these steps' arguments could not be copied there: each is

package/dist/runtime/pipeline.d.ts

@@ -17,7 +17,11 @@ import type { AvState } from "./request-state.js";
  * What a pipeline is told about the HTTP request a client-origin operation arrived on.
  */
 export type AvTransportContext = {
-    readonly method: "POST";
+    /**
+     * `"POST"`, or `"GET"` for a read of a Resource with `cache` (a browser's
+     * prefetch or a CDN's refetch is a GET too).
+     */
+    readonly method: "POST" | "GET";
     readonly headers: Readonly<Record<string, string>>;
 };
 /** What a pipeline ctx states about the request, whatever the stage. */

package/dist/runtime/record.guard.d.ts

@@ -0,0 +1,14 @@
+/** An object that is not a list: what core reads as a record of named values. */
+export declare function isRecord<T extends Readonly<Record<string, unknown>> = Readonly<Record<string, unknown>>>(value: unknown): value is T;
+/**
+ * A **plain** record: an object literal (prototype `Object.prototype` or
+ * `null`), not a `Date`, a core `AvDecimal`, a `Uint8Array` or another class
+ * instance. The one discriminant between an argument OBJECT and a VALUE wherever
+ * a position admits both: a write record, a directive's operand, a filter
+ * position above all, where a plain record is an operator object and anything
+ * else is a value that equality shorthand holds to the field's scalar. The
+ * validator (`operation-validator-core.ts`) reads a filter position through this
+ * same answer, and an adapter's filter translation is expected to, so a position
+ * cannot be operators to one reader and a value to another.
+ */
+export declare function isPlainRecord<T extends Readonly<Record<string, unknown>> = Readonly<Record<string, unknown>>>(value: unknown): value is T;

package/dist/runtime/record.guard.js

@@ -0,0 +1,10 @@
+export function isRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+export function isPlainRecord(value) {
+    if (!isRecord(value)) {
+        return false;
+    }
+    const prototype = Object.getPrototypeOf(value);
+    return prototype === Object.prototype || prototype === null;
+}