@procedures/client 0.47.2 → 0.48.1

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

@@ -1,105 +1,111 @@
 /**
  * HTTP Constants
  *
- * Shared HTTP enums and constants used by both client and server adapters.
+ * Shared HTTP constants used by both client and server adapters.
  */
 
 /**
  * HTTP Methods
  */
-export enum HTTPMethod {
-  GET = "GET",
-  POST = "POST",
-  PUT = "PUT",
-  PATCH = "PATCH",
-  DELETE = "DELETE",
-  OPTIONS = "OPTIONS",
-  HEAD = "HEAD",
-}
+export const HTTPMethod = {
+  GET: "GET",
+  POST: "POST",
+  PUT: "PUT",
+  PATCH: "PATCH",
+  DELETE: "DELETE",
+  OPTIONS: "OPTIONS",
+  HEAD: "HEAD",
+} as const;
+
+/** This type is the union of the values of `HTTPMethod`. */
+export type HTTPMethod = (typeof HTTPMethod)[keyof typeof HTTPMethod];
 
 /**
  * HTTP Status Codes
  *
- * Comprehensive enum of all standard HTTP status codes.
+ * All standard HTTP status codes.
  */
-export enum HTTPStatus {
+export const HTTPStatus = {
   // Unknown
-  UNKNOWN = 0,
+  UNKNOWN: 0,
 
   // 1xx Informational
-  CONTINUE = 100,
-  SWITCHING_PROTOCOLS = 101,
-  PROCESSING = 102,
-  EARLY_HINTS = 103,
-  RESPONSE_IS_TOO_LARGE = 104,
+  CONTINUE: 100,
+  SWITCHING_PROTOCOLS: 101,
+  PROCESSING: 102,
+  EARLY_HINTS: 103,
+  RESPONSE_IS_TOO_LARGE: 104,
 
   // 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,
-  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,
+  BAD_REQUEST: 400,
+  UNAUTHORIZED: 401,
+  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,
 
   // 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,
-  HTTP_NETWORK_CONNECT_TIMEOUT_ERROR = 599,
-}
+  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,
+  HTTP_NETWORK_CONNECT_TIMEOUT_ERROR: 599,
+} as const;
+
+/** This type is the union of the values of `HTTPStatus`. */
+export type HTTPStatus = (typeof HTTPStatus)[keyof typeof HTTPStatus];
 
 /**
  * HTTP Transport Protocol Name

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

@@ -15,28 +15,31 @@ import { httpStatusToErrorCode } from "../../../client/errors/http-errors.js";
  *
  * Categorizes errors into semantic codes instead of magic strings.
  */
-export enum HTTPErrorCode {
+export const HTTPErrorCode = {
   // Network errors
-  NETWORK_ERROR = "NETWORK_ERROR",
-  CONNECTION_REFUSED = "CONNECTION_REFUSED",
-  TIMEOUT = "TIMEOUT",
-  ABORTED = "ABORTED",
+  NETWORK_ERROR: "NETWORK_ERROR",
+  CONNECTION_REFUSED: "CONNECTION_REFUSED",
+  TIMEOUT: "TIMEOUT",
+  ABORTED: "ABORTED",
 
   // HTTP errors (mapped from status codes)
-  HTTP_ERROR = "HTTP_ERROR",
+  HTTP_ERROR: "HTTP_ERROR",
 
   // Parse/serialization errors
-  INVALID_RESPONSE = "INVALID_RESPONSE",
-  PARSE_ERROR = "PARSE_ERROR",
-  SERIALIZE_ERROR = "SERIALIZE_ERROR",
+  INVALID_RESPONSE: "INVALID_RESPONSE",
+  PARSE_ERROR: "PARSE_ERROR",
+  SERIALIZE_ERROR: "SERIALIZE_ERROR",
 
   // Configuration errors
-  INVALID_URL = "INVALID_URL",
-  INVALID_METHOD = "INVALID_METHOD",
+  INVALID_URL: "INVALID_URL",
+  INVALID_METHOD: "INVALID_METHOD",
 
   // Unknown
-  UNKNOWN = "UNKNOWN",
-}
+  UNKNOWN: "UNKNOWN",
+} as const;
+
+/** This type is the union of the values of `HTTPErrorCode`. */
+export type HTTPErrorCode = (typeof HTTPErrorCode)[keyof typeof HTTPErrorCode];
 
 export const HTTPErrorMessage : Record<HTTPErrorCode, string> = {
   [HTTPErrorCode.PARSE_ERROR] : "Failed to parse response",

package/src/adapters/port/transport.ts

@@ -69,6 +69,8 @@ function isFrame(value: unknown): value is WebSocketMessage {
 
 /** The transport over a message port, in the two directions. */
 export class PortTransport implements Transport {
+  private readonly port: PortLike;
+
   readonly name = "port";
   private readonly outgoing: OutgoingCalls;
   private readonly incoming: IncomingCalls | undefined;
@@ -77,9 +79,10 @@ export class PortTransport implements Transport {
   private readonly onNodeMessage = (data: unknown): void => this.receive(data);
 
   constructor(
-    private readonly port: PortLike,
+    port: PortLike,
     options: PortTransportOptions = {},
   ) {
+    this.port = port;
     const send = (frame: WebSocketMessage): void => this.port.postMessage(frame);
     const isOpen = (): boolean => this.open;
     this.outgoing = new OutgoingCalls({

package/src/adapters/sequence.ts

@@ -32,10 +32,14 @@ export const STREAM_ITEM_METADATA_KEY = "stream";
 
 /** The order of the stream frames of one call, at the side that receives them. */
 export class StreamSequence {
+  private readonly logger?: Logger | undefined;
+
   private last = 0;
 
   /** The logger of the warning of a gap (CLI-87). Without it, the warning goes to `console.warn`. */
-  constructor(private readonly logger?: Logger | undefined) {}
+  constructor(logger?: Logger | undefined) {
+    this.logger = logger;
+  }
 
   /**
    * This function examines the `seq` of a frame. It gives -1 for a frame to drop: its `seq` is

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

@@ -190,12 +190,25 @@ export type WebSocketClass = new (url: string) => unknown;
 /**
  * WebSocket connection state.
  */
-export enum WebSocketState {
-  CONNECTING = "CONNECTING",
-  CONNECTED = "CONNECTED",
-  DISCONNECTING = "DISCONNECTING",
-  DISCONNECTED = "DISCONNECTED",
-  RECONNECTING = "RECONNECTING",
+export const WebSocketState = {
+  CONNECTING: "CONNECTING",
+  CONNECTED: "CONNECTED",
+  DISCONNECTING: "DISCONNECTING",
+  DISCONNECTED: "DISCONNECTED",
+  RECONNECTING: "RECONNECTING",
+} as const;
+
+/** This type is the union of the values of `WebSocketState`. */
+export type WebSocketState = (typeof WebSocketState)[keyof typeof WebSocketState];
+
+/** These types keep each member of `WebSocketState` usable as a type. */
+// eslint-disable-next-line @typescript-eslint/no-namespace
+export declare namespace WebSocketState {
+  export type CONNECTING = typeof WebSocketState.CONNECTING;
+  export type CONNECTED = typeof WebSocketState.CONNECTED;
+  export type DISCONNECTING = typeof WebSocketState.DISCONNECTING;
+  export type DISCONNECTED = typeof WebSocketState.DISCONNECTED;
+  export type RECONNECTING = typeof WebSocketState.RECONNECTING;
 }
 
 /**

package/src/adapters/websocket/shared/rpc.ts

@@ -72,9 +72,13 @@ export class ItemQueue<T> {
  * The stream takes one for each item that it sends, and waits when it has none.
  */
 export class StreamCredit {
+  private credit: number;
+
   private wake: (() => void) | undefined;
 
-  constructor(private credit: number) {}
+  constructor(credit: number) {
+    this.credit = credit;
+  }
 
   grant(n: number): void {
     this.credit += n;
@@ -175,10 +179,14 @@ export interface OutgoingCallsOptions {
 
 /** The calls that this side sends on one socket. */
 export class OutgoingCalls {
+  private readonly options: OutgoingCallsOptions;
+
   private readonly pending = new Map<string, PendingCall>();
   private seq = 0;
 
-  constructor(private readonly options: OutgoingCallsOptions) {}
+  constructor(options: OutgoingCallsOptions) {
+    this.options = options;
+  }
 
   /** The number of calls that wait for their frames. */
   get size(): number {
@@ -332,12 +340,16 @@ export interface IncomingCallsOptions {
 
 /** The calls that the other side sends on one socket, served by a handler. */
 export class IncomingCalls {
+  private readonly options: IncomingCallsOptions;
+
   /** The calls that run, by wire id: a cancel frame or a closed socket aborts them */
   private readonly inflight = new Map<string, AbortController>();
   /** The flow control of the streams that run, by wire id */
   private readonly credits = new Map<string, StreamCredit>();
 
-  constructor(private readonly options: IncomingCallsOptions) {}
+  constructor(options: IncomingCallsOptions) {
+    this.options = options;
+  }
 
   /** The number of calls that run. */
   get size(): number {

package/src/browser.ts

@@ -609,12 +609,32 @@ export type {
   TypedEventBus,
   EventHandler,
   EventBusOptions,
+  EventFanOutOptions,
   EventListenOptions,
   EventWaitOptions,
   ChannelMap,
 } from "./events/index.js";
 // The remote events: a peer subscribes to the topics of the bus of another peer (EVENTS.md)
 export { EventPublisher, topicMatcher, EVENTS_SUBSCRIBE_PATH, SubscriptionError, remoteEvents, subscribeRemote } from "./events/index.js";
+// The live state: keyed values in memory on a topic (LIVE-STATE-2026-11.md)
+export { LiveState, liveTopic, liveTopicTarget, liveView, LIVE_SET_PATH, LIVE_SNAPSHOT_PATH, LIVE_LEAVE_PATH, MAX_LIVE_KEY_LENGTH, DEFAULT_LIVE_KEYS, DEFAULT_LIVE_TOPICS, DEFAULT_LIVE_VALUE_BYTES } from "./events/index.js";
+export type {
+  AdmitLiveSet,
+  AdmitLiveLeave,
+  LiveLeaveCall,
+  LiveAdmission,
+  LiveClient,
+  LiveEntry,
+  LiveEvent,
+  LiveGone,
+  LiveGoneReason,
+  LiveSetCall,
+  LiveSetOptions,
+  LiveStateHost,
+  LiveStateOptions,
+  LiveView,
+  LiveViewOptions,
+} from "./events/index.js";
 export type {
   EventPublisherOptions,
   TopicRule,

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];