@procedures/client 0.2.2 → 0.3.0

package/dist/tracing/traceparent.d.ts

@@ -0,0 +1,26 @@
+/**
+ * The W3C trace context (roadmap R16): `traceparent` is `00-<trace id>-<span id>-<flags>`, with a
+ * trace id of 32 hex digits and a span id of 16. The tracing middleware of a client sends it in
+ * the metadata of a call (and HTTP as the `traceparent` header). The tracing interceptor of a
+ * server continues that trace, and gives it to the nested calls, so one trace goes from the
+ * client to the last handler. Before, the client and the server made two traces.
+ */
+/** The metadata key of the W3C trace context of a call. */
+export declare const TRACEPARENT_METADATA_KEY = "traceparent";
+/** A trace context: the trace, the span of the caller, and the sampled flag. */
+export interface TraceContext {
+    readonly traceId: string;
+    readonly spanId: string;
+    readonly sampled: boolean;
+}
+/** This function makes a new trace id: 32 random hex digits. */
+export declare function newTraceId(): string;
+/** This function makes a new span id: 16 random hex digits. */
+export declare function newSpanId(): string;
+/** True when the ids have the W3C form. */
+export declare function isW3cIds(traceId: string, spanId: string): boolean;
+/** The `traceparent` of a trace and a span. */
+export declare function formatTraceparent(traceId: string, spanId: string, sampled?: boolean): string;
+/** The trace context of a `traceparent` value, or undefined when it is not valid. */
+export declare function parseTraceparent(value: unknown): TraceContext | undefined;
+//# sourceMappingURL=traceparent.d.ts.map

package/dist/tracing/traceparent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"traceparent.d.ts","sourceRoot":"","sources":["../../src/tracing/traceparent.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,2DAA2D;AAC3D,eAAO,MAAM,wBAAwB,gBAAgB,CAAC;AAMtD,gFAAgF;AAChF,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;CAC3B;AAUD,gEAAgE;AAChE,wBAAgB,UAAU,IAAI,MAAM,CAGnC;AAED,+DAA+D;AAC/D,wBAAgB,SAAS,IAAI,MAAM,CAGlC;AAED,2CAA2C;AAC3C,wBAAgB,QAAQ,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAEjE;AAED,+CAA+C;AAC/C,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,UAAO,GAAG,MAAM,CAEzF;AAED,qFAAqF;AACrF,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,OAAO,GAAG,YAAY,GAAG,SAAS,CAOzE"}

package/dist/tracing/traceparent.js

@@ -0,0 +1,53 @@
+/**
+ * The W3C trace context (roadmap R16): `traceparent` is `00-<trace id>-<span id>-<flags>`, with a
+ * trace id of 32 hex digits and a span id of 16. The tracing middleware of a client sends it in
+ * the metadata of a call (and HTTP as the `traceparent` header). The tracing interceptor of a
+ * server continues that trace, and gives it to the nested calls, so one trace goes from the
+ * client to the last handler. Before, the client and the server made two traces.
+ */
+/** The metadata key of the W3C trace context of a call. */
+export const TRACEPARENT_METADATA_KEY = "traceparent";
+const TRACEPARENT = /^00-([0-9a-f]{32})-([0-9a-f]{16})-([0-9a-f]{2})$/;
+const ZERO_TRACE = "0".repeat(32);
+const ZERO_SPAN = "0".repeat(16);
+function randomHex(bytes) {
+    const values = new Uint8Array(bytes);
+    const crypto = globalThis.crypto;
+    if (crypto?.getRandomValues)
+        crypto.getRandomValues(values);
+    else
+        for (let index = 0; index < bytes; index++)
+            values[index] = Math.floor(Math.random() * 256);
+    return Array.from(values, (value) => value.toString(16).padStart(2, "0")).join("");
+}
+/** This function makes a new trace id: 32 random hex digits. */
+export function newTraceId() {
+    const id = randomHex(16);
+    return id === ZERO_TRACE ? newTraceId() : id;
+}
+/** This function makes a new span id: 16 random hex digits. */
+export function newSpanId() {
+    const id = randomHex(8);
+    return id === ZERO_SPAN ? newSpanId() : id;
+}
+/** True when the ids have the W3C form. */
+export function isW3cIds(traceId, spanId) {
+    return /^[0-9a-f]{32}$/.test(traceId) && /^[0-9a-f]{16}$/.test(spanId) && traceId !== ZERO_TRACE && spanId !== ZERO_SPAN;
+}
+/** The `traceparent` of a trace and a span. */
+export function formatTraceparent(traceId, spanId, sampled = true) {
+    return `00-${traceId}-${spanId}-${sampled ? "01" : "00"}`;
+}
+/** The trace context of a `traceparent` value, or undefined when it is not valid. */
+export function parseTraceparent(value) {
+    if (typeof value !== "string")
+        return undefined;
+    const match = TRACEPARENT.exec(value.trim().toLowerCase());
+    if (!match)
+        return undefined;
+    const [, traceId, spanId, flags] = match;
+    if (traceId === ZERO_TRACE || spanId === ZERO_SPAN)
+        return undefined;
+    return { traceId: traceId, spanId: spanId, sampled: (parseInt(flags, 16) & 1) === 1 };
+}
+//# sourceMappingURL=traceparent.js.map

