@the-open-engine/zeroshot 6.28.0 → 6.29.1

package/lib/cluster/connection-state.d.mts

@@ -0,0 +1,13 @@
+export type ConnectionState = 'OPEN' | 'CLOSING' | 'CLOSED';
+export declare const CONNECTION_TRANSITIONS: Readonly<Record<ConnectionState, readonly ConnectionState[]>>;
+export declare const PROTOCOL_DIAGNOSTIC_CAPACITY = 128;
+export interface ConnectionCloseSnapshot {
+    readonly code: number | null;
+    readonly reason: null;
+}
+export type Deferred<T> = {
+    readonly promise: Promise<T>;
+    readonly resolve: (value: T) => void;
+    readonly reject: (reason: unknown) => void;
+};
+export declare function deferred<T>(): Deferred<T>;

package/lib/cluster/connection-state.d.ts

@@ -0,0 +1,13 @@
+export type ConnectionState = 'OPEN' | 'CLOSING' | 'CLOSED';
+export declare const CONNECTION_TRANSITIONS: Readonly<Record<ConnectionState, readonly ConnectionState[]>>;
+export declare const PROTOCOL_DIAGNOSTIC_CAPACITY = 128;
+export interface ConnectionCloseSnapshot {
+    readonly code: number | null;
+    readonly reason: null;
+}
+export type Deferred<T> = {
+    readonly promise: Promise<T>;
+    readonly resolve: (value: T) => void;
+    readonly reject: (reason: unknown) => void;
+};
+export declare function deferred<T>(): Deferred<T>;

package/lib/cluster/connection-state.mjs

@@ -0,0 +1,21 @@
+if (!Object.prototype.hasOwnProperty.call(Symbol, 'asyncDispose')) {
+    Object.defineProperty(Symbol, 'asyncDispose', {
+        configurable: false, enumerable: false,
+        value: Symbol.for('Symbol.asyncDispose'), writable: false,
+    });
+}
+export const CONNECTION_TRANSITIONS = Object.freeze({
+    OPEN: Object.freeze(['CLOSING']),
+    CLOSING: Object.freeze(['CLOSED']),
+    CLOSED: Object.freeze([]),
+});
+export const PROTOCOL_DIAGNOSTIC_CAPACITY = 128;
+export function deferred() {
+    let resolve;
+    let reject;
+    const promise = new Promise((onResolve, onReject) => {
+        resolve = onResolve;
+        reject = onReject;
+    });
+    return { promise, resolve, reject };
+}

package/lib/cluster/connection-types.cjs

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/cluster/connection-types.d.cts

@@ -0,0 +1,33 @@
+import type { FrameRecord } from './frames.js';
+import type { BoundedQueue } from './queue.js';
+import type { ClusterMethod } from './generated/protocol.js';
+export interface CallOptions {
+    readonly signal?: AbortSignal;
+    readonly requestTimeoutMs?: number;
+}
+export type SubscriptionKind = 'watch' | 'logs' | 'agent/attach';
+export type SubscriptionRegistration = {
+    readonly id: string;
+    readonly kind: SubscriptionKind;
+    readonly queue: BoundedQueue<FrameRecord>;
+    overflowed: boolean;
+    cancelSent: boolean;
+    abortHandler?: () => void;
+    abortSignal?: AbortSignal;
+};
+export type EstablishedSubscription<R> = {
+    readonly result: R;
+    readonly registration: SubscriptionRegistration;
+};
+export type PendingEntry = {
+    readonly id: string;
+    readonly method: ClusterMethod;
+    readonly expectedId: string;
+    readonly resolve: (value: unknown) => void;
+    readonly reject: (reason: unknown) => void;
+    readonly subscriptionKind?: SubscriptionKind;
+    settled: boolean;
+    abortHandler?: () => void;
+    signal?: AbortSignal;
+    timeout?: ReturnType<typeof setTimeout>;
+};

package/lib/cluster/connection-types.d.mts

