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

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";
 /**
@@ -6,14 +6,15 @@ import type { AvProtocolResponse } from "./http-response.encoder.js";
  * entity tag, the quoted contract hash. The bytes include `protocol.hash`, although
  * the hash's own input excludes it.
  */
-export type ContractDocument = {
+type ContractDocument = {
     readonly body: string;
     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;
+export {};

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 { AvRequestProtocol, RemoteOperationRequest } from "../runtime/operation-request.js";
+import type { AvAgentTransactionRequest, AvClientTransactionRequest } from "../transactions/transaction-request.js";
 import type { AvProtocolResponse } from "./http-response.encoder.js";
 /** One HTTP request as a host hands it to the protocol. */
 export type AvProtocolRequest = {
     /** 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<AvClientTransactionRequest | AvAgentTransactionRequest>;
 /**
  * `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,23 @@ 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;
+/** A `/_access/can` request as core answers it: its origin, identity and body. */
+type DecodedCanRequest = {
+    readonly origin: RemoteRequestOrigin;
+    readonly requestId: string;
+    readonly protocol: AvRequestProtocol;
+    /** The body, a JSON object: `{ questions }`, read by core. */
+    readonly body: object;
+};
+/**
+ * The `/_access/can` request as the request core answers, or its answer: the same
+ * steps as {@link decodeTransactionRequest}, with the path exactly `/_access/can`
+ * and its absence being a Contract without its `access` section. The body is read
+ * as a JSON object and handed to core verbatim; its `questions` are core's to
+ * judge.
+ */
+export declare function decodeCanRequest(contracts: AvContracts, received: AvProtocolRequest, origin?: RemoteRequestOrigin): Decoded<DecodedCanRequest>;
 /**
  * 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

@@ -1,22 +1,22 @@
-import { checkOperationRoute, checkTransactionsRoute, } from "./absent-route.responder.js";
+import { checkAccessCanRoute, checkOperationRoute, checkTransactionsRoute, } from "./absent-route.responder.js";
 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),
@@ -52,14 +52,37 @@ export function decodeTransactionRequest(contracts, received) {
         }
         : refused(body.response, read.requestId);
 }
+export function decodeCanRequest(contracts, received, origin = "client") {
+    const read = readRequest(received);
+    if (!read.ok) {
+        return read;
+    }
+    const route = checkAccessCanRoute(contracts, read, origin);
+    if (!route.ok) {
+        return refused(route.response, read.requestId);
+    }
+    const body = readBody(read, contracts, origin);
+    return body.ok
+        ? {
+            ok: true,
+            request: {
+                origin,
+                requestId: read.requestId,
+                protocol: route.protocol,
+                body: body.value,
+            },
+            requestId: read.requestId,
+        }
+        : refused(body.response, read.requestId);
+}
 function refused(response, requestId) {
     return { ok: false, 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

@@ -1,10 +1,12 @@
-import type { ClientProtocolIdentity } from "../runtime/operation-request.js";
+import type { AvRequestProtocol } from "../runtime/operation-request.js";
 import type { OperationRouteSegments } from "./absent-route.responder.js";
 import type { AvProtocolRequest } from "./http-request.decoder.js";
 import type { AvProtocolResponse } from "./http-response.encoder.js";
-/** `POST <entrypoint>/_transactions`. */
+/** `POST <api>/_transactions`. */
 export declare const TRANSACTIONS_ROUTE = "/_transactions";
-/** `GET <entrypoint>/_contract`. */
+/** `POST <api>/_access/can`. */
+export declare const ACCESS_CAN_ROUTE = "/_access/can";
+/** `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 +14,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;
@@ -25,10 +27,10 @@ export type ReadRequest = {
     /** Adopted from `Aventara-Request-Id`, else minted. */
     readonly requestId: string;
     /** `undefined` when either identity header is absent (`A2000`). */
-    readonly protocol: ClientProtocolIdentity | undefined;
+    readonly protocol: AvRequestProtocol | undefined;
 };
 /** What a value that is not an `AvProtocolRequest` reads as. */
-export type UnreadableRequest = {
+type UnreadableRequest = {
     readonly ok: false;
     readonly response: AvProtocolResponse;
     readonly requestId: string;
@@ -43,3 +45,4 @@ export declare function readRequest(received: unknown): ReadRequest | Unreadable
  * `undefined` when it is not one.
  */
 export declare function operationRouteSegments(path: string): OperationRouteSegments | undefined;
+export {};

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

@@ -3,6 +3,7 @@ import { transportFailure } from "./protocol-failure.js";
 import { adoptedRequestId, normalizeHeaders, protocolIdentityOf, } from "./protocol-headers.js";
 const OPERATION_ROUTE = /^\/_resources\/([^/]*)\/([^/]*)\/([^/]*)$/;
 export const TRANSACTIONS_ROUTE = "/_transactions";
+export const ACCESS_CAN_ROUTE = "/_access/can";
 export const CONTRACT_ROUTE = "/_contract";
 export const POST_ONLY = Object.freeze(["POST"]);
 export const GET_ONLY = Object.freeze(["GET"]);

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 { isAvDecimal } from "../runtime/decimal.js";
 import { SERIALIZATION_FAILURE_MESSAGE } from "../runtime/error-boundary.js";
 import { operationFailure, } from "../runtime/operation-response.js";
 import { httpStatus } from "./http-status.table.js";
 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 (isAvDecimal(value)) {
+        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-headers.d.ts

@@ -1,4 +1,4 @@
-import type { ClientProtocolIdentity } from "../runtime/operation-request.js";
+import type { AvRequestProtocol } from "../runtime/operation-request.js";
 /** `AvProtocol.headers` — the header names the protocol owns, as passive data. */
 export declare const headers: Readonly<{
     readonly protocolVersion: "Aventara-Protocol-Version";
@@ -22,11 +22,11 @@ export declare function normalizeHeaders(received: ReceivedHeaders): Readonly<Re
  */
 export declare function headerValue(normalized: Readonly<Record<string, string>>, name: string): string | undefined;
 /**
- * The identity headers as the `ClientProtocolIdentity` core checks, or `undefined`
+ * The identity headers as the `AvRequestProtocol` core checks, or `undefined`
  * when either is ABSENT — a request without them is malformed: it does not say which
  * protocol and ClientContract it speaks, so there is nothing to compare.
  */
-export declare function protocolIdentityOf(normalized: Readonly<Record<string, string>>): ClientProtocolIdentity | undefined;
+export declare function protocolIdentityOf(normalized: Readonly<Record<string, string>>): AvRequestProtocol | undefined;
 /**
  * The identity headers a request did not send, in the order the framework sends them —
  * what the `A2000` answering it names. Empty exactly when {@link protocolIdentityOf}

package/dist/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";
@@ -17,11 +17,16 @@ export type SurfaceRoute = ({
     readonly kind: "transactions";
     readonly method: "POST";
     readonly path: "/_transactions";
+} | {
+    readonly kind: "can";
+    readonly method: "POST";
+    readonly path: "/_access/can";
 };
 /**
  * The route list of one ClientContract: every route a host mounts, from one list,
  * deep-frozen — exactly the advertised operation triples in the Contract's own key
  * order, then `GET /_contract`, then `POST /_transactions` when, and only when,
- * `transactions === "interactive"`.
+ * `transactions === "interactive"`, then `POST /_access/can` when, and only when,
+ * the Contract has its `access` section.
  */
-export declare function surfaceOf(client: ClientContract): readonly SurfaceRoute[];
+export declare function surfaceOf(client: AvContractClient): readonly SurfaceRoute[];

package/dist/protocol/protocol-surface.js

@@ -37,5 +37,12 @@ export function surfaceOf(client) {
             path: "/_transactions",
         }));
     }
+    if (client.access !== undefined) {
+        routes.push(Object.freeze({
+            kind: "can",
+            method: "POST",
+            path: "/_access/can",
+        }));
+    }
     return Object.freeze(routes);
 }