package/dist/tracing/traceparent.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"traceparent.js","sourceRoot":"","sources":["../../src/tracing/traceparent.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,2DAA2D;AAC3D,MAAM,CAAC,MAAM,wBAAwB,GAAG,aAAa,CAAC;AAEtD,MAAM,WAAW,GAAG,kDAAkD,CAAC;AACvE,MAAM,UAAU,GAAG,GAAG,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;AAClC,MAAM,SAAS,GAAG,GAAG,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;AASjC,SAAS,SAAS,CAAC,KAAa;IAC9B,MAAM,MAAM,GAAG,IAAI,UAAU,CAAC,KAAK,CAAC,CAAC;IACrC,MAAM,MAAM,GAAI,UAAmF,CAAC,MAAM,CAAC;IAC3G,IAAI,MAAM,EAAE,eAAe;QAAE,MAAM,CAAC,eAAe,CAAC,MAAM,CAAC,CAAC;;QACvD,KAAK,IAAI,KAAK,GAAG,CAAC,EAAE,KAAK,GAAG,KAAK,EAAE,KAAK,EAAE;YAAE,MAAM,CAAC,KAAK,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,EAAE,GAAG,GAAG,CAAC,CAAC;IACjG,OAAO,KAAK,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC,QAAQ,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;AACrF,CAAC;AAED,gEAAgE;AAChE,MAAM,UAAU,UAAU;IACxB,MAAM,EAAE,GAAG,SAAS,CAAC,EAAE,CAAC,CAAC;IACzB,OAAO,EAAE,KAAK,UAAU,CAAC,CAAC,CAAC,UAAU,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;AAC/C,CAAC;AAED,+DAA+D;AAC/D,MAAM,UAAU,SAAS;IACvB,MAAM,EAAE,GAAG,SAAS,CAAC,CAAC,CAAC,CAAC;IACxB,OAAO,EAAE,KAAK,SAAS,CAAC,CAAC,CAAC,SAAS,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;AAC7C,CAAC;AAED,2CAA2C;AAC3C,MAAM,UAAU,QAAQ,CAAC,OAAe,EAAE,MAAc;IACtD,OAAO,gBAAgB,CAAC,IAAI,CAAC,OAAO,CAAC,IAAI,gBAAgB,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,OAAO,KAAK,UAAU,IAAI,MAAM,KAAK,SAAS,CAAC;AAC3H,CAAC;AAED,+CAA+C;AAC/C,MAAM,UAAU,iBAAiB,CAAC,OAAe,EAAE,MAAc,EAAE,OAAO,GAAG,IAAI;IAC/E,OAAO,MAAM,OAAO,IAAI,MAAM,IAAI,OAAO,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC;AAC5D,CAAC;AAED,qFAAqF;AACrF,MAAM,UAAU,gBAAgB,CAAC,KAAc;IAC7C,IAAI,OAAO,KAAK,KAAK,QAAQ;QAAE,OAAO,SAAS,CAAC;IAChD,MAAM,KAAK,GAAG,WAAW,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,WAAW,EAAE,CAAC,CAAC;IAC3D,IAAI,CAAC,KAAK;QAAE,OAAO,SAAS,CAAC;IAC7B,MAAM,CAAC,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,CAAC,GAAG,KAAK,CAAC;IACzC,IAAI,OAAO,KAAK,UAAU,IAAI,MAAM,KAAK,SAAS;QAAE,OAAO,SAAS,CAAC;IACrE,OAAO,EAAE,OAAO,EAAE,OAAQ,EAAE,MAAM,EAAE,MAAO,EAAE,OAAO,EAAE,CAAC,QAAQ,CAAC,KAAM,EAAE,EAAE,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC,EAAE,CAAC;AAC3F,CAAC"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package",
   "name": "@procedures/client",
-  "version": "0.2.2",
+  "version": "0.3.0",
   "description": "Procedures as data for TypeScript: define typed procedures once and call them in process, over HTTP, WebSocket, the CLI or MCP. Streaming, middleware, retries, caching and a JSON program format.",
   "keywords": [
     "rpc",
@@ -90,14 +90,20 @@
     "provenance": true
   },
   "dependencies": {
+    "@mark1russell7/algebra": "^0.5.0",
+    "@mark1russell7/quantity": "^0.2.0",
+    "@mark1russell7/service": "^0.4.0",
     "ws": "^8.18.3",
     "zod": "^4.6.5"
   },
   "devDependencies": {
     "@mark1russell7/cue": "^1.0.0",
+    "@stryker-mutator/core": "10.0.0",
+    "@stryker-mutator/vitest-runner": "10.0.0",
     "@types/express": "^5.0.0",
     "@types/node": "^22.0.0",
     "@types/ws": "^8.18.1",
+    "fast-check": "^4.10.2",
     "typescript": "^7.0.2",
     "vitest": "^5.0.3"
   },

package/src/adapters/http/client/transport.ts

@@ -12,6 +12,21 @@ import type {
 } from "../../../client/types.js";
 
 import type { HttpTransportOptions } from "./types.js";
+import { DELIVERY_METADATA_KEY, RETRY_AFTER_METADATA_KEY, isNotSentError } from "../../../client/middleware/items.js";
+
+/**
+ * The wait that an error response asks for, in milliseconds: `retryAfterMs` of the body of the
+ * server transport, or else the Retry-After header (seconds, or an HTTP date).
+ */
+function retryAfterMsOf(header: string | null, body: unknown): number | undefined {
+  const fromBody = (body as { retryAfterMs?: unknown } | null | undefined)?.retryAfterMs;
+  if (typeof fromBody === "number" && Number.isFinite(fromBody) && fromBody >= 0) return fromBody;
+  if (header === null || header.trim() === "") return undefined;
+  const seconds = Number(header);
+  if (Number.isFinite(seconds) && seconds >= 0) return seconds * 1000;
+  const date = Date.parse(header);
+  return Number.isNaN(date) ? undefined : Math.max(0, date - Date.now());
+}
 
 /** The media type of a stream response: one JSON value on each line. */
 const NDJSON = "application/x-ndjson";
@@ -32,6 +47,8 @@ import {
   createAbortError,
   createErrorFromException,
 } from "../shared/index.js";
+import { optionalMs } from "../../../duration.js";
+import { PROTOCOL_HEADER, PROTOCOL_VERSION } from "../../../protocol.js";
 
 /**
  * HTTP Client Transport
@@ -74,7 +91,7 @@ export class HttpTransport implements Transport {
     this.headerConverter =
       options.headerConverter || createDefaultHeaderConverter();
     this.defaultHeaders = options.defaultHeaders || {};
-    this.timeout = options.timeout;
+    this.timeout = optionalMs(options.timeout, "timeout");
   }
 
   /**
@@ -123,6 +140,8 @@ export class HttpTransport implements Transport {
           [HTTPHeaders.CONTENT_TYPE]: "application/json",
           // A streaming procedure answers with NDJSON; other procedures with JSON
           Accept: `${NDJSON}, application/json`,
+          // The protocol version of this client (roadmap R25)
+          [PROTOCOL_HEADER]: String(PROTOCOL_VERSION),
           ...this.defaultHeaders,
           ...metadataHeaders,
         },
@@ -153,6 +172,13 @@ export class HttpTransport implements Transport {
       // the client kept only the HTTP status ("HTTP 500").
       const status = this.httpStatusToUniversal(response.status as HTTPStatus, responseBody);
       finished = true;
+      if (status.type === "error") {
+        const retryAfter = retryAfterMsOf(response.headers.get("Retry-After"), responseBody);
+        if (retryAfter !== undefined) metadata[RETRY_AFTER_METADATA_KEY] = retryAfter;
+        // The reason of a FORBIDDEN error (roadmap R25)
+        const reason = (responseBody as { reason?: unknown } | null | undefined)?.reason;
+        if (typeof reason === "string") metadata["reason"] = reason;
+      }
 
       // Yield single response item
       yield {
@@ -183,7 +209,9 @@ export class HttpTransport implements Transport {
           retryable: errorDetails.retryable,
         },
         payload: null as TRes,
-        metadata: {},
+        // A refused connection sent nothing. After a reset or a timeout, the server can have
+        // the request, so only an idempotent call can go again (R1).
+        metadata: { [DELIVERY_METADATA_KEY]: isNotSentError(error) ? "not-sent" : "indeterminate" },
       };
     } finally {
       if (timeoutId) clearTimeout(timeoutId);
@@ -251,7 +279,7 @@ export class HttpTransport implements Transport {
         id,
         status: { type: "error", code: "STREAM_ENDED", message: "The stream ended without its end line", retryable: true },
         payload: null as TRes,
-        metadata,
+        metadata: { ...metadata, [DELIVERY_METADATA_KEY]: "indeterminate" },
       };
     } finally {
       reader.releaseLock();

package/src/adapters/http/client/types.ts

@@ -6,6 +6,7 @@
  */
 
 import type { UrlStrategy, HttpMethodStrategy, HeaderConverter } from "../shared/index.js";
+import type { Duration } from "../../../duration.js";
 
 /**
  * HTTP Client Transport Configuration
@@ -28,6 +29,6 @@ export interface HttpTransportOptions {
   /** Default headers applied to all requests */
   defaultHeaders?: Record<string, string>;
 
-  /** Timeout for fetch requests (milliseconds) */
-  timeout?: number;
+  /** The time to the first item of a response, for example `seconds(30)` */
+  timeout?: Duration;
 }