@@ -0,0 +1,33 @@
+import type { FrameRecord } from './frames.js';
+import type { BoundedQueue } from './queue.js';
+import type { ClusterMethod } from './generated/protocol.js';
+export interface CallOptions {
+    readonly signal?: AbortSignal;
+    readonly requestTimeoutMs?: number;
+}
+export type SubscriptionKind = 'watch' | 'logs' | 'agent/attach';
+export type SubscriptionRegistration = {
+    readonly id: string;
+    readonly kind: SubscriptionKind;
+    readonly queue: BoundedQueue<FrameRecord>;
+    overflowed: boolean;
+    cancelSent: boolean;
+    abortHandler?: () => void;
+    abortSignal?: AbortSignal;
+};
+export type EstablishedSubscription<R> = {
+    readonly result: R;
+    readonly registration: SubscriptionRegistration;
+};
+export type PendingEntry = {
+    readonly id: string;
+    readonly method: ClusterMethod;
+    readonly expectedId: string;
+    readonly resolve: (value: unknown) => void;
+    readonly reject: (reason: unknown) => void;
+    readonly subscriptionKind?: SubscriptionKind;
+    settled: boolean;
+    abortHandler?: () => void;
+    signal?: AbortSignal;
+    timeout?: ReturnType<typeof setTimeout>;
+};

package/lib/cluster/connection-types.d.ts

@@ -0,0 +1,33 @@
+import type { FrameRecord } from './frames.js';
+import type { BoundedQueue } from './queue.js';
+import type { ClusterMethod } from './generated/protocol.js';
+export interface CallOptions {
+    readonly signal?: AbortSignal;
+    readonly requestTimeoutMs?: number;
+}
+export type SubscriptionKind = 'watch' | 'logs' | 'agent/attach';
+export type SubscriptionRegistration = {
+    readonly id: string;
+    readonly kind: SubscriptionKind;
+    readonly queue: BoundedQueue<FrameRecord>;
+    overflowed: boolean;
+    cancelSent: boolean;
+    abortHandler?: () => void;
+    abortSignal?: AbortSignal;
+};
+export type EstablishedSubscription<R> = {
+    readonly result: R;
+    readonly registration: SubscriptionRegistration;
+};
+export type PendingEntry = {
+    readonly id: string;
+    readonly method: ClusterMethod;
+    readonly expectedId: string;
+    readonly resolve: (value: unknown) => void;
+    readonly reject: (reason: unknown) => void;
+    readonly subscriptionKind?: SubscriptionKind;
+    settled: boolean;
+    abortHandler?: () => void;
+    signal?: AbortSignal;
+    timeout?: ReturnType<typeof setTimeout>;
+};

package/lib/cluster/connection-types.mjs

@@ -0,0 +1 @@
+export {};

package/lib/cluster/connection.cjs

@@ -1,48 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Connection = exports.CLOSE_REASON_MAX_BYTES = exports.PROTOCOL_DIAGNOSTIC_CAPACITY = exports.CONNECTION_TRANSITIONS = void 0;
+exports.Connection = exports.PROTOCOL_DIAGNOSTIC_CAPACITY = exports.CONNECTION_TRANSITIONS = void 0;
 const protocol_js_1 = require("./generated/protocol.cjs");
 const errors_js_1 = require("./errors.cjs");
 const frames_js_1 = require("./frames.cjs");
 const queue_js_1 = require("./queue.cjs");
 const socket_js_1 = require("./socket.cjs");
 const validators_js_1 = require("./validators.cjs");
-if (!Object.prototype.hasOwnProperty.call(Symbol, 'asyncDispose')) {
-    Object.defineProperty(Symbol, 'asyncDispose', {
-        configurable: false, enumerable: false,
-        value: Symbol.for('Symbol.asyncDispose'), writable: false,
-    });
-}
-exports.CONNECTION_TRANSITIONS = Object.freeze({
-    OPEN: Object.freeze(['CLOSING']),
-    CLOSING: Object.freeze(['CLOSED']),
-    CLOSED: Object.freeze([]),
-});
-exports.PROTOCOL_DIAGNOSTIC_CAPACITY = 128;
-exports.CLOSE_REASON_MAX_BYTES = 123;
-const CLOSE_REASON_ENCODER = new TextEncoder();
-function boundedCloseReason(reason) {
-    const retained = [];
-    const scratch = new Uint8Array(4);
-    let bytes = 0;
-    for (const codePoint of reason) {
-        const { written } = CLOSE_REASON_ENCODER.encodeInto(codePoint, scratch);
-        if (bytes + written > exports.CLOSE_REASON_MAX_BYTES)
-            break;
-        retained.push(codePoint);
-        bytes += written;
-    }
-    return retained.join('');
-}
-function deferred() {
-    let resolve;
-    let reject;
-    const promise = new Promise((onResolve, onReject) => {
-        resolve = onResolve;
-        reject = onReject;
-    });
-    return { promise, resolve, reject };
-}
+const connection_state_js_1 = require("./connection-state.cjs");
+var connection_state_js_2 = require("./connection-state.cjs");
+Object.defineProperty(exports, "CONNECTION_TRANSITIONS", { enumerable: true, get: function () { return connection_state_js_2.CONNECTION_TRANSITIONS; } });
+Object.defineProperty(exports, "PROTOCOL_DIAGNOSTIC_CAPACITY", { enumerable: true, get: function () { return connection_state_js_2.PROTOCOL_DIAGNOSTIC_CAPACITY; } });
 class Connection {
     #state = 'OPEN';
     #sequence = 1;
@@ -53,7 +21,9 @@ class Connection {
     #ownedSubscriptions = new WeakSet();
     #closePromise;
     #closeCode;
-    #closeReason;
+    #closedCompletion = (0, connection_state_js_1.deferred)();
+    closed = this.#closedCompletion.promise;
+    #closeSnapshot;
     closeDiagnostics = [];
     protocolDiagnostics = [];
     #socket;
@@ -67,7 +37,8 @@ class Connection {
     get pendingSize() { return this.#pending.size; }
     get subscriptionCount() { return this.#subscriptions.size; }
     get closeCode() { return this.#closeCode; }
-    get closeReason() { return this.#closeReason; }
+    get closeReason() { return undefined; }
+    get closeSnapshot() { return this.#closeSnapshot; }
     call(method, params, options = {}) {
         if (!protocol_js_1.UNARY_METHODS.includes(method)) {
             throw new errors_js_1.ClusterConfigError(`${method} is a subscription method`, 'INVALID_METHOD');
@@ -104,7 +75,7 @@ class Connection {
         if (options.requestTimeoutMs !== undefined && options.requestTimeoutMs < 0)
             return Promise.reject(new errors_js_1.ClusterConfigError('requestTimeoutMs must be non-negative', 'INVALID_TIMEOUT'));
         const id = this.#allocateId();
-        const result = deferred();
+        const result = (0, connection_state_js_1.deferred)();
         const entry = { id, method, expectedId: id, resolve: result.resolve, reject: result.reject, settled: false, ...(subscriptionKind === undefined ? {} : { subscriptionKind }) };
         this.#pending.set(id, entry);
         if (options.signal) {
@@ -337,7 +308,7 @@ class Connection {
         }
     }
     #recordProtocolError(message, cause) {
-        if (this.protocolDiagnostics.length === exports.PROTOCOL_DIAGNOSTIC_CAPACITY)
+        if (this.protocolDiagnostics.length === connection_state_js_1.PROTOCOL_DIAGNOSTIC_CAPACITY)
             this.protocolDiagnostics.shift();
         this.protocolDiagnostics.push(new errors_js_1.ClusterProtocolError(message, 'INVALID_PEER_FRAME', cause === undefined ? undefined : { cause }));
     }
@@ -347,15 +318,11 @@ class Connection {
         const first = args[0];
         if (typeof first === 'number') {
             this.#closeCode = first;
-            const raw = args.length > 1 ? String(args[1]) : undefined;
-            this.#closeReason = raw === undefined ? undefined : boundedCloseReason(raw);
         }
         else if (first !== null && typeof first === 'object') {
             const event = first;
             if (typeof event.code === 'number')
                 this.#closeCode = event.code;
-            if (typeof event.reason === 'string')
-                this.#closeReason = boundedCloseReason(event.reason);
         }
     }
     #startClose(sendCancels) {
@@ -405,9 +372,14 @@ class Connection {
             }
         }
         this.#transition('CLOSED');
+        this.#closeSnapshot = Object.freeze({
+            code: this.#closeCode ?? null,
+            reason: null,
+        });
+        this.#closedCompletion.resolve(this.#closeSnapshot);
     }
     #transition(to) {
-        if (!exports.CONNECTION_TRANSITIONS[this.#state].includes(to))
+        if (!connection_state_js_1.CONNECTION_TRANSITIONS[this.#state].includes(to))
             throw new errors_js_1.ClusterInternalError(`illegal connection transition ${this.#state} -> ${to}`, 'ILLEGAL_STATE_TRANSITION');
         this.#state = to;
     }

package/lib/cluster/connection.d.cts

@@ -0,0 +1,26 @@
+import type { ClusterMethodParams, ClusterMethodResults, SubscriptionMethod, UnaryClusterMethod } from './generated/protocol.js';
+import { ClusterProtocolError } from './errors.js';
+import type { WebSocketLike } from './socket.js';
+import { type ConnectionCloseSnapshot, type ConnectionState } from './connection-state.js';
+export { CONNECTION_TRANSITIONS, PROTOCOL_DIAGNOSTIC_CAPACITY, type ConnectionCloseSnapshot, type ConnectionState, } from './connection-state.js';
+import type { CallOptions, EstablishedSubscription, SubscriptionRegistration } from './connection-types.js';
+export type { CallOptions, EstablishedSubscription, SubscriptionKind, SubscriptionRegistration, } from './connection-types.js';
+export declare class Connection {
+    #private;
+    readonly closed: Promise<ConnectionCloseSnapshot>;
+    readonly closeDiagnostics: unknown[];
+    readonly protocolDiagnostics: ClusterProtocolError[];
+    constructor(socket: WebSocketLike);
+    get state(): ConnectionState;
+    get pendingSize(): number;
+    get subscriptionCount(): number;
+    get closeCode(): number | undefined;
+    get closeReason(): undefined;
+    get closeSnapshot(): ConnectionCloseSnapshot | undefined;
+    call<M extends UnaryClusterMethod>(method: M, params: ClusterMethodParams[M], options?: CallOptions): Promise<ClusterMethodResults[M]>;
+    cancelSubscription(registration: SubscriptionRegistration): Promise<void>;
+    openSubscription<M extends SubscriptionMethod>(method: M, params: ClusterMethodParams[M], options?: CallOptions): Promise<EstablishedSubscription<ClusterMethodResults[M]>>;
+    unregisterSubscription(id: string, registration: SubscriptionRegistration): void;
+    recordDiagnostic(error: unknown): void;
+    close(): Promise<void>;
+}

package/lib/cluster/connection.d.mts

@@ -0,0 +1,26 @@
+import type { ClusterMethodParams, ClusterMethodResults, SubscriptionMethod, UnaryClusterMethod } from './generated/protocol.js';
+import { ClusterProtocolError } from './errors.js';
+import type { WebSocketLike } from './socket.js';
+import { type ConnectionCloseSnapshot, type ConnectionState } from './connection-state.js';
+export { CONNECTION_TRANSITIONS, PROTOCOL_DIAGNOSTIC_CAPACITY, type ConnectionCloseSnapshot, type ConnectionState, } from './connection-state.js';
+import type { CallOptions, EstablishedSubscription, SubscriptionRegistration } from './connection-types.js';
+export type { CallOptions, EstablishedSubscription, SubscriptionKind, SubscriptionRegistration, } from './connection-types.js';
+export declare class Connection {
+    #private;
+    readonly closed: Promise<ConnectionCloseSnapshot>;
+    readonly closeDiagnostics: unknown[];
+    readonly protocolDiagnostics: ClusterProtocolError[];
+    constructor(socket: WebSocketLike);
+    get state(): ConnectionState;
+    get pendingSize(): number;
+    get subscriptionCount(): number;
+    get closeCode(): number | undefined;
+    get closeReason(): undefined;
+    get closeSnapshot(): ConnectionCloseSnapshot | undefined;
+    call<M extends UnaryClusterMethod>(method: M, params: ClusterMethodParams[M], options?: CallOptions): Promise<ClusterMethodResults[M]>;
+    cancelSubscription(registration: SubscriptionRegistration): Promise<void>;
+    openSubscription<M extends SubscriptionMethod>(method: M, params: ClusterMethodParams[M], options?: CallOptions): Promise<EstablishedSubscription<ClusterMethodResults[M]>>;
+    unregisterSubscription(id: string, registration: SubscriptionRegistration): void;
+    recordDiagnostic(error: unknown): void;
+    close(): Promise<void>;
+}

package/lib/cluster/connection.d.ts

@@ -1,32 +1,13 @@
 import type { ClusterMethodParams, ClusterMethodResults, SubscriptionMethod, UnaryClusterMethod } from './generated/protocol.js';
 import { ClusterProtocolError } from './errors.js';
-import type { FrameRecord } from './frames.js';
-import { BoundedQueue } from './queue.js';
 import type { WebSocketLike } from './socket.js';
-export type ConnectionState = 'OPEN' | 'CLOSING' | 'CLOSED';
-export declare const CONNECTION_TRANSITIONS: Readonly<Record<ConnectionState, readonly ConnectionState[]>>;
-export declare const PROTOCOL_DIAGNOSTIC_CAPACITY = 128;
-export declare const CLOSE_REASON_MAX_BYTES = 123;
-export interface CallOptions {
-    readonly signal?: AbortSignal;
-    readonly requestTimeoutMs?: number;
-}
-export type SubscriptionKind = 'watch' | 'logs' | 'agent/attach';
-export type SubscriptionRegistration = {
-    readonly id: string;
-    readonly kind: SubscriptionKind;
-    readonly queue: BoundedQueue<FrameRecord>;
-    overflowed: boolean;
-    cancelSent: boolean;
-    abortHandler?: () => void;
-    abortSignal?: AbortSignal;
-};
-export type EstablishedSubscription<R> = {
-    readonly result: R;
-    readonly registration: SubscriptionRegistration;
-};
+import { type ConnectionCloseSnapshot, type ConnectionState } from './connection-state.js';
+export { CONNECTION_TRANSITIONS, PROTOCOL_DIAGNOSTIC_CAPACITY, type ConnectionCloseSnapshot, type ConnectionState, } from './connection-state.js';
+import type { CallOptions, EstablishedSubscription, SubscriptionRegistration } from './connection-types.js';
+export type { CallOptions, EstablishedSubscription, SubscriptionKind, SubscriptionRegistration, } from './connection-types.js';
 export declare class Connection {
     #private;
+    readonly closed: Promise<ConnectionCloseSnapshot>;
     readonly closeDiagnostics: unknown[];
     readonly protocolDiagnostics: ClusterProtocolError[];
     constructor(socket: WebSocketLike);
@@ -34,7 +15,8 @@ export declare class Connection {
     get pendingSize(): number;
     get subscriptionCount(): number;
     get closeCode(): number | undefined;
-    get closeReason(): string | undefined;
+    get closeReason(): undefined;
+    get closeSnapshot(): ConnectionCloseSnapshot | undefined;
     call<M extends UnaryClusterMethod>(method: M, params: ClusterMethodParams[M], options?: CallOptions): Promise<ClusterMethodResults[M]>;
     cancelSubscription(registration: SubscriptionRegistration): Promise<void>;
     openSubscription<M extends SubscriptionMethod>(method: M, params: ClusterMethodParams[M], options?: CallOptions): Promise<EstablishedSubscription<ClusterMethodResults[M]>>;

package/lib/cluster/connection.mjs

@@ -4,42 +4,8 @@ import { boundedFrameText, isRecord } from './frames.mjs';
 import { BoundedQueue } from './queue.mjs';
 import { addSocketListener } from './socket.mjs';
 import { assertDefinition, assertMethodResult } from './validators.mjs';
-if (!Object.prototype.hasOwnProperty.call(Symbol, 'asyncDispose')) {
-    Object.defineProperty(Symbol, 'asyncDispose', {
-        configurable: false, enumerable: false,
-        value: Symbol.for('Symbol.asyncDispose'), writable: false,
-    });
-}
-export const CONNECTION_TRANSITIONS = Object.freeze({
-    OPEN: Object.freeze(['CLOSING']),
-    CLOSING: Object.freeze(['CLOSED']),
-    CLOSED: Object.freeze([]),
-});
-export const PROTOCOL_DIAGNOSTIC_CAPACITY = 128;
-export const CLOSE_REASON_MAX_BYTES = 123;
-const CLOSE_REASON_ENCODER = new TextEncoder();
-function boundedCloseReason(reason) {
-    const retained = [];
-    const scratch = new Uint8Array(4);
-    let bytes = 0;
-    for (const codePoint of reason) {
-        const { written } = CLOSE_REASON_ENCODER.encodeInto(codePoint, scratch);
-        if (bytes + written > CLOSE_REASON_MAX_BYTES)
-            break;
-        retained.push(codePoint);
-        bytes += written;
-    }
-    return retained.join('');
-}
-function deferred() {
-    let resolve;
-    let reject;
-    const promise = new Promise((onResolve, onReject) => {
-        resolve = onResolve;
-        reject = onReject;
-    });
-    return { promise, resolve, reject };
-}
+import { CONNECTION_TRANSITIONS, PROTOCOL_DIAGNOSTIC_CAPACITY, deferred, } from './connection-state.mjs';
+export { CONNECTION_TRANSITIONS, PROTOCOL_DIAGNOSTIC_CAPACITY, } from './connection-state.mjs';
 export class Connection {
     #state = 'OPEN';
     #sequence = 1;
@@ -50,7 +16,9 @@ export class Connection {
     #ownedSubscriptions = new WeakSet();
     #closePromise;
     #closeCode;
-    #closeReason;
+    #closedCompletion = deferred();
+    closed = this.#closedCompletion.promise;
+    #closeSnapshot;
     closeDiagnostics = [];
     protocolDiagnostics = [];
     #socket;
@@ -64,7 +32,8 @@ export class Connection {
     get pendingSize() { return this.#pending.size; }
     get subscriptionCount() { return this.#subscriptions.size; }
     get closeCode() { return this.#closeCode; }
-    get closeReason() { return this.#closeReason; }
+    get closeReason() { return undefined; }
+    get closeSnapshot() { return this.#closeSnapshot; }
     call(method, params, options = {}) {
         if (!UNARY_METHODS.includes(method)) {
             throw new ClusterConfigError(`${method} is a subscription method`, 'INVALID_METHOD');
@@ -344,15 +313,11 @@ export class Connection {
         const first = args[0];
         if (typeof first === 'number') {
             this.#closeCode = first;
-            const raw = args.length > 1 ? String(args[1]) : undefined;
-            this.#closeReason = raw === undefined ? undefined : boundedCloseReason(raw);
         }
         else if (first !== null && typeof first === 'object') {
             const event = first;
             if (typeof event.code === 'number')
                 this.#closeCode = event.code;
-            if (typeof event.reason === 'string')
-                this.#closeReason = boundedCloseReason(event.reason);
         }
     }
     #startClose(sendCancels) {
@@ -402,6 +367,11 @@ export class Connection {
             }
         }
         this.#transition('CLOSED');
+        this.#closeSnapshot = Object.freeze({
+            code: this.#closeCode ?? null,
+            reason: null,
+        });
+        this.#closedCompletion.resolve(this.#closeSnapshot);
     }
     #transition(to) {
         if (!CONNECTION_TRANSITIONS[this.#state].includes(to))

package/lib/cluster/errors.cjs

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ClusterRpcError = exports.ClusterRequestError = exports.ClusterTimeoutError = exports.ClusterTransportError = exports.ClusterProtocolError = exports.ClusterInternalError = exports.ClusterStateError = exports.ClusterConfigError = exports.ClusterError = void 0;
+exports.ClusterRpcError = exports.ClusterUpgradeError = exports.ClusterRequestError = exports.ClusterTimeoutError = exports.ClusterTransportError = exports.ClusterProtocolError = exports.ClusterInternalError = exports.ClusterStateError = exports.ClusterConfigError = exports.ClusterError = void 0;
 exports.requestAbortError = requestAbortError;
 class ClusterError extends Error {
     code;
@@ -32,6 +32,14 @@ exports.ClusterTimeoutError = ClusterTimeoutError;
 class ClusterRequestError extends ClusterError {
 }
 exports.ClusterRequestError = ClusterRequestError;
+class ClusterUpgradeError extends ClusterTransportError {
+    status;
+    constructor(status) {
+        super(`WebSocket upgrade rejected with HTTP ${status}`, 'UPGRADE_REJECTED');
+        this.status = status;
+    }
+}
+exports.ClusterUpgradeError = ClusterUpgradeError;
 function requestAbortError(method) {
     return new DOMException(`${method} aborted locally; the server may still have committed this request`, 'AbortError');
 }

package/lib/cluster/errors.d.cts

@@ -0,0 +1,29 @@
+import type { DomainErrorData } from './generated/protocol.js';
+export declare class ClusterError extends Error {
+    readonly code: string;
+    constructor(message: string, code: string, options?: ErrorOptions);
+}
+export declare class ClusterConfigError extends ClusterError {
+}
+export declare class ClusterStateError extends ClusterError {
+}
+export declare class ClusterInternalError extends ClusterError {
+}
+export declare class ClusterProtocolError extends ClusterError {
+}
+export declare class ClusterTransportError extends ClusterError {
+}
+export declare class ClusterTimeoutError extends ClusterError {
+}
+export declare class ClusterRequestError extends ClusterError {
+}
+export declare class ClusterUpgradeError extends ClusterTransportError {
+    readonly status: number;
+    constructor(status: number);
+}
+export declare function requestAbortError(method: string): DOMException;
+export declare class ClusterRpcError extends ClusterError {
+    readonly rpcCode: number;
+    readonly data?: DomainErrorData | undefined;
+    constructor(rpcCode: number, message: string, data?: DomainErrorData | undefined);
+}

package/lib/cluster/errors.d.mts

@@ -0,0 +1,29 @@
+import type { DomainErrorData } from './generated/protocol.js';
+export declare class ClusterError extends Error {
+    readonly code: string;
+    constructor(message: string, code: string, options?: ErrorOptions);
+}
+export declare class ClusterConfigError extends ClusterError {
+}
+export declare class ClusterStateError extends ClusterError {
+}
+export declare class ClusterInternalError extends ClusterError {
+}
+export declare class ClusterProtocolError extends ClusterError {
+}
+export declare class ClusterTransportError extends ClusterError {
+}
+export declare class ClusterTimeoutError extends ClusterError {
+}
+export declare class ClusterRequestError extends ClusterError {
+}
+export declare class ClusterUpgradeError extends ClusterTransportError {
+    readonly status: number;
+    constructor(status: number);
+}
+export declare function requestAbortError(method: string): DOMException;
+export declare class ClusterRpcError extends ClusterError {
+    readonly rpcCode: number;
+    readonly data?: DomainErrorData | undefined;
+    constructor(rpcCode: number, message: string, data?: DomainErrorData | undefined);
+}

package/lib/cluster/errors.d.ts

@@ -17,6 +17,10 @@ export declare class ClusterTimeoutError extends ClusterError {
 }
 export declare class ClusterRequestError extends ClusterError {
 }
+export declare class ClusterUpgradeError extends ClusterTransportError {
+    readonly status: number;
+    constructor(status: number);
+}
 export declare function requestAbortError(method: string): DOMException;
 export declare class ClusterRpcError extends ClusterError {
     readonly rpcCode: number;

package/lib/cluster/errors.mjs

@@ -20,6 +20,13 @@ export class ClusterTimeoutError extends ClusterError {
 }
 export class ClusterRequestError extends ClusterError {
 }
+export class ClusterUpgradeError extends ClusterTransportError {
+    status;
+    constructor(status) {
+        super(`WebSocket upgrade rejected with HTTP ${status}`, 'UPGRADE_REJECTED');
+        this.status = status;
+    }
+}
 export function requestAbortError(method) {
     return new DOMException(`${method} aborted locally; the server may still have committed this request`, 'AbortError');
 }

package/lib/cluster/frames.d.cts

@@ -0,0 +1,12 @@
+export type FrameRecord = Readonly<Record<string, unknown>>;
+export type BoundedFrameText = {
+    readonly kind: 'frame';
+    readonly text: string;
+    readonly bytes: number;
+} | {
+    readonly kind: 'oversized';
+} | {
+    readonly kind: 'unsupported';
+};
+export declare function boundedFrameText(event: unknown, maximum: number): BoundedFrameText;
+export declare function isRecord(value: unknown): value is FrameRecord;

package/lib/cluster/frames.d.mts

@@ -0,0 +1,12 @@
+export type FrameRecord = Readonly<Record<string, unknown>>;
+export type BoundedFrameText = {
+    readonly kind: 'frame';
+    readonly text: string;
+    readonly bytes: number;
+} | {
+    readonly kind: 'oversized';
+} | {
+    readonly kind: 'unsupported';
+};
+export declare function boundedFrameText(event: unknown, maximum: number): BoundedFrameText;
+export declare function isRecord(value: unknown): value is FrameRecord;

package/lib/cluster/generated/protocol-schema.d.cts

@@ -0,0 +1 @@
+export declare const CLUSTER_PROTOCOL_SCHEMA: unknown;

package/lib/cluster/generated/protocol-schema.d.mts

@@ -0,0 +1 @@
+export declare const CLUSTER_PROTOCOL_SCHEMA: unknown;