@symmio/trading-core 3.0.0 → 3.1.0

package/dist/websocket/gasless/resolve-gasless-stream-url.d.ts

@@ -0,0 +1,58 @@
+import { SymmioGaslessConfig } from '../../core/chains/types.js';
+import { GaslessService } from '../../gasless/types.js';
+/**
+ * A resolved status-stream endpoint: the `ws(s)://` URL to dial and the
+ * protocol instance every message from it must name.
+ *
+ * @internal
+ */
+export interface GaslessStreamEndpoint {
+    /** Full stream URL, `…/v1/instances/{instance}/{service}/ws`. */
+    url: string;
+    /** The instance the endpoint pins; the `ready` frame is checked against it. */
+    protocolInstance: string;
+    /** The service the stream carries. */
+    service: GaslessService;
+    /** The chain the endpoint was resolved for (for error messages and hub keys). */
+    chainId: number;
+}
+/**
+ * Resolve the status-stream endpoint for one `(chain, service)`.
+ *
+ * The stream shares the gateway's URL forms with HTTP, so both start from
+ * {@link parseGaslessUrl}:
+ *
+ * - **origin** → `wss://host/v1/instances/{instance}/{service}/ws`
+ * - **instance root** → the same, with the configured path
+ * - **service base** → `{url}/ws`, for that service only
+ * - **proxy root** → only from `statusStream.origin`, because a proxy that
+ *   forwards HTTP cannot be assumed to forward a WebSocket upgrade, and a
+ *   relative proxy path has no host core could turn into `ws(s)` without a
+ *   browser global
+ *
+ * The stream is anonymous: a browser `WebSocket` cannot send an `Authorization`
+ * header, so `apiKey` never reaches it. A partner key raises HTTP limits only.
+ *
+ * @param chainId - The chain the config belongs to.
+ * @param gasless - The chain's gasless config.
+ * @param service - Which service's stream to resolve.
+ * @returns The endpoint to dial.
+ * @throws {SymmError} `GASLESS_STREAM_NOT_CONFIGURED` when `statusStream` is absent or disabled.
+ * @throws {SymmError} `GASLESS_STREAM_ORIGIN_REQUIRED` for a proxy root with no `statusStream.origin`.
+ * @throws {SymmError} `GASLESS_STREAM_ORIGIN_CONFLICT` when `origin` is set on a gateway url form.
+ * @throws {SymmError} `GASLESS_PROTOCOL_INSTANCE_REQUIRED` when a proxy root declares no `protocolInstance`.
+ * @throws {SymmError} Every {@link parseGaslessUrl} config error, plus `GASLESS_URL_SERVICE_MISMATCH`.
+ *
+ * @internal
+ */
+export declare function resolveGaslessStreamUrl(chainId: number, gasless: SymmioGaslessConfig, service: GaslessService): GaslessStreamEndpoint;
+/**
+ * Whether `(chain, service)` has a status stream the SDK can dial.
+ *
+ * Non-throwing companion to {@link resolveGaslessStreamUrl}: a consumer can ask
+ * before subscribing, and fall back to HTTP polling when the answer is `false`.
+ *
+ * @internal
+ */
+export declare function canResolveGaslessStreamUrl(chainId: number, gasless: SymmioGaslessConfig, service: GaslessService): boolean;
+//# sourceMappingURL=resolve-gasless-stream-url.d.ts.map

package/dist/websocket/gasless/resolve-gasless-stream-url.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve-gasless-stream-url.d.ts","sourceRoot":"","sources":["../../../src/websocket/gasless/resolve-gasless-stream-url.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AAEnE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAG1D;;;;;GAKG;AACH,MAAM,WAAW,qBAAqB;IACpC,iEAAiE;IACjE,GAAG,EAAE,MAAM,CAAC;IACZ,+EAA+E;IAC/E,gBAAgB,EAAE,MAAM,CAAC;IACzB,sCAAsC;IACtC,OAAO,EAAE,cAAc,CAAC;IACxB,iFAAiF;IACjF,OAAO,EAAE,MAAM,CAAC;CACjB;AAWD;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAgB,uBAAuB,CACrC,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,mBAAmB,EAC5B,OAAO,EAAE,cAAc,GACtB,qBAAqB,CA4DvB;AAED;;;;;;;GAOG;AACH,wBAAgB,0BAA0B,CACxC,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,mBAAmB,EAC5B,OAAO,EAAE,cAAc,GACtB,OAAO,CAOT"}

package/dist/websocket/gasless/resolve-gasless-stream-url.js

@@ -0,0 +1,59 @@
+import { SymmError as e } from "../../shared/errors/symm-error.js";
+import { assertGaslessUrlServes as t, parseGaslessUrl as n } from "../../gasless/gasless-url.js";
+//#region src/websocket/gasless/resolve-gasless-stream-url.ts
+function r(e) {
+	return e.replace(/^http:/i, "ws:").replace(/^https:/i, "wss:");
+}
+function i(t, n) {
+	return new e("config", t, n);
+}
+function a(e, a, o) {
+	if (!a.statusStream?.enabled) throw i("GASLESS_STREAM_NOT_CONFIGURED", `Gasless: chain ${e} does not enable the status stream. Set \`gasless.statusStream.enabled\` once operators confirm the WebSocket for this deployment; until then status reads poll over HTTP.`);
+	let s = n(e, a);
+	t(e, s, o);
+	let c = a.statusStream.origin?.trim().replace(/\/+$/, "");
+	if (s.form === "proxy-root") {
+		if (!c) throw i("GASLESS_STREAM_ORIGIN_REQUIRED", `Gasless: chain ${e} routes HTTP through a proxy, so the status stream needs \`gasless.statusStream.origin\` — the gateway's own origin. A proxy that forwards HTTP does not necessarily forward a WebSocket upgrade, and the stream is anonymous either way.`);
+		if (!s.protocolInstance) throw i("GASLESS_PROTOCOL_INSTANCE_REQUIRED", `Gasless: chain ${e} streams from \`statusStream.origin\` but declares no \`protocolInstance\`. The instance key selects the deployment and is checked on every stream message.`);
+		let t = n(e, {
+			url: c,
+			protocolInstance: s.protocolInstance
+		});
+		if (t.form !== "origin") throw i("GASLESS_STREAM_ORIGIN_REQUIRED", `Gasless: chain ${e} sets \`gasless.statusStream.origin\` to a url with a path. It must be the gateway's bare origin; the SDK appends the instance and service path itself.`);
+		return {
+			url: `${r(t.url)}/v1/instances/${encodeURIComponent(t.protocolInstance)}/${o}/ws`,
+			protocolInstance: t.protocolInstance,
+			service: o,
+			chainId: e
+		};
+	}
+	if (c) throw i("GASLESS_STREAM_ORIGIN_CONFLICT", `Gasless: chain ${e} sets \`gasless.statusStream.origin\` while its \`url\` already names the gateway. Remove the origin — the stream derives from \`url\` — or point \`url\` at your proxy.`);
+	let l = r(s.url);
+	return s.form === "origin" ? {
+		url: `${l}/v1/instances/${encodeURIComponent(s.protocolInstance)}/${o}/ws`,
+		protocolInstance: s.protocolInstance,
+		service: o,
+		chainId: e
+	} : s.form === "instance-root" ? {
+		url: `${l}/${o}/ws`,
+		protocolInstance: s.protocolInstance,
+		service: o,
+		chainId: e
+	} : {
+		url: `${l}/ws`,
+		protocolInstance: s.protocolInstance,
+		service: o,
+		chainId: e
+	};
+}
+function o(e, t, n) {
+	try {
+		return a(e, t, n), !0;
+	} catch {
+		return !1;
+	}
+}
+//#endregion
+export { o as canResolveGaslessStreamUrl, a as resolveGaslessStreamUrl };
+
+//# sourceMappingURL=resolve-gasless-stream-url.js.map

package/dist/websocket/gasless/resolve-gasless-stream-url.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve-gasless-stream-url.js","names":[],"sources":["../../../src/websocket/gasless/resolve-gasless-stream-url.ts"],"sourcesContent":["import type { SymmioGaslessConfig } from \"../../core/chains/types\";\nimport { assertGaslessUrlServes, parseGaslessUrl } from \"../../gasless/gasless-url\";\nimport type { GaslessService } from \"../../gasless/types\";\nimport { SymmError } from \"../../shared/errors/symm-error\";\n\n/**\n * A resolved status-stream endpoint: the `ws(s)://` URL to dial and the\n * protocol instance every message from it must name.\n *\n * @internal\n */\nexport interface GaslessStreamEndpoint {\n  /** Full stream URL, `…/v1/instances/{instance}/{service}/ws`. */\n  url: string;\n  /** The instance the endpoint pins; the `ready` frame is checked against it. */\n  protocolInstance: string;\n  /** The service the stream carries. */\n  service: GaslessService;\n  /** The chain the endpoint was resolved for (for error messages and hub keys). */\n  chainId: number;\n}\n\n/** Swap an `http(s)` scheme for its WebSocket counterpart. */\nfunction toWebSocketScheme(url: string): string {\n  return url.replace(/^http:/i, \"ws:\").replace(/^https:/i, \"wss:\");\n}\n\nfunction streamError(code: string, message: string): SymmError {\n  return new SymmError(\"config\", code, message);\n}\n\n/**\n * Resolve the status-stream endpoint for one `(chain, service)`.\n *\n * The stream shares the gateway's URL forms with HTTP, so both start from\n * {@link parseGaslessUrl}:\n *\n * - **origin** → `wss://host/v1/instances/{instance}/{service}/ws`\n * - **instance root** → the same, with the configured path\n * - **service base** → `{url}/ws`, for that service only\n * - **proxy root** → only from `statusStream.origin`, because a proxy that\n *   forwards HTTP cannot be assumed to forward a WebSocket upgrade, and a\n *   relative proxy path has no host core could turn into `ws(s)` without a\n *   browser global\n *\n * The stream is anonymous: a browser `WebSocket` cannot send an `Authorization`\n * header, so `apiKey` never reaches it. A partner key raises HTTP limits only.\n *\n * @param chainId - The chain the config belongs to.\n * @param gasless - The chain's gasless config.\n * @param service - Which service's stream to resolve.\n * @returns The endpoint to dial.\n * @throws {SymmError} `GASLESS_STREAM_NOT_CONFIGURED` when `statusStream` is absent or disabled.\n * @throws {SymmError} `GASLESS_STREAM_ORIGIN_REQUIRED` for a proxy root with no `statusStream.origin`.\n * @throws {SymmError} `GASLESS_STREAM_ORIGIN_CONFLICT` when `origin` is set on a gateway url form.\n * @throws {SymmError} `GASLESS_PROTOCOL_INSTANCE_REQUIRED` when a proxy root declares no `protocolInstance`.\n * @throws {SymmError} Every {@link parseGaslessUrl} config error, plus `GASLESS_URL_SERVICE_MISMATCH`.\n *\n * @internal\n */\nexport function resolveGaslessStreamUrl(\n  chainId: number,\n  gasless: SymmioGaslessConfig,\n  service: GaslessService,\n): GaslessStreamEndpoint {\n  if (!gasless.statusStream?.enabled) {\n    throw streamError(\n      \"GASLESS_STREAM_NOT_CONFIGURED\",\n      `Gasless: chain ${chainId} does not enable the status stream. Set \\`gasless.statusStream.enabled\\` once operators confirm the WebSocket for this deployment; until then status reads poll over HTTP.`,\n    );\n  }\n\n  const parsed = parseGaslessUrl(chainId, gasless);\n  assertGaslessUrlServes(chainId, parsed, service);\n  const origin = gasless.statusStream.origin?.trim().replace(/\\/+$/, \"\");\n\n  if (parsed.form === \"proxy-root\") {\n    if (!origin) {\n      throw streamError(\n        \"GASLESS_STREAM_ORIGIN_REQUIRED\",\n        `Gasless: chain ${chainId} routes HTTP through a proxy, so the status stream needs \\`gasless.statusStream.origin\\` — the gateway's own origin. A proxy that forwards HTTP does not necessarily forward a WebSocket upgrade, and the stream is anonymous either way.`,\n      );\n    }\n    if (!parsed.protocolInstance) {\n      throw streamError(\n        \"GASLESS_PROTOCOL_INSTANCE_REQUIRED\",\n        `Gasless: chain ${chainId} streams from \\`statusStream.origin\\` but declares no \\`protocolInstance\\`. The instance key selects the deployment and is checked on every stream message.`,\n      );\n    }\n    const base = parseGaslessUrl(chainId, { url: origin, protocolInstance: parsed.protocolInstance });\n    if (base.form !== \"origin\") {\n      throw streamError(\n        \"GASLESS_STREAM_ORIGIN_REQUIRED\",\n        `Gasless: chain ${chainId} sets \\`gasless.statusStream.origin\\` to a url with a path. It must be the gateway's bare origin; the SDK appends the instance and service path itself.`,\n      );\n    }\n    return {\n      url: `${toWebSocketScheme(base.url)}/v1/instances/${encodeURIComponent(base.protocolInstance)}/${service}/ws`,\n      protocolInstance: base.protocolInstance,\n      service,\n      chainId,\n    };\n  }\n\n  if (origin) {\n    throw streamError(\n      \"GASLESS_STREAM_ORIGIN_CONFLICT\",\n      `Gasless: chain ${chainId} sets \\`gasless.statusStream.origin\\` while its \\`url\\` already names the gateway. Remove the origin — the stream derives from \\`url\\` — or point \\`url\\` at your proxy.`,\n    );\n  }\n\n  const base = toWebSocketScheme(parsed.url);\n  if (parsed.form === \"origin\") {\n    return {\n      url: `${base}/v1/instances/${encodeURIComponent(parsed.protocolInstance)}/${service}/ws`,\n      protocolInstance: parsed.protocolInstance,\n      service,\n      chainId,\n    };\n  }\n  if (parsed.form === \"instance-root\") {\n    return { url: `${base}/${service}/ws`, protocolInstance: parsed.protocolInstance, service, chainId };\n  }\n  return { url: `${base}/ws`, protocolInstance: parsed.protocolInstance, service, chainId };\n}\n\n/**\n * Whether `(chain, service)` has a status stream the SDK can dial.\n *\n * Non-throwing companion to {@link resolveGaslessStreamUrl}: a consumer can ask\n * before subscribing, and fall back to HTTP polling when the answer is `false`.\n *\n * @internal\n */\nexport function canResolveGaslessStreamUrl(\n  chainId: number,\n  gasless: SymmioGaslessConfig,\n  service: GaslessService,\n): boolean {\n  try {\n    resolveGaslessStreamUrl(chainId, gasless, service);\n    return true;\n  } catch {\n    return false;\n  }\n}\n"],"mappings":";;;AAuBA,SAAS,EAAkB,GAAqB;CAC9C,OAAO,EAAI,QAAQ,WAAW,KAAK,EAAE,QAAQ,YAAY,MAAM;AACjE;AAEA,SAAS,EAAY,GAAc,GAA4B;CAC7D,OAAO,IAAI,EAAU,UAAU,GAAM,CAAO;AAC9C;AA+BA,SAAgB,EACd,GACA,GACA,GACuB;CACvB,IAAI,CAAC,EAAQ,cAAc,SACzB,MAAM,EACJ,iCACA,kBAAkB,EAAQ,2KAC5B;CAGF,IAAM,IAAS,EAAgB,GAAS,CAAO;CAC/C,EAAuB,GAAS,GAAQ,CAAO;CAC/C,IAAM,IAAS,EAAQ,aAAa,QAAQ,KAAK,EAAE,QAAQ,QAAQ,EAAE;CAErE,IAAI,EAAO,SAAS,cAAc;EAChC,IAAI,CAAC,GACH,MAAM,EACJ,kCACA,kBAAkB,EAAQ,0OAC5B;EAEF,IAAI,CAAC,EAAO,kBACV,MAAM,EACJ,sCACA,kBAAkB,EAAQ,4JAC5B;EAEF,IAAM,IAAO,EAAgB,GAAS;GAAE,KAAK;GAAQ,kBAAkB,EAAO;EAAiB,CAAC;EAChG,IAAI,EAAK,SAAS,UAChB,MAAM,EACJ,kCACA,kBAAkB,EAAQ,wJAC5B;EAEF,OAAO;GACL,KAAK,GAAG,EAAkB,EAAK,GAAG,EAAE,gBAAgB,mBAAmB,EAAK,gBAAgB,EAAE,GAAG,EAAQ;GACzG,kBAAkB,EAAK;GACvB;GACA;EACF;CACF;CAEA,IAAI,GACF,MAAM,EACJ,kCACA,kBAAkB,EAAQ,yKAC5B;CAGF,IAAM,IAAO,EAAkB,EAAO,GAAG;CAYzC,OAXI,EAAO,SAAS,WACX;EACL,KAAK,GAAG,EAAK,gBAAgB,mBAAmB,EAAO,gBAAgB,EAAE,GAAG,EAAQ;EACpF,kBAAkB,EAAO;EACzB;EACA;CACF,IAEE,EAAO,SAAS,kBACX;EAAE,KAAK,GAAG,EAAK,GAAG,EAAQ;EAAM,kBAAkB,EAAO;EAAkB;EAAS;CAAQ,IAE9F;EAAE,KAAK,GAAG,EAAK;EAAM,kBAAkB,EAAO;EAAkB;EAAS;CAAQ;AAC1F;AAUA,SAAgB,EACd,GACA,GACA,GACS;CACT,IAAI;EAEF,OADA,EAAwB,GAAS,GAAS,CAAO,GAC1C;CACT,QAAQ;EACN,OAAO;CACT;AACF"}

package/dist/websocket/gasless/types.d.ts

@@ -0,0 +1,48 @@
+import { GaslessRequest, GaslessRequestTransaction } from '../../gasless/types.js';
+import { GaslessCloseReason } from './close-code-policy.js';
+/**
+ * Health of a gasless status stream, as reported to watchers.
+ *
+ * `live` is the only state where HTTP polling can stand down: a selector is
+ * subscribed and the gateway has sent its snapshot. Every other state means the
+ * caller should keep (or resume) polling.
+ */
+export type GaslessStreamStatus = 
+/** No socket yet — nothing subscribed, or the first dial has not started. */
+"idle"
+/** Dialing, or waiting for the `ready` handshake and this selector's snapshot. */
+ | "connecting"
+/** Subscribed and delivering; poll fallback can pause. */
+ | "live"
+/** Temporarily not delivering (reconnecting, throttled, or over the subscription cap); poll meanwhile. */
+ | "degraded"
+/** Permanently off for this config — streams disabled, unauthorized, misrouted, or a client bug. */
+ | "disabled";
+/**
+ * Why a stream is in its current state, when that is not obvious from the
+ * status alone.
+ */
+export interface GaslessStreamStatusDetail {
+    /** The cause, from the close-code policy or the gateway's own command error. */
+    reason: GaslessCloseReason | "not-configured" | "not-found" | "subscription-limit" | "instance-mismatch" | "terminal";
+    /** WebSocket close code, when a close produced this state. */
+    closeCode?: number;
+    /** One sentence naming what would change it. */
+    detail: string;
+}
+/**
+ * One delivery from a subscribed status stream.
+ *
+ * `snapshot` is the full current state, sent right after a subscribe (including
+ * after a reconnect); `update` follows every stored change. Both carry complete
+ * data, never a patch, so a consumer replaces its state from each one.
+ */
+export interface GaslessRequestStreamUpdate {
+    /** Whether this frame is the subscribe snapshot or a later change. */
+    kind: "snapshot" | "update";
+    /** The workflow record, or `null` when the gateway sent one the SDK could not normalize. */
+    request: GaslessRequest | null;
+    /** Every stored transaction attempt for the workflow, in the gateway's order. */
+    transactions: readonly GaslessRequestTransaction[];
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/websocket/gasless/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/websocket/gasless/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,yBAAyB,EAAE,MAAM,qBAAqB,CAAC;AACrF,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AAE9D;;;;;;GAMG;AACH,MAAM,MAAM,mBAAmB;AAC7B,6EAA6E;AAC3E,MAAM;AACR,kFAAkF;GAChF,YAAY;AACd,0DAA0D;GACxD,MAAM;AACR,0GAA0G;GACxG,UAAU;AACZ,oGAAoG;GAClG,UAAU,CAAC;AAEf;;;GAGG;AACH,MAAM,WAAW,yBAAyB;IACxC,gFAAgF;IAChF,MAAM,EAAE,kBAAkB,GAAG,gBAAgB,GAAG,WAAW,GAAG,oBAAoB,GAAG,mBAAmB,GAAG,UAAU,CAAC;IACtH,8DAA8D;IAC9D,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,gDAAgD;IAChD,MAAM,EAAE,MAAM,CAAC;CAChB;AAED;;;;;;GAMG;AACH,MAAM,WAAW,0BAA0B;IACzC,sEAAsE;IACtE,IAAI,EAAE,UAAU,GAAG,QAAQ,CAAC;IAC5B,4FAA4F;IAC5F,OAAO,EAAE,cAAc,GAAG,IAAI,CAAC;IAC/B,iFAAiF;IACjF,YAAY,EAAE,SAAS,yBAAyB,EAAE,CAAC;CACpD"}

package/dist/websocket/gasless/watch-gasless-request.d.ts

@@ -0,0 +1,72 @@
+import { Config } from '../../core/config/index.js';
+import { GaslessService } from '../../gasless/types.js';
+import { SymmError } from '../../shared/errors/symm-error.js';
+import { ChainIdParameter, Compute } from '../../shared/types/properties.js';
+import { GaslessRequestStreamUpdate, GaslessStreamStatus, GaslessStreamStatusDetail } from './types.js';
+/**
+ * Parameters for {@link watchGaslessRequest}.
+ */
+export type WatchGaslessRequestParameters = Compute<ChainIdParameter & {
+    /** Stable service id returned by a gasless submit. */
+    requestId: string;
+    /** Which service stores the workflow. Defaults to `"operations"`. */
+    service?: GaslessService;
+    /** Called with the subscribe snapshot and every later change; both carry complete state. */
+    onUpdate: (update: GaslessRequestStreamUpdate) => void;
+    /** Called whenever the stream's health changes, so a caller can poll while it is not `live`. */
+    onStatusChange?: (status: GaslessStreamStatus, detail: GaslessStreamStatusDetail | null) => void;
+    /** Called on a stream-level error; the subscription stays and the caller keeps polling. */
+    onError?: (error: SymmError) => void;
+}>;
+/** Releases a {@link watchGaslessRequest} subscription. */
+export type UnwatchGaslessRequest = () => void;
+/**
+ * Subscribe to one relayer workflow's live status.
+ *
+ * **Opens a socket and nothing else — it never issues HTTP.** The gateway's
+ * status stream is optional and off unless a deployment declares
+ * `gasless.statusStream.enabled`, so a caller pairs this with
+ * `getGaslessRequestQueryOptions` (or `useGaslessRequest`, which does it for
+ * you) and polls while `onStatusChange` reports anything but `"live"`. A
+ * `watch*` that silently became an HTTP poller would break its own contract:
+ * `Unwatch` would tear down two unlike resources and `onStatusChange` would
+ * describe a transport the data no longer came from.
+ *
+ * One socket per `(config, service, instance)` is shared by every watcher, its
+ * subscriptions are replayed after each reconnect, and a terminal workflow
+ * status unsubscribes itself.
+ *
+ * @param config - The SDK config.
+ * @param parameters - Request id, optional chain/service override, handlers.
+ * @returns An unwatch function that releases this subscription.
+ * @throws {SymmError} synchronously when the chain has no gasless block, the
+ *   stream is not enabled, or the endpoint cannot be derived
+ *   (`GASLESS_STREAM_NOT_CONFIGURED`, `GASLESS_STREAM_ORIGIN_REQUIRED`,
+ *   `GASLESS_STREAM_ORIGIN_CONFLICT`, plus the url/config errors).
+ *
+ * @example
+ * ```ts
+ * const unwatch = watchGaslessRequest(config, {
+ *   requestId,
+ *   onUpdate: ({ request }) => render(request),
+ *   onStatusChange: (status) => setPolling(status !== "live"),
+ * });
+ * ```
+ */
+export declare function watchGaslessRequest(config: Config, parameters: WatchGaslessRequestParameters): UnwatchGaslessRequest;
+/**
+ * Whether `(chain, service)` can be streamed at all.
+ *
+ * Non-throwing: a consumer asks before subscribing and falls back to polling
+ * when the answer is `false` — an un-upgraded deployment, a proxy without a
+ * declared gateway origin, or simply a deployment whose operators have not
+ * enabled status WebSockets yet.
+ *
+ * @param config - The SDK config.
+ * @param parameters - Optional chain and service override.
+ * @returns `true` when {@link watchGaslessRequest} would resolve an endpoint.
+ */
+export declare function supportsGaslessStatusStream(config: Config, parameters?: Compute<ChainIdParameter & {
+    service?: GaslessService;
+}>): boolean;
+//# sourceMappingURL=watch-gasless-request.d.ts.map

package/dist/websocket/gasless/watch-gasless-request.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"watch-gasless-request.d.ts","sourceRoot":"","sources":["../../../src/websocket/gasless/watch-gasless-request.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAEhD,OAAO,EAA4B,KAAK,cAAc,EAAE,MAAM,qBAAqB,CAAC;AACpF,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gCAAgC,CAAC;AAChE,OAAO,KAAK,EAAE,gBAAgB,EAAE,OAAO,EAAE,MAAM,+BAA+B,CAAC;AAG/E,OAAO,KAAK,EAAE,0BAA0B,EAAE,mBAAmB,EAAE,yBAAyB,EAAE,MAAM,SAAS,CAAC;AAE1G;;GAEG;AACH,MAAM,MAAM,6BAA6B,GAAG,OAAO,CACjD,gBAAgB,GAAG;IACjB,sDAAsD;IACtD,SAAS,EAAE,MAAM,CAAC;IAClB,qEAAqE;IACrE,OAAO,CAAC,EAAE,cAAc,CAAC;IACzB,4FAA4F;IAC5F,QAAQ,EAAE,CAAC,MAAM,EAAE,0BAA0B,KAAK,IAAI,CAAC;IACvD,gGAAgG;IAChG,cAAc,CAAC,EAAE,CAAC,MAAM,EAAE,mBAAmB,EAAE,MAAM,EAAE,yBAAyB,GAAG,IAAI,KAAK,IAAI,CAAC;IACjG,2FAA2F;IAC3F,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,SAAS,KAAK,IAAI,CAAC;CACtC,CACF,CAAC;AAEF,2DAA2D;AAC3D,MAAM,MAAM,qBAAqB,GAAG,MAAM,IAAI,CAAC;AAE/C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,6BAA6B,GAAG,qBAAqB,CAsBpH;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,2BAA2B,CACzC,MAAM,EAAE,MAAM,EACd,UAAU,GAAE,OAAO,CAAC,gBAAgB,GAAG;IAAE,OAAO,CAAC,EAAE,cAAc,CAAA;CAAE,CAAM,GACxE,OAAO,CAST"}

package/dist/websocket/gasless/watch-gasless-request.js

@@ -0,0 +1,35 @@
+import { resolveGaslessService as e } from "../../gasless/resolve-gasless.js";
+import { isGaslessRequestTerminal as t } from "../../gasless/types.js";
+import { acquireGaslessStreamSelector as n, releaseGaslessStreamSelector as r } from "./gasless-stream-hub.js";
+import { canResolveGaslessStreamUrl as i, resolveGaslessStreamUrl as a } from "./resolve-gasless-stream-url.js";
+//#region src/websocket/gasless/watch-gasless-request.ts
+function o(i, o) {
+	let { chainId: s, requestId: c, service: l = "operations", onUpdate: u, onStatusChange: d, onError: f } = o, p = i.getChainConfig(s), m = e(i, { chainId: s }), h = a(p.chainId, m, l), g = {
+		kind: "request",
+		requestId: c
+	};
+	return n(i, {
+		endpoint: h,
+		selector: g,
+		listener: {
+			onUpdate: (e) => {
+				e.request && t(e.request.status) && r(i, h.url, g), u(e);
+			},
+			onStatusChange: d,
+			onError: f
+		}
+	});
+}
+function s(t, n = {}) {
+	let { chainId: r, service: a = "operations" } = n;
+	try {
+		let n = t.getChainConfig(r), o = e(t, { chainId: r });
+		return i(n.chainId, o, a);
+	} catch {
+		return !1;
+	}
+}
+//#endregion
+export { s as supportsGaslessStatusStream, o as watchGaslessRequest };
+
+//# sourceMappingURL=watch-gasless-request.js.map

package/dist/websocket/gasless/watch-gasless-request.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"watch-gasless-request.js","names":[],"sources":["../../../src/websocket/gasless/watch-gasless-request.ts"],"sourcesContent":["import type { Config } from \"../../core/config\";\nimport { resolveGaslessService } from \"../../gasless/resolve-gasless\";\nimport { isGaslessRequestTerminal, type GaslessService } from \"../../gasless/types\";\nimport type { SymmError } from \"../../shared/errors/symm-error\";\nimport type { ChainIdParameter, Compute } from \"../../shared/types/properties\";\nimport { acquireGaslessStreamSelector, releaseGaslessStreamSelector } from \"./gasless-stream-hub\";\nimport { canResolveGaslessStreamUrl, resolveGaslessStreamUrl } from \"./resolve-gasless-stream-url\";\nimport type { GaslessRequestStreamUpdate, GaslessStreamStatus, GaslessStreamStatusDetail } from \"./types\";\n\n/**\n * Parameters for {@link watchGaslessRequest}.\n */\nexport type WatchGaslessRequestParameters = Compute<\n  ChainIdParameter & {\n    /** Stable service id returned by a gasless submit. */\n    requestId: string;\n    /** Which service stores the workflow. Defaults to `\"operations\"`. */\n    service?: GaslessService;\n    /** Called with the subscribe snapshot and every later change; both carry complete state. */\n    onUpdate: (update: GaslessRequestStreamUpdate) => void;\n    /** Called whenever the stream's health changes, so a caller can poll while it is not `live`. */\n    onStatusChange?: (status: GaslessStreamStatus, detail: GaslessStreamStatusDetail | null) => void;\n    /** Called on a stream-level error; the subscription stays and the caller keeps polling. */\n    onError?: (error: SymmError) => void;\n  }\n>;\n\n/** Releases a {@link watchGaslessRequest} subscription. */\nexport type UnwatchGaslessRequest = () => void;\n\n/**\n * Subscribe to one relayer workflow's live status.\n *\n * **Opens a socket and nothing else — it never issues HTTP.** The gateway's\n * status stream is optional and off unless a deployment declares\n * `gasless.statusStream.enabled`, so a caller pairs this with\n * `getGaslessRequestQueryOptions` (or `useGaslessRequest`, which does it for\n * you) and polls while `onStatusChange` reports anything but `\"live\"`. A\n * `watch*` that silently became an HTTP poller would break its own contract:\n * `Unwatch` would tear down two unlike resources and `onStatusChange` would\n * describe a transport the data no longer came from.\n *\n * One socket per `(config, service, instance)` is shared by every watcher, its\n * subscriptions are replayed after each reconnect, and a terminal workflow\n * status unsubscribes itself.\n *\n * @param config - The SDK config.\n * @param parameters - Request id, optional chain/service override, handlers.\n * @returns An unwatch function that releases this subscription.\n * @throws {SymmError} synchronously when the chain has no gasless block, the\n *   stream is not enabled, or the endpoint cannot be derived\n *   (`GASLESS_STREAM_NOT_CONFIGURED`, `GASLESS_STREAM_ORIGIN_REQUIRED`,\n *   `GASLESS_STREAM_ORIGIN_CONFLICT`, plus the url/config errors).\n *\n * @example\n * ```ts\n * const unwatch = watchGaslessRequest(config, {\n *   requestId,\n *   onUpdate: ({ request }) => render(request),\n *   onStatusChange: (status) => setPolling(status !== \"live\"),\n * });\n * ```\n */\nexport function watchGaslessRequest(config: Config, parameters: WatchGaslessRequestParameters): UnwatchGaslessRequest {\n  const { chainId, requestId, service = \"operations\", onUpdate, onStatusChange, onError } = parameters;\n  const chain = config.getChainConfig(chainId);\n  const gasless = resolveGaslessService(config, { chainId });\n  const endpoint = resolveGaslessStreamUrl(chain.chainId, gasless, service);\n  const selector = { kind: \"request\", requestId } as const;\n\n  return acquireGaslessStreamSelector(config, {\n    endpoint,\n    selector,\n    listener: {\n      onUpdate: (update) => {\n        /** A terminal record ends the subscription: the gateway sends nothing more. */\n        if (update.request && isGaslessRequestTerminal(update.request.status)) {\n          releaseGaslessStreamSelector(config, endpoint.url, selector);\n        }\n        onUpdate(update);\n      },\n      onStatusChange,\n      onError,\n    },\n  });\n}\n\n/**\n * Whether `(chain, service)` can be streamed at all.\n *\n * Non-throwing: a consumer asks before subscribing and falls back to polling\n * when the answer is `false` — an un-upgraded deployment, a proxy without a\n * declared gateway origin, or simply a deployment whose operators have not\n * enabled status WebSockets yet.\n *\n * @param config - The SDK config.\n * @param parameters - Optional chain and service override.\n * @returns `true` when {@link watchGaslessRequest} would resolve an endpoint.\n */\nexport function supportsGaslessStatusStream(\n  config: Config,\n  parameters: Compute<ChainIdParameter & { service?: GaslessService }> = {},\n): boolean {\n  const { chainId, service = \"operations\" } = parameters;\n  try {\n    const chain = config.getChainConfig(chainId);\n    const gasless = resolveGaslessService(config, { chainId });\n    return canResolveGaslessStreamUrl(chain.chainId, gasless, service);\n  } catch {\n    return false;\n  }\n}\n"],"mappings":";;;;;AA+DA,SAAgB,EAAoB,GAAgB,GAAkE;CACpH,IAAM,EAAE,YAAS,cAAW,aAAU,cAAc,aAAU,mBAAgB,eAAY,GACpF,IAAQ,EAAO,eAAe,CAAO,GACrC,IAAU,EAAsB,GAAQ,EAAE,WAAQ,CAAC,GACnD,IAAW,EAAwB,EAAM,SAAS,GAAS,CAAO,GAClE,IAAW;EAAE,MAAM;EAAW;CAAU;CAE9C,OAAO,EAA6B,GAAQ;EAC1C;EACA;EACA,UAAU;GACR,WAAW,MAAW;IAKpB,AAHI,EAAO,WAAW,EAAyB,EAAO,QAAQ,MAAM,KAClE,EAA6B,GAAQ,EAAS,KAAK,CAAQ,GAE7D,EAAS,CAAM;GACjB;GACA;GACA;EACF;CACF,CAAC;AACH;AAcA,SAAgB,EACd,GACA,IAAuE,CAAC,GAC/D;CACT,IAAM,EAAE,YAAS,aAAU,iBAAiB;CAC5C,IAAI;EACF,IAAM,IAAQ,EAAO,eAAe,CAAO,GACrC,IAAU,EAAsB,GAAQ,EAAE,WAAQ,CAAC;EACzD,OAAO,EAA2B,EAAM,SAAS,GAAS,CAAO;CACnE,QAAQ;EACN,OAAO;CACT;AACF"}

package/dist/websocket/index.d.ts

@@ -1,3 +1,4 @@
+export * from './gasless/index.js';
 export * from './notifications/index.js';
 export * from './prices/index.js';
 export * from './socket/index.js';

package/dist/websocket/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/websocket/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAC;AAChC,cAAc,UAAU,CAAC;AACzB,cAAc,UAAU,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/websocket/index.ts"],"names":[],"mappings":"AAAA,cAAc,WAAW,CAAC;AAC1B,cAAc,iBAAiB,CAAC;AAChC,cAAc,UAAU,CAAC;AACzB,cAAc,UAAU,CAAC"}

package/dist/websocket/socket/create-reconnecting-socket.d.ts

@@ -6,7 +6,10 @@ import { SocketStatus } from './socket-status.js';
  * 10s exponential backoff with jitter).
  */
 export interface ReconnectingSocketReconnectOptions {
-    /** Reconnect after an unclean close. Default `true`. */
+    /**
+     * Redial when the connection closes, or a dial throws, without `close()`
+     * having been called. The close code is not inspected. Default `true`.
+     */
     enabled?: boolean;
     /** Max consecutive retries before giving up. Default `Infinity`. */
     maxAttempts?: number;
@@ -37,7 +40,13 @@ export interface SocketCloseInfo {
     code?: number;
     /** WebSocket close reason, if any. */
     reason?: string;
-    /** Whether the socket will attempt to reconnect after this close. */
+    /** Whether the connection closed cleanly (the closing handshake completed), if the implementation reported it. */
+    wasClean?: boolean;
+    /**
+     * Whether the socket will attempt to reconnect after this close. Calling
+     * {@link ReconnectingSocket.close} from inside `onClose` cancels a reconnect
+     * reported here as `true`.
+     */
     willReconnect: boolean;
 }
 /**
@@ -62,11 +71,20 @@ export interface ReconnectingSocketOptions {
     heartbeat?: ReconnectingSocketHeartbeatOptions;
     /** Called each time the socket transitions to `open`. */
     onOpen?: () => void;
-    /** Called each time the underlying connection closes (transient or terminal). */
+    /**
+     * Called each time the underlying connection closes (transient or terminal).
+     * A dial that throws is reported to `onError` instead, and `close()` while no
+     * connection exists (for example during a backoff wait) settles the status
+     * without calling this.
+     */
     onClose?: (info: SocketCloseInfo) => void;
     /** Called on a transport-level error; receives the raw error event. */
     onError?: (event: unknown) => void;
-    /** Called for each inbound frame; `data` is the raw `event.data` (usually a JSON string). */
+    /**
+     * Called for each inbound frame; `data` is the raw `event.data` (usually a
+     * JSON string). Not called after `close()`, even for a frame the
+     * implementation still delivers while the connection finishes closing.
+     */
     onMessage?: (data: unknown) => void;
     /** Called whenever {@link SocketStatus} changes. */
     onStatusChange?: (status: SocketStatus) => void;
@@ -79,8 +97,23 @@ export interface ReconnectingSocketOptions {
 export interface ReconnectingSocket {
     /** Send a text frame now if open, otherwise buffer it until the next open. */
     send(data: string): void;
-    /** Close permanently (no reconnect), flushing timers. Idempotent. */
-    close(): void;
+    /**
+     * Close permanently: cancel any pending reconnect, stop the heartbeat, drop
+     * buffered sends, and close the current connection. From this call on no
+     * frame reaches `onMessage`, even while the connection is still closing. Safe
+     * to call from any callback, including `onClose` and `onStatusChange`.
+     * Idempotent — only the first call acts, so a later call's `code` and
+     * `reason` are ignored.
+     *
+     * `code` and `reason` are checked before the connection is touched, the same
+     * way for every implementation and whether or not a connection is open. When
+     * either breaks the limits below, a `RangeError` goes to `onError` and the
+     * connection closes without them.
+     *
+     * @param code - Close code to send: `1000`, or an integer from `3000` to `4999` — the codes the WebSocket standard lets a client send. Any other code is rejected, even one the implementation would send (the `ws` package accepts `1001`).
+     * @param reason - Close reason to send, at most 123 UTF-8 bytes.
+     */
+    close(code?: number, reason?: string): void;
     /** Current connection status. */
     getStatus(): SocketStatus;
 }

package/dist/websocket/socket/create-reconnecting-socket.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"create-reconnecting-socket.d.ts","sourceRoot":"","sources":["../../../src/websocket/socket/create-reconnecting-socket.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAiB,MAAM,8BAA8B,CAAC;AAExF,OAAO,EAAsB,KAAK,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAExE;;;;GAIG;AACH,MAAM,WAAW,kCAAkC;IACjD,wDAAwD;IACxD,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,oEAAoE;IACpE,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,0DAA0D;IAC1D,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,sEAAsE;IACtE,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,2DAA2D;IAC3D,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB;AAED;;;GAGG;AACH,MAAM,WAAW,kCAAkC;IACjD,mEAAmE;IACnE,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,kEAAkE;IAClE,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,qDAAqD;IACrD,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,gEAAgE;IAChE,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,sCAAsC;IACtC,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,qEAAqE;IACrE,aAAa,EAAE,OAAO,CAAC;CACxB;AAED;;GAEG;AACH,MAAM,WAAW,yBAAyB;IACxC,yCAAyC;IACzC,GAAG,EAAE,MAAM,CAAC;IACZ,uEAAuE;IACvE,SAAS,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;IAC9B,+FAA+F;IAC/F,oBAAoB,EAAE,oBAAoB,CAAC;IAC3C;;;;OAIG;IACH,eAAe,CAAC,EAAE,MAAM,MAAM,EAAE,CAAC;IACjC,wBAAwB;IACxB,SAAS,CAAC,EAAE,kCAAkC,CAAC;IAC/C,wBAAwB;IACxB,SAAS,CAAC,EAAE,kCAAkC,CAAC;IAC/C,yDAAyD;IACzD,MAAM,CAAC,EAAE,MAAM,IAAI,CAAC;IACpB,iFAAiF;IACjF,OAAO,CAAC,EAAE,CAAC,IAAI,EAAE,eAAe,KAAK,IAAI,CAAC;IAC1C,uEAAuE;IACvE,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,CAAC;IACnC,6FAA6F;IAC7F,SAAS,CAAC,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,IAAI,CAAC;IACpC,oDAAoD;IACpD,cAAc,CAAC,EAAE,CAAC,MAAM,EAAE,YAAY,KAAK,IAAI,CAAC;IAChD,6FAA6F;IAC7F,MAAM,CAAC,EAAE,MAAM,MAAM,CAAC;CACvB;AAED;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC,8EAA8E;IAC9E,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,qEAAqE;IACrE,KAAK,IAAI,IAAI,CAAC;IACd,iCAAiC;IACjC,SAAS,IAAI,YAAY,CAAC;CAC3B;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,yBAAyB,GAAG,kBAAkB,CAwJ/F"}
+{"version":3,"file":"create-reconnecting-socket.d.ts","sourceRoot":"","sources":["../../../src/websocket/socket/create-reconnecting-socket.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAiB,MAAM,8BAA8B,CAAC;AAExF,OAAO,EAAsB,KAAK,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAExE;;;;GAIG;AACH,MAAM,WAAW,kCAAkC;IACjD;;;OAGG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,oEAAoE;IACpE,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,0DAA0D;IAC1D,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,sEAAsE;IACtE,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,2DAA2D;IAC3D,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB;AAED;;;GAGG;AACH,MAAM,WAAW,kCAAkC;IACjD,mEAAmE;IACnE,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,kEAAkE;IAClE,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,qDAAqD;IACrD,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,gEAAgE;IAChE,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,sCAAsC;IACtC,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,kHAAkH;IAClH,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB;;;;OAIG;IACH,aAAa,EAAE,OAAO,CAAC;CACxB;AAED;;GAEG;AACH,MAAM,WAAW,yBAAyB;IACxC,yCAAyC;IACzC,GAAG,EAAE,MAAM,CAAC;IACZ,uEAAuE;IACvE,SAAS,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;IAC9B,+FAA+F;IAC/F,oBAAoB,EAAE,oBAAoB,CAAC;IAC3C;;;;OAIG;IACH,eAAe,CAAC,EAAE,MAAM,MAAM,EAAE,CAAC;IACjC,wBAAwB;IACxB,SAAS,CAAC,EAAE,kCAAkC,CAAC;IAC/C,wBAAwB;IACxB,SAAS,CAAC,EAAE,kCAAkC,CAAC;IAC/C,yDAAyD;IACzD,MAAM,CAAC,EAAE,MAAM,IAAI,CAAC;IACpB;;;;;OAKG;IACH,OAAO,CAAC,EAAE,CAAC,IAAI,EAAE,eAAe,KAAK,IAAI,CAAC;IAC1C,uEAAuE;IACvE,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,CAAC;IACnC;;;;OAIG;IACH,SAAS,CAAC,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,IAAI,CAAC;IACpC,oDAAoD;IACpD,cAAc,CAAC,EAAE,CAAC,MAAM,EAAE,YAAY,KAAK,IAAI,CAAC;IAChD,6FAA6F;IAC7F,MAAM,CAAC,EAAE,MAAM,MAAM,CAAC;CACvB;AAED;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC,8EAA8E;IAC9E,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB;;;;;;;;;;;;;;;OAeG;IACH,KAAK,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5C,iCAAiC;IACjC,SAAS,IAAI,YAAY,CAAC;CAC3B;AA0BD;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,yBAAyB,GAAG,kBAAkB,CAiO/F"}

package/dist/websocket/socket/create-reconnecting-socket.js

@@ -1,101 +1,140 @@
 import { computeBackoffDelay as e } from "./backoff.js";
 import { SOCKET_READY_STATE as t } from "./socket-status.js";
 //#region src/websocket/socket/create-reconnecting-socket.ts
-function n(n) {
+var n = 123;
+function r(e) {
+	return e === 1e3 || Number.isInteger(e) && e >= 3e3 && e <= 4999;
+}
+function i(e, t) {
+	if (e !== void 0 && !r(e)) return /* @__PURE__ */ RangeError(`WebSocket close code ${e} is not allowed; use 1000 or an integer from 3000 to 4999.`);
+	if (t === void 0) return;
+	let i = new TextEncoder().encode(t).length;
+	if (!(i <= n)) return /* @__PURE__ */ RangeError(`WebSocket close reason is ${i} UTF-8 bytes; the limit is ${n}.`);
+}
+function a(n) {
 	let r = {
 		enabled: n.reconnect?.enabled ?? !0,
 		maxAttempts: n.reconnect?.maxAttempts ?? Infinity,
 		baseDelayMs: n.reconnect?.baseDelayMs ?? 500,
 		maxDelayMs: n.reconnect?.maxDelayMs ?? 1e4,
 		jitter: n.reconnect?.jitter ?? !0
-	}, i = {
+	}, a = {
 		enabled: n.heartbeat?.enabled ?? !1,
 		intervalMs: n.heartbeat?.intervalMs ?? 3e4,
 		message: n.heartbeat?.message ?? "ping"
-	}, a = null, o = "connecting", s = 0, c = !1, l = [], u = null, d = null;
-	function f(e) {
-		o !== e && (o = e, n.onStatusChange?.(e));
-	}
-	function p() {
-		u !== null && (clearTimeout(u), u = null);
+	}, o = null, s = "connecting", c = 0, l = !1, u = [], d = null, f = null;
+	function p(e) {
+		s !== e && (s = e, n.onStatusChange?.(e));
 	}
 	function m() {
-		d !== null && (clearInterval(d), d = null);
+		d !== null && (clearTimeout(d), d = null);
+	}
+	function h() {
+		f !== null && (clearInterval(f), f = null);
+	}
+	function g(e) {
+		return !l && o === e;
+	}
+	function _() {
+		return !l && r.enabled && c < r.maxAttempts;
 	}
-	function h(e, r) {
+	function v(e, r) {
 		try {
 			e.readyState === t.OPEN && e.send(r);
 		} catch (e) {
 			n.onError?.(e);
 		}
 	}
-	function g(e) {
-		i.enabled && (m(), d = setInterval(() => h(e, i.message), i.intervalMs));
+	function y(e) {
+		!a.enabled || !g(e) || (h(), f = setInterval(() => v(e, a.message), a.intervalMs));
 	}
-	function _() {
-		p(), f("connecting");
+	function b() {
+		if (m(), l || (p("connecting"), l)) return;
 		let e;
 		try {
 			e = new n.webSocketConstructor(n.url, n.protocols);
 		} catch (e) {
-			n.onError?.(e), v();
+			n.onError?.(e), _() ? x() : p("closed");
 			return;
 		}
-		a = e, e.onopen = () => {
-			if (a === e) {
-				s = 0, f("open"), n.onOpen?.();
-				for (let t of n.getOpenMessages?.() ?? []) h(e, t);
-				if (l.length > 0) {
-					let t = l;
-					l = [];
-					for (let n of t) h(e, n);
+		o = e, e.onopen = () => {
+			if (g(e) && (c = 0, p("open"), g(e) && (n.onOpen?.(), g(e)))) {
+				for (let t of n.getOpenMessages?.() ?? []) v(e, t);
+				if (u.length > 0) {
+					let t = u;
+					u = [];
+					for (let n of t) v(e, n);
 				}
-				g(e);
+				y(e);
 			}
 		}, e.onmessage = (t) => {
-			a === e && n.onMessage?.(t.data);
+			g(e) && n.onMessage?.(t.data);
 		}, e.onerror = (t) => {
-			a === e && n.onError?.(t);
+			o === e && n.onError?.(t);
 		}, e.onclose = (t) => {
-			if (a !== e) return;
-			m(), a = null;
-			let i = !c && r.enabled && s < r.maxAttempts;
+			if (o !== e) return;
+			h(), o = null;
+			let r = _();
 			if (n.onClose?.({
 				code: t?.code,
 				reason: t?.reason,
-				willReconnect: i
-			}), !i) {
-				f("closed");
+				wasClean: t?.wasClean,
+				willReconnect: r
+			}), r && !l) {
+				x();
 				return;
 			}
-			v();
+			p("closed");
 		};
 	}
-	function v() {
-		f("reconnecting");
-		let t = e(s, r, n.random);
-		s += 1, u = setTimeout(_, t);
+	function x() {
+		if (l || (p("reconnecting"), l)) return;
+		let t = e(c, r, n.random);
+		c += 1, d = setTimeout(b, t);
 	}
-	function y(e) {
-		a && a.readyState === t.OPEN ? h(a, e) : l.push(e);
+	function S(e) {
+		o && o.readyState === t.OPEN ? v(o, e) : u.push(e);
 	}
-	function b() {
-		if (!c) if (c = !0, p(), m(), l = [], a) {
-			f("closing");
-			try {
-				a.close();
-			} catch {
-				f("closed");
-			}
-		} else f("closed");
+	function C(e, t) {
+		try {
+			e.close();
+		} finally {
+			n.onError?.(t);
+		}
+	}
+	function w(e, t, n) {
+		if (t === void 0 && n === void 0) {
+			e.close();
+			return;
+		}
+		try {
+			e.close(t, n);
+		} catch (t) {
+			C(e, t);
+		}
+	}
+	function T(e, t) {
+		if (l) return;
+		l = !0, m(), h(), u = [];
+		let r = i(e, t), a = o;
+		if (!a) {
+			p("closed"), r && n.onError?.(r);
+			return;
+		}
+		p("closing");
+		try {
+			r ? C(a, r) : w(a, e, t);
+		} catch {
+			p("closed");
+		}
 	}
-	return _(), {
-		send: y,
-		close: b,
-		getStatus: () => o
+	return b(), {
+		send: S,
+		close: T,
+		getStatus: () => s
 	};
 }
 //#endregion
-export { n as createReconnectingSocket };
+export { a as createReconnectingSocket };
 
 //# sourceMappingURL=create-reconnecting-socket.js.map