package/src/adapters/http/server/transport.ts

@@ -10,16 +10,23 @@ import { createServer } from "http";
 import type { Server as HttpServer } from "http";
 import type { ServerTransport, ServerRequest, ServerResponse } from "../../../server/types.js";
 import type { Metadata } from "../../../client/types.js";
-import type { Server } from "../../../server/index.js";
+import type { RequestHandler } from "../../../server/types.js";
 import { HTTPMethod, HTTPHeaders, decodeMetadataHeader, METADATA_HEADER_LIMIT } from "../shared/index.js";
 import { ERROR_REGISTRY } from "../../../client/errors/index.js";
 import type { HttpServerTransportOptions } from "./types.js";
 import { createPatternServerUrlStrategy } from "./strategies.js";
 import { checkBrowserRequest, type BrowserGuardOptions } from "../../../server/browser-guard.js";
+import { bearerOf, withoutSecretHeaders } from "../../../server/request-auth.js";
+import { PROTOCOL_HEADER, PROTOCOL_VERSION, httpStatusOf, protocolVersionOf } from "../../../protocol.js";
 
 /** The media type of a stream response: one JSON value on each line. */
 const NDJSON = "application/x-ndjson";
 
+/** True when a stream response can run without an end (`STREAM_METADATA_KEY` of procedure-server.ts). */
+function isUnboundedStream(response: { metadata?: Record<string, unknown> | undefined }): boolean {
+  return response.metadata?.["stream"] === "unbounded";
+}
+
 /** The metadata keys that the transport sets: a query parameter or a header cannot replace them. */
 const RESERVED_METADATA = new Set(["headers", "query", "params"]);
 
@@ -64,24 +71,6 @@ function write(res: Response, chunk: string, signal: AbortSignal): Promise<void>
   });
 }
 
-/**
- * The HTTP status of the error codes of a procedure invocation (they are not in the error
- * registry, so before, a validation error was a 500).
- */
-const INVOCATION_HTTP_STATUS: Record<string, number> = {
-  VALIDATION_ERROR: 400,
-  NOT_EXPOSED: 403,
-  NOT_DECLARED: 403,
-  FORBIDDEN: 403,
-  NOT_FOUND: 404,
-  NO_HANDLER: 404,
-  ABORTED: 499,
-  TIMEOUT: 504,
-  OUTPUT_VALIDATION_ERROR: 500,
-  NO_OUTPUT: 500,
-  HANDLER_ERROR: 500,
-};
-
 /**
  * HTTP server transport adapter for Express.
  *
@@ -126,7 +115,7 @@ export class HttpServerTransport implements ServerTransport {
     corsOptions: HttpServerTransportOptions["corsOptions"] | undefined;
     httpServer: HttpServer | undefined;
   };
-  private server: Server;
+  private server: RequestHandler;
   /** The controllers of the requests in progress: stop() aborts them (deep dive TRN-15) */
   private openRequests = new Set<AbortController>();
   private stopped = false;
@@ -134,7 +123,7 @@ export class HttpServerTransport implements ServerTransport {
   /** The browser checks of each procedure call (see `server/browser-guard.ts`) */
   private readonly guard: BrowserGuardOptions;
 
-  constructor(server: Server, options: HttpServerTransportOptions = {}) {
+  constructor(server: RequestHandler, options: HttpServerTransportOptions = {}) {
     this.server = server;
     const basePath = options.basePath ?? "/api";
     this.options = {
@@ -198,7 +187,8 @@ export class HttpServerTransport implements ServerTransport {
           HTTPHeaders.TRACE_ID,
           HTTPHeaders.SPAN_ID,
           HTTPHeaders.PARENT_SPAN_ID,
-          HTTPHeaders.TIMEOUT,
+          "traceparent",
+          PROTOCOL_HEADER,
           HTTPHeaders.METADATA,
           "collection",
           "collectionName",
@@ -256,6 +246,18 @@ export class HttpServerTransport implements ServerTransport {
    * Converts to unified RPC format, processes, and sends response.
    */
   private async handleHttpRequest(req: Request, res: Response): Promise<void> {
+    // The protocol version of this server, on each response (roadmap R25)
+    res.setHeader(PROTOCOL_HEADER, String(PROTOCOL_VERSION));
+    const version = protocolVersionOf(req.headers[PROTOCOL_HEADER.toLowerCase()]);
+    if (version !== undefined && version > PROTOCOL_VERSION) {
+      res.status(400).json({
+        error: `This server speaks the protocol ${PROTOCOL_VERSION}, and the request uses ${version}`,
+        code: "PROTOCOL_VERSION",
+        retryable: false,
+        protocol: PROTOCOL_VERSION,
+      });
+      return;
+    }
     if (this.stopped) {
       res.status(503).json({ error: "Server stopped", code: "SERVER_STOPPED", retryable: true });
       return;
@@ -360,6 +362,26 @@ export class HttpServerTransport implements ServerTransport {
   ): Promise<void> {
     const ndjson = String(req.headers.accept ?? "").includes(NDJSON);
 
+    if (!ndjson && isUnboundedStream(response)) {
+      // The last item of a stream without an end never comes: refuse the call, and end the stream
+      // (roadmap R15: before, the request waited until a timeout)
+      void Promise.resolve(stream[Symbol.asyncIterator]().return?.()).catch(() => undefined);
+      this.serverResponseToHttp(
+        {
+          id: response.id,
+          status: {
+            type: "error",
+            code: "NOT_ACCEPTABLE",
+            message: `This procedure gives a stream that can run without an end. Send "Accept: ${NDJSON}" to read its items.`,
+            retryable: false,
+          },
+          metadata: {},
+        },
+        res
+      );
+      return;
+    }
+
     if (!ndjson) {
       let last: { value: unknown } | undefined;
       try {
@@ -424,11 +446,14 @@ export class HttpServerTransport implements ServerTransport {
     const id =
       (req.headers["x-request-id"] as string) ??
       `req-${Date.now()}-${Math.random()}`;
+    const bearer = bearerOf(req.headers["authorization"]);
 
     // Build metadata from headers and query params. The flattened query parameters cannot
     // replace headers, query or params (before, "?headers=x" replaced metadata.headers).
+    // The headers without the secrets: the credentials go in request.credentials, not in the
+    // metadata, so a handler and a nested call do not see them (roadmap R18)
     const metadata: Metadata = {
-      headers: req.headers as Record<string, string>,
+      headers: withoutSecretHeaders(req.headers as Record<string, string>),
       query: req.query,
       params: req.params,
     };
@@ -505,6 +530,8 @@ export class HttpServerTransport implements ServerTransport {
       method,
       payload,
       metadata,
+      // A network request: ProcedureServer examines the token (roadmap R18)
+      credentials: bearer === undefined ? {} : { bearer },
     };
   }
 
@@ -524,7 +551,7 @@ export class HttpServerTransport implements ServerTransport {
       // HTTP status via the error registry rather than parseInt (which yields NaN -> 500, so every
       // error became a 500). See documentation/BUGS-2026-07.md (M7).
       const mapped =
-        INVOCATION_HTTP_STATUS[status.code] ??
+        httpStatusOf(status.code) ??
         (ERROR_REGISTRY as Record<string, { httpStatus?: number }>)[status.code]?.httpStatus;
       httpStatusCode = mapped ?? (status.type === "success" ? 200 : 500);
     } else if (typeof status.code === "number") {
@@ -551,10 +578,19 @@ export class HttpServerTransport implements ServerTransport {
       }
       res.json(payload);
     } else {
+      // The wait that the error asks for: a Retry-After header in seconds, and the exact
+      // milliseconds in the body (R12)
+      const retryAfterMs = metadata["retry-after"];
+      const hasRetryAfter = typeof retryAfterMs === "number" && Number.isFinite(retryAfterMs) && retryAfterMs >= 0;
+      if (hasRetryAfter) res.setHeader("Retry-After", String(Math.ceil(retryAfterMs / 1000)));
+      // The reason of a FORBIDDEN error travels on each face (roadmap R25)
+      const reason = typeof metadata["reason"] === "string" ? metadata["reason"] : undefined;
       res.json({
         error: status.message,
         code: status.code,
         retryable: status.retryable,
+        ...(hasRetryAfter ? { retryAfterMs } : {}),
+        ...(reason !== undefined ? { reason } : {}),
       });
     }
   }

package/src/adapters/http/shared/headers.ts

@@ -95,7 +95,7 @@ export interface HeaderConverter {
  * Implements standard conventions for converting metadata to headers:
  * - Auth: Bearer token, API key
  * - Tracing: X-Trace-Id, X-Span-Id format
- * - Timeouts: X-Timeout header
+ * - The deadline: `procedure-timeout` in X-Metadata (no X-Timeout header)
  * - Custom fields: Pass through as-is
  */
 export class DefaultHeaderConverter implements HeaderConverter {
@@ -120,7 +120,10 @@ export class DefaultHeaderConverter implements HeaderConverter {
       headers[HTTPHeaders.API_KEY] = metadata.auth.apiKey;
     }
 
-    // Distributed Tracing
+    // Distributed Tracing: the W3C trace context, and the older headers (roadmap R16)
+    if (typeof metadata["traceparent"] === "string") {
+      headers["traceparent"] = metadata["traceparent"];
+    }
     if (metadata.tracing?.traceId) {
       headers[HTTPHeaders.TRACE_ID] = metadata.tracing.traceId;
     }
@@ -131,10 +134,8 @@ export class DefaultHeaderConverter implements HeaderConverter {
       headers[HTTPHeaders.PARENT_SPAN_ID] = metadata.tracing.parentSpanId;
     }
 
-    // Timeouts
-    if (metadata.timeout?.overall) {
-      headers[HTTPHeaders.TIMEOUT] = String(metadata.timeout.overall);
-    }
+    // No X-Timeout: the remaining time of the deadline goes as procedure-timeout in X-Metadata,
+    // which the server uses (roadmap R10). The server ignored X-Timeout.
 
     const custom: Record<string, unknown> = {};
     for (const [key, value] of Object.entries(metadata)) {

package/src/adapters/local/client/transport.ts

@@ -9,9 +9,41 @@ import type { Handler, LocalTransportOptions } from "./types.js";
 import { methodKey } from "./types.js";
 import type { ProcedureRegistry } from "../../../procedures/registry.js";
 import type { AnyProcedure } from "../../../procedures/types.js";
-import { InvocationError, invokeProcedure, isAsyncIterable } from "../../../procedures/invoke.js";
+import { InvocationError, invokeProcedure, isAsyncIterable, type Interceptor } from "../../../procedures/invoke.js";
+import { TIMEOUT_METADATA_KEY } from "../../../client/deadline.js";
+import { narrowCapability } from "../../../procedures/capability.js";
+import type { Capability, ClearanceOrder } from "../../../procedures/types.js";
 import { methodToPath } from "../../../server/method.js";
 
+/** The value of `untilAborted` when the signal aborts first. */
+const ABORTED: unique symbol = Symbol("aborted");
+
+/** The value of a promise, or ABORTED when the signal aborts first. The promise runs on. */
+function untilAborted<T>(promise: Promise<T>, signal: AbortSignal | undefined): Promise<T | typeof ABORTED> {
+  if (!signal) return promise;
+  if (signal.aborted) {
+    promise.catch(() => undefined);
+    return Promise.resolve(ABORTED);
+  }
+  return new Promise((resolve, reject) => {
+    const onAbort = (): void => {
+      promise.catch(() => undefined);
+      resolve(ABORTED);
+    };
+    signal.addEventListener("abort", onAbort, { once: true });
+    promise.then(
+      (value) => {
+        signal.removeEventListener("abort", onAbort);
+        resolve(value);
+      },
+      (error: unknown) => {
+        signal.removeEventListener("abort", onAbort);
+        reject(error);
+      },
+    );
+  });
+}
+
 function successItem<TRes>(id: string, payload: unknown): ResponseItem<TRes> {
   return { id, status: { type: "success", code: 200 }, payload: payload as TRes, metadata: {} };
 }
@@ -53,10 +85,16 @@ export class LocalTransport implements Transport {
   private readonly handlers = new Map<string, Handler>();
   private readonly throwOnMissing: boolean;
   private readonly registry: ProcedureRegistry | undefined;
+  private readonly interceptors: readonly Interceptor[] | undefined;
+  private readonly capability: Capability | undefined;
+  private readonly clearanceOrder: ClearanceOrder | undefined;
 
   constructor(options: LocalTransportOptions = {}) {
     this.throwOnMissing = options.throwOnMissing !== false;
     this.registry = options.registry;
+    this.interceptors = options.interceptors;
+    this.capability = options.capability;
+    this.clearanceOrder = options.clearanceOrder;
 
     // Register pre-configured handlers. A key without a version ("users.get") gets the
     // empty version, as methodKey() makes it: before, such a key was never found.
@@ -136,21 +174,44 @@ export class LocalTransport implements Transport {
       let values: AsyncIterable<unknown> | undefined;
       let value: unknown;
       if (procedure) {
-        const output = await invokeProcedure(procedure, message.payload, {
+        // The interceptors, the capability and the deadline of the call, as on a server (R14)
+        const timeoutMs = message.metadata[TIMEOUT_METADATA_KEY];
+        const capability =
+          typeof timeoutMs === "number" && Number.isFinite(timeoutMs) && timeoutMs >= 0
+            ? narrowCapability(this.capability, { timeoutMs }, this.clearanceOrder)
+            : this.capability;
+        const output = await untilAborted(invokeProcedure(procedure, message.payload, {
           registry: this.registry,
           metadata: message.metadata,
           signal: message.signal,
-        });
+          ...(this.interceptors ? { interceptors: this.interceptors } : {}),
+          ...(capability ? { capability } : {}),
+          ...(this.clearanceOrder ? { clearanceOrder: this.clearanceOrder } : {}),
+        }), message.signal);
+        if (output === ABORTED) {
+          // The caller stops waiting at once, as over HTTP and WebSocket (the conformance suite
+          // of roadmap R18 found this: before, a local call waited for its handler)
+          yield errorItem<TRes>(message.id, "ABORTED", "Request was aborted");
+          return;
+        }
         if (output.kind === "stream") values = output.items;
         else value = output.value;
       } else {
         // Execute handler (may be sync, async or an async generator)
-        const result = await handler!(message.payload, message);
+        const result = await untilAborted(Promise.resolve(handler!(message.payload, message)), message.signal);
+        if (result === ABORTED) {
+          yield errorItem<TRes>(message.id, "ABORTED", "Request was aborted");
+          return;
+        }
         if (isAsyncIterable(result)) values = result;
         else value = result;
       }
 
       if (values === undefined) {
+        if (message.signal?.aborted) {
+          yield errorItem<TRes>(message.id, "ABORTED", "Request was aborted");
+          return;
+        }
         yield successItem<TRes>(message.id, value);
         return;
       }
@@ -164,7 +225,10 @@ export class LocalTransport implements Transport {
     } catch (error) {
       // The handler threw, or the invocation failed (its code: VALIDATION_ERROR, ABORTED and so on)
       const code = error instanceof InvocationError ? error.code : "HANDLER_ERROR";
-      yield errorItem<TRes>(message.id, code, error instanceof Error ? error.message : "Unknown error");
+      const item = errorItem<TRes>(message.id, code, error instanceof Error ? error.message : "Unknown error");
+      // The reason of a FORBIDDEN error travels on each face (roadmap R25)
+      if (error instanceof InvocationError && error.reason) item.metadata = { reason: error.reason };
+      yield item;
     }
   }
 
@@ -172,6 +236,7 @@ export class LocalTransport implements Transport {
     // No resources to clean up
   }
 
+
   /**
    * Clear all handlers.
    */

package/src/adapters/local/client/types.ts

@@ -6,6 +6,8 @@
 
 import type { Message, Method } from "../../../client/types.js";
 import type { ProcedureRegistry } from "../../../procedures/registry.js";
+import type { Interceptor } from "../../../procedures/invoke.js";
+import type { Capability, ClearanceOrder } from "../../../procedures/types.js";
 
 /**
  * Handler function for a method.
@@ -47,4 +49,20 @@ export interface LocalTransportOptions {
    * The procedure runs through `invokeProcedure()`, as on a server.
    */
   registry?: ProcedureRegistry;
+
+  /**
+   * The interceptors of each procedure that the transport runs, as on a server: policy, tracing,
+   * timeouts, metrics (roadmap R14). Before, a local call had none.
+   */
+  interceptors?: readonly Interceptor[] | undefined;
+
+  /**
+   * The capability of each call. The remaining time that a call sends (`procedure-timeout`)
+   * makes its deadline earlier, as on a server: a `Client` with a timeout gives a local call a
+   * deadline too (roadmap R14).
+   */
+  capability?: Capability | undefined;
+
+  /** The order of the clearance values of the capability. */
+  clearanceOrder?: ClearanceOrder | undefined;
 }

package/src/adapters/mock/client/transport.ts

@@ -11,6 +11,7 @@ import type {
   MockTransportOptions,
   CallHistoryEntry,
 } from "./types.js";
+import { optionalMs } from "../../../duration.js";
 
 /**
  * Mock transport implementation for testing.
@@ -26,8 +27,8 @@ import type {
  * ```typescript
  * // Create mock transport with latency
  * const mock = new MockTransport({
- *   minLatency: 10,
- *   maxLatency: 50,
+ *   minLatency: ms(10),
+ *   maxLatency: ms(50),
  * });
  *
  * // Mock a specific response
@@ -57,14 +58,15 @@ import type {
 export class MockTransport implements Transport {
   readonly name = "mock";
 
-  private options: Required<MockTransportOptions>;
+  /** The options, with the latencies in milliseconds */
+  private options: Required<Omit<MockTransportOptions, "minLatency" | "maxLatency">> & { minLatency: number; maxLatency: number };
   private responses = new Map<ResponseMatcher, MockResponse>();
   private history: CallHistoryEntry[] = [];
 
   constructor(options: MockTransportOptions = {}) {
     this.options = {
-      minLatency: options.minLatency ?? 0,
-      maxLatency: options.maxLatency ?? 0,
+      minLatency: optionalMs(options.minLatency, "minLatency") ?? 0,
+      maxLatency: optionalMs(options.maxLatency, "maxLatency") ?? 0,
       failureRate: options.failureRate ?? 0,
       defaultErrorMessage: options.defaultErrorMessage ?? "Mock transport error",
       trackHistory: options.trackHistory ?? true,
@@ -247,7 +249,8 @@ export class MockTransport implements Transport {
 
     // Apply custom delay if specified
     if (mockResponse.delay !== undefined) {
-      await new Promise((resolve) => setTimeout(resolve, mockResponse.delay));
+      const delay = optionalMs(mockResponse.delay, "delay");
+      await new Promise((resolve) => setTimeout(resolve, delay));
     }
 
     // Handle error response