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

package/dist/operations/write-scope.resolver.d.ts

@@ -1,15 +1,15 @@
-import type { WriteScope } from "../contracts/capability.js";
-import type { Contract } from "../contracts/contract.js";
-import type { Resource } from "../contracts/resource.js";
-import type { OperationIdentity } from "./operation-identity.js";
+import type { AvWriteScope } from "../contracts/capability.js";
+import type { AvContract } from "../contracts/contract.js";
+import type { AvResource } from "../contracts/resource.js";
+import type { AvOperationIdentity } from "./operation-identity.js";
 /**
  * Which write position one request's top-level `data` (or `create`/`update`)
  * argument sits in, read off the variant the Resource advertises. `"nested"`
  * wherever nothing narrower is stated.
  */
-export declare function resolveWriteScope(resource: Resource<Contract> | undefined, request: OperationIdentity): WriteScope;
+export declare function resolveWriteScope(resource: AvResource<AvContract> | undefined, request: AvOperationIdentity): AvWriteScope;
 /**
  * The position a write NESTED beneath an admitted relation directive sits in: the
  * unrestricted one, at every depth, under every top-level scope.
  */
-export declare const NESTED_WRITE_SCOPE: WriteScope;
+export declare const NESTED_WRITE_SCOPE: AvWriteScope;

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

@@ -1,8 +1,9 @@
-import type { FrameworkContracts } from "../compiler/contract.compiler.js";
-import { type OperationIdentity } from "../operations/operation-identity.js";
-import { type FrameworkDiagnosticsSink } from "../runtime/diagnostics-reporter.js";
+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 OperationFailureResponse } from "../runtime/operation-response.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";
 import { type AvProtocolResponse } from "./http-response.encoder.js";
@@ -23,10 +24,10 @@ export type OperationRouteSegments = {
 /** What a route check resolves to: the operation it names, or the answer that refuses it. */
 export type OperationRouteResolution = {
     readonly ok: true;
-    readonly operation: OperationIdentity;
+    readonly operation: AvOperationIdentity;
 } | {
     readonly ok: false;
-    readonly failure: OperationFailureResponse;
+    readonly failure: AvOperationFailureResponse;
 };
 /**
  * An operation route `/_resources/<resource>/<family>/<variant>` under one client
@@ -35,7 +36,7 @@ export type OperationRouteResolution = {
  * is a standard operation the Resource advertises, read through
  * `isOperationVariantAvailable` alone.
  */
-export declare function resolveOperationRoute(contracts: FrameworkContracts, protocol: ClientProtocolIdentity, route: OperationRouteSegments): OperationRouteResolution;
+export declare function resolveOperationRoute(contracts: AvContracts, protocol: ClientProtocolIdentity, 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
@@ -43,7 +44,7 @@ export declare function resolveOperationRoute(contracts: FrameworkContracts, pro
  * it — and is otherwise absent with core's own refusal of a plan. `undefined` when the
  * route is there.
  */
-export declare function transactionsRouteFailure(contracts: FrameworkContracts, protocol: ClientProtocolIdentity): OperationFailureResponse | undefined;
+export declare function transactionsRouteFailure(contracts: AvContracts, protocol: ClientProtocolIdentity, 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.
@@ -63,9 +64,9 @@ type RouteCheck<Route> = ({
  * for both route styles: `decodeOperation` reads the body only after it passes,
  * `answerAbsent` never.
  */
-export declare function checkOperationRoute(contracts: FrameworkContracts, read: ReadRequest): RouteCheck<{
+export declare function checkOperationRoute(contracts: AvContracts, read: ReadRequest, origin?: RemoteRequestOrigin): RouteCheck<{
     readonly resource: string;
-    readonly operation: OperationIdentity;
+    readonly operation: AvOperationIdentity;
 }>;
 /**
  * `/_transactions`' checks before its body: the path (`A2000` unless exactly
@@ -73,12 +74,12 @@ export declare function checkOperationRoute(contracts: FrameworkContracts, read:
  * {@link transactionsRouteFailure} — version, hash, `"interactive"` — and the
  * method (`A2012`, `Allow: POST`).
  */
-export declare function checkTransactionsRoute(contracts: FrameworkContracts, read: ReadRequest): RouteCheck<object>;
+export declare function checkTransactionsRoute(contracts: AvContracts, read: ReadRequest, origin?: RemoteRequestOrigin): RouteCheck<object>;
 /**
  * `protocol.answerAbsent(request)` — the fallback a host that mounts one route per
  * `protocol.surface()` entry mounts for every path it did not. Never a catch-all into
  * framework handling: it reads no body, runs no pipeline, calls no Adapter, and takes
  * only the compiled Contracts. In order:
  */
-export declare function answerAbsentRequest(contracts: FrameworkContracts, received: AvProtocolRequest, sink?: FrameworkDiagnosticsSink): AvProtocolResponse | undefined;
+export declare function answerAbsentRequest(contracts: AvContracts, received: AvProtocolRequest, sink?: AvDiagnosticsSink, origin?: RemoteRequestOrigin): AvProtocolResponse | undefined;
 export {};

package/dist/protocol/absent-route.responder.js

@@ -12,13 +12,13 @@ import { CONTRACT_ROUTE, GET_ONLY, isProtocolPath, operationRouteSegments, POST_
 import { encodeOperationResponse, } from "./http-response.encoder.js";
 import { identityHeadersMissing, transportFailure, } from "./protocol-failure.js";
 import { missingIdentityHeaders } from "./protocol-headers.js";
-import { UnmountedRouteError } from "./unmounted-route.error.js";
-export function resolveOperationRoute(contracts, protocol, route) {
-    const identityFailure = protocolIdentityFailure(contracts, protocol);
+import { AvUnmountedRouteError } from "./unmounted-route.error.js";
+export function resolveOperationRoute(contracts, protocol, route, origin = "client") {
+    const identityFailure = protocolIdentityFailure(contracts, protocol, origin);
     if (identityFailure !== undefined) {
         return { ok: false, failure: identityFailure };
     }
-    const resource = lookupResource(contracts.client, route.resource);
+    const resource = lookupResource(contracts[origin], route.resource);
     if (resource === undefined) {
         return {
             ok: false,
@@ -32,19 +32,19 @@ export function resolveOperationRoute(contracts, protocol, route) {
         return {
             ok: false,
             failure: mapValidationOutcome([
-                operationUnavailableIssue(contracts.client, route),
+                operationUnavailableIssue(contracts[origin], route),
             ]),
         };
     }
     return { ok: true, operation };
 }
-export function transactionsRouteFailure(contracts, protocol) {
-    return (protocolIdentityFailure(contracts, protocol) ??
-        (contracts.client.transactions === "interactive"
+export function transactionsRouteFailure(contracts, protocol, origin = "client") {
+    return (protocolIdentityFailure(contracts, protocol, origin) ??
+        (contracts[origin].transactions === "interactive"
             ? undefined
             : transactionsUnavailableFailure()));
 }
-export function checkOperationRoute(contracts, read) {
+export function checkOperationRoute(contracts, read, origin = "client") {
     const segments = operationRouteSegments(read.request.path);
     if (segments === undefined) {
         return refusedWith(transportFailure("A2000", read.requestId));
@@ -52,7 +52,7 @@ export function checkOperationRoute(contracts, read) {
     if (read.protocol === undefined) {
         return refusedWith(identityFailureOf(read));
     }
-    const route = resolveOperationRoute(contracts, read.protocol, segments);
+    const route = resolveOperationRoute(contracts, read.protocol, segments, origin);
     if (!route.ok) {
         return refusedWith(encodeOperationResponse(route.failure, read.requestId));
     }
@@ -65,14 +65,14 @@ export function checkOperationRoute(contracts, read) {
         }
         : refusedWith(transportFailure("A2012", read.requestId, POST_ONLY));
 }
-export function checkTransactionsRoute(contracts, read) {
+export function checkTransactionsRoute(contracts, read, origin = "client") {
     if (read.request.path !== TRANSACTIONS_ROUTE) {
         return refusedWith(transportFailure("A2000", read.requestId));
     }
     if (read.protocol === undefined) {
         return refusedWith(identityFailureOf(read));
     }
-    const absent = transactionsRouteFailure(contracts, read.protocol);
+    const absent = transactionsRouteFailure(contracts, read.protocol, origin);
     if (absent !== undefined) {
         return refusedWith(encodeOperationResponse(absent, read.requestId));
     }
@@ -86,7 +86,7 @@ function identityFailureOf(read) {
 function refusedWith(response) {
     return { ok: false, response };
 }
-export function answerAbsentRequest(contracts, received, sink) {
+export function answerAbsentRequest(contracts, received, sink, origin = "client") {
     const read = readRequest(received);
     if (!read.ok) {
         return read.response;
@@ -101,30 +101,30 @@ export function answerAbsentRequest(contracts, received, sink) {
             : transportFailure("A2012", read.requestId, GET_ONLY);
     }
     if (path === TRANSACTIONS_ROUTE) {
-        const route = checkTransactionsRoute(contracts, read);
+        const route = checkTransactionsRoute(contracts, read, origin);
         if (!route.ok) {
             return route.response;
         }
         createReporter(sink, {
             kind: "transaction",
-            origin: "client",
+            origin,
             requestId: read.requestId,
-        })(new UnmountedRouteError("transactions", `POST ${TRANSACTIONS_ROUTE}`), "A3000");
+        })(new AvUnmountedRouteError("transactions", `POST ${TRANSACTIONS_ROUTE}`), "A3000");
         return unmounted(read.requestId);
     }
-    const route = checkOperationRoute(contracts, read);
+    const route = checkOperationRoute(contracts, read, origin);
     if (!route.ok) {
         return route.response;
     }
     const { family, variant } = route.operation;
     createReporter(sink, {
         kind: "operation",
-        origin: "client",
+        origin,
         resource: route.resource,
         family,
         variant,
         requestId: read.requestId,
-    })(new UnmountedRouteError(`${route.resource}.${family}.${variant}`, `POST ${path}`), "A3000");
+    })(new AvUnmountedRouteError(`${route.resource}.${family}.${variant}`, `POST ${path}`), "A3000");
     return unmounted(read.requestId);
 }
 function unmounted(requestId) {

package/dist/protocol/contract-document.responder.d.ts

@@ -1,4 +1,4 @@
-import type { ClientContract } from "../contracts/contract.js";
+import type { AvContractClient } from "../contracts/contract.js";
 import type { AvProtocolRequest } from "./http-request.decoder.js";
 import type { AvProtocolResponse } from "./http-response.encoder.js";
 /**
@@ -11,9 +11,9 @@ export type ContractDocument = {
     readonly etag: string;
 };
 /** The bound ClientContract as the document `_contract` serves. */
-export declare function contractDocumentOf(client: ClientContract): ContractDocument;
+export declare function contractDocumentOf(client: AvContractClient): ContractDocument;
 /**
- * `protocol.encodeContract(request)`: the `GET <entrypoint>/_contract` responder. In
+ * `protocol.encodeContract(request)`: the `GET <api>/_contract` responder. In
  * order:
  */
 export declare function encodeContractRequest(document: ContractDocument, received: AvProtocolRequest): AvProtocolResponse;

package/dist/protocol/contract-document.responder.js

@@ -1,10 +1,10 @@
-import { canonicalizeContract } from "../contracts/contract-canonicalizer.js";
+import { canonicalContractTextOf } from "../contracts/contract-canonicalizer.js";
 import { CONTRACT_ROUTE, GET_ONLY, readRequest, } from "./http-request.reader.js";
 import { transportFailure } from "./protocol-failure.js";
 import { headers, headerValue } from "./protocol-headers.js";
 export function contractDocumentOf(client) {
     return Object.freeze({
-        body: canonicalizeContract(client),
+        body: canonicalContractTextOf(client),
         etag: `"${client.protocol.hash}"`,
     });
 }

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

@@ -1,15 +1,16 @@
-import type { FrameworkContracts } from "../compiler/contract.compiler.js";
-import type { ClientOperationRequest } from "../runtime/operation-request.js";
-import type { ClientTransactionRequest } from "../transactions/transaction-request.js";
+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 { AvProtocolResponse } from "./http-response.encoder.js";
 /** One HTTP request as a host hands it to the protocol. */
 export type AvProtocolRequest = {
     /** The HTTP method as received. Anything but `POST` on a framework route is `A2012`. */
     readonly method: string;
     /**
-     * The request path RELATIVE to the configured entrypoint, as received (not yet
-     * URL-decoded): `/_resources/users/find/many`, `/_transactions`, `/_contract` —
-     * the space `protocol.surface()`'s paths live in.
+     * The request path relative to the configured `api` mount path, as received (not yet
+     * URL-decoded): `/_resources/users/find/many`, `/_transactions`, `/_contract`,
+     * in the same form as the paths `protocol.surface()` returns.
      */
     readonly path: string;
     /**
@@ -19,8 +20,8 @@ export type AvProtocolRequest = {
      */
     readonly headers: Readonly<Record<string, string | readonly string[] | undefined>>;
     /**
-     * The body, in one of two explicitly named arms — the decoder never guesses which
-     * one it was given:
+     * The body, in one of two explicitly named arms, so the decoder never guesses
+     * which one it was given:
      */
     readonly body: {
         readonly kind: "raw";
@@ -45,19 +46,22 @@ type Decoded<Request> = {
     readonly response: AvProtocolResponse;
     readonly requestId: string;
 };
-/** What `protocol.decodeOperation` answers. */
-export type DecodedOperation = Decoded<ClientOperationRequest>;
+/**
+ * What `protocol.decodeOperation` answers: a client-origin request, or an
+ * agent-origin one from a binding made with `{ origin: "agent" }`.
+ */
+export type DecodedOperation = Decoded<RemoteOperationRequest>;
 /** `protocol.decodeOperation`'s success value: the request `framework.execute` takes. */
 export type DecodedOperationRequest = Extract<DecodedOperation, {
     ok: true;
 }>;
 /** What `protocol.decodeTransaction` answers. */
-export type DecodedTransaction = Decoded<ClientTransactionRequest>;
+export type DecodedTransaction = Decoded<ClientTransactionRequest | AgentTransactionRequest>;
 /**
  * `protocol.decodeOperation(request)` — one operation route's HTTP request as
  * the client-origin request `framework.execute` takes, or its answer.
  */
-export declare function decodeOperationRequest(contracts: FrameworkContracts, received: AvProtocolRequest): DecodedOperation;
+export declare function decodeOperationRequest(contracts: AvContracts, received: AvProtocolRequest, origin?: RemoteRequestOrigin): DecodedOperation;
 /**
  * `protocol.decodeTransaction(request)` — the `/_transactions` request as the client-
  * origin plan request `framework.executeTransaction` takes, or its answer. The same
@@ -66,7 +70,7 @@ export declare function decodeOperationRequest(contracts: FrameworkContracts, re
  * the plan then runs under ClientContract rules: the plan is client origin and cannot
  * say otherwise. The body is the plan verbatim.
  */
-export declare function decodeTransactionRequest(contracts: FrameworkContracts, received: AvProtocolRequest): DecodedTransaction;
+export declare function decodeTransactionRequest(contracts: AvContracts, received: AvProtocolRequest, origin?: RemoteRequestOrigin): DecodedTransaction;
 /**
  * Whether `value` is a body this decoder parsed from raw content. Only the protocol's
  * own shortcuts ask, about a request they have just decoded, before any host code

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

@@ -2,21 +2,21 @@ import { checkOperationRoute, checkTransactionsRoute, } from "./absent-route.res
 import { readRequest } from "./http-request.reader.js";
 import { transportFailure, } from "./protocol-failure.js";
 import { headerValue } from "./protocol-headers.js";
-export function decodeOperationRequest(contracts, received) {
+export function decodeOperationRequest(contracts, received, origin = "client") {
     const read = readRequest(received);
     if (!read.ok) {
         return read;
     }
-    const route = checkOperationRoute(contracts, read);
+    const route = checkOperationRoute(contracts, read, origin);
     if (!route.ok) {
         return refused(route.response, read.requestId);
     }
-    const body = readBody(read, contracts);
+    const body = readBody(read, contracts, origin);
     return body.ok
         ? {
             ok: true,
             request: {
-                origin: "client",
+                origin,
                 requestId: read.requestId,
                 resource: route.resource,
                 ...route.operation,
@@ -28,21 +28,21 @@ export function decodeOperationRequest(contracts, received) {
         }
         : refused(body.response, read.requestId);
 }
-export function decodeTransactionRequest(contracts, received) {
+export function decodeTransactionRequest(contracts, received, origin = "client") {
     const read = readRequest(received);
     if (!read.ok) {
         return read;
     }
-    const route = checkTransactionsRoute(contracts, read);
+    const route = checkTransactionsRoute(contracts, read, origin);
     if (!route.ok) {
         return refused(route.response, read.requestId);
     }
-    const body = readBody(read, contracts);
+    const body = readBody(read, contracts, origin);
     return body.ok
         ? {
             ok: true,
             request: {
-                origin: "client",
+                origin,
                 requestId: read.requestId,
                 protocol: route.protocol,
                 transport: transportOf(read),
@@ -58,8 +58,8 @@ function refused(response, requestId) {
 function transportOf(read) {
     return { method: "POST", headers: read.headers };
 }
-function readBody(read, contracts) {
-    const code = bodyValue(read.request.body, headerValue(read.headers, "content-type"), contracts.client.limits.maxRequestBytes);
+function readBody(read, contracts, origin) {
+    const code = bodyValue(read.request.body, headerValue(read.headers, "content-type"), contracts[origin].limits.maxRequestBytes);
     return typeof code === "string"
         ? { ok: false, response: transportFailure(code, read.requestId) }
         : { ok: true, value: code.value };

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

@@ -2,9 +2,9 @@ import type { ClientProtocolIdentity } from "../runtime/operation-request.js";
 import type { OperationRouteSegments } from "./absent-route.responder.js";
 import type { AvProtocolRequest } from "./http-request.decoder.js";
 import type { AvProtocolResponse } from "./http-response.encoder.js";
-/** `POST <entrypoint>/_transactions`. */
+/** `POST <api>/_transactions`. */
 export declare const TRANSACTIONS_ROUTE = "/_transactions";
-/** `GET <entrypoint>/_contract`. */
+/** `GET <api>/_contract`. */
 export declare const CONTRACT_ROUTE = "/_contract";
 /** The methods an operation or `/_transactions` route accepts: `POST`, only. */
 export declare const POST_ONLY: readonly string[];
@@ -12,7 +12,7 @@ export declare const POST_ONLY: readonly string[];
 export declare const GET_ONLY: readonly string[];
 /**
  * Whether a path lies in the protocol's namespace: underscore-prefixed paths beneath
- * the entrypoint are reserved for framework facilities; every other path is the
+ * the `api` mount path are reserved for framework facilities; every other path is the
  * host's.
  */
 export declare function isProtocolPath(path: string): boolean;

package/dist/protocol/http-response.encoder.d.ts

@@ -1,5 +1,5 @@
-import { type OperationResponse } from "../runtime/operation-response.js";
-import type { TransactionResponse } from "../transactions/transaction-response.js";
+import { type AvOperationResponse } from "../runtime/operation-response.js";
+import type { AvTransactionResponse } from "../transactions/transaction-response.js";
 /**
  * One HTTP response as the protocol hands it to a host: what the encoders
  * (`protocol.encodeOperation` / `encodeTransaction`) and `protocol.failure`
@@ -28,7 +28,7 @@ export type UnencodableReport = (error: unknown, operation?: number) => void;
  * `requestId` is echoed as `Aventara-Request-Id` — pass the id the request ran under,
  * which the decoder supplies.
  */
-export declare function encodeOperationResponse(response: OperationResponse, requestId: string, report?: UnencodableReport): AvProtocolResponse;
+export declare function encodeOperationResponse(response: AvOperationResponse, requestId: string, report?: UnencodableReport): AvProtocolResponse;
 /**
  * `protocol.encodeTransaction(response, requestId)`: the same for a plan's response. A
  * committed plan is `200 A1009` — even when it created something — with each
@@ -37,4 +37,4 @@ export declare function encodeOperationResponse(response: OperationResponse, req
  * status. A step whose result cannot be encoded answers `A3003` → 500 naming that step
  * as `cause.operation`, as every internal failure inside a plan does.
  */
-export declare function encodeTransactionResponse(response: TransactionResponse, requestId: string, report?: UnencodableReport): AvProtocolResponse;
+export declare function encodeTransactionResponse(response: AvTransactionResponse, requestId: string, report?: UnencodableReport): AvProtocolResponse;

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

@@ -1,16 +1,16 @@
 import { encodeBase64, WIRE_SCALAR_PATTERNS, } from "../contracts/wire-scalar-format.js";
-import { Decimal } from "../runtime/decimal.js";
+import { AvDecimal } 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";
 import { headers } from "./protocol-headers.js";
 export function encodeOperationResponse(response, requestId, report) {
     try {
-        return written(response, toWire(response.data, new Set()), requestId);
+        return written(response, toWireText(response.data), requestId);
     }
     catch (error) {
         report?.(error);
-        return written(serializationFailure(), null, requestId);
+        return written(serializationFailure(), "null", requestId);
     }
 }
 export function encodeTransactionResponse(response, requestId, report) {
@@ -25,13 +25,16 @@ export function encodeTransactionResponse(response, requestId, report) {
         }
         const steps = [];
         for (step = 0; step < data.length; step += 1) {
-            steps.push(toWireElement(data, step, new Set()));
+            if (!Object.hasOwn(data, step)) {
+                throw unencodable(data);
+            }
+            steps.push(toWireText(data[step]));
         }
-        return written(response, steps, requestId);
+        return written(response, `[${steps.join(",")}]`, requestId);
     }
     catch (error) {
         report?.(error, step);
-        return written(serializationFailure(step), null, requestId);
+        return written(serializationFailure(step), "null", requestId);
     }
 }
 function serializationFailure(operation) {
@@ -51,82 +54,118 @@ function written(response, wireData, requestId) {
             "Content-Type": "application/json",
             [headers.requestId]: requestId,
         },
-        body: JSON.stringify({ data: wireData, code, cause }),
+        body: `{"data":${wireData},${JSON.stringify({ code, cause }).slice(1)}`,
     };
 }
 function unencodable(value) {
     return new TypeError("A result value has no wire form.", { cause: value });
 }
-function toWire(value, ancestors) {
+function toWireText(value) {
+    const output = [];
+    const ancestors = new Set();
+    const stack = [{ kind: "value", value }];
+    while (stack.length > 0) {
+        const task = stack.pop();
+        if (task.kind === "text") {
+            output.push(task.text);
+            continue;
+        }
+        if (task.kind === "leave") {
+            ancestors.delete(task.container);
+            continue;
+        }
+        const current = task.value;
+        const scalar = scalarWireText(current);
+        if (scalar !== undefined) {
+            output.push(scalar);
+            continue;
+        }
+        const container = current;
+        if (ancestors.has(container)) {
+            throw unencodable(container);
+        }
+        ancestors.add(container);
+        stack.push({ kind: "leave", container });
+        if (Array.isArray(container)) {
+            pushList(stack, container);
+        }
+        else {
+            pushRecord(stack, container);
+        }
+    }
+    return output.join("");
+}
+function pushList(stack, list) {
+    const tasks = [{ kind: "text", text: "[" }];
+    for (let index = 0; index < list.length; index += 1) {
+        if (!Object.hasOwn(list, index)) {
+            throw unencodable(list);
+        }
+        if (index > 0) {
+            tasks.push({ kind: "text", text: "," });
+        }
+        tasks.push({ kind: "value", value: list[index] });
+    }
+    tasks.push({ kind: "text", text: "]" });
+    pushReversed(stack, tasks);
+}
+function pushRecord(stack, record) {
+    const prototype = Object.getPrototypeOf(record);
+    if (prototype !== Object.prototype && prototype !== null) {
+        throw unencodable(record);
+    }
+    const tasks = [{ kind: "text", text: "{" }];
+    for (const key of Object.keys(record)) {
+        const member = record[key];
+        if (member === undefined) {
+            continue;
+        }
+        tasks.push({
+            kind: "text",
+            text: `${tasks.length > 1 ? "," : ""}${JSON.stringify(key)}:`,
+        });
+        tasks.push({ kind: "value", value: member });
+    }
+    tasks.push({ kind: "text", text: "}" });
+    pushReversed(stack, tasks);
+}
+function pushReversed(stack, tasks) {
+    for (let index = tasks.length - 1; index >= 0; index -= 1) {
+        stack.push(tasks[index]);
+    }
+}
+function scalarWireText(value) {
     switch (typeof value) {
         case "string":
         case "boolean":
-            return value;
+            return JSON.stringify(value);
         case "number":
             if (Number.isFinite(value)) {
-                return value;
+                return JSON.stringify(value);
             }
             throw unencodable(value);
         case "bigint":
-            return value.toString(10);
+            return JSON.stringify(value.toString(10));
         case "object":
             break;
         default:
             throw unencodable(value);
     }
     if (value === null) {
-        return null;
+        return "null";
     }
     if (value instanceof Date) {
         const wire = Number.isNaN(value.getTime()) ? "" : value.toISOString();
         if (!WIRE_SCALAR_PATTERNS.datetime.test(wire)) {
             throw unencodable(value);
         }
-        return wire;
+        return JSON.stringify(wire);
     }
-    if (value instanceof Decimal) {
-        return value.toString();
+    if (value instanceof AvDecimal) {
+        return JSON.stringify(value.toString());
     }
     if (value instanceof Uint8Array) {
-        return encodeBase64(value);
-    }
-    if (ancestors.has(value)) {
-        throw unencodable(value);
-    }
-    ancestors.add(value);
-    try {
-        return Array.isArray(value)
-            ? toWireList(value, ancestors)
-            : toWireRecord(value, ancestors);
-    }
-    finally {
-        ancestors.delete(value);
-    }
-}
-function toWireList(list, ancestors) {
-    const wire = [];
-    for (let index = 0; index < list.length; index += 1) {
-        wire.push(toWireElement(list, index, ancestors));
-    }
-    return wire;
-}
-function toWireElement(list, index, ancestors) {
-    if (!Object.hasOwn(list, index)) {
-        throw unencodable(list);
-    }
-    return toWire(list[index], ancestors);
-}
-function toWireRecord(record, ancestors) {
-    const prototype = Object.getPrototypeOf(record);
-    if (prototype !== Object.prototype && prototype !== null) {
-        throw unencodable(record);
-    }
-    const members = [];
-    for (const key of Object.keys(record)) {
-        const member = record[key];
-        if (member !== undefined) {
-            members.push([key, toWire(member, ancestors)]);
-        }
+        return JSON.stringify(encodeBase64(value));
     }
-    return Object.fromEntries(members);
+    return undefined;
 }

package/dist/protocol/http-status.table.d.ts

@@ -1,7 +1,7 @@
-import type { OperationCode } from "../runtime/operation-response.js";
+import type { AvOperationCode } from "../runtime/operation-response.js";
 /**
  * `AvProtocol.httpStatus` — the HTTP status each A-code carries, as passive data.
  */
 export declare const httpStatus: {
-    readonly [C in OperationCode]: number;
+    readonly [C in AvOperationCode]: number;
 };

package/dist/protocol/operation-response.guard.d.ts

@@ -1,5 +1,5 @@
-import { type OperationResponse } from "../runtime/operation-response.js";
+import { type AvOperationResponse } from "../runtime/operation-response.js";
 /**
  * The HTTP status plays no part — a code is read even at an unexpected status.
  */
-export declare function isOperationResponse(value: unknown): value is OperationResponse;
+export declare function isOperationResponse(value: unknown): value is AvOperationResponse;