@uengage.io/platform-sdk 0.15.0 → 2.0.0

package/dist/realtime/connect.d.ts

@@ -0,0 +1,106 @@
+import { type RealtimeEvent } from './envelope';
+import { type RealtimeEndpoints, type RealtimeEnv } from './endpoints';
+/**
+ * The slice of the WebSocket API this client uses.
+ *
+ * Declared structurally rather than relying on a DOM lib: the SDK
+ * compiles against `lib: ES2022` only, and this keeps the client
+ * injectable so tests can drive the protocol with a fake socket.
+ */
+export interface MinimalWebSocket {
+    readyState: number;
+    send(data: string): void;
+    close(code?: number, reason?: string): void;
+    onopen: ((ev: unknown) => void) | null;
+    onmessage: ((ev: {
+        data: unknown;
+    }) => void) | null;
+    onerror: ((ev: unknown) => void) | null;
+    onclose: ((ev: {
+        code?: number;
+        reason?: string;
+    }) => void) | null;
+}
+export type WebSocketCtor = new (url: string, protocols?: string | string[]) => MinimalWebSocket;
+/** Where an event handed to `onUpdate` came from. */
+export interface UpdateMeta {
+    channel: string;
+    /**
+     * `'snapshot'` — the channel's last value, fetched from the last-value
+     * cache on subscribe or after a reconnect. `'live'` — delivered over
+     * the socket.
+     *
+     * Apps generally don't need to branch on this; the SDK has already
+     * ordered and de-duplicated both sources by ULID. It's there for
+     * telemetry and for UIs that want to distinguish "restored" from
+     * "just happened".
+     */
+    origin: 'snapshot' | 'live';
+}
+export interface SubscribeOptions {
+    /**
+     * Fires once with the channel's latest known value (if any), then on
+     * every live event. Never fires with an event older than one already
+     * delivered on this subscription.
+     */
+    onUpdate(event: RealtimeEvent, meta: UpdateMeta): void;
+    /**
+     * Subscription-level failures: a rejected subscribe, a malformed
+     * frame, a failed snapshot fetch. Transient socket drops are handled
+     * internally by the reconnect loop and are not surfaced here.
+     */
+    onError?(error: Error): void;
+    /**
+     * Replace the built-in last-value fetch for this channel. Return null
+     * when there is no snapshot. Useful when a domain has a better source
+     * of truth than the cache — e.g. falling back to the order-details API
+     * for an order whose transitions predate bus instrumentation.
+     */
+    getSnapshot?(channel: string): Promise<RealtimeEvent | null>;
+}
+export interface Subscription {
+    readonly channel: string;
+    unsubscribe(): void;
+}
+export interface RealtimeClient {
+    /**
+     * Subscribe to a channel. Channels are the only concept here — the
+     * realtime layer knows nothing about orders; `/orders/{id}` is a
+     * naming convention enforced by the service's namespace policy, not by
+     * this client.
+     *
+     * On this call, and again after every reconnect, the SDK opens the
+     * subscription *first* and only then fetches the channel's last value,
+     * so no event can fall between the snapshot and the stream.
+     */
+    subscribe(channel: string, options: SubscribeOptions): Subscription;
+    /** Close the shared socket and stop reconnecting. */
+    close(): void;
+}
+export interface RealtimeConnectOptions {
+    /** Resolves endpoints from the built-in table. Mutually exclusive with `endpoints`. */
+    env?: RealtimeEnv;
+    /** Explicit endpoints, for environments not in the table. */
+    endpoints?: RealtimeEndpoints;
+    /**
+     * Supplies the platform JWT. Called on connect, on every (re)subscribe,
+     * and again after a token-expiry reconnect — so returning a fresh token
+     * from your session store is enough to keep a long-lived connection
+     * authenticated.
+     */
+    getToken(): string | Promise<string>;
+    /** Inject a WebSocket implementation. Defaults to `globalThis.WebSocket`. */
+    webSocketImpl?: WebSocketCtor;
+    /** Inject a fetch implementation for snapshot fetches. Defaults to `globalThis.fetch`. */
+    fetchFn?: typeof fetch;
+    /** Backoff ceiling for reconnects. Default 30_000. */
+    maxReconnectDelayMs?: number;
+}
+export declare function connect(options: RealtimeConnectOptions): RealtimeClient;
+/**
+ * Full-jitter exponential backoff. Full jitter (rather than
+ * delay ± jitter) matters here because every tab watching an order
+ * reconnects on the same server-side event; without it they retry in
+ * lockstep.
+ */
+export declare function jitteredBackoff(attempt: number, maxDelayMs: number): number;

package/dist/realtime/connect.js

@@ -0,0 +1,450 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.connect = connect;
+exports.jitteredBackoff = jitteredBackoff;
+const envelope_1 = require("./envelope");
+const endpoints_1 = require("./endpoints");
+const protocol_1 = require("./protocol");
+const WS_OPEN = 1;
+const BASE_RECONNECT_DELAY_MS = 500;
+const DEFAULT_MAX_RECONNECT_DELAY_MS = 30_000;
+const DEFAULT_KEEPALIVE_TIMEOUT_MS = 60_000;
+/**
+ * Grace on top of the server's advertised keepalive interval before we
+ * call the connection dead. A `ka` is due every `connectionTimeoutMs`;
+ * waiting 1.5× absorbs normal jitter without letting a black-holed
+ * socket sit there looking healthy.
+ */
+const KEEPALIVE_GRACE = 1.5;
+/**
+ * How long a socket may sit between "we started opening it" and
+ * `connection_ack` before we give up on it.
+ *
+ * The keepalive watchdog can only start once a frame has arrived, so it
+ * cannot cover the handshake itself. A socket whose TCP/WS open succeeds
+ * but which then goes silent - black-holed connection, NAT mapping
+ * dropped right after open, radio dozing - would otherwise never fire
+ * `onclose`, never arm the keepalive, and leave `connecting` true so
+ * `ensureSocket()` short-circuits forever. Every subscription would be
+ * silently dead with nothing surfaced.
+ *
+ * It covers the token step too, which is why it is armed before
+ * `getToken()` is awaited rather than after the socket exists: an
+ * app-supplied token refresh is usually a `fetch`, and a `fetch` that never
+ * settles produces the same permanent wedge without ever creating a socket.
+ */
+const CONNECT_DEADLINE_MS = 15_000;
+function connect(options) {
+    const endpoints = resolveEndpoints(options);
+    const WebSocketImpl = options.webSocketImpl ?? globalWebSocket();
+    const fetchFn = options.fetchFn ?? globalThis.fetch;
+    const maxReconnectDelayMs = options.maxReconnectDelayMs ?? DEFAULT_MAX_RECONNECT_DELAY_MS;
+    const subscriptions = new Map();
+    let socket;
+    let acked = false;
+    let connecting = false;
+    let closedByCaller = false;
+    let reconnectAttempt = 0;
+    let reconnectTimer;
+    let keepaliveTimer;
+    let connectTimer;
+    let keepaliveTimeoutMs = DEFAULT_KEEPALIVE_TIMEOUT_MS;
+    /**
+     * Bumped for every connect attempt, and again when the connect deadline
+     * abandons one. `ensureSocket`'s async body checks it after every `await`
+     * so a slow `getToken()` that settles late cannot adopt its socket over a
+     * newer attempt's.
+     */
+    let connectGeneration = 0;
+    // ─── Socket lifecycle ────────────────────────────────────────────────
+    function ensureSocket() {
+        if (closedByCaller || connecting || socket)
+            return;
+        connecting = true;
+        const generation = ++connectGeneration;
+        // Armed BEFORE the token await, not after the socket exists. `getToken()`
+        // is app-supplied and the normal implementation is a `fetch`, which can
+        // hang indefinitely across a network transition. If it never settles and
+        // the deadline were armed later, `connecting` would stay true with no
+        // socket and no timer, `scheduleReconnect()` would never run, and every
+        // subsequent `subscribe()` would short-circuit on `connecting` - the
+        // client dead for the page's lifetime with nothing on `onError`.
+        armConnectDeadline(generation);
+        void (async () => {
+            let ws;
+            try {
+                const token = await options.getToken();
+                // The deadline may have abandoned this attempt while the token was
+                // pending. Bail before building a socket nobody will own.
+                if (closedByCaller || generation !== connectGeneration)
+                    return;
+                const header = (0, protocol_1.authHeader)(endpoints.httpDomain, token);
+                ws = new WebSocketImpl(`wss://${endpoints.realtimeDomain}/event/realtime`, [
+                    protocol_1.EVENT_WS_SUBPROTOCOL,
+                    (0, protocol_1.authSubprotocol)(header),
+                ]);
+            }
+            catch (err) {
+                if (generation !== connectGeneration)
+                    return;
+                connecting = false;
+                clearConnectDeadline();
+                broadcastError(toError(err, 'realtime: failed to open connection'));
+                scheduleReconnect();
+                return;
+            }
+            if (closedByCaller || generation !== connectGeneration) {
+                // Superseded between the token resolving and the socket opening.
+                // Close the orphan rather than leaking it.
+                try {
+                    ws.close(1000, 'superseded');
+                }
+                catch {
+                    // Nothing useful to do; it was never adopted.
+                }
+                return;
+            }
+            socket = ws;
+            ws.onopen = () => {
+                ws.send((0, protocol_1.connectionInitFrame)());
+            };
+            ws.onmessage = (ev) => {
+                armKeepalive();
+                handleFrame(typeof ev.data === 'string' ? ev.data : String(ev.data));
+            };
+            ws.onerror = () => {
+                // `onclose` always follows; reconnect is driven from there so the
+                // two paths can't both schedule a retry.
+            };
+            ws.onclose = () => {
+                teardownSocket();
+                if (!closedByCaller)
+                    scheduleReconnect();
+            };
+        })();
+    }
+    function teardownSocket() {
+        if (socket) {
+            socket.onopen = null;
+            socket.onmessage = null;
+            socket.onerror = null;
+            socket.onclose = null;
+        }
+        socket = undefined;
+        connecting = false;
+        acked = false;
+        clearKeepalive();
+        clearConnectDeadline();
+        for (const record of subscriptions.values())
+            record.sent = false;
+    }
+    /**
+     * Fail a handshake that never completes. Cleared by `connection_ack`,
+     * after which the keepalive watchdog takes over.
+     */
+    function armConnectDeadline(generation) {
+        clearConnectDeadline();
+        connectTimer = setTimeout(() => {
+            connectTimer = undefined;
+            if (generation !== connectGeneration)
+                return;
+            // Abandon this attempt by retiring its generation. A `getToken()` still
+            // pending when this fires can then no longer install its socket, which
+            // would otherwise land un-deadlined and un-acked on top of the fresh
+            // attempt scheduled below.
+            connectGeneration++;
+            const stalled = socket;
+            teardownSocket();
+            broadcastError(new Error('realtime: connection timed out before connection_ack'));
+            try {
+                stalled?.close(4001, 'connect timeout');
+            }
+            catch {
+                // Already gone; the reconnect below is what matters.
+            }
+            if (!closedByCaller)
+                scheduleReconnect();
+        }, CONNECT_DEADLINE_MS);
+        unref(connectTimer);
+    }
+    function clearConnectDeadline() {
+        if (connectTimer)
+            clearTimeout(connectTimer);
+        connectTimer = undefined;
+    }
+    function scheduleReconnect() {
+        if (closedByCaller || reconnectTimer)
+            return;
+        if (subscriptions.size === 0)
+            return;
+        const delay = jitteredBackoff(reconnectAttempt, maxReconnectDelayMs);
+        reconnectAttempt++;
+        reconnectTimer = setTimeout(() => {
+            reconnectTimer = undefined;
+            ensureSocket();
+        }, delay);
+        unref(reconnectTimer);
+    }
+    function armKeepalive() {
+        clearKeepalive();
+        keepaliveTimer = setTimeout(() => {
+            // No frame — not even a `ka` — within the grace window. The socket
+            // may look open while delivering nothing (backgrounded tab, dozing
+            // radio, silently dropped NAT mapping); force it closed so the
+            // normal reconnect path runs.
+            const dead = socket;
+            teardownSocket();
+            try {
+                dead?.close(4000, 'keepalive timeout');
+            }
+            catch {
+                // Already gone; the reconnect below is what matters.
+            }
+            if (!closedByCaller)
+                scheduleReconnect();
+        }, keepaliveTimeoutMs * KEEPALIVE_GRACE);
+        unref(keepaliveTimer);
+    }
+    function clearKeepalive() {
+        if (keepaliveTimer)
+            clearTimeout(keepaliveTimer);
+        keepaliveTimer = undefined;
+    }
+    // ─── Frame handling ──────────────────────────────────────────────────
+    function handleFrame(raw) {
+        const frame = (0, protocol_1.parseServerFrame)(raw);
+        if (!frame)
+            return;
+        switch (frame.type) {
+            case 'connection_ack': {
+                acked = true;
+                connecting = false;
+                reconnectAttempt = 0;
+                clearConnectDeadline();
+                const advertised = frame.connectionTimeoutMs;
+                if (typeof advertised === 'number' && advertised > 0)
+                    keepaliveTimeoutMs = advertised;
+                armKeepalive();
+                for (const record of subscriptions.values())
+                    void openSubscription(record);
+                return;
+            }
+            case 'ka':
+                return;
+            case 'subscribe_success': {
+                return;
+            }
+            case 'data': {
+                const dataFrame = frame;
+                const record = subscriptions.get(dataFrame.id);
+                if (!record || record.closed)
+                    return;
+                const payload = (0, protocol_1.parseDataFrameEvent)(dataFrame);
+                const event = (0, envelope_1.asRealtimeEvent)(payload);
+                if (!event) {
+                    reportError(record, new Error(`realtime: dropped malformed event on ${record.channel}`));
+                    return;
+                }
+                deliver(record, event, 'live');
+                return;
+            }
+            case 'subscribe_error':
+            case 'connection_error':
+            case 'publish_error': {
+                const errorFrame = frame;
+                const message = `realtime: ${(0, protocol_1.errorFrameMessage)(errorFrame)}`;
+                if (errorFrame.id) {
+                    const record = subscriptions.get(errorFrame.id);
+                    if (record) {
+                        reportError(record, new Error(message));
+                        return;
+                    }
+                }
+                broadcastError(new Error(message));
+                return;
+            }
+            default:
+                return;
+        }
+    }
+    function deliver(record, event, origin) {
+        if (record.closed)
+            return;
+        if (!(0, envelope_1.isNewer)(event.id, record.lastEventId))
+            return;
+        record.lastEventId = event.id;
+        try {
+            record.options.onUpdate(event, { channel: record.channel, origin });
+        }
+        catch (err) {
+            reportError(record, toError(err, 'realtime: onUpdate threw'));
+        }
+    }
+    function reportError(record, error) {
+        if (!record.options.onError)
+            return;
+        try {
+            record.options.onError(error);
+        }
+        catch {
+            // A throwing error handler must not take down the socket.
+        }
+    }
+    function broadcastError(error) {
+        for (const record of subscriptions.values())
+            reportError(record, error);
+    }
+    // ─── Subscriptions ───────────────────────────────────────────────────
+    /**
+     * Open (or re-open) one subscription: send the subscribe frame first,
+     * then fetch the channel's last value.
+     *
+     * Order matters. AppSync Events has no retention, so anything published
+     * between "we asked for the snapshot" and "the stream is live" would be
+     * lost forever. Subscribing first means the worst case is a duplicate,
+     * which the ULID guard in `deliver` absorbs.
+     */
+    async function openSubscription(record) {
+        if (record.closed || !socket || !acked || record.sent)
+            return;
+        let token;
+        try {
+            token = await options.getToken();
+        }
+        catch (err) {
+            reportError(record, toError(err, 'realtime: getToken failed'));
+            return;
+        }
+        if (record.closed || !socket || socket.readyState !== WS_OPEN)
+            return;
+        record.sent = true;
+        try {
+            socket.send((0, protocol_1.subscribeFrame)(record.id, record.channel, (0, protocol_1.authHeader)(endpoints.httpDomain, token)));
+        }
+        catch (err) {
+            record.sent = false;
+            reportError(record, toError(err, 'realtime: subscribe frame failed to send'));
+            return;
+        }
+        await hydrate(record, token);
+    }
+    async function hydrate(record, token) {
+        try {
+            const snapshot = record.options.getSnapshot
+                ? await record.options.getSnapshot(record.channel)
+                : await fetchLatest(record.channel, token);
+            if (snapshot)
+                deliver(record, snapshot, 'snapshot');
+        }
+        catch (err) {
+            reportError(record, toError(err, `realtime: snapshot fetch failed for ${record.channel}`));
+        }
+    }
+    async function fetchLatest(channel, token) {
+        const url = `${endpoints.apiBase}/v1/realtime/latest?channel=${encodeURIComponent(channel)}`;
+        const res = await fetchFn(url, { headers: { authorization: `Bearer ${token}` } });
+        if (res.status === 404)
+            return null;
+        if (!res.ok)
+            throw new Error(`snapshot fetch returned HTTP ${res.status}`);
+        const body = (await res.json());
+        return (0, envelope_1.asRealtimeEvent)(body?.event);
+    }
+    return {
+        subscribe(channel, subscribeOptions) {
+            const record = {
+                id: randomId(),
+                channel,
+                options: subscribeOptions,
+                sent: false,
+                closed: false,
+            };
+            subscriptions.set(record.id, record);
+            if (acked && socket) {
+                void openSubscription(record);
+            }
+            else {
+                ensureSocket();
+            }
+            return {
+                channel,
+                unsubscribe() {
+                    if (record.closed)
+                        return;
+                    record.closed = true;
+                    subscriptions.delete(record.id);
+                    if (socket && socket.readyState === WS_OPEN && record.sent) {
+                        try {
+                            socket.send((0, protocol_1.unsubscribeFrame)(record.id));
+                        }
+                        catch {
+                            // Socket is going away anyway; the server drops the
+                            // subscription when the connection closes.
+                        }
+                    }
+                },
+            };
+        },
+        close() {
+            closedByCaller = true;
+            if (reconnectTimer)
+                clearTimeout(reconnectTimer);
+            reconnectTimer = undefined;
+            for (const record of subscriptions.values())
+                record.closed = true;
+            subscriptions.clear();
+            const open = socket;
+            teardownSocket();
+            try {
+                open?.close(1000, 'client closed');
+            }
+            catch {
+                // Nothing useful to do if the socket is already torn down.
+            }
+        },
+    };
+}
+// ─── Helpers ───────────────────────────────────────────────────────────
+function resolveEndpoints(options) {
+    if (options.endpoints)
+        return options.endpoints;
+    if (!options.env) {
+        throw new Error('realtime.connect: pass either {env} or {endpoints}');
+    }
+    const resolved = (0, endpoints_1.endpointsFor)(options.env);
+    return { ...resolved, apiBase: resolved.apiBase || endpoints_1.API_BASE[options.env] };
+}
+function globalWebSocket() {
+    const ctor = globalThis.WebSocket;
+    if (!ctor) {
+        throw new Error('realtime.connect: no global WebSocket. Pass {webSocketImpl} (Node < 22, or a test double).');
+    }
+    return ctor;
+}
+/**
+ * Full-jitter exponential backoff. Full jitter (rather than
+ * delay ± jitter) matters here because every tab watching an order
+ * reconnects on the same server-side event; without it they retry in
+ * lockstep.
+ */
+function jitteredBackoff(attempt, maxDelayMs) {
+    const ceiling = Math.min(maxDelayMs, BASE_RECONNECT_DELAY_MS * 2 ** attempt);
+    return Math.floor(Math.random() * ceiling);
+}
+function randomId() {
+    const c = globalThis.crypto;
+    if (c?.randomUUID)
+        return c.randomUUID();
+    return `sub-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
+}
+function toError(err, fallbackMessage) {
+    if (err instanceof Error)
+        return err;
+    return new Error(`${fallbackMessage}: ${String(err)}`);
+}
+function unref(timer) {
+    const t = timer;
+    if (typeof t.unref === 'function')
+        t.unref();
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"connect.js","sourceRoot":"","sources":["../../src/realtime/connect.ts"],"names":[],"mappings":"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","sourcesContent":["import { asRealtimeEvent, isNewer, type RealtimeEvent } from './envelope';\nimport { API_BASE, endpointsFor, type RealtimeEndpoints, type RealtimeEnv } from './endpoints';\nimport {\n  EVENT_WS_SUBPROTOCOL,\n  authHeader,\n  authSubprotocol,\n  connectionInitFrame,\n  errorFrameMessage,\n  parseDataFrameEvent,\n  parseServerFrame,\n  subscribeFrame,\n  unsubscribeFrame,\n  type DataFrame,\n  type ErrorFrame,\n} from './protocol';\n\n/**\n * The slice of the WebSocket API this client uses.\n *\n * Declared structurally rather than relying on a DOM lib: the SDK\n * compiles against `lib: ES2022` only, and this keeps the client\n * injectable so tests can drive the protocol with a fake socket.\n */\nexport interface MinimalWebSocket {\n  readyState: number;\n  send(data: string): void;\n  close(code?: number, reason?: string): void;\n  onopen: ((ev: unknown) => void) | null;\n  onmessage: ((ev: { data: unknown }) => void) | null;\n  onerror: ((ev: unknown) => void) | null;\n  onclose: ((ev: { code?: number; reason?: string }) => void) | null;\n}\n\nexport type WebSocketCtor = new (url: string, protocols?: string | string[]) => MinimalWebSocket;\n\nconst WS_OPEN = 1;\n\n/** Where an event handed to `onUpdate` came from. */\nexport interface UpdateMeta {\n  channel: string;\n  /**\n   * `'snapshot'` — the channel's last value, fetched from the last-value\n   * cache on subscribe or after a reconnect. `'live'` — delivered over\n   * the socket.\n   *\n   * Apps generally don't need to branch on this; the SDK has already\n   * ordered and de-duplicated both sources by ULID. It's there for\n   * telemetry and for UIs that want to distinguish \"restored\" from\n   * \"just happened\".\n   */\n  origin: 'snapshot' | 'live';\n}\n\nexport interface SubscribeOptions {\n  /**\n   * Fires once with the channel's latest known value (if any), then on\n   * every live event. Never fires with an event older than one already\n   * delivered on this subscription.\n   */\n  onUpdate(event: RealtimeEvent, meta: UpdateMeta): void;\n  /**\n   * Subscription-level failures: a rejected subscribe, a malformed\n   * frame, a failed snapshot fetch. Transient socket drops are handled\n   * internally by the reconnect loop and are not surfaced here.\n   */\n  onError?(error: Error): void;\n  /**\n   * Replace the built-in last-value fetch for this channel. Return null\n   * when there is no snapshot. Useful when a domain has a better source\n   * of truth than the cache — e.g. falling back to the order-details API\n   * for an order whose transitions predate bus instrumentation.\n   */\n  getSnapshot?(channel: string): Promise<RealtimeEvent | null>;\n}\n\nexport interface Subscription {\n  readonly channel: string;\n  unsubscribe(): void;\n}\n\nexport interface RealtimeClient {\n  /**\n   * Subscribe to a channel. Channels are the only concept here — the\n   * realtime layer knows nothing about orders; `/orders/{id}` is a\n   * naming convention enforced by the service's namespace policy, not by\n   * this client.\n   *\n   * On this call, and again after every reconnect, the SDK opens the\n   * subscription *first* and only then fetches the channel's last value,\n   * so no event can fall between the snapshot and the stream.\n   */\n  subscribe(channel: string, options: SubscribeOptions): Subscription;\n  /** Close the shared socket and stop reconnecting. */\n  close(): void;\n}\n\nexport interface RealtimeConnectOptions {\n  /** Resolves endpoints from the built-in table. Mutually exclusive with `endpoints`. */\n  env?: RealtimeEnv;\n  /** Explicit endpoints, for environments not in the table. */\n  endpoints?: RealtimeEndpoints;\n  /**\n   * Supplies the platform JWT. Called on connect, on every (re)subscribe,\n   * and again after a token-expiry reconnect — so returning a fresh token\n   * from your session store is enough to keep a long-lived connection\n   * authenticated.\n   */\n  getToken(): string | Promise<string>;\n  /** Inject a WebSocket implementation. Defaults to `globalThis.WebSocket`. */\n  webSocketImpl?: WebSocketCtor;\n  /** Inject a fetch implementation for snapshot fetches. Defaults to `globalThis.fetch`. */\n  fetchFn?: typeof fetch;\n  /** Backoff ceiling for reconnects. Default 30_000. */\n  maxReconnectDelayMs?: number;\n}\n\ninterface SubscriptionRecord {\n  id: string;\n  channel: string;\n  options: SubscribeOptions;\n  /** Highest envelope id delivered so far — the ordering/dedupe guard. */\n  lastEventId?: string;\n  /** Cleared on socket loss, set once the server acks the subscribe. */\n  sent: boolean;\n  closed: boolean;\n}\n\nconst BASE_RECONNECT_DELAY_MS = 500;\nconst DEFAULT_MAX_RECONNECT_DELAY_MS = 30_000;\nconst DEFAULT_KEEPALIVE_TIMEOUT_MS = 60_000;\n/**\n * Grace on top of the server's advertised keepalive interval before we\n * call the connection dead. A `ka` is due every `connectionTimeoutMs`;\n * waiting 1.5× absorbs normal jitter without letting a black-holed\n * socket sit there looking healthy.\n */\nconst KEEPALIVE_GRACE = 1.5;\n/**\n * How long a socket may sit between \"we started opening it\" and\n * `connection_ack` before we give up on it.\n *\n * The keepalive watchdog can only start once a frame has arrived, so it\n * cannot cover the handshake itself. A socket whose TCP/WS open succeeds\n * but which then goes silent - black-holed connection, NAT mapping\n * dropped right after open, radio dozing - would otherwise never fire\n * `onclose`, never arm the keepalive, and leave `connecting` true so\n * `ensureSocket()` short-circuits forever. Every subscription would be\n * silently dead with nothing surfaced.\n *\n * It covers the token step too, which is why it is armed before\n * `getToken()` is awaited rather than after the socket exists: an\n * app-supplied token refresh is usually a `fetch`, and a `fetch` that never\n * settles produces the same permanent wedge without ever creating a socket.\n */\nconst CONNECT_DEADLINE_MS = 15_000;\n\nexport function connect(options: RealtimeConnectOptions): RealtimeClient {\n  const endpoints = resolveEndpoints(options);\n  const WebSocketImpl = options.webSocketImpl ?? globalWebSocket();\n  const fetchFn = options.fetchFn ?? (globalThis.fetch as typeof fetch);\n  const maxReconnectDelayMs = options.maxReconnectDelayMs ?? DEFAULT_MAX_RECONNECT_DELAY_MS;\n\n  const subscriptions = new Map<string, SubscriptionRecord>();\n\n  let socket: MinimalWebSocket | undefined;\n  let acked = false;\n  let connecting = false;\n  let closedByCaller = false;\n  let reconnectAttempt = 0;\n  let reconnectTimer: ReturnType<typeof setTimeout> | undefined;\n  let keepaliveTimer: ReturnType<typeof setTimeout> | undefined;\n  let connectTimer: ReturnType<typeof setTimeout> | undefined;\n  let keepaliveTimeoutMs = DEFAULT_KEEPALIVE_TIMEOUT_MS;\n  /**\n   * Bumped for every connect attempt, and again when the connect deadline\n   * abandons one. `ensureSocket`'s async body checks it after every `await`\n   * so a slow `getToken()` that settles late cannot adopt its socket over a\n   * newer attempt's.\n   */\n  let connectGeneration = 0;\n\n  // ─── Socket lifecycle ────────────────────────────────────────────────\n\n  function ensureSocket(): void {\n    if (closedByCaller || connecting || socket) return;\n    connecting = true;\n    const generation = ++connectGeneration;\n\n    // Armed BEFORE the token await, not after the socket exists. `getToken()`\n    // is app-supplied and the normal implementation is a `fetch`, which can\n    // hang indefinitely across a network transition. If it never settles and\n    // the deadline were armed later, `connecting` would stay true with no\n    // socket and no timer, `scheduleReconnect()` would never run, and every\n    // subsequent `subscribe()` would short-circuit on `connecting` - the\n    // client dead for the page's lifetime with nothing on `onError`.\n    armConnectDeadline(generation);\n\n    void (async () => {\n      let ws: MinimalWebSocket;\n      try {\n        const token = await options.getToken();\n        // The deadline may have abandoned this attempt while the token was\n        // pending. Bail before building a socket nobody will own.\n        if (closedByCaller || generation !== connectGeneration) return;\n        const header = authHeader(endpoints.httpDomain, token);\n        ws = new WebSocketImpl(`wss://${endpoints.realtimeDomain}/event/realtime`, [\n          EVENT_WS_SUBPROTOCOL,\n          authSubprotocol(header),\n        ]);\n      } catch (err) {\n        if (generation !== connectGeneration) return;\n        connecting = false;\n        clearConnectDeadline();\n        broadcastError(toError(err, 'realtime: failed to open connection'));\n        scheduleReconnect();\n        return;\n      }\n\n      if (closedByCaller || generation !== connectGeneration) {\n        // Superseded between the token resolving and the socket opening.\n        // Close the orphan rather than leaking it.\n        try {\n          ws.close(1000, 'superseded');\n        } catch {\n          // Nothing useful to do; it was never adopted.\n        }\n        return;\n      }\n\n      socket = ws;\n      ws.onopen = () => {\n        ws.send(connectionInitFrame());\n      };\n      ws.onmessage = (ev) => {\n        armKeepalive();\n        handleFrame(typeof ev.data === 'string' ? ev.data : String(ev.data));\n      };\n      ws.onerror = () => {\n        // `onclose` always follows; reconnect is driven from there so the\n        // two paths can't both schedule a retry.\n      };\n      ws.onclose = () => {\n        teardownSocket();\n        if (!closedByCaller) scheduleReconnect();\n      };\n    })();\n  }\n\n  function teardownSocket(): void {\n    if (socket) {\n      socket.onopen = null;\n      socket.onmessage = null;\n      socket.onerror = null;\n      socket.onclose = null;\n    }\n    socket = undefined;\n    connecting = false;\n    acked = false;\n    clearKeepalive();\n    clearConnectDeadline();\n    for (const record of subscriptions.values()) record.sent = false;\n  }\n\n  /**\n   * Fail a handshake that never completes. Cleared by `connection_ack`,\n   * after which the keepalive watchdog takes over.\n   */\n  function armConnectDeadline(generation: number): void {\n    clearConnectDeadline();\n    connectTimer = setTimeout(() => {\n      connectTimer = undefined;\n      if (generation !== connectGeneration) return;\n      // Abandon this attempt by retiring its generation. A `getToken()` still\n      // pending when this fires can then no longer install its socket, which\n      // would otherwise land un-deadlined and un-acked on top of the fresh\n      // attempt scheduled below.\n      connectGeneration++;\n      const stalled = socket;\n      teardownSocket();\n      broadcastError(new Error('realtime: connection timed out before connection_ack'));\n      try {\n        stalled?.close(4001, 'connect timeout');\n      } catch {\n        // Already gone; the reconnect below is what matters.\n      }\n      if (!closedByCaller) scheduleReconnect();\n    }, CONNECT_DEADLINE_MS);\n    unref(connectTimer);\n  }\n\n  function clearConnectDeadline(): void {\n    if (connectTimer) clearTimeout(connectTimer);\n    connectTimer = undefined;\n  }\n\n  function scheduleReconnect(): void {\n    if (closedByCaller || reconnectTimer) return;\n    if (subscriptions.size === 0) return;\n    const delay = jitteredBackoff(reconnectAttempt, maxReconnectDelayMs);\n    reconnectAttempt++;\n    reconnectTimer = setTimeout(() => {\n      reconnectTimer = undefined;\n      ensureSocket();\n    }, delay);\n    unref(reconnectTimer);\n  }\n\n  function armKeepalive(): void {\n    clearKeepalive();\n    keepaliveTimer = setTimeout(() => {\n      // No frame — not even a `ka` — within the grace window. The socket\n      // may look open while delivering nothing (backgrounded tab, dozing\n      // radio, silently dropped NAT mapping); force it closed so the\n      // normal reconnect path runs.\n      const dead = socket;\n      teardownSocket();\n      try {\n        dead?.close(4000, 'keepalive timeout');\n      } catch {\n        // Already gone; the reconnect below is what matters.\n      }\n      if (!closedByCaller) scheduleReconnect();\n    }, keepaliveTimeoutMs * KEEPALIVE_GRACE);\n    unref(keepaliveTimer);\n  }\n\n  function clearKeepalive(): void {\n    if (keepaliveTimer) clearTimeout(keepaliveTimer);\n    keepaliveTimer = undefined;\n  }\n\n  // ─── Frame handling ──────────────────────────────────────────────────\n\n  function handleFrame(raw: string): void {\n    const frame = parseServerFrame(raw);\n    if (!frame) return;\n\n    switch (frame.type) {\n      case 'connection_ack': {\n        acked = true;\n        connecting = false;\n        reconnectAttempt = 0;\n        clearConnectDeadline();\n        const advertised = (frame as { connectionTimeoutMs?: number }).connectionTimeoutMs;\n        if (typeof advertised === 'number' && advertised > 0) keepaliveTimeoutMs = advertised;\n        armKeepalive();\n        for (const record of subscriptions.values()) void openSubscription(record);\n        return;\n      }\n      case 'ka':\n        return;\n      case 'subscribe_success': {\n        return;\n      }\n      case 'data': {\n        const dataFrame = frame as DataFrame;\n        const record = subscriptions.get(dataFrame.id);\n        if (!record || record.closed) return;\n        const payload = parseDataFrameEvent(dataFrame);\n        const event = asRealtimeEvent(payload);\n        if (!event) {\n          reportError(record, new Error(`realtime: dropped malformed event on ${record.channel}`));\n          return;\n        }\n        deliver(record, event, 'live');\n        return;\n      }\n      case 'subscribe_error':\n      case 'connection_error':\n      case 'publish_error': {\n        const errorFrame = frame as ErrorFrame;\n        const message = `realtime: ${errorFrameMessage(errorFrame)}`;\n        if (errorFrame.id) {\n          const record = subscriptions.get(errorFrame.id);\n          if (record) {\n            reportError(record, new Error(message));\n            return;\n          }\n        }\n        broadcastError(new Error(message));\n        return;\n      }\n      default:\n        return;\n    }\n  }\n\n  function deliver(record: SubscriptionRecord, event: RealtimeEvent, origin: UpdateMeta['origin']) {\n    if (record.closed) return;\n    if (!isNewer(event.id, record.lastEventId)) return;\n    record.lastEventId = event.id;\n    try {\n      record.options.onUpdate(event, { channel: record.channel, origin });\n    } catch (err) {\n      reportError(record, toError(err, 'realtime: onUpdate threw'));\n    }\n  }\n\n  function reportError(record: SubscriptionRecord, error: Error): void {\n    if (!record.options.onError) return;\n    try {\n      record.options.onError(error);\n    } catch {\n      // A throwing error handler must not take down the socket.\n    }\n  }\n\n  function broadcastError(error: Error): void {\n    for (const record of subscriptions.values()) reportError(record, error);\n  }\n\n  // ─── Subscriptions ───────────────────────────────────────────────────\n\n  /**\n   * Open (or re-open) one subscription: send the subscribe frame first,\n   * then fetch the channel's last value.\n   *\n   * Order matters. AppSync Events has no retention, so anything published\n   * between \"we asked for the snapshot\" and \"the stream is live\" would be\n   * lost forever. Subscribing first means the worst case is a duplicate,\n   * which the ULID guard in `deliver` absorbs.\n   */\n  async function openSubscription(record: SubscriptionRecord): Promise<void> {\n    if (record.closed || !socket || !acked || record.sent) return;\n    let token: string;\n    try {\n      token = await options.getToken();\n    } catch (err) {\n      reportError(record, toError(err, 'realtime: getToken failed'));\n      return;\n    }\n    if (record.closed || !socket || socket.readyState !== WS_OPEN) return;\n    record.sent = true;\n    try {\n      socket.send(\n        subscribeFrame(record.id, record.channel, authHeader(endpoints.httpDomain, token)),\n      );\n    } catch (err) {\n      record.sent = false;\n      reportError(record, toError(err, 'realtime: subscribe frame failed to send'));\n      return;\n    }\n    await hydrate(record, token);\n  }\n\n  async function hydrate(record: SubscriptionRecord, token: string): Promise<void> {\n    try {\n      const snapshot = record.options.getSnapshot\n        ? await record.options.getSnapshot(record.channel)\n        : await fetchLatest(record.channel, token);\n      if (snapshot) deliver(record, snapshot, 'snapshot');\n    } catch (err) {\n      reportError(record, toError(err, `realtime: snapshot fetch failed for ${record.channel}`));\n    }\n  }\n\n  async function fetchLatest(channel: string, token: string): Promise<RealtimeEvent | null> {\n    const url = `${endpoints.apiBase}/v1/realtime/latest?channel=${encodeURIComponent(channel)}`;\n    const res = await fetchFn(url, { headers: { authorization: `Bearer ${token}` } });\n    if (res.status === 404) return null;\n    if (!res.ok) throw new Error(`snapshot fetch returned HTTP ${res.status}`);\n    const body = (await res.json()) as { event?: unknown };\n    return asRealtimeEvent(body?.event);\n  }\n\n  return {\n    subscribe(channel, subscribeOptions) {\n      const record: SubscriptionRecord = {\n        id: randomId(),\n        channel,\n        options: subscribeOptions,\n        sent: false,\n        closed: false,\n      };\n      subscriptions.set(record.id, record);\n\n      if (acked && socket) {\n        void openSubscription(record);\n      } else {\n        ensureSocket();\n      }\n\n      return {\n        channel,\n        unsubscribe() {\n          if (record.closed) return;\n          record.closed = true;\n          subscriptions.delete(record.id);\n          if (socket && socket.readyState === WS_OPEN && record.sent) {\n            try {\n              socket.send(unsubscribeFrame(record.id));\n            } catch {\n              // Socket is going away anyway; the server drops the\n              // subscription when the connection closes.\n            }\n          }\n        },\n      };\n    },\n\n    close() {\n      closedByCaller = true;\n      if (reconnectTimer) clearTimeout(reconnectTimer);\n      reconnectTimer = undefined;\n      for (const record of subscriptions.values()) record.closed = true;\n      subscriptions.clear();\n      const open = socket;\n      teardownSocket();\n      try {\n        open?.close(1000, 'client closed');\n      } catch {\n        // Nothing useful to do if the socket is already torn down.\n      }\n    },\n  };\n}\n\n// ─── Helpers ───────────────────────────────────────────────────────────\n\nfunction resolveEndpoints(options: RealtimeConnectOptions): RealtimeEndpoints {\n  if (options.endpoints) return options.endpoints;\n  if (!options.env) {\n    throw new Error('realtime.connect: pass either {env} or {endpoints}');\n  }\n  const resolved = endpointsFor(options.env);\n  return { ...resolved, apiBase: resolved.apiBase || API_BASE[options.env] };\n}\n\nfunction globalWebSocket(): WebSocketCtor {\n  const ctor = (globalThis as { WebSocket?: WebSocketCtor }).WebSocket;\n  if (!ctor) {\n    throw new Error(\n      'realtime.connect: no global WebSocket. Pass {webSocketImpl} (Node < 22, or a test double).',\n    );\n  }\n  return ctor;\n}\n\n/**\n * Full-jitter exponential backoff. Full jitter (rather than\n * delay ± jitter) matters here because every tab watching an order\n * reconnects on the same server-side event; without it they retry in\n * lockstep.\n */\nexport function jitteredBackoff(attempt: number, maxDelayMs: number): number {\n  const ceiling = Math.min(maxDelayMs, BASE_RECONNECT_DELAY_MS * 2 ** attempt);\n  return Math.floor(Math.random() * ceiling);\n}\n\nfunction randomId(): string {\n  const c = (globalThis as { crypto?: { randomUUID?: () => string } }).crypto;\n  if (c?.randomUUID) return c.randomUUID();\n  return `sub-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;\n}\n\nfunction toError(err: unknown, fallbackMessage: string): Error {\n  if (err instanceof Error) return err;\n  return new Error(`${fallbackMessage}: ${String(err)}`);\n}\n\nfunction unref(timer: ReturnType<typeof setTimeout>): void {\n  const t = timer as { unref?: () => void };\n  if (typeof t.unref === 'function') t.unref();\n}\n"]}

package/dist/realtime/endpoints.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Per-environment realtime endpoints.
+ *
+ * Frontends pass `connect({ env: 'prod' })` and get URLs from here — no
+ * hostnames or ARNs in app code.
+ *
+ * AppSync assigns the Event API's DNS names at create time
+ * (`<apiId>.appsync-api.<region>.amazonaws.com` and the matching
+ * `appsync-realtime-api` host), so they cannot be known before the stack
+ * is deployed. Until `services/realtime` has been deployed to an
+ * environment its entry stays null and `connect({ env })` throws with
+ * instructions; `connect({ endpoints })` always works.
+ */
+export interface RealtimeEndpoints {
+    /** AppSync Event API HTTP domain. Also the `host` in the auth header. */
+    httpDomain: string;
+    /** AppSync Event API realtime (WebSocket) domain. */
+    realtimeDomain: string;
+    /** Platform API base URL, used for the last-value snapshot fetch. */
+    apiBase: string;
+}
+export type RealtimeEnv = 'dev' | 'uat' | 'prod';
+/** Platform API base per environment — known ahead of any deploy. */
+export declare const API_BASE: Record<RealtimeEnv, string>;
+export declare function endpointsFor(env: RealtimeEnv): RealtimeEndpoints;