@aventara/core 0.1.0-pilot.4 → 1.0.0-rc.1

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

@@ -3,6 +3,7 @@ import { isOperationVariantAvailable, } from "../contracts/resource-operations.j
 import { parseOperationIdentity, } from "../operations/operation-identity.js";
 import { operationUnavailableIssue } from "../operations/operation-validator.js";
 import { resourceUnavailableIssue } from "../operations/operation-validator-core.js";
+import { createReporter, } from "../runtime/diagnostics-reporter.js";
 import { INTERNAL_FAILURE_MESSAGE, operationFailure, } from "../runtime/operation-response.js";
 import { protocolIdentityFailure } from "../runtime/operation-runtime.js";
 import { mapValidationOutcome } from "../runtime/outcome-mapper.js";
@@ -11,12 +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";
-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,
@@ -29,18 +31,20 @@ export function resolveOperationRoute(contracts, protocol, route) {
         !isOperationVariantAvailable(lookupOwn(lookupOwn(advertised, route.family), route.variant))) {
         return {
             ok: false,
-            failure: mapValidationOutcome([operationUnavailableIssue(route)]),
+            failure: mapValidationOutcome([
+                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));
@@ -48,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));
     }
@@ -61,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));
     }
@@ -82,7 +86,7 @@ function identityFailureOf(read) {
 function refusedWith(response) {
     return { ok: false, response };
 }
-export function answerAbsentRequest(contracts, received) {
+export function answerAbsentRequest(contracts, received, sink, origin = "client") {
     const read = readRequest(received);
     if (!read.ok) {
         return read.response;
@@ -96,10 +100,32 @@ export function answerAbsentRequest(contracts, received) {
             ? unmounted(read.requestId)
             : transportFailure("A2012", read.requestId, GET_ONLY);
     }
-    const route = path === TRANSACTIONS_ROUTE
-        ? checkTransactionsRoute(contracts, read)
-        : checkOperationRoute(contracts, read);
-    return route.ok ? unmounted(read.requestId) : route.response;
+    if (path === TRANSACTIONS_ROUTE) {
+        const route = checkTransactionsRoute(contracts, read, origin);
+        if (!route.ok) {
+            return route.response;
+        }
+        createReporter(sink, {
+            kind: "transaction",
+            origin,
+            requestId: read.requestId,
+        })(new AvUnmountedRouteError("transactions", `POST ${TRANSACTIONS_ROUTE}`), "A3000");
+        return unmounted(read.requestId);
+    }
+    const route = checkOperationRoute(contracts, read, origin);
+    if (!route.ok) {
+        return route.response;
+    }
+    const { family, variant } = route.operation;
+    createReporter(sink, {
+        kind: "operation",
+        origin,
+        resource: route.resource,
+        family,
+        variant,
+        requestId: read.requestId,
+    })(new AvUnmountedRouteError(`${route.resource}.${family}.${variant}`, `POST ${path}`), "A3000");
+    return unmounted(read.requestId);
 }
 function unmounted(requestId) {
     return encodeOperationResponse(operationFailure("A3000", { message: INTERNAL_FAILURE_MESSAGE }), 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,5 +70,11 @@ 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
+ * could hold it; it is exported from no entry point.
+ */
+export declare function isParsedByDecoder(value: unknown): boolean;
 export {};

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: {
-                scope: "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: {
-                scope: "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 };
@@ -85,7 +85,15 @@ function bodyValue(body, contentType, maxRequestBytes) {
     catch {
         return "A2000";
     }
-    return isJsonObject(value) ? { value } : "A2000";
+    if (!isJsonObject(value)) {
+        return "A2000";
+    }
+    PARSED_HERE.add(value);
+    return { value };
+}
+const PARSED_HERE = new WeakSet();
+export function isParsedByDecoder(value) {
+    return typeof value === "object" && value !== null && PARSED_HERE.has(value);
 }
 function isJsonMediaType(contentType) {
     return (contentType

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;

package/dist/protocol/protocol-surface.d.ts

@@ -1,5 +1,5 @@
-import type { ClientContract } from "../contracts/contract.js";
-import { type OperationIdentity } from "../operations/operation-identity.js";
+import type { AvContractClient } from "../contracts/contract.js";
+import { type AvOperationIdentity } from "../operations/operation-identity.js";
 /**
  * One route of the protocol surface: a route a host mounts for the bound
  * ClientContract, tagged by `kind`.
@@ -9,7 +9,7 @@ export type SurfaceRoute = ({
     readonly method: "POST";
     readonly path: `/_resources/${string}`;
     readonly resource: string;
-} & OperationIdentity) | {
+} & AvOperationIdentity) | {
     readonly kind: "contract";
     readonly method: "GET";
     readonly path: "/_contract";
@@ -24,4 +24,4 @@ export type SurfaceRoute = ({
  * order, then `GET /_contract`, then `POST /_transactions` when, and only when,
  * `transactions === "interactive"`.
  */
-export declare function surfaceOf(client: ClientContract): readonly SurfaceRoute[];
+export declare function surfaceOf(client: AvContractClient): readonly SurfaceRoute[];