@aventara/core 1.0.0-rc.4 → 1.0.0-rc.9

package/dist/policy/policy-session.js

@@ -1,3 +1,4 @@
+import { adapterPrimaryIdentifier } from "../adapters/adapter-identifier.js";
 import { lookupField, lookupResource } from "../contracts/contract-lookup.js";
 import { validateOperationArguments } from "../operations/operation-validator-core.js";
 import { normalizeOperationScalarValues } from "../runtime/scalar-runtime.js";
@@ -84,11 +85,11 @@ function questionKey(resource, where) {
         return undefined;
     }
 }
-function existsOperation(core, resource, where) {
+function existsOperation(core, model, resource, where) {
     const contract = lookupResource(core, resource);
-    const [identifier] = contract?.identifiers ?? [];
+    const identifier = adapterPrimaryIdentifier(model, resource);
     const first = contract?.operations.find?.first !== undefined;
-    return first && identifier !== undefined
+    return first && identifier.length > 0
         ? {
             resource,
             family: "find",
@@ -102,16 +103,16 @@ function existsOperation(core, resource, where) {
             arguments: { where },
         };
 }
-export function openPolicySession(policy, core, principal, origin, execution) {
+export function openPolicySession(policy, core, model, principal, origin, execution) {
     const caches = {
         scopes: new Map(),
         createGrants: new Map(),
         fields: new Map(),
         exists: new WeakMap(),
     };
-    return sessionOn(policy, core, principal, origin, execution, caches);
+    return sessionOn(policy, core, model, principal, origin, execution, caches);
 }
-function sessionOn(policy, core, principal, origin, execution, caches) {
+function sessionOn(policy, core, model, principal, origin, execution, caches) {
     const { engine } = policy;
     const exists = (resource, where) => {
         const key = questionKey(resource, where);
@@ -124,7 +125,7 @@ function sessionOn(policy, core, principal, origin, execution, caches) {
         if (known !== undefined) {
             return known;
         }
-        const operation = existsOperation(core, resource, where);
+        const operation = existsOperation(core, model, resource, where);
         const answer = execution.boundary
             .execute(() => execution.executor.execute(operation))
             .then((result) => typeof result === "number" ? result > 0 : result != null);
@@ -174,11 +175,11 @@ function sessionOn(policy, core, principal, origin, execution, caches) {
             return scope;
         },
         fields(resource, access) {
-            const key = `${resource}\u0000${access}`;
+            const key = `${resource}\u0000${access.access}\u0000${access.access === "write" ? access.action : ""}`;
             let fields = caches.fields.get(key);
             if (fields === undefined) {
                 fields = Promise.resolve()
-                    .then(() => engine.fieldsOf({ principal, origin, resource, access }))
+                    .then(() => engine.fieldsOf({ principal, origin, resource, ...access }))
                     .then((answer) => fieldsAnswer(core, resource, answer));
                 caches.fields.set(key, fields);
             }
@@ -211,10 +212,10 @@ function sessionOn(policy, core, principal, origin, execution, caches) {
                 policy.afterChecks[resource]?.includes(action) === true);
         },
         on(next) {
-            return sessionOn(policy, core, principal, origin, next, caches);
+            return sessionOn(policy, core, model, principal, origin, next, caches);
         },
         renewed() {
-            return sessionOn(policy, core, principal, origin, execution, {
+            return sessionOn(policy, core, model, principal, origin, execution, {
                 ...caches,
                 exists: new WeakMap(),
             });

package/dist/policy/policy-startup.validator.js

@@ -3,30 +3,28 @@ const TO_MANY_OPERATORS = new Set(["some", "every", "none"]);
 function invalid(path, message) {
     return { code: "CONFIG_INVALID_VALUE", path, message };
 }
-function governedDiagnostics(core, governed) {
+function governedDiagnostics(core, { at, governed }) {
     const diagnostics = [];
     for (const [resourceName, names] of Object.entries(governed)) {
-        const path = `policy.engine.governed.${resourceName}`;
+        const path = `${at}.governed.${resourceName}`;
         const resource = lookupResource(core, resourceName);
         if (resource === undefined) {
-            diagnostics.push(invalid(path, `${path}: "${resourceName}" is no Resource of the Core Contract`));
+            diagnostics.push(invalid(path, `"${resourceName}" is no Resource of the Core Contract`));
             continue;
         }
         for (const name of names) {
             if (lookupField(resource, name) === undefined) {
-                diagnostics.push(invalid(path, `${path}: "${name}" is no field or relation of Resource "${resourceName}" in the Core Contract`));
+                diagnostics.push(invalid(path, `"${name}" is no field or relation of Resource "${resourceName}" in the Core Contract`));
             }
         }
     }
     return diagnostics;
 }
-function afterCheckDiagnostics(core, afterChecks) {
+function afterCheckDiagnostics(core, { at, afterChecks }) {
     return Object.keys(afterChecks).flatMap((resourceName) => {
-        const path = `policy.engine.afterChecks.${resourceName}`;
+        const path = `${at}.afterChecks.${resourceName}`;
         return lookupResource(core, resourceName) === undefined
-            ? [
-                invalid(path, `${path}: "${resourceName}" is no Resource of the Core Contract`),
-            ]
+            ? [invalid(path, `"${resourceName}" is no Resource of the Core Contract`)]
             : [];
     });
 }
@@ -84,10 +82,10 @@ function pathFault(core, path) {
     }
     return `the path ends at Resource "${current}", not at a field`;
 }
-function pathDiagnostics(core, paths) {
+function pathDiagnostics(core, policy) {
     const diagnostics = [];
-    for (const [rule, list] of Object.entries(paths)) {
-        const at = `policy.engine.paths.${rule}`;
+    for (const [rule, list] of Object.entries(policy.paths)) {
+        const at = `${policy.at}.paths.${rule}`;
         for (const path of list) {
             const fault = pathFault(core, path);
             if (fault !== undefined) {
@@ -99,8 +97,8 @@ function pathDiagnostics(core, paths) {
 }
 export function policyStartupDiagnostics(core, policy) {
     return [
-        ...governedDiagnostics(core, policy.governed),
-        ...pathDiagnostics(core, policy.paths),
-        ...afterCheckDiagnostics(core, policy.afterChecks),
+        ...governedDiagnostics(core, policy),
+        ...pathDiagnostics(core, policy),
+        ...afterCheckDiagnostics(core, policy),
     ];
 }

package/dist/policy/policy-write.runtime.d.ts

@@ -9,6 +9,13 @@ import type { PolicySession } from "./policy-session.js";
 export type PolicyWrite = PolicyRead & {
     /** A unique write that matched nothing: `A4002` for a row the caller can read, `A2003` otherwise. */
     readonly miss?: () => Promise<AvOperationFailureResponse>;
+    /**
+     * A unique update holding nested writes whose adapter call failed: the miss's
+     * answer when its row is outside the scopes (an adapter may fail the nested
+     * write there instead of answering the miss), `undefined` when the failure
+     * stands.
+     */
+    readonly failedMiss?: () => Promise<AvOperationFailureResponse | undefined>;
 };
 /**
  * Whether a write the policy checks needs an interactive transaction to roll

package/dist/policy/policy-write.runtime.js

@@ -1,3 +1,4 @@
+import { adapterPrimaryIdentifier } from "../adapters/adapter-identifier.js";
 import { lookupField, lookupResource } from "../contracts/contract-lookup.js";
 import { uniqueMissFailure } from "../runtime/outcome-mapper.js";
 import { frozenCopy } from "../runtime/readonly-value.js";
@@ -5,7 +6,7 @@ import { policyRefusal } from "./policy-admission.js";
 import { afterCheckFields, afterUpdate, checkChanged, } from "./policy-after-update.runtime.js";
 import { allOf, everyOf, noneOf, someOf, whereOf, } from "./policy-condition.js";
 import { planNestedWrites, writesNested, } from "./policy-nested-write.runtime.js";
-import { enforceReadPolicy, identifiedRows, identifierOf, returnedRowChecks, } from "./policy-read.runtime.js";
+import { enforceReadPolicy, identifiedRows, returnedRowChecks, } from "./policy-read.runtime.js";
 const UNVERIFIABLE = "cannot be verified on this database: it has no interactive transaction to roll the write back in";
 function isRecord(value) {
     return value !== null && typeof value === "object" && !Array.isArray(value);
@@ -52,7 +53,7 @@ async function checkCreated(session, core, model, resource, grants, created) {
     if (created.length === 0) {
         return undefined;
     }
-    const these = identifiedRows(core, identifierOf(model, resource), resource, created);
+    const these = identifiedRows(core, adapterPrimaryIdentifier(model, resource), resource, created);
     const missed = allOf(these, someOf([...grants.values()].map(noneOf)));
     if (missed !== false &&
         (await session.renewed().exists(resource, whereOf(missed)))) {
@@ -72,7 +73,7 @@ function uncheckableCreate(model, request, grants, inTransaction) {
         return refused(`${what}, which ${UNVERIFIABLE}.`);
     }
     if (request.variant === "count" ||
-        identifierOf(model, request.resource).length === 0) {
+        adapterPrimaryIdentifier(model, request.resource).length === 0) {
         return refused(`${what}, and this create does not return the rows it creates to check by.`);
     }
     return undefined;
@@ -244,7 +245,8 @@ async function enforceScopedWrite(session, core, model, request, plan, adapterAr
     if (changes !== undefined && !inTransaction) {
         return refused(`The policy checks this update on Resource "${resource}" after it runs (${changes.after ? "its grant's after condition" : "whether it moves a row out of what the caller may read"}), which ${UNVERIFIABLE}.`);
     }
-    if (changes !== undefined && identifierOf(model, resource).length === 0) {
+    if (changes !== undefined &&
+        adapterPrimaryIdentifier(model, resource).length === 0) {
         return refused(`The policy checks this update on Resource "${resource}" after it runs, and the Resource has no identifier to find the changed rows by.`);
     }
     const nested = action === "update"
@@ -259,6 +261,19 @@ async function enforceScopedWrite(session, core, model, request, plan, adapterAr
     const miss = request.variant === "unique"
         ? missOf(session, request, args.where)
         : undefined;
+    const failedMiss = miss !== undefined && nested !== undefined
+        ? async () => {
+            const reach = allOf(isRecord(args.where) ? args.where : true, scope);
+            return reach !== false &&
+                (await session.renewed().exists(resource, whereOf(reach)))
+                ? undefined
+                : miss();
+        }
+        : undefined;
+    const misses = {
+        ...(miss === undefined ? {} : { miss }),
+        ...(failedMiss === undefined ? {} : { failedMiss }),
+    };
     const carried = changes?.after === true
         ? afterCheckFields(core, model, resource)
         : undefined;
@@ -272,7 +287,7 @@ async function enforceScopedWrite(session, core, model, request, plan, adapterAr
         return blocked;
     }
     if (read.kind !== "run") {
-        return miss === undefined ? read : { ...read, miss };
+        return { ...read, ...misses };
     }
     let run = read;
     if (action === "delete" && run.checks.root.length > 0) {
@@ -294,7 +309,7 @@ async function enforceScopedWrite(session, core, model, request, plan, adapterAr
                     ...runArgs,
                     select: changes.after
                         ? [...afterCheckFields(core, model, resource)]
-                        : [...identifierOf(model, resource)],
+                        : [...adapterPrimaryIdentifier(model, resource)],
                 },
             };
             run = withChangedRows(asMany, (data) => checkChanged(session, core, model, resource, changes, rowsOf(data), changes.after));
@@ -305,7 +320,7 @@ async function enforceScopedWrite(session, core, model, request, plan, adapterAr
         }
         if (counted) {
             const runArgs = isRecord(run.arguments) ? run.arguments : {};
-            const identifier = identifierOf(model, resource);
+            const identifier = adapterPrimaryIdentifier(model, resource);
             changed = await session.rows(resource, isRecord(runArgs.where) ? runArgs.where : {}, identifier);
             if (changed.length === 0) {
                 return { kind: "empty", data: 0 };
@@ -329,7 +344,7 @@ async function enforceScopedWrite(session, core, model, request, plan, adapterAr
         run = withNestedWrites(run, "data", nested);
     }
     run = withoutCarried(run, args, carried);
-    return miss === undefined ? run : { ...run, miss };
+    return { ...run, ...misses };
 }
 async function enforceUpsert(session, core, model, request, plan, adapterArguments, args, inTransaction) {
     const resource = request.resource;

package/dist/prebuilt/core-version.generated.d.ts

@@ -1,2 +1,2 @@
 /** The version of this `@aventara/core`. */
-export declare const CORE_VERSION = "1.0.0-rc.4";
+export declare const CORE_VERSION = "1.0.0-rc.9";

package/dist/prebuilt/core-version.generated.js

@@ -1 +1 @@
-export const CORE_VERSION = "1.0.0-rc.4";
+export const CORE_VERSION = "1.0.0-rc.9";

package/dist/prebuilt/prebuilt-changes.d.ts

@@ -0,0 +1,28 @@
+import type { PrebuiltPartFingerprints } from "./prebuilt-inputs.fingerprint.js";
+/** `a`, `a and b`, `a, b and c`. */
+export declare function listedNames(names: readonly string[]): string;
+/** What a prebuilt file was written in, by and for. */
+export type PrebuiltHeader = {
+    readonly format: number;
+    readonly core: string;
+    readonly protocol: number;
+};
+/**
+ * Each way a stored file's header differs from `current`, in the order the
+ * runtime checks them: the file format, the core version, the protocol.
+ */
+export declare function prebuiltHeaderChanges(stored: unknown, current: PrebuiltHeader): readonly string[];
+/**
+ * Each way a stored file's part fingerprints differ from `current`: the
+ * Resources whose inputs changed, the new ones, the gone ones, and, when
+ * `sameHeader`, the inputs that belong to no single Resource.
+ */
+export declare function prebuiltInputChanges(stored: unknown, current: PrebuiltPartFingerprints, sameHeader?: boolean): readonly string[];
+/**
+ * What differs between a stored prebuilt file and `current`, one clause per
+ * difference: its header's, then its inputs' (`… since it was written`).
+ * Empty when the two record the same header and inputs.
+ */
+export declare function prebuiltFileChanges(stored: unknown, current: PrebuiltHeader & {
+    readonly fingerprints: PrebuiltPartFingerprints;
+}): readonly string[];

package/dist/prebuilt/prebuilt-changes.js

@@ -0,0 +1,65 @@
+function isRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+export function listedNames(names) {
+    return names.length < 2
+        ? names.join("")
+        : `${names.slice(0, -1).join(", ")} and ${names.at(-1)}`;
+}
+export function prebuiltHeaderChanges(stored, current) {
+    const header = isRecord(stored) ? stored : {};
+    const changes = [];
+    if (header.format !== current.format) {
+        changes.push(`it is written in file format ${String(header.format)}, and this @aventara/core reads format ${current.format}`);
+    }
+    if (header.core !== current.core) {
+        changes.push(`it was built by @aventara/core ${String(header.core)}, and this is ${current.core}`);
+    }
+    if (header.protocol !== current.protocol) {
+        changes.push(`it was built for protocol version ${String(header.protocol)}, and this @aventara/core speaks version ${current.protocol}`);
+    }
+    return changes;
+}
+export function prebuiltInputChanges(stored, current, sameHeader = true) {
+    const storedResources = isRecord(stored) ? stored.resources : undefined;
+    const before = isRecord(storedResources) ? storedResources : {};
+    const changed = [];
+    const added = [];
+    const removed = [];
+    for (const [name, fingerprint] of Object.entries(current.resources)) {
+        if (!Object.hasOwn(before, name)) {
+            added.push(name);
+        }
+        else if (before[name] !== fingerprint) {
+            changed.push(name);
+        }
+    }
+    for (const name of Object.keys(before)) {
+        if (!Object.hasOwn(current.resources, name)) {
+            removed.push(name);
+        }
+    }
+    const resources = (names) => `${names.length === 1 ? "Resource" : "Resources"} ${listedNames(names)}`;
+    const be = (names) => (names.length === 1 ? "is" : "are");
+    const changes = [];
+    if (changed.length > 0) {
+        changes.push(`${resources(changed)} changed`);
+    }
+    if (added.length > 0) {
+        changes.push(`${resources(added)} ${be(added)} new`);
+    }
+    if (removed.length > 0) {
+        changes.push(`${resources(removed)} ${be(removed)} gone`);
+    }
+    if (sameHeader && (!isRecord(stored) || stored.shared !== current.shared)) {
+        changes.push("the configuration or model outside the Resources changed");
+    }
+    return changes;
+}
+export function prebuiltFileChanges(stored, current) {
+    const header = prebuiltHeaderChanges(stored, current);
+    const inputs = prebuiltInputChanges(isRecord(stored) ? stored.fingerprints : undefined, current.fingerprints, header.length === 0);
+    return inputs.length === 0
+        ? header
+        : [...header, `${listedNames(inputs)} since it was written`];
+}

package/dist/prebuilt/prebuilt-contracts.loader.js

@@ -3,53 +3,18 @@ import { recordCanonicalContractText } from "../contracts/contract-canonicalizer
 import { AVENTARA_PROTOCOL_VERSION } from "../contracts/contract-protocol.js";
 import { emitFrameworkWarning } from "../runtime/framework-warning.emitter.js";
 import { CORE_VERSION } from "./core-version.generated.js";
+import { listedNames, prebuiltHeaderChanges, prebuiltInputChanges, } from "./prebuilt-changes.js";
 import { PREBUILT_FORMAT } from "./prebuilt-contracts.js";
 import { prebuiltInputsFingerprint, prebuiltPartFingerprints, } from "./prebuilt-inputs.fingerprint.js";
 export const PREBUILT_STALE_WARNING = "AVENTARA_PREBUILT_STALE";
 function isRecord(value) {
     return value !== null && typeof value === "object" && !Array.isArray(value);
 }
-function listed(names) {
-    return names.length < 2
-        ? names.join("")
-        : `${names.slice(0, -1).join(", ")} and ${names.at(-1)}`;
-}
 async function changedInputs(stored, model, config) {
-    const live = await prebuiltPartFingerprints(model, config);
-    const storedResources = isRecord(stored) ? stored.resources : undefined;
-    const before = isRecord(storedResources) ? storedResources : {};
-    const changed = [];
-    const added = [];
-    const removed = [];
-    for (const [name, fingerprint] of Object.entries(live.resources)) {
-        if (!Object.hasOwn(before, name)) {
-            added.push(name);
-        }
-        else if (before[name] !== fingerprint) {
-            changed.push(name);
-        }
-    }
-    for (const name of Object.keys(before)) {
-        if (!Object.hasOwn(live.resources, name)) {
-            removed.push(name);
-        }
-    }
-    const parts = [];
-    if (changed.length > 0) {
-        parts.push(`${changed.length === 1 ? "Resource" : "Resources"} ${listed(changed)} changed`);
-    }
-    if (added.length > 0) {
-        parts.push(`${added.length === 1 ? "Resource" : "Resources"} ${listed(added)} ${added.length === 1 ? "is" : "are"} new`);
-    }
-    if (removed.length > 0) {
-        parts.push(`${removed.length === 1 ? "Resource" : "Resources"} ${listed(removed)} ${removed.length === 1 ? "is" : "are"} gone`);
-    }
-    if (!isRecord(stored) || stored.shared !== live.shared) {
-        parts.push("the configuration or model outside the Resources changed");
-    }
-    return parts.length === 0
+    const changes = prebuiltInputChanges(stored, await prebuiltPartFingerprints(model, config));
+    return changes.length === 0
         ? "its fingerprint does not match the configuration and model"
-        : `${listed(parts)} since it was built`;
+        : `${listedNames(changes)} since it was built`;
 }
 function textAt(record, key) {
     const value = Object.hasOwn(record, key) ? record[key] : undefined;
@@ -86,23 +51,13 @@ export async function loadPrebuiltContracts(prebuilt, model, config, resolved) {
     if (!isRecord(prebuilt)) {
         return { ok: false, reason: "it is not a prebuilt Contracts file" };
     }
-    if (prebuilt.format !== PREBUILT_FORMAT) {
-        return {
-            ok: false,
-            reason: `it is written in file format ${String(prebuilt.format)}, and this @aventara/core reads format ${PREBUILT_FORMAT}`,
-        };
-    }
-    if (prebuilt.core !== CORE_VERSION) {
-        return {
-            ok: false,
-            reason: `it was built by @aventara/core ${String(prebuilt.core)}, and this is ${CORE_VERSION}`,
-        };
-    }
-    if (prebuilt.protocol !== AVENTARA_PROTOCOL_VERSION) {
-        return {
-            ok: false,
-            reason: `it was built for protocol version ${String(prebuilt.protocol)}, and this @aventara/core speaks version ${AVENTARA_PROTOCOL_VERSION}`,
-        };
+    const [header] = prebuiltHeaderChanges(prebuilt, {
+        format: PREBUILT_FORMAT,
+        core: CORE_VERSION,
+        protocol: AVENTARA_PROTOCOL_VERSION,
+    });
+    if (header !== undefined) {
+        return { ok: false, reason: header };
     }
     if ((await prebuiltInputsFingerprint(model, config)) !== prebuilt.fingerprint) {
         return {

package/dist/prebuilt/prebuilt-inputs.fingerprint.js

@@ -126,12 +126,27 @@ function policyInput(policy) {
         : undefined;
     return { ...policy, engine: { governed: governed ?? null } };
 }
+function accessInput(access) {
+    if (!isRecord(access)) {
+        return access;
+    }
+    const engine = access.policy;
+    const governed = engine !== null && typeof engine === "object"
+        ? engine.governed
+        : undefined;
+    return { policy: { governed: governed ?? null } };
+}
 function authoredInputs(config) {
     const authored = config;
     const root = {};
     for (const key of Object.keys(authored)) {
         if (!NOT_INPUTS.has(key)) {
-            root[key] = key === "policy" ? policyInput(authored[key]) : authored[key];
+            root[key] =
+                key === "policy"
+                    ? policyInput(authored[key])
+                    : key === "access"
+                        ? accessInput(authored[key])
+                        : authored[key];
         }
     }
     return root;

package/dist/protocol/absent-route.responder.d.ts

@@ -2,7 +2,7 @@ import type { AvContracts } from "../compiler/contract.compiler.js";
 import type { RemoteRequestOrigin } from "../config/config-layer.js";
 import { type AvOperationIdentity } from "../operations/operation-identity.js";
 import { type AvDiagnosticsSink } from "../runtime/diagnostics-reporter.js";
-import type { ClientProtocolIdentity } from "../runtime/operation-request.js";
+import type { AvRequestProtocol } from "../runtime/operation-request.js";
 import { type AvOperationFailureResponse } from "../runtime/operation-response.js";
 import type { AvProtocolRequest } from "./http-request.decoder.js";
 import { type ReadRequest } from "./http-request.reader.js";
@@ -36,7 +36,7 @@ export type OperationRouteResolution = {
  * is a standard operation the Resource advertises, read through
  * `isOperationVariantAvailable` alone.
  */
-export declare function resolveOperationRoute(contracts: AvContracts, protocol: ClientProtocolIdentity, route: OperationRouteSegments, origin?: RemoteRequestOrigin): OperationRouteResolution;
+export declare function resolveOperationRoute(contracts: AvContracts, protocol: AvRequestProtocol, route: OperationRouteSegments, origin?: RemoteRequestOrigin): OperationRouteResolution;
 /**
  * The `/_transactions` route under one client protocol identity: version → hash → the
  * ClientContract's transaction capability. The route exists only when that capability
@@ -44,14 +44,14 @@ export declare function resolveOperationRoute(contracts: AvContracts, protocol:
  * it — and is otherwise absent with core's own refusal of a plan. `undefined` when the
  * route is there.
  */
-export declare function transactionsRouteFailure(contracts: AvContracts, protocol: ClientProtocolIdentity, origin?: RemoteRequestOrigin): AvOperationFailureResponse | undefined;
+export declare function transactionsRouteFailure(contracts: AvContracts, protocol: AvRequestProtocol, origin?: RemoteRequestOrigin): AvOperationFailureResponse | undefined;
 /**
  * What a route's checks before its body resolve to: the route a request
  * reaches, or the framework response that answers it instead.
  */
 type RouteCheck<Route> = ({
     readonly ok: true;
-    readonly protocol: ClientProtocolIdentity;
+    readonly protocol: AvRequestProtocol;
 } & Route) | {
     readonly ok: false;
     readonly response: AvProtocolResponse;

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

@@ -1,7 +1,7 @@
 import type { AvContracts } from "../compiler/contract.compiler.js";
 import type { RemoteRequestOrigin } from "../config/config-layer.js";
 import type { RemoteOperationRequest } from "../runtime/operation-request.js";
-import type { AgentTransactionRequest, ClientTransactionRequest } from "../transactions/transaction-request.js";
+import type { AvAgentTransactionRequest, AvClientTransactionRequest } from "../transactions/transaction-request.js";
 import type { AvProtocolResponse } from "./http-response.encoder.js";
 /** One HTTP request as a host hands it to the protocol. */
 export type AvProtocolRequest = {
@@ -56,7 +56,7 @@ export type DecodedOperationRequest = Extract<DecodedOperation, {
     ok: true;
 }>;
 /** What `protocol.decodeTransaction` answers. */
-export type DecodedTransaction = Decoded<ClientTransactionRequest | AgentTransactionRequest>;
+export type DecodedTransaction = Decoded<AvClientTransactionRequest | AvAgentTransactionRequest>;
 /**
  * `protocol.decodeOperation(request)` — one operation route's HTTP request as
  * the client-origin request `framework.execute` takes, or its answer.

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

@@ -1,4 +1,4 @@
-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";
@@ -25,7 +25,7 @@ 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 = {

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/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);

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

@@ -1,3 +1,4 @@
+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";
@@ -37,12 +38,6 @@ function appendUniqueProjection(values, value) {
         values.push(value);
     }
 }
-function adapterIdentifier(model, resource) {
-    const resources = model.resources;
-    return ((Object.hasOwn(resources, resource)
-        ? resources[resource]?.identifiers?.[0]
-        : undefined) ?? []);
-}
 function supportsProjection(request) {
     if (request.family === "upsert") {
         return true;
@@ -59,7 +54,7 @@ function addScalarProjection(core, model, active, compute, resourceName, fieldNa
     if (stage !== undefined) {
         appendUnique(computed, fieldName);
         if (stage.dependsOn.length === 0) {
-            for (const member of adapterIdentifier(model, resourceName)) {
+            for (const member of adapterPrimaryIdentifier(model, resourceName)) {
                 appendUniqueProjection(adapterSelect, member);
             }
         }

package/dist/runtime/context-executor.runtime.d.ts

@@ -7,7 +7,7 @@ import type { AvOperationFamily } from "../operations/operation-identity.js";
 import { type AvDiagnosticsSink } from "./diagnostics-reporter.js";
 import type { AvComputeContext } from "./field-compute.js";
 import type { MisuseReporter } from "./misuse-reporter.js";
-import type { ApplicationOperationRequest } from "./operation-request.js";
+import type { AvApplicationOperationRequest } from "./operation-request.js";
 import type { AvOperationResponse } from "./operation-response.js";
 import type { AvContext, AvTransactionContext, AvTransportContext } from "./pipeline.js";
 import type { AvState } from "./request-state.js";
@@ -35,7 +35,7 @@ export type ContextFacts = {
     readonly $args: unknown;
 };
 /** Runs one raw application-origin call in `transaction`, or standalone. Total. */
-export type RawOperationRunner<M extends AvAdapterModel> = (request: ApplicationOperationRequest, transaction: AvAdapterTransactionExecutor<M> | undefined) => Promise<AvOperationResponse>;
+export type RawOperationRunner<M extends AvAdapterModel> = (request: AvApplicationOperationRequest, transaction: AvAdapterTransactionExecutor<M> | undefined) => Promise<AvOperationResponse>;
 export type ContextExecutorDependencies<M extends AvAdapterModel> = {
     /** The model, as construction read it once: the ctx's Resources. */
     readonly model: M;