@procedures/client 0.47.1 → 0.48.0

package/src/client/batch-executor.ts

@@ -110,7 +110,11 @@ function cancelledResult(path: ProcedurePath, message: string): ProcedureCallRes
  * ```
  */
 export class BatchExecutor {
-  constructor(private readonly execute: ProcedureExecutor) {}
+  private readonly execute: ProcedureExecutor;
+
+  constructor(execute: ProcedureExecutor) {
+    this.execute = execute;
+  }
 
   /**
    * Execute resolved routes with the specified strategy.

package/src/client/client.ts

@@ -38,7 +38,7 @@ import type {
   TypedClientMiddleware,
 } from "./types.js";
 import { ClientError } from "./types.js";
-import { compose } from "../middleware/compose.js";
+import { compose } from "@mark1russell7/collections/layers";
 import { pathToMethod } from "../server/method.js";
 import type { CallOptions, ClientContextInput } from "./context.js";
 import { mergeContext, normalizeCallOptions } from "./context.js";
@@ -920,9 +920,8 @@ export class Client<TContext = {}> {
       yield* self.transport.send<TReq, TRes>(context.message);
     };
 
-    // Use universal middleware composition
-    // compose(...middleware, finalRunner) applies middleware in order (onion model)
-    return compose<false>(...(this.middleware as any[]), transportRunner) as ClientRunner<TReq, TRes>;
+    // The first middleware is the outermost one (onion model)
+    return compose(...(this.middleware as ClientMiddleware<TReq, TRes>[]))(transportRunner);
   }
 
   /**

package/src/client/errors/README.md

@@ -4,8 +4,8 @@ Protocol-agnostic error handling with rich metadata and bidirectional HTTP statu
 
 ## Zero Magic Strings & Numbers
 
-- **ErrorCode enum** - All error codes use enum values (no string literals)
-- **HTTPStatus enum** - All HTTP status codes use enum values (no magic numbers)
+- **ErrorCode** - All error codes use the values of this object (no string literals)
+- **HTTPStatus** - All HTTP status codes use the values of this object (no magic numbers)
 - **Single source of truth** - `HTTP_STATUS_ERROR_MAP` defines bidirectional mapping
 
 ## Architecture
@@ -67,7 +67,7 @@ import { errorCodeToHTTPStatus, ErrorCode, HTTPStatus } from "@common/client/err
 // Map error code to HTTP status
 function handleError(code: ErrorCode): number {
   const status = errorCodeToHTTPStatus(code);
-  return status; // Returns HTTPStatus enum value (404, 500, etc.)
+  return status; // Returns a value of HTTPStatus (404, 500, etc.)
 }
 
 // Example
@@ -100,8 +100,8 @@ try {
 common/src/client/errors/
 ├── README.md              ← You are here
 ├── index.ts               ← Public API exports
-├── codes.ts               ← ErrorCode enum (70+ codes)
-├── http-status.ts         ← HTTPStatus enum (all HTTP status codes)
+├── codes.ts               ← ErrorCode (70+ codes)
+├── http-status.ts         ← HTTPStatus (all HTTP status codes)
 ├── types.ts               ← TypeScript interfaces
 ├── registry.ts            ← ERROR_REGISTRY with full metadata
 ├── http-errors.ts         ← HTTP-specific errors + bidirectional mapping
@@ -135,7 +135,7 @@ Works across all transports:
 
 Full TypeScript support:
 ```typescript
-// All enums are type-safe
+// All values are type-safe
 const code: ErrorCode = ErrorCode.TIMEOUT;
 const status: HTTPStatus = HTTPStatus.NOT_FOUND;
 
@@ -201,7 +201,7 @@ console.error(formatError(error, true)); // include stack trace
 
 ## Best Practices
 
-1. **Always use enum values** - Never use string literals or magic numbers
+1. **Always use the named values** - Never use string literals or magic numbers
 2. **Use the registry** - Don't create error metadata manually
 3. **Provide context** - Include requestId, transport, method when creating errors
 4. **Check retryable flag** - Respect the metadata when implementing retry logic
@@ -209,7 +209,7 @@ console.error(formatError(error, true)); // include stack trace
 
 ## Adding New Errors
 
-1. Add to `ErrorCode` enum in `codes.ts`
+1. Add to `ErrorCode` in `codes.ts`
 2. Add metadata to `ERROR_REGISTRY` in `registry.ts` or `HTTP_ERROR_REGISTRY` in `http-errors.ts`
 3. If HTTP-related, add to `HTTP_STATUS_ERROR_MAP` in `http-errors.ts`
 
@@ -217,11 +217,11 @@ console.error(formatError(error, true)); // include stack trace
 
 Example:
 ```typescript
-// 1. Add to ErrorCode enum
-export enum ErrorCode {
+// 1. Add to ErrorCode
+export const ErrorCode = {
   // ... existing codes
-  MY_NEW_ERROR = "MY_NEW_ERROR",
-}
+  MY_NEW_ERROR: "MY_NEW_ERROR",
+} as const;
 
 // 2. Add to registry
 export const ERROR_REGISTRY: ErrorRegistry = {

package/src/client/errors/codes.ts

@@ -1,8 +1,8 @@
 /**
- * Error Code Enums
+ * Error Codes
  *
- * Comprehensive enum of ALL error codes.
- * NO MAGIC STRINGS - use these enums everywhere!
+ * ALL error codes.
+ * NO MAGIC STRINGS - use these values everywhere!
  */
 
 /**
@@ -10,81 +10,84 @@
  *
  * Protocol-agnostic error codes that work across all transports.
  */
-export enum ErrorCode {
+export const ErrorCode = {
   // Network errors
-  NETWORK_ERROR = "NETWORK_ERROR",
-  CONNECTION_REFUSED = "CONNECTION_REFUSED",
-  DNS_ERROR = "DNS_ERROR",
-  STREAM_ENDED = "STREAM_ENDED",
+  NETWORK_ERROR: "NETWORK_ERROR",
+  CONNECTION_REFUSED: "CONNECTION_REFUSED",
+  DNS_ERROR: "DNS_ERROR",
+  STREAM_ENDED: "STREAM_ENDED",
 
   // Timeout errors
-  TIMEOUT = "TIMEOUT",
-  CONNECTION_TIMEOUT = "CONNECTION_TIMEOUT",
-  READ_TIMEOUT = "READ_TIMEOUT",
-  DEADLINE_EXCEEDED = "DEADLINE_EXCEEDED",
+  TIMEOUT: "TIMEOUT",
+  CONNECTION_TIMEOUT: "CONNECTION_TIMEOUT",
+  READ_TIMEOUT: "READ_TIMEOUT",
+  DEADLINE_EXCEEDED: "DEADLINE_EXCEEDED",
 
   // Cancellation
-  ABORTED = "ABORTED",
+  ABORTED: "ABORTED",
 
   // Protocol/parsing errors
-  PARSE_ERROR = "PARSE_ERROR",
-  SERIALIZE_ERROR = "SERIALIZE_ERROR",
-  INVALID_RESPONSE = "INVALID_RESPONSE",
-  PROTOCOL_ERROR = "PROTOCOL_ERROR",
+  PARSE_ERROR: "PARSE_ERROR",
+  SERIALIZE_ERROR: "SERIALIZE_ERROR",
+  INVALID_RESPONSE: "INVALID_RESPONSE",
+  PROTOCOL_ERROR: "PROTOCOL_ERROR",
 
   // Client errors (4xx equivalent)
-  BAD_REQUEST = "BAD_REQUEST",
-  UNAUTHORIZED = "UNAUTHORIZED",
-  FORBIDDEN = "FORBIDDEN",
-  NOT_FOUND = "NOT_FOUND",
-  METHOD_NOT_ALLOWED = "METHOD_NOT_ALLOWED",
-  NOT_ACCEPTABLE = "NOT_ACCEPTABLE",
-  PROXY_AUTHENTICATION_REQUIRED = "PROXY_AUTHENTICATION_REQUIRED",
-  CONFLICT = "CONFLICT",
-  GONE = "GONE",
-  LENGTH_REQUIRED = "LENGTH_REQUIRED",
-  PRECONDITION_FAILED = "PRECONDITION_FAILED",
-  PAYLOAD_TOO_LARGE = "PAYLOAD_TOO_LARGE",
-  URI_TOO_LONG = "URI_TOO_LONG",
-  UNSUPPORTED_MEDIA_TYPE = "UNSUPPORTED_MEDIA_TYPE",
-  RANGE_NOT_SATISFIABLE = "RANGE_NOT_SATISFIABLE",
-  EXPECTATION_FAILED = "EXPECTATION_FAILED",
-  IM_A_TEAPOT = "IM_A_TEAPOT",
-  MISDIRECTED_REQUEST = "MISDIRECTED_REQUEST",
-  UNPROCESSABLE_ENTITY = "UNPROCESSABLE_ENTITY",
-  LOCKED = "LOCKED",
-  FAILED_DEPENDENCY = "FAILED_DEPENDENCY",
-  TOO_EARLY = "TOO_EARLY",
-  UPGRADE_REQUIRED = "UPGRADE_REQUIRED",
-  PRECONDITION_REQUIRED = "PRECONDITION_REQUIRED",
-  TOO_MANY_REQUESTS = "TOO_MANY_REQUESTS",
-  REQUEST_HEADER_FIELDS_TOO_LARGE = "REQUEST_HEADER_FIELDS_TOO_LARGE",
-  UNAVAILABLE_FOR_LEGAL_REASONS = "UNAVAILABLE_FOR_LEGAL_REASONS",
-  CLIENT_CLOSED_REQUEST = "CLIENT_CLOSED_REQUEST",
-  METADATA_TOO_LARGE = "METADATA_TOO_LARGE",
+  BAD_REQUEST: "BAD_REQUEST",
+  UNAUTHORIZED: "UNAUTHORIZED",
+  FORBIDDEN: "FORBIDDEN",
+  NOT_FOUND: "NOT_FOUND",
+  METHOD_NOT_ALLOWED: "METHOD_NOT_ALLOWED",
+  NOT_ACCEPTABLE: "NOT_ACCEPTABLE",
+  PROXY_AUTHENTICATION_REQUIRED: "PROXY_AUTHENTICATION_REQUIRED",
+  CONFLICT: "CONFLICT",
+  GONE: "GONE",
+  LENGTH_REQUIRED: "LENGTH_REQUIRED",
+  PRECONDITION_FAILED: "PRECONDITION_FAILED",
+  PAYLOAD_TOO_LARGE: "PAYLOAD_TOO_LARGE",
+  URI_TOO_LONG: "URI_TOO_LONG",
+  UNSUPPORTED_MEDIA_TYPE: "UNSUPPORTED_MEDIA_TYPE",
+  RANGE_NOT_SATISFIABLE: "RANGE_NOT_SATISFIABLE",
+  EXPECTATION_FAILED: "EXPECTATION_FAILED",
+  IM_A_TEAPOT: "IM_A_TEAPOT",
+  MISDIRECTED_REQUEST: "MISDIRECTED_REQUEST",
+  UNPROCESSABLE_ENTITY: "UNPROCESSABLE_ENTITY",
+  LOCKED: "LOCKED",
+  FAILED_DEPENDENCY: "FAILED_DEPENDENCY",
+  TOO_EARLY: "TOO_EARLY",
+  UPGRADE_REQUIRED: "UPGRADE_REQUIRED",
+  PRECONDITION_REQUIRED: "PRECONDITION_REQUIRED",
+  TOO_MANY_REQUESTS: "TOO_MANY_REQUESTS",
+  REQUEST_HEADER_FIELDS_TOO_LARGE: "REQUEST_HEADER_FIELDS_TOO_LARGE",
+  UNAVAILABLE_FOR_LEGAL_REASONS: "UNAVAILABLE_FOR_LEGAL_REASONS",
+  CLIENT_CLOSED_REQUEST: "CLIENT_CLOSED_REQUEST",
+  METADATA_TOO_LARGE: "METADATA_TOO_LARGE",
 
   // Server errors (5xx equivalent)
-  INTERNAL_ERROR = "INTERNAL_ERROR",
-  NOT_IMPLEMENTED = "NOT_IMPLEMENTED",
-  BAD_GATEWAY = "BAD_GATEWAY",
-  SERVICE_UNAVAILABLE = "SERVICE_UNAVAILABLE",
-  GATEWAY_TIMEOUT = "GATEWAY_TIMEOUT",
-  HTTP_VERSION_NOT_SUPPORTED = "HTTP_VERSION_NOT_SUPPORTED",
-  VARIANT_ALSO_NEGOTIATES = "VARIANT_ALSO_NEGOTIATES",
-  INSUFFICIENT_STORAGE = "INSUFFICIENT_STORAGE",
-  LOOP_DETECTED = "LOOP_DETECTED",
-  NOT_EXTENDED = "NOT_EXTENDED",
-  NETWORK_AUTHENTICATION_REQUIRED = "NETWORK_AUTHENTICATION_REQUIRED",
-  HTTP_NETWORK_CONNECT_TIMEOUT = "HTTP_NETWORK_CONNECT_TIMEOUT",
+  INTERNAL_ERROR: "INTERNAL_ERROR",
+  NOT_IMPLEMENTED: "NOT_IMPLEMENTED",
+  BAD_GATEWAY: "BAD_GATEWAY",
+  SERVICE_UNAVAILABLE: "SERVICE_UNAVAILABLE",
+  GATEWAY_TIMEOUT: "GATEWAY_TIMEOUT",
+  HTTP_VERSION_NOT_SUPPORTED: "HTTP_VERSION_NOT_SUPPORTED",
+  VARIANT_ALSO_NEGOTIATES: "VARIANT_ALSO_NEGOTIATES",
+  INSUFFICIENT_STORAGE: "INSUFFICIENT_STORAGE",
+  LOOP_DETECTED: "LOOP_DETECTED",
+  NOT_EXTENDED: "NOT_EXTENDED",
+  NETWORK_AUTHENTICATION_REQUIRED: "NETWORK_AUTHENTICATION_REQUIRED",
+  HTTP_NETWORK_CONNECT_TIMEOUT: "HTTP_NETWORK_CONNECT_TIMEOUT",
 
   // Configuration errors
-  INVALID_CONFIG = "INVALID_CONFIG",
-  INVALID_URL = "INVALID_URL",
-  INVALID_METHOD = "INVALID_METHOD",
+  INVALID_CONFIG: "INVALID_CONFIG",
+  INVALID_URL: "INVALID_URL",
+  INVALID_METHOD: "INVALID_METHOD",
 
   // HTTP-specific
-  HTTP_ERROR = "HTTP_ERROR",
+  HTTP_ERROR: "HTTP_ERROR",
 
   // Unknown
-  UNKNOWN = "UNKNOWN",
-}
+  UNKNOWN: "UNKNOWN",
+} as const;
+
+/** This type is the union of the values of `ErrorCode`. */
+export type ErrorCode = (typeof ErrorCode)[keyof typeof ErrorCode];

package/src/client/errors/http-status.ts

@@ -1,82 +1,85 @@
 /**
  * HTTP Status Code Constants
  *
- * Comprehensive enum of HTTP status codes.
+ * All HTTP status codes.
  * NO MAGIC NUMBERS - use these constants everywhere!
  */
 
-export enum HTTPStatus {
+export const HTTPStatus = {
   // 1xx Informational
-  CONTINUE = 100,
-  SWITCHING_PROTOCOLS = 101,
-  PROCESSING = 102,
-  EARLY_HINTS = 103,
+  CONTINUE: 100,
+  SWITCHING_PROTOCOLS: 101,
+  PROCESSING: 102,
+  EARLY_HINTS: 103,
 
   // 2xx Success
-  OK = 200,
-  CREATED = 201,
-  ACCEPTED = 202,
-  NON_AUTHORITATIVE_INFORMATION = 203,
-  NO_CONTENT = 204,
-  RESET_CONTENT = 205,
-  PARTIAL_CONTENT = 206,
-  MULTI_STATUS = 207,
-  ALREADY_REPORTED = 208,
-  IM_USED = 226,
+  OK: 200,
+  CREATED: 201,
+  ACCEPTED: 202,
+  NON_AUTHORITATIVE_INFORMATION: 203,
+  NO_CONTENT: 204,
+  RESET_CONTENT: 205,
+  PARTIAL_CONTENT: 206,
+  MULTI_STATUS: 207,
+  ALREADY_REPORTED: 208,
+  IM_USED: 226,
 
   // 3xx Redirection
-  MULTIPLE_CHOICES = 300,
-  MOVED_PERMANENTLY = 301,
-  FOUND = 302,
-  SEE_OTHER = 303,
-  NOT_MODIFIED = 304,
-  USE_PROXY = 305,
-  TEMPORARY_REDIRECT = 307,
-  PERMANENT_REDIRECT = 308,
+  MULTIPLE_CHOICES: 300,
+  MOVED_PERMANENTLY: 301,
+  FOUND: 302,
+  SEE_OTHER: 303,
+  NOT_MODIFIED: 304,
+  USE_PROXY: 305,
+  TEMPORARY_REDIRECT: 307,
+  PERMANENT_REDIRECT: 308,
 
   // 4xx Client Errors
-  BAD_REQUEST = 400,
-  UNAUTHORIZED = 401,
-  PAYMENT_REQUIRED = 402,
-  FORBIDDEN = 403,
-  NOT_FOUND = 404,
-  METHOD_NOT_ALLOWED = 405,
-  NOT_ACCEPTABLE = 406,
-  PROXY_AUTHENTICATION_REQUIRED = 407,
-  REQUEST_TIMEOUT = 408,
-  CONFLICT = 409,
-  GONE = 410,
-  LENGTH_REQUIRED = 411,
-  PRECONDITION_FAILED = 412,
-  PAYLOAD_TOO_LARGE = 413,
-  URI_TOO_LONG = 414,
-  UNSUPPORTED_MEDIA_TYPE = 415,
-  RANGE_NOT_SATISFIABLE = 416,
-  EXPECTATION_FAILED = 417,
-  IM_A_TEAPOT = 418,
-  MISDIRECTED_REQUEST = 421,
-  UNPROCESSABLE_ENTITY = 422,
-  LOCKED = 423,
-  FAILED_DEPENDENCY = 424,
-  TOO_EARLY = 425,
-  UPGRADE_REQUIRED = 426,
-  PRECONDITION_REQUIRED = 428,
-  TOO_MANY_REQUESTS = 429,
-  REQUEST_HEADER_FIELDS_TOO_LARGE = 431,
-  UNAVAILABLE_FOR_LEGAL_REASONS = 451,
-  CLIENT_CLOSED_REQUEST = 499, // nginx-specific
+  BAD_REQUEST: 400,
+  UNAUTHORIZED: 401,
+  PAYMENT_REQUIRED: 402,
+  FORBIDDEN: 403,
+  NOT_FOUND: 404,
+  METHOD_NOT_ALLOWED: 405,
+  NOT_ACCEPTABLE: 406,
+  PROXY_AUTHENTICATION_REQUIRED: 407,
+  REQUEST_TIMEOUT: 408,
+  CONFLICT: 409,
+  GONE: 410,
+  LENGTH_REQUIRED: 411,
+  PRECONDITION_FAILED: 412,
+  PAYLOAD_TOO_LARGE: 413,
+  URI_TOO_LONG: 414,
+  UNSUPPORTED_MEDIA_TYPE: 415,
+  RANGE_NOT_SATISFIABLE: 416,
+  EXPECTATION_FAILED: 417,
+  IM_A_TEAPOT: 418,
+  MISDIRECTED_REQUEST: 421,
+  UNPROCESSABLE_ENTITY: 422,
+  LOCKED: 423,
+  FAILED_DEPENDENCY: 424,
+  TOO_EARLY: 425,
+  UPGRADE_REQUIRED: 426,
+  PRECONDITION_REQUIRED: 428,
+  TOO_MANY_REQUESTS: 429,
+  REQUEST_HEADER_FIELDS_TOO_LARGE: 431,
+  UNAVAILABLE_FOR_LEGAL_REASONS: 451,
+  CLIENT_CLOSED_REQUEST: 499, // nginx-specific
 
   // 5xx Server Errors
-  INTERNAL_SERVER_ERROR = 500,
-  NOT_IMPLEMENTED = 501,
-  BAD_GATEWAY = 502,
-  SERVICE_UNAVAILABLE = 503,
-  GATEWAY_TIMEOUT = 504,
-  HTTP_VERSION_NOT_SUPPORTED = 505,
-  VARIANT_ALSO_NEGOTIATES = 506,
-  INSUFFICIENT_STORAGE = 507,
-  LOOP_DETECTED = 508,
-  NOT_EXTENDED = 510,
-  NETWORK_AUTHENTICATION_REQUIRED = 511,
-  NETWORK_CONNECT_TIMEOUT = 599, // non-standard
-}
+  INTERNAL_SERVER_ERROR: 500,
+  NOT_IMPLEMENTED: 501,
+  BAD_GATEWAY: 502,
+  SERVICE_UNAVAILABLE: 503,
+  GATEWAY_TIMEOUT: 504,
+  HTTP_VERSION_NOT_SUPPORTED: 505,
+  VARIANT_ALSO_NEGOTIATES: 506,
+  INSUFFICIENT_STORAGE: 507,
+  LOOP_DETECTED: 508,
+  NOT_EXTENDED: 510,
+  NETWORK_AUTHENTICATION_REQUIRED: 511,
+  NETWORK_CONNECT_TIMEOUT: 599, // non-standard
+} as const;
+
+/** This type is the union of the values of `HTTPStatus`. */
+export type HTTPStatus = (typeof HTTPStatus)[keyof typeof HTTPStatus];

package/src/client/errors/types.ts

@@ -8,39 +8,68 @@
 /**
  * Error severity levels.
  */
-export enum ErrorSeverity {
+export const ErrorSeverity = {
   /** Informational - not an actual error */
-  INFO = "info",
+  INFO: "info",
   /** Warning - degraded but functional */
-  WARNING = "warning",
+  WARNING: "warning",
   /** Error - operation failed */
-  ERROR = "error",
+  ERROR: "error",
   /** Critical - system-level failure */
-  CRITICAL = "critical",
+  CRITICAL: "critical",
+} as const;
+
+/** This type is the union of the values of `ErrorSeverity`. */
+export type ErrorSeverity = (typeof ErrorSeverity)[keyof typeof ErrorSeverity];
+
+/** These types keep each member of `ErrorSeverity` usable as a type. */
+// eslint-disable-next-line @typescript-eslint/no-namespace
+export declare namespace ErrorSeverity {
+  export type INFO = typeof ErrorSeverity.INFO;
+  export type WARNING = typeof ErrorSeverity.WARNING;
+  export type ERROR = typeof ErrorSeverity.ERROR;
+  export type CRITICAL = typeof ErrorSeverity.CRITICAL;
 }
 
 /**
  * Error categories for classification.
  */
-export enum ErrorCategory {
+export const ErrorCategory = {
   /** Network-level errors (connectivity, DNS, etc.) */
-  NETWORK = "network",
+  NETWORK: "network",
   /** Client-side errors (validation, configuration) */
-  CLIENT = "client",
+  CLIENT: "client",
   /** Server-side errors (5xx, internal errors) */
-  SERVER = "server",
+  SERVER: "server",
   /** Protocol-level errors (parsing, encoding) */
-  PROTOCOL = "protocol",
+  PROTOCOL: "protocol",
   /** Authentication/authorization errors */
-  AUTH = "auth",
+  AUTH: "auth",
   /** Rate limiting and throttling */
-  RATE_LIMIT = "rate_limit",
+  RATE_LIMIT: "rate_limit",
   /** Timeout errors */
-  TIMEOUT = "timeout",
+  TIMEOUT: "timeout",
   /** Cancellation errors */
-  CANCELLED = "cancelled",
+  CANCELLED: "cancelled",
   /** Unknown/uncategorized errors */
-  UNKNOWN = "unknown",
+  UNKNOWN: "unknown",
+} as const;
+
+/** This type is the union of the values of `ErrorCategory`. */
+export type ErrorCategory = (typeof ErrorCategory)[keyof typeof ErrorCategory];
+
+/** These types keep each member of `ErrorCategory` usable as a type. */
+// eslint-disable-next-line @typescript-eslint/no-namespace
+export declare namespace ErrorCategory {
+  export type NETWORK = typeof ErrorCategory.NETWORK;
+  export type CLIENT = typeof ErrorCategory.CLIENT;
+  export type SERVER = typeof ErrorCategory.SERVER;
+  export type PROTOCOL = typeof ErrorCategory.PROTOCOL;
+  export type AUTH = typeof ErrorCategory.AUTH;
+  export type RATE_LIMIT = typeof ErrorCategory.RATE_LIMIT;
+  export type TIMEOUT = typeof ErrorCategory.TIMEOUT;
+  export type CANCELLED = typeof ErrorCategory.CANCELLED;
+  export type UNKNOWN = typeof ErrorCategory.UNKNOWN;
 }
 
 /**

package/src/client/middleware/circuit-breaker.ts

@@ -116,13 +116,18 @@ export interface CircuitBreakerStats {
  * Circuit breaker error thrown when circuit is open.
  */
 export class CircuitBreakerError extends Error {
+  public readonly state: CircuitState;
+  public readonly lastError: Error | null;
+
   constructor(
-    public readonly state: CircuitState,
-    public readonly lastError: Error | null
+    state: CircuitState,
+    lastError: Error | null
   ) {
     super(
       `Circuit breaker is ${state}${lastError ? `: ${lastError.message}` : ""}`
     );
+    this.state = state;
+    this.lastError = lastError;
     this.name = "CircuitBreakerError";
   }
 }

package/src/client/middleware/lru.ts

@@ -8,6 +8,9 @@
  * `hashMap` of that package).
  */
 export class LruMap<K, V> {
+  private readonly capacity: number;
+  private readonly onEvict?: ((key: K, value: V) => void) | undefined;
+
   private readonly entries = new Map<K, V>();
 
   /**
@@ -15,9 +18,11 @@ export class LruMap<K, V> {
    * @param onEvict - Called for each key that a write removes to keep the capacity.
    */
   constructor(
-    private readonly capacity: number,
-    private readonly onEvict?: (key: K, value: V) => void
+    capacity: number,
+    onEvict?: (key: K, value: V) => void
   ) {
+    this.capacity = capacity;
+    this.onEvict = onEvict;
     if (!Number.isInteger(capacity) || capacity < 1) {
       throw new RangeError(`The capacity of an LRU map must be a positive whole number, not ${capacity}`);
     }

package/src/client/middleware/rate-limit.ts

@@ -89,11 +89,14 @@ export interface RateLimitStats {
  * Rate limit error thrown when limit exceeded.
  */
 export class RateLimitError extends Error {
+  public readonly stats: RateLimitStats;
+
   constructor(
     message: string,
-    public readonly stats: RateLimitStats
+    stats: RateLimitStats
   ) {
     super(message);
+    this.stats = stats;
     this.name = "RateLimitError";
   }
 }

package/src/client/middleware/resilience.ts

@@ -16,6 +16,7 @@
  * call goes to the server as `procedure-timeout` with each try (`client/deadline.ts`).
  */
 
+import { compose } from "@mark1russell7/collections/layers";
 import type { ClientMiddleware, ClientRunner, TypedClientMiddleware } from "../types.js";
 import type { CacheContext, CircuitBreakerContext, RateLimitContext, RetryContext, TimeoutContext } from "./contexts.js";
 import { createCacheMiddleware, type CacheOptions } from "./cache.js";
@@ -76,6 +77,6 @@ export function resilience(options: ResilienceOptions): TypedClientMiddleware<Re
     layers.push(createTimeoutMiddleware({ perAttempt: options.perAttempt, ...(message ? { message: `${message} (per-attempt)` } : {}) }) as ClientMiddleware);
   }
   const composed = <TReq, TRes>(next: ClientRunner<TReq, TRes>): ClientRunner<TReq, TRes> =>
-    layers.reduceRight<ClientRunner<TReq, TRes>>((inner, layer) => (layer as ClientMiddleware<TReq, TRes>)(inner), next);
+    compose(...(layers as ClientMiddleware<TReq, TRes>[]))(next);
   return composed as TypedClientMiddleware<ResilienceContext, {}>;
 }

package/src/client/route-resolver.ts

@@ -99,7 +99,11 @@ export interface RouteResolutionResult {
  * ```
  */
 export class RouteResolver {
-  constructor(private readonly registry: ProcedureRegistry) {}
+  private readonly registry: ProcedureRegistry;
+
+  constructor(registry: ProcedureRegistry) {
+    this.registry = registry;
+  }
 
   /**
    * Resolve a route structure to procedures.

package/src/client/types.ts

@@ -326,6 +326,9 @@ export type AccumulateContext<
  * Client error thrown when response has error status.
  */
 export class ClientError extends Error {
+  public readonly status: Extract<Status, { type: "error" }>;
+  public readonly responseId: string;
+
   /**
    * The metadata of the error response, for example `reason` of a `FORBIDDEN` error, or
    * `conflicts` of a `VERSION_CONFLICT` error (roadmap CLI-16). Empty when the response has none.
@@ -333,11 +336,13 @@ export class ClientError extends Error {
   public readonly metadata: Metadata;
 
   constructor(
-    public readonly status: Extract<Status, { type: "error" }>,
-    public readonly responseId: string,
+    status: Extract<Status, { type: "error" }>,
+    responseId: string,
     metadata: Metadata = {},
   ) {
     super(status.message);
+    this.status = status;
+    this.responseId = responseId;
     this.name = "ClientError";
     this.metadata = metadata;
   }

package/src/client/validation/types.ts

@@ -114,18 +114,25 @@ export type ValidationPhase = "input" | "output";
  * Error thrown when validation fails.
  */
 export class ValidationError extends Error {
+  /** Which phase of validation failed */
+  public readonly phase: ValidationPhase;
+  /** The underlying Zod error */
+  public readonly zodError: ZodErrorLike;
+  /** The method being called */
+  public readonly method: Method;
+
   override readonly name = "ValidationError";
 
   constructor(
     message: string,
-    /** Which phase of validation failed */
-    public readonly phase: ValidationPhase,
-    /** The underlying Zod error */
-    public readonly zodError: ZodErrorLike,
-    /** The method being called */
-    public readonly method: Method,
+    phase: ValidationPhase,
+    zodError: ZodErrorLike,
+    method: Method,
   ) {
     super(message);
+    this.phase = phase;
+    this.zodError = zodError;
+    this.method = method;
 
     // Maintain proper stack trace in V8 environments
     if (Error.captureStackTrace) {