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

package/dist/runtime/core-class.brand.d.ts

@@ -0,0 +1,10 @@
+/** The registered symbol every copy of this major brands class `name` with. */
+export declare function coreBrandOf(name: string): symbol;
+/** Whether `value` carries `brand`, wherever it was made: one `in`. */
+export declare function hasCoreBrand(value: unknown, brand: symbol): boolean;
+/**
+ * Brands `type`'s prototype as `name` and makes `instanceof type` read the brand.
+ * A developer's own subclass of `type` inherits the static `Symbol.hasInstance`, so
+ * on any constructor but `type` itself it answers as `instanceof` always does.
+ */
+export declare function brandCoreClass(type: abstract new (...args: never[]) => object, name: string): symbol;

package/dist/runtime/core-class.brand.js

@@ -0,0 +1,21 @@
+import { CORE_VERSION } from "../prebuilt/core-version.generated.js";
+const CORE_MAJOR = CORE_VERSION.slice(0, CORE_VERSION.indexOf("."));
+export function coreBrandOf(name) {
+    return Symbol.for(`aventara.core.${name}@${CORE_MAJOR}`);
+}
+export function hasCoreBrand(value, brand) {
+    return typeof value === "object" && value !== null && brand in value;
+}
+const ordinaryHasInstance = Function.prototype[Symbol.hasInstance];
+export function brandCoreClass(type, name) {
+    const brand = coreBrandOf(name);
+    Object.defineProperty(type.prototype, brand, { value: true });
+    Object.defineProperty(type, Symbol.hasInstance, {
+        value: function hasInstance(value) {
+            return this === type
+                ? hasCoreBrand(value, brand)
+                : ordinaryHasInstance.call(this, value);
+        },
+    });
+    return brand;
+}

package/dist/runtime/create-requirement.js

@@ -13,7 +13,7 @@ function edgesOf(table, resource) {
     return Array.isArray(listed) ? listed : [];
 }
 function referencesOf(edge) {
-    return Array.isArray(edge.references) ? edge.references : [];
+    return Array.isArray(edge.referenceFields) ? edge.referenceFields : [];
 }
 function creatableScalar(contract, resource, field) {
     const found = lookupField(lookupResource(contract, resource), field);

package/dist/runtime/decimal.d.ts

@@ -12,3 +12,17 @@ export declare class AvDecimal {
      */
     toJSON(): string;
 }
+/**
+ * Whether `value` is an `AvDecimal`, made by this copy of core or by another of
+ * its major: one `in`, for the hot paths that ask about every value.
+ */
+export declare function isAvDecimal(value: unknown): value is AvDecimal;
+/**
+ * The digits of `value`, read without running anything the caller could have put
+ * on it when this copy made it. Another copy's decimal is read through its own
+ * `toString`, which only that copy can answer; what it returns is checked as a
+ * decimal string, so the caller's copy keeps the grammar.
+ *
+ * @throws TypeError when another copy's decimal does not answer a decimal string.
+ */
+export declare function decimalDigitsOf(value: AvDecimal): string;

package/dist/runtime/decimal.js

@@ -1,6 +1,11 @@
 import { WIRE_SCALAR_PATTERNS } from "../contracts/wire-scalar-format.js";
+import { brandCoreClass, hasCoreBrand } from "./core-class.brand.js";
+let ownDigitsOf;
 export class AvDecimal {
     #value;
+    static {
+        ownDigitsOf = (value) => (#value in value ? value.#value : undefined);
+    }
     constructor(value) {
         if (typeof value !== "string") {
             throw new TypeError("Decimal value must be a string.");
@@ -17,3 +22,19 @@ export class AvDecimal {
         return this.#value;
     }
 }
+const DECIMAL_BRAND = brandCoreClass(AvDecimal, "AvDecimal");
+export function isAvDecimal(value) {
+    return hasCoreBrand(value, DECIMAL_BRAND);
+}
+export function decimalDigitsOf(value) {
+    const own = ownDigitsOf(value);
+    if (own !== undefined) {
+        return own;
+    }
+    const digits = value.toString();
+    if (typeof digits !== "string" ||
+        !WIRE_SCALAR_PATTERNS.decimal.test(digits)) {
+        throw new TypeError("Decimal value must be a valid decimal string.");
+    }
+    return digits;
+}

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

@@ -1,7 +1,7 @@
 import type { AvRequestOrigin } from "../config/config-layer.js";
 import type { AvOperationFamily } from "../operations/operation-identity.js";
-import type { FrameworkTransactionRequest } from "../transactions/transaction-request.js";
-import type { FrameworkOperationRequest } from "./operation-request.js";
+import type { AvTransactionRequest } from "../transactions/transaction-request.js";
+import type { AvOperationRequest } from "./operation-request.js";
 import { type AvOperationErrorCode, type AvOperationFailureResponse } from "./operation-response.js";
 /**
  * One unplanned failure of an operation: the raw error, the code the caller
@@ -100,14 +100,14 @@ 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: FrameworkOperationRequest, operation?: number): DiagnosticsReporter;
+export declare function createDiagnosticsReporter(sink: AvDiagnosticsSink | undefined, request: AvOperationRequest, operation?: number): DiagnosticsReporter;
 /** The diagnostics channel of one transaction request. */
 export type TransactionDiagnosticsChannel = {
     /** A plan-level report; `operation` attributes it to a recorded failing index. */
     readonly transaction: (operation?: number) => DiagnosticsReporter;
     /** A report carrying one plan operation's own identity and index. */
-    readonly operation: (request: FrameworkOperationRequest, operation: number) => DiagnosticsReporter;
+    readonly operation: (request: AvOperationRequest, operation: number) => DiagnosticsReporter;
 };
 /** Binds the configured sink to one transaction request and its plan operations. */
-export declare function createTransactionDiagnosticsChannel(sink: AvDiagnosticsSink | undefined, request: FrameworkTransactionRequest): TransactionDiagnosticsChannel;
+export declare function createTransactionDiagnosticsChannel(sink: AvDiagnosticsSink | undefined, request: AvTransactionRequest): TransactionDiagnosticsChannel;
 export {};

package/dist/runtime/diagnostics-reporter.js

@@ -1,3 +1,4 @@
+import { coreBrandOf } from "./core-class.brand.js";
 import { internalFailure, } from "./operation-response.js";
 import { requestIdOf } from "./request-id.js";
 const IGNORE_DIAGNOSTIC = () => undefined;
@@ -31,7 +32,18 @@ export function createReporter(sink, identity) {
         }
     };
 }
-const CONFIGURED_SINKS = new WeakMap();
+const CONFIGURED_SINKS = sharedSinkRegistry();
+function sharedSinkRegistry() {
+    const key = coreBrandOf("diagnostics");
+    const holder = globalThis;
+    const existing = holder[key];
+    if (existing instanceof WeakMap) {
+        return existing;
+    }
+    const registry = new WeakMap();
+    Object.defineProperty(holder, key, { value: registry });
+    return registry;
+}
 export function mcpFailureReporterOf(framework) {
     const sink = CONFIGURED_SINKS.get(framework);
     return (error) => {

package/dist/runtime/framework-error.js

@@ -1,3 +1,4 @@
+import { brandCoreClass } from "./core-class.brand.js";
 export class AvError extends Error {
     name = "AvError";
     code;
@@ -30,3 +31,11 @@ export class AvProtocolError extends AvError {
 export class AvContractMismatchError extends AvError {
     name = "AvContractMismatchError";
 }
+brandCoreClass(AvError, "AvError");
+brandCoreClass(AvValidationError, "AvValidationError");
+brandCoreClass(AvNotFoundError, "AvNotFoundError");
+brandCoreClass(AvConflictError, "AvConflictError");
+brandCoreClass(AvAuthError, "AvAuthError");
+brandCoreClass(AvInternalError, "AvInternalError");
+brandCoreClass(AvProtocolError, "AvProtocolError");
+brandCoreClass(AvContractMismatchError, "AvContractMismatchError");

package/dist/runtime/operation-request.d.ts

@@ -6,7 +6,7 @@ import type { AvState } from "./request-state.js";
  * The protocol version and Contract hash a remote caller says it was built for:
  * the Client Contract's for a client, the Agent Contract's for an agent.
  */
-export type ClientProtocolIdentity = {
+export type AvRequestProtocol = {
     readonly version: number;
     readonly hash: string;
 };
@@ -21,7 +21,7 @@ type RuntimeOperationBase = AvOperationIdentity & {
     readonly state?: AvState;
 };
 /** An in-process request, run under the Application Contract. */
-export type ApplicationOperationRequest = RuntimeOperationBase & {
+export type AvApplicationOperationRequest = RuntimeOperationBase & {
     readonly origin: "application";
     readonly protocol?: never;
     readonly transport?: never;
@@ -30,24 +30,24 @@ export type ApplicationOperationRequest = RuntimeOperationBase & {
  * A remote request, run under the Client Contract; `protocol` is the identity
  * the client sent.
  */
-export type ClientOperationRequest = RuntimeOperationBase & {
+export type AvClientOperationRequest = RuntimeOperationBase & {
     readonly origin: "client";
-    readonly protocol: ClientProtocolIdentity;
+    readonly protocol: AvRequestProtocol;
     readonly transport?: AvTransportContext;
 };
 /**
  * An AI agent's request, run under the Agent Contract; `protocol` is the
  * identity of the Agent Contract the caller (an MCP server) was built from.
  */
-export type AgentOperationRequest = RuntimeOperationBase & {
+export type AvAgentOperationRequest = RuntimeOperationBase & {
     readonly origin: "agent";
-    readonly protocol: ClientProtocolIdentity;
+    readonly protocol: AvRequestProtocol;
     readonly transport?: AvTransportContext;
 };
 /** A request from outside the server: a client's or an agent's. */
-export type RemoteOperationRequest = ClientOperationRequest | AgentOperationRequest;
+export type RemoteOperationRequest = AvClientOperationRequest | AvAgentOperationRequest;
 /** One operation request, as `framework.execute` takes it. */
-export type FrameworkOperationRequest = ApplicationOperationRequest | ClientOperationRequest | AgentOperationRequest;
+export type AvOperationRequest = AvApplicationOperationRequest | AvClientOperationRequest | AvAgentOperationRequest;
 type WithoutArguments<Request> = Request extends unknown ? Omit<Request, "arguments"> : never;
 /**
  * A request as every stage after the Framework Validation Layer sees it:
@@ -57,7 +57,7 @@ type WithoutArguments<Request> = Request extends unknown ? Omit<Request, "argume
  * unreachable by type. Distributive, so the origin and family/variant
  * correlations survive the omission.
  */
-export type OperationExecutionRequest = WithoutArguments<FrameworkOperationRequest>;
+export type OperationExecutionRequest = WithoutArguments<AvOperationRequest>;
 /**
  * A request whose stages run: its `state` settled once, the seed or the `{}`
  * the runtime made for it, so every stage is told the same object.

package/dist/runtime/operation-runtime.d.ts

@@ -8,14 +8,14 @@ import type { AvRequestOrigin, RemoteRequestOrigin } from "../config/config-laye
 import type { AvContract } from "../contracts/contract.js";
 import type { OperationValidationOptions, SemanticOperationArguments } from "../operations/operation-validator.js";
 import { type PolicyCaller } from "../policy/policy-request.js";
-import type { FrameworkTransactionRequest } from "../transactions/transaction-request.js";
+import type { AvTransactionRequest } from "../transactions/transaction-request.js";
 import { type ArgumentsSource } from "./caller-data.door.js";
 import { type ContextExecutor, type ExecutorScope } from "./context-executor.runtime.js";
 import { type RecordWriteFacts } from "./create-requirement.js";
 import { type DiagnosticsReporter } from "./diagnostics-reporter.js";
 import { type OuterFailureLayer } from "./error-boundary.js";
 import { type FieldStagePlan } from "./field-stage.plan.js";
-import type { ClientProtocolIdentity, FrameworkOperationRequest, StatefulOperationRequest } from "./operation-request.js";
+import type { AvOperationRequest, AvRequestProtocol, StatefulOperationRequest } from "./operation-request.js";
 import type { AvOperationFailureResponse, AvOperationResponse } from "./operation-response.js";
 import type { AvState } from "./request-state.js";
 import { type NormalizationWrite } from "./scalar-runtime.js";
@@ -70,7 +70,7 @@ export declare function withRequestState<Request extends {
  * `request` with its policy session when the policy checks it, or the failure
  * deriving its principal answered.
  */
-export declare function withRequestPolicy<M extends AvAdapterModel>(dependencies: Pick<OperationRuntimeDependencies<M>, "adapter" | "config" | "contracts">, request: StatefulOperationRequest, caller: PolicyCaller | undefined, report: DiagnosticsReporter): StatefulOperationRequest | AvOperationFailureResponse;
+export declare function withRequestPolicy<M extends AvAdapterModel>(dependencies: Pick<OperationRuntimeDependencies<M>, "adapter" | "config" | "contracts">, request: StatefulOperationRequest, caller: PolicyCaller | undefined, report: DiagnosticsReporter): StatefulOperationRequest | AvOperationFailureResponse | Promise<StatefulOperationRequest | AvOperationFailureResponse>;
 /**
  * Builds what every operation's pipeline shares, the ctx executor included: its
  * raw calls run the application's operation path with every developer stage
@@ -85,15 +85,15 @@ export declare function createPipelineDependencies<M extends AvAdapterModel>(dep
  * request's arguments are the caller's own objects, copied at the door, or data
  * no caller holds (see {@link ArgumentsSource}).
  */
-export type FrameworkOperationExecutor = (request: FrameworkOperationRequest, report: DiagnosticsReporter, source: ArgumentsSource, 
+export type FrameworkOperationExecutor = (request: AvOperationRequest, report: DiagnosticsReporter, source: ArgumentsSource, 
 /** The principal an application call runs as (`{ as }`), when it names one. */
 caller?: PolicyCaller) => Promise<AvOperationResponse>;
 /** Selects the Contract of the request's origin. */
-export declare function activeContract(contracts: AvContracts, request: FrameworkOperationRequest | FrameworkTransactionRequest): AvContract;
+export declare function activeContract(contracts: AvContracts, request: AvOperationRequest | AvTransactionRequest): AvContract;
 /** Creates the transport-independent operation executor owned by core. */
 export declare function createOperationRuntime<M extends AvAdapterModel>(dependencies: OperationRuntimeDependencies<M>, pipelineDependencies: OperationPipelineDependencies<M>): FrameworkOperationExecutor;
 /** Validates the request-level protocol identity. */
-export declare function validateProtocolIdentity(contracts: AvContracts, request: FrameworkOperationRequest | FrameworkTransactionRequest): AvOperationFailureResponse | undefined;
+export declare function validateProtocolIdentity(contracts: AvContracts, request: AvOperationRequest | AvTransactionRequest): AvOperationFailureResponse | undefined;
 /**
  * The stale-client check on one remote protocol identity: the protocol version first
  * (`A2006`), then the hash of the origin's Contract (`A2005`): the ClientContract's
@@ -102,7 +102,7 @@ export declare function validateProtocolIdentity(contracts: AvContracts, request
  * (`@aventara/core/protocol`) call it too, so a stale client hears the same envelope
  * whichever layer answers.
  */
-export declare function protocolIdentityFailure(contracts: AvContracts, protocol: ClientProtocolIdentity, origin: RemoteRequestOrigin): AvOperationFailureResponse | undefined;
+export declare function protocolIdentityFailure(contracts: AvContracts, protocol: AvRequestProtocol, origin: RemoteRequestOrigin): AvOperationFailureResponse | undefined;
 export type ValidatedOperationArguments = {
     readonly ok: true;
     readonly arguments: SemanticOperationArguments;
@@ -111,7 +111,7 @@ export type ValidatedOperationArguments = {
     readonly response: AvOperationFailureResponse;
 };
 /** Validates one operation's arguments through the Framework Validation Layer. */
-export declare function validateOperationRequest(contract: AvContract, request: FrameworkOperationRequest, options?: OperationValidationOptions, write?: NormalizationWrite): ValidatedOperationArguments;
+export declare function validateOperationRequest(contract: AvContract, request: AvOperationRequest, options?: OperationValidationOptions, write?: NormalizationWrite): ValidatedOperationArguments;
 /** The subject a refused output of an operation's pipes is reported under at a plan step. */
 export declare const STEP_PIPES = "Pipes";
 /**

package/dist/runtime/operation-runtime.js

@@ -44,13 +44,19 @@ export function withRequestState(request) {
     return { ...request, state: requestStateOf(request.state) };
 }
 export function withRequestPolicy(dependencies, request, caller, report) {
+    const failed = (error) => {
+        report(error, "A3000");
+        return internalFailure();
+    };
+    const withPolicy = (policy) => policy === undefined ? request : { ...request, policy };
     try {
         const policy = openRequestPolicy(dependencies.config.policy, dependencies.contracts.core, request, caller, dependencies.adapter);
-        return policy === undefined ? request : { ...request, policy };
+        return policy instanceof Promise
+            ? policy.then(withPolicy, failed)
+            : withPolicy(policy);
     }
     catch (error) {
-        report(error, "A3000");
-        return internalFailure();
+        return failed(error);
     }
 }
 export function createPipelineDependencies(dependencies, model) {
@@ -197,7 +203,8 @@ export function createOperationRuntime(dependencies, pipelineDependencies) {
         if (!validated.ok) {
             return validated.response;
         }
-        const stateful = withRequestPolicy(dependencies, withRequestState(request), caller, report);
+        const opened = withRequestPolicy(dependencies, withRequestState(request), caller, report);
+        const stateful = opened instanceof Promise ? await opened : opened;
         if (!("state" in stateful)) {
             return stateful;
         }
@@ -612,8 +619,10 @@ export async function executeAdmittedOperation(dependencies, request, contract,
             let operation = request;
             let settle;
             let writeMiss;
+            let failedWriteMiss;
             if (policyWrite !== undefined && policyWrite.kind !== "refused") {
                 writeMiss = policyWrite.miss;
+                failedWriteMiss = policyWrite.failedMiss;
                 if (policyWrite.kind === "empty") {
                     if (writeMiss !== undefined && policyWrite.data === null) {
                         refuseWrite(await writeMiss());
@@ -643,11 +652,23 @@ export async function executeAdmittedOperation(dependencies, request, contract,
                 settle = read.settle;
             }
             const { policy: _session, ...identity } = operation;
-            let adapterData = await adapterBoundary.execute(() => executor.execute({
-                ...identity,
-                resource: request.resource,
-                arguments: adapterArguments,
-            }));
+            let adapterData;
+            try {
+                adapterData = await adapterBoundary.execute(() => executor.execute({
+                    ...identity,
+                    resource: request.resource,
+                    arguments: adapterArguments,
+                }));
+            }
+            catch (error) {
+                const missed = failedWriteMiss === undefined
+                    ? undefined
+                    : await failedWriteMiss().catch(() => undefined);
+                if (missed !== undefined) {
+                    refuseWrite(missed);
+                }
+                throw error;
+            }
             if (writeMiss !== undefined && adapterData === null) {
                 refuseWrite(await writeMiss());
             }

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

@@ -1,4 +1,4 @@
-import type { AgentTransactionRequest, ClientTransactionRequest } from "../transactions/transaction-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";
@@ -15,7 +15,7 @@ export type OwnedExecution = {
      * at the call, and these steps' arguments could not be copied there: each is
      * answered at its turn as the door answers that failure.
      */
-    readonly executeTransaction: (request: ClientTransactionRequest | AgentTransactionRequest, refused?: ReadonlyMap<number, AvCallerDataError>) => Promise<AvTransactionResponse>;
+    readonly executeTransaction: (request: AvClientTransactionRequest | AvAgentTransactionRequest, refused?: ReadonlyMap<number, AvCallerDataError>) => Promise<AvTransactionResponse>;
 };
 /** Records `framework`'s owned entries; called once, at construction. */
 export declare function recordOwnedExecution(framework: object, execution: OwnedExecution): void;

package/dist/runtime/readonly-value.d.ts

@@ -1,4 +1,4 @@
-import { AvDecimal } from "./decimal.js";
+import { type AvDecimal } from "./decimal.js";
 /** A value `AvDeepReadonly` leaves as it is: a primitive, a function, or a scalar instance. */
 export type AvDeepReadonlyLeaf = string | number | boolean | bigint | symbol | null | undefined | Date | Uint8Array | AvDecimal | ((...args: never[]) => unknown);
 /**

package/dist/runtime/readonly-value.js

@@ -1,4 +1,4 @@
-import { AvDecimal } from "./decimal.js";
+import { isAvDecimal } from "./decimal.js";
 function isContainer(value) {
     if (value === null || typeof value !== "object") {
         return false;
@@ -6,7 +6,7 @@ function isContainer(value) {
     if (Array.isArray(value)) {
         return true;
     }
-    if (value instanceof AvDecimal) {
+    if (isAvDecimal(value)) {
         return false;
     }
     const prototype = Object.getPrototypeOf(value);

package/dist/runtime/referential-action.d.ts

@@ -29,7 +29,7 @@ export type ReferentialEdge = {
      * relation `field` and any of these names the reference twice and is refused;
      * a required relation may be written through all of them instead.
      */
-    readonly references: readonly string[];
+    readonly referenceFields: readonly string[];
     /** What deleting a `target` row does to rows of the ENCLOSING Resource. */
     readonly onDelete: ReferentialDeleteEffect;
 };

package/dist/runtime/scalar-runtime.js

@@ -4,7 +4,7 @@ import { FILTER_MODES, } from "../contracts/capability.js";
 import { lookupField, lookupOwn, lookupResource, } from "../contracts/contract-lookup.js";
 import { decodeBase64, WIRE_SCALAR_PATTERNS, } from "../contracts/wire-scalar-format.js";
 import { routeTransactionReferenceCandidate, } from "../transactions/transaction-reference.js";
-import { AvDecimal } from "./decimal.js";
+import { AvDecimal, isAvDecimal } from "./decimal.js";
 import { fieldCheckIssues } from "./field-check.evaluator.js";
 const INT_MIN = -(2 ** 31);
 const INT_MAX = 2 ** 31 - 1;
@@ -238,10 +238,9 @@ function normalizeScalarAtom(contract, field, value, origin, path, allowNull) {
             break;
         case "decimal":
             if (origin === "application") {
-                normalized =
-                    value instanceof AvDecimal
-                        ? { ok: true, value }
-                        : { ok: false, issues: [typeIssue(path, "an Aventara Decimal")] };
+                normalized = isAvDecimal(value)
+                    ? { ok: true, value }
+                    : { ok: false, issues: [typeIssue(path, "an Aventara Decimal")] };
             }
             else if (typeof value !== "string") {
                 normalized = {

package/dist/transactions/operation-arguments-encoder.js

@@ -1,6 +1,6 @@
 import { lookupField, lookupResource } from "../contracts/contract-lookup.js";
 import { encodeBase64 } from "../contracts/wire-scalar-format.js";
-import { AvDecimal } from "../runtime/decimal.js";
+import { isAvDecimal } from "../runtime/decimal.js";
 import { isRelationMutationDirective, RELATION_MUTATION_RECORD_SITES, } from "../runtime/mutation-planner.js";
 import { isTransactionReferenceCandidate } from "./transaction-reference.js";
 function isPlainRecord(value) {
@@ -27,9 +27,11 @@ function encodeScalarAtom(field, value) {
         case "bigint":
             return typeof value === "bigint" ? value.toString(10) : value;
         case "decimal":
-            return value instanceof AvDecimal ? value.toString() : value;
+            return isAvDecimal(value) ? value.toString() : value;
         case "datetime":
-            return value instanceof Date ? value.toISOString() : value;
+            return value instanceof Date && !Number.isNaN(value.getTime())
+                ? value.toISOString()
+                : value;
         case "bytes":
             return value instanceof Uint8Array ? encodeBase64(value) : value;
         default:
@@ -282,6 +284,9 @@ function isUniqueOperation(operation) {
             operation.family === "upsert"));
 }
 export function encodeOperationArgumentsForWire(contract, operation, args) {
+    if (!isPlainRecord(args)) {
+        return args;
+    }
     const encoded = cloneRecord(args);
     if (hasOwnWireProperty(args, "where")) {
         encoded.where = isUniqueOperation(operation)

package/dist/transactions/sql-statement.d.ts

@@ -10,7 +10,7 @@ import type { AvTransactionReference } from "./transaction-reference.js";
  * `${value}::jsonb`), or a `$ref` to an earlier step's field, resolved when the
  * earlier steps have run and then bound like any other value.
  */
-export type SqlStatementValue = AvAdapterSqlValue | AvTransactionReference;
+export type AvSqlStatementValue = AvAdapterSqlValue | AvTransactionReference;
 /**
  * `framework.appTx.$sql`: a developer SQL step, written only as a tagged template —
  * ``framework.appTx.$sql`select pgmq.send('jobs', jsonb_build_object('id', ${ref}))` ``.
@@ -23,7 +23,7 @@ export type SqlStatementValue = AvAdapterSqlValue | AvTransactionReference;
  * SQL step's rows. No guard, pipe, hook, interceptor or filter runs around it: it
  * has no Resource or operation for one to wrap.
  */
-export type SqlStatementBuilder = <Row = unknown>(strings: TemplateStringsArray, ...values: readonly SqlStatementValue[]) => AvOperation<Row[], "application">;
+export type AvSqlStatementBuilder = <Row = unknown>(strings: TemplateStringsArray, ...values: readonly AvSqlStatementValue[]) => AvOperation<Row[], "application">;
 /** One value of a planned SQL step, as the typed runner bound it. */
 export type PlannedSqlValue = {
     readonly kind: "value";

package/dist/transactions/sql-statement.validator.js

@@ -1,7 +1,7 @@
 import { validationIssue } from "../operations/validation-code.js";
 import { AvCallerDataError, locateCallerDataError, } from "../runtime/caller-data.copier.js";
 import { refuseCallerData } from "../runtime/caller-data.door.js";
-import { AvDecimal } from "../runtime/decimal.js";
+import { isAvDecimal } from "../runtime/decimal.js";
 import { planStepPath } from "../runtime/error-boundary.js";
 import { operationFailure } from "../runtime/operation-response.js";
 import { mapValidationOutcome } from "../runtime/outcome-mapper.js";
@@ -19,7 +19,7 @@ export function normalizeSqlValue(value, path) {
         typeof value === "string" ||
         typeof value === "boolean" ||
         typeof value === "bigint" ||
-        value instanceof AvDecimal ||
+        isAvDecimal(value) ||
         value instanceof Uint8Array) {
         return { ok: true, value };
     }

package/dist/transactions/transaction-integrity-error.js

@@ -1,3 +1,4 @@
+import { brandCoreClass } from "../runtime/core-class.brand.js";
 const TRANSACTION_INTEGRITY_MESSAGES = {
     "transaction-unavailable": "Adapter transaction function is unavailable.",
     "resolved-after-abort": "Adapter transaction resolved after the framework requested rollback.",
@@ -15,3 +16,4 @@ export class AvTransactionIntegrityError extends Error {
         this.violation = violation;
     }
 }
+brandCoreClass(AvTransactionIntegrityError, "AvTransactionIntegrityError");

package/dist/transactions/transaction-plan-assembler.d.ts

@@ -2,13 +2,15 @@ import type { AvContracts } from "../compiler/contract.compiler.js";
 import type { AvOperationIdentity } from "../operations/operation-identity.js";
 import { AvCallerDataError } from "../runtime/caller-data.copier.js";
 import type { MisuseReporter } from "../runtime/misuse-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 { AvOperation, OperationFingerprint } from "./deferred-operation.js";
 import type { PlannedSqlStatement } from "./sql-statement.js";
 import type { TransactionOperationOrigin } from "./transaction-request.js";
 /** The origin a handle's builder gives it. */
 type HandleOrigin = "application" | "client";
+/** The scalar forms a builder takes its arguments in. */
+type ArgumentForms = "wire" | "application";
 /** One wire node, exactly as the transaction runtime receives it. */
 type WireOperationNode = {
     readonly resource: string;
@@ -37,8 +39,13 @@ export type AssembledTransactionPlan = {
     readonly response: AvOperationFailureResponse;
 };
 export type TransactionPlanAssembler = {
-    /** Defers one operation into a handle; nothing runs. */
-    defer(origin: HandleOrigin, resource: string, identity: AvOperationIdentity, args: unknown): AvOperation<unknown>;
+    /**
+     * Defers one operation into a handle; nothing runs. `forms` says which scalar
+     * forms a client-origin handle's arguments are in: `"wire"` (`clientTx`, the
+     * default) or `"application"` (`serverClientTx`), encoded into the wire forms
+     * from the builder's copy.
+     */
+    defer(origin: HandleOrigin, resource: string, identity: AvOperationIdentity, args: unknown, forms?: ArgumentForms): AvOperation<unknown>;
     /** Defers one `appTx.$sql` statement into a handle; nothing runs. */
     deferSql(strings: unknown, values: readonly unknown[]): AvOperation<unknown>;
     /** Binds a list of handles into the passive plan, or refuses it. */
@@ -49,5 +56,5 @@ export type TransactionPlanAssembler = {
  * handle, so a handle another instance built — typed against another model,
  * bound to other Contracts — is refused rather than run.
  */
-export declare function createTransactionPlanAssembler(contracts: AvContracts, protocol: ClientProtocolIdentity, misuse: MisuseReporter): TransactionPlanAssembler;
+export declare function createTransactionPlanAssembler(contracts: AvContracts, protocol: AvRequestProtocol, misuse: MisuseReporter): TransactionPlanAssembler;
 export {};

package/dist/transactions/transaction-plan-assembler.js

@@ -139,8 +139,23 @@ export function createTransactionPlanAssembler(contracts, protocol, misuse) {
         handles.set(handle, record);
         return handle;
     };
-    const defer = (origin, resource, identity, args) => {
-        const copy = snapshot(args, STEP_REFERENCE_MIRROR);
+    const defer = (origin, resource, identity, args, forms = "wire") => {
+        const snapped = snapshot(args, STEP_REFERENCE_MIRROR);
+        let copy = snapped;
+        if (origin === "client" &&
+            forms === "application" &&
+            snapped.refused === undefined) {
+            try {
+                copy = {
+                    args: encodeOperationArgumentsForWire(contracts.client, { resource, ...identity }, snapped.args),
+                };
+            }
+            catch (error) {
+                if (!(error instanceof AvCallerDataError)) {
+                    throw error;
+                }
+            }
+        }
         let sent = copy.args;
         try {
             sent = withoutUnsentWriteValues(origin === "application" ? contracts.application : contracts.client, { resource, family: identity.family }, copy.args);

package/dist/transactions/transaction-plan-validator.d.ts

@@ -4,7 +4,7 @@ import type { AvScalarField } from "../contracts/field.js";
 import type { SemanticOperationArguments } from "../operations/operation-validator.js";
 import { AvCallerDataError } from "../runtime/caller-data.copier.js";
 import { type ReadProjectionPlan } from "../runtime/computed-read-runtime.js";
-import type { FrameworkOperationRequest } from "../runtime/operation-request.js";
+import type { AvOperationRequest } from "../runtime/operation-request.js";
 import type { AvOperationFailureResponse } from "../runtime/operation-response.js";
 import type { OperationPipelineDependencies } from "../runtime/operation-runtime.js";
 import type { CascadeClosure } from "../runtime/referential-action.js";
@@ -13,7 +13,7 @@ import type { PlannedSqlStatement, ValidatedSqlStatement } from "./sql-statement
 import type { AvTransactionReference } from "./transaction-reference.js";
 import { type TransactionSlotShape } from "./transaction-reference.js";
 import { type TransactionReferenceCandidateSlot } from "./transaction-reference-collector.js";
-import type { FrameworkTransactionRequest, TransactionOperationOrigin } from "./transaction-request.js";
+import type { AvTransactionRequest, TransactionOperationOrigin } from "./transaction-request.js";
 /**
  * Where a plan's step arguments came from, so the validator knows whether to copy
  * them at the door (see `ArgumentsSource`):
@@ -65,7 +65,7 @@ export type TransactionReferenceSlot = {
 };
 export type CandidateTransactionOperation = {
     readonly index: number;
-    readonly request: FrameworkOperationRequest;
+    readonly request: AvOperationRequest;
     readonly arguments: SemanticOperationArguments;
     readonly projection: ReadProjectionPlan | undefined;
     readonly declaredFingerprint: unknown;
@@ -74,7 +74,7 @@ export type CandidateTransactionOperation = {
 export type ValidatedTransactionOperation = {
     readonly kind: "operation";
     readonly index: number;
-    readonly request: FrameworkOperationRequest;
+    readonly request: AvOperationRequest;
     /**
      * The Contract of this operation's origin, which is the plan's: the one it was
      * validated against, the one it runs under, and the one a later `$ref` reads its
@@ -118,4 +118,4 @@ export declare function transactionsUnavailableFailure(): AvOperationFailureResp
 /**
  * Whole-plan Framework Validation Layer for transaction structure and identity.
  */
-export declare function validateTransactionPlan<M extends AvAdapterModel>(dependencies: TransactionPlanDependencies<M>, request: FrameworkTransactionRequest, origins?: readonly TransactionOperationOrigin[], planArguments?: PlanArguments): Promise<TransactionPlanValidationResult>;
+export declare function validateTransactionPlan<M extends AvAdapterModel>(dependencies: TransactionPlanDependencies<M>, request: AvTransactionRequest, origins?: readonly TransactionOperationOrigin[], planArguments?: PlanArguments): Promise<TransactionPlanValidationResult>;