@stapel/chat-react 0.1.0

package/dist/model/threadWindow.js

@@ -0,0 +1,100 @@
+export const EMPTY_THREAD_WINDOW = {
+    messages: [],
+    hasOlder: false,
+    olderAnchor: null,
+};
+function ascending(items) {
+    return [...items].sort((a, b) => a.seq - b.seq);
+}
+/** The tip: the highest `seq` in the window, or 0 for an empty one. */
+export function threadLastSeq(window) {
+    const last = window.messages[window.messages.length - 1];
+    return last ? last.seq : 0;
+}
+/** The oldest `seq` in the window, or 0 for an empty one. */
+export function threadFirstSeq(window) {
+    const first = window.messages[0];
+    return first ? first.seq : 0;
+}
+/**
+ * A fresh window from the newest page (`GET …/messages` with no anchor).
+ * This is also the resync path: whatever was loaded before is dropped,
+ * because a window that cannot be proven contiguous is worse than a short
+ * one.
+ */
+export function threadWindowFromPage(page) {
+    return {
+        messages: ascending(page.items),
+        hasOlder: page.has_next,
+        olderAnchor: page.next_anchor ?? null,
+    };
+}
+/**
+ * Merge a backfill page (`direction=next` from the window's oldest seq) onto
+ * the FRONT. Anything at or above the current oldest is dropped as a
+ * duplicate — the anchor is exclusive, so this only fires on a retry.
+ */
+export function mergeOlderPage(window, page) {
+    const first = threadFirstSeq(window);
+    const older = ascending(page.items).filter((message) => first === 0 || message.seq < first);
+    if (older.length === 0) {
+        return { ...window, hasOlder: page.has_next, olderAnchor: page.next_anchor ?? null };
+    }
+    return {
+        messages: [...older, ...window.messages],
+        hasOlder: page.has_next,
+        olderAnchor: page.next_anchor ?? null,
+    };
+}
+/**
+ * Merge a tail page (`direction=prev` anchored on the window's tip) onto the
+ * END — the poll-by-seq step.
+ *
+ * Two independent hole detectors, because either one alone can be fooled:
+ *  - the seq test (`first new seq === tip + 1`), which is only meaningful
+ *    because seq is gapless;
+ *  - the paginator's own `has_prev`, which is how a window that was TRUNCATED
+ *    (more messages above the anchor than `limit`) says so.
+ */
+export function mergeNewerPage(window, page) {
+    const tip = threadLastSeq(window);
+    const newer = ascending(page.items).filter((message) => message.seq > tip);
+    if (newer.length === 0) {
+        // Nothing new. `has_prev` cannot be trusted to mean anything here — there
+        // is no window to be truncated — so this is simply "still up to date".
+        return { window, gap: false };
+    }
+    const firstNew = newer[0];
+    // `tip + 1` also covers the empty window: the first message of a
+    // conversation is seq 1, so a page starting at 5 into an empty thread is a
+    // hole, not a beginning.
+    const contiguous = firstNew !== undefined && firstNew.seq === tip + 1;
+    if (!contiguous || page.has_prev) {
+        return { window, gap: true };
+    }
+    return {
+        window: { ...window, messages: [...window.messages, ...newer] },
+        gap: false,
+    };
+}
+/**
+ * Merge ONE message onto the end — a live socket frame, or the row a `send`
+ * just returned.
+ *
+ * Already-known seq is dropped (the socket dedupes too, but the sender's own
+ * REST answer and the frame it fans out to itself are two paths to the same
+ * row, and only this rule makes them idempotent). A seq beyond the tip + 1 is
+ * a hole: the window is left untouched and the caller re-hydrates.
+ */
+export function mergeMessage(window, message) {
+    const tip = threadLastSeq(window);
+    if (message.seq <= tip)
+        return { window, gap: false };
+    if (message.seq !== tip + 1)
+        return { window, gap: true };
+    return {
+        window: { ...window, messages: [...window.messages, message] },
+        gap: false,
+    };
+}
+//# sourceMappingURL=threadWindow.js.map

package/dist/model/threadWindow.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"threadWindow.js","sourceRoot":"","sources":["../../src/model/threadWindow.ts"],"names":[],"mappings":"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"}

package/dist/nav/manifest.d.ts

@@ -0,0 +1,23 @@
+/**
+ * This pair's contribution to the scripted-fullstack nav contract
+ * (`@stapel/core`'s `NavEntry`/`PackageNavManifest`).
+ * `scripts/gen-nav-manifest.mjs` reads `navEntries` below, stamps
+ * `package`/`version` from THIS package's own `package.json`, and emits
+ * `packages/chat-react/nav-manifest.json` plus this package's slice of the
+ * root aggregate.
+ *
+ * ONE ENTRY, MEMBER-ONLY. Chat is a member surface end to end: every endpoint
+ * is `IsAuthenticated`, and the socket closes 4401 without a session. The
+ * public storefront links INTO it ("message the seller"), but the link lands
+ * on a member route — which is why `surface` is stated explicitly here rather
+ * than left to be derived: a public container that forgot the audience filter
+ * would otherwise mount an inbox for visitors who have none.
+ *
+ * The thread route (`/…/chat/:id`) is deliberately NOT an entry: it is not a
+ * menu destination, and the nav contract addresses routes by static path. A
+ * container mounts `<ConversationThreadPanel conversationId={…}/>` under its
+ * own `:id` child route.
+ */
+import type { NavEntry } from "@stapel/core";
+export declare const navEntries: readonly NavEntry[];
+//# sourceMappingURL=manifest.d.ts.map

package/dist/nav/manifest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"manifest.d.ts","sourceRoot":"","sources":["../../src/nav/manifest.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAC;AAE7C,eAAO,MAAM,UAAU,EAAE,SAAS,QAAQ,EAazC,CAAC"}

package/dist/nav/manifest.js

@@ -0,0 +1,15 @@
+export const navEntries = [
+    {
+        id: "chat.conversations",
+        labelKey: "chat.nav.conversations",
+        icon: "MessageOutlined",
+        route: { path: "chat" },
+        component: { export: "ConversationListPanel", subpath: "default" },
+        placement: { level: "top" },
+        menuVisibleDefault: true,
+        requiresAuth: true,
+        surface: "member",
+        order: 25,
+    },
+];
+//# sourceMappingURL=manifest.js.map

package/dist/nav/manifest.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"manifest.js","sourceRoot":"","sources":["../../src/nav/manifest.ts"],"names":[],"mappings":"AAsBA,MAAM,CAAC,MAAM,UAAU,GAAwB;IAC7C;QACE,EAAE,EAAE,oBAAoB;QACxB,QAAQ,EAAE,wBAAwB;QAClC,IAAI,EAAE,iBAAiB;QACvB,KAAK,EAAE,EAAE,IAAI,EAAE,MAAM,EAAE;QACvB,SAAS,EAAE,EAAE,MAAM,EAAE,uBAAuB,EAAE,OAAO,EAAE,SAAS,EAAE;QAClE,SAAS,EAAE,EAAE,KAAK,EAAE,KAAK,EAAE;QAC3B,kBAAkB,EAAE,IAAI;QACxB,YAAY,EAAE,IAAI;QAClB,OAAO,EAAE,QAAQ;QACjB,KAAK,EAAE,EAAE;KACV;CACF,CAAC"}

package/dist/realtime/chatSocket.d.ts

@@ -0,0 +1,93 @@
+import type { ChatServerFrame } from "./frames.js";
+/**
+ * Connection state, named as the realtime spec (§7) names it, so the
+ * substrate migration is a rename of nothing.
+ *
+ *  - `connecting` — a socket is being opened (including a reconnect wait),
+ *  - `open` — connected; frames are arriving,
+ *  - `degraded` — the socket dropped and a reconnect is pending,
+ *  - `closed` — it will not come back on its own (deliberate close, a
+ *    refusal, or the retry budget spent).
+ */
+export type ChatConnectionState = "connecting" | "open" | "degraded" | "closed";
+/** Why the socket will not come back. `undefined` while it still might. */
+export type ChatSocketRefusal = "unauthenticated" | "not_participant" | "unreachable";
+export interface ChatSocketStatus {
+    readonly state: ChatConnectionState;
+    /** Set only in `closed`, and only when the reason is known. */
+    readonly refusal: ChatSocketRefusal | undefined;
+    /** Consecutive failed connects since the last `open`. */
+    readonly attempt: number;
+}
+/** The callbacks the transport hands back to this client. */
+export interface ChatSocketHandlers {
+    readonly onOpen: () => void;
+    /** One decoded payload (the `data` of a message event). */
+    readonly onData: (data: unknown) => void;
+    readonly onClose: (code: number) => void;
+    readonly onError: () => void;
+}
+/** What a transport must offer: send text, close. */
+export interface ChatSocketConnection {
+    send(payload: string): void;
+    close(): void;
+}
+/**
+ * Opens one socket. Injectable so tests drive the protocol without a network
+ * and a host can wrap the socket (instrumentation, a proxy, React Native).
+ */
+export type ChatWebSocketFactory = (url: string, handlers: ChatSocketHandlers) => ChatSocketConnection;
+/** Reconnect backoff knobs (exponential, jittered, capped). */
+export interface ChatReconnectOptions {
+    readonly baseDelayMs?: number;
+    readonly maxDelayMs?: number;
+    /** Consecutive failures after which the socket gives up (and the caller
+     * falls back to polling). Default 6. */
+    readonly maxAttempts?: number;
+}
+/** Cancel handle for a scheduled callback. */
+export type ChatCancel = () => void;
+export interface ChatSocketOptions {
+    /** Fully-qualified socket URL, e.g. `wss://host/ws/chat/<uuid>`. */
+    readonly url: string;
+    /**
+     * The highest seq the CONSUMER holds, read afresh at every connect. A
+     * function, not a value, because the consumer keeps advancing while the
+     * socket is down — which is the whole point of resuming by seq.
+     */
+    readonly lastSeq: () => number;
+    readonly onFrame: (frame: ChatServerFrame) => void;
+    readonly onStatus: (status: ChatSocketStatus) => void;
+    readonly webSocket?: ChatWebSocketFactory;
+    readonly reconnect?: ChatReconnectOptions;
+    /** Injectable timer (tests). Returns its own cancel. */
+    readonly schedule?: (fn: () => void, ms: number) => ChatCancel;
+    /** Injectable jitter source (tests). */
+    readonly random?: () => number;
+}
+export interface ChatSocket {
+    /** Current status (also pushed through `onStatus`). */
+    status(): ChatSocketStatus;
+    /** Acknowledge delivery up to `seq` (the server tracks it; nothing
+     * depends on it — a dropped ack costs nothing). */
+    ack(seq: number): void;
+    /** Liveness probe. */
+    ping(): void;
+    /** Close deliberately: no reconnect, no further callbacks. */
+    close(): void;
+}
+/**
+ * The browser transport. Uses `addEventListener` rather than the `on*`
+ * properties so the structural contract above stays independent of the DOM
+ * `WebSocket` type (and so a host wrapper can be a plain object).
+ */
+export declare function browserWebSocketFactory(url: string, handlers: ChatSocketHandlers): ChatSocketConnection;
+/** True when the environment can open a socket at all (SSR / node cannot). */
+export declare function canOpenWebSocket(): boolean;
+/**
+ * Open a resumable conversation socket. Connects immediately; returns the
+ * handle that closes it. Every state change is pushed through `onStatus`, so
+ * a React layer can render the transport without polling this object.
+ */
+export declare function createChatSocket(options: ChatSocketOptions): ChatSocket;
+//# sourceMappingURL=chatSocket.d.ts.map

package/dist/realtime/chatSocket.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chatSocket.d.ts","sourceRoot":"","sources":["../../src/realtime/chatSocket.ts"],"names":[],"mappings":"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"}

package/dist/realtime/chatSocket.js

@@ -0,0 +1,199 @@
+/**
+ * A resumable client for stapel-chat's own socket protocol.
+ *
+ * The module is store-first and transport-thin: the socket never owns state,
+ * it relays the durable `seq`-ordered journal (`consumers.py` header). This
+ * client is the mirror image of that discipline —
+ *
+ *  - **resume, not subscribe.** Every (re)connect opens with
+ *    `hello{last_seq}` carrying the seq the CONSUMER already holds, so the
+ *    server replays exactly what was missed and then goes live. A reconnect
+ *    after five seconds or five minutes is the same operation.
+ *  - **idempotent by seq.** The server drops frames it has already sent; this
+ *    client drops frames whose `seq` it has already surfaced. The
+ *    replay/live overlap after a resume is therefore invisible to the
+ *    consumer, on both ends of the wire.
+ *  - **a gap is not a stall.** Past `REPLAY_LIMIT` the server answers
+ *    `error{resync}`; this client forwards it verbatim and stops pretending
+ *    to be up to date. Re-hydration is the consumer's job (it owns the REST
+ *    history), which is what keeps correctness independent of delivery.
+ *  - **a refusal is not a retry.** Close codes 4401 (unauthenticated) and
+ *    4403 (not a participant) are answers, not faults: reconnecting would
+ *    hammer the host with a question it already declined. Everything else is
+ *    a fault and reconnects with exponential backoff + jitter.
+ *
+ * No React, no `@stapel/core`, no DOM assumptions beyond an injectable socket
+ * factory — the future `@stapel/realtime` substrate is meant to replace this
+ * file wholesale, so nothing above it may reach into it.
+ */
+import { decodeServerFrame } from "./frames.js";
+import { CHAT_WS_CLOSE_NOT_PARTICIPANT, CHAT_WS_CLOSE_UNAUTHENTICATED, } from "./frames.js";
+const DEFAULT_BASE_DELAY_MS = 500;
+const DEFAULT_MAX_DELAY_MS = 15_000;
+const DEFAULT_MAX_ATTEMPTS = 6;
+function defaultSchedule(fn, ms) {
+    const handle = setTimeout(fn, ms);
+    return () => {
+        clearTimeout(handle);
+    };
+}
+/**
+ * The browser transport. Uses `addEventListener` rather than the `on*`
+ * properties so the structural contract above stays independent of the DOM
+ * `WebSocket` type (and so a host wrapper can be a plain object).
+ */
+export function browserWebSocketFactory(url, handlers) {
+    const socket = new WebSocket(url);
+    socket.addEventListener("open", () => {
+        handlers.onOpen();
+    });
+    socket.addEventListener("message", (event) => {
+        handlers.onData(event.data);
+    });
+    socket.addEventListener("close", (event) => {
+        handlers.onClose(event.code);
+    });
+    socket.addEventListener("error", () => {
+        handlers.onError();
+    });
+    return {
+        send: (payload) => {
+            socket.send(payload);
+        },
+        close: () => {
+            socket.close();
+        },
+    };
+}
+/** True when the environment can open a socket at all (SSR / node cannot). */
+export function canOpenWebSocket() {
+    return typeof WebSocket !== "undefined";
+}
+function refusalFor(code) {
+    if (code === CHAT_WS_CLOSE_UNAUTHENTICATED)
+        return "unauthenticated";
+    if (code === CHAT_WS_CLOSE_NOT_PARTICIPANT)
+        return "not_participant";
+    return undefined;
+}
+/**
+ * Open a resumable conversation socket. Connects immediately; returns the
+ * handle that closes it. Every state change is pushed through `onStatus`, so
+ * a React layer can render the transport without polling this object.
+ */
+export function createChatSocket(options) {
+    const factory = options.webSocket ?? browserWebSocketFactory;
+    const schedule = options.schedule ?? defaultSchedule;
+    const random = options.random ?? Math.random;
+    const baseDelay = options.reconnect?.baseDelayMs ?? DEFAULT_BASE_DELAY_MS;
+    const maxDelay = options.reconnect?.maxDelayMs ?? DEFAULT_MAX_DELAY_MS;
+    const maxAttempts = options.reconnect?.maxAttempts ?? DEFAULT_MAX_ATTEMPTS;
+    let connection = null;
+    let cancelRetry = null;
+    let disposed = false;
+    let attempt = 0;
+    /** Highest seq handed to the consumer — the dedup cursor. */
+    let maxSeqSeen = 0;
+    let status = {
+        state: "connecting",
+        refusal: undefined,
+        attempt: 0,
+    };
+    function setStatus(state, refusal) {
+        status = { state, refusal, attempt };
+        options.onStatus(status);
+    }
+    function send(frame) {
+        if (!connection)
+            return;
+        try {
+            connection.send(JSON.stringify(frame));
+        }
+        catch {
+            // A send on a socket that just died is not an error worth surfacing:
+            // the close handler is already on its way and will reconnect.
+        }
+    }
+    function backoffDelay() {
+        const exponential = baseDelay * 2 ** Math.max(0, attempt - 1);
+        const capped = Math.min(exponential, maxDelay);
+        // Full jitter — a fleet of tabs reconnecting after one server blip must
+        // not arrive as one wave.
+        return Math.round(capped * (0.5 + random() * 0.5));
+    }
+    function connect() {
+        if (disposed)
+            return;
+        setStatus("connecting");
+        // The consumer may have advanced by REST while we were down; never hand
+        // it a frame it already has.
+        maxSeqSeen = Math.max(maxSeqSeen, options.lastSeq());
+        connection = factory(options.url, {
+            onOpen: () => {
+                if (disposed)
+                    return;
+                attempt = 0;
+                send({ type: "hello", last_seq: options.lastSeq() });
+                setStatus("open");
+            },
+            onData: (data) => {
+                if (disposed)
+                    return;
+                const frame = decodeServerFrame(data);
+                // An unreadable frame must NOT advance the cursor — the gap it would
+                // hide is exactly what resume-by-seq exists to close.
+                if (!frame)
+                    return;
+                if (frame.type === "message") {
+                    if (frame.seq <= maxSeqSeen)
+                        return;
+                    maxSeqSeen = frame.seq;
+                }
+                options.onFrame(frame);
+            },
+            onError: () => {
+                // `error` always precedes `close` on a browser socket; the close
+                // handler owns the reconnect so the two cannot both schedule one.
+            },
+            onClose: (code) => {
+                if (disposed)
+                    return;
+                connection = null;
+                const refusal = refusalFor(code);
+                if (refusal) {
+                    // The host answered the question. Asking again, faster, is the
+                    // classic way to turn a 4403 into an outage.
+                    setStatus("closed", refusal);
+                    return;
+                }
+                attempt += 1;
+                if (attempt >= maxAttempts) {
+                    setStatus("closed", "unreachable");
+                    return;
+                }
+                setStatus("degraded");
+                cancelRetry = schedule(connect, backoffDelay());
+            },
+        });
+    }
+    connect();
+    return {
+        status: () => status,
+        ack: (seq) => {
+            send({ type: "ack", seq });
+        },
+        ping: () => {
+            send({ type: "ping" });
+        },
+        close: () => {
+            disposed = true;
+            cancelRetry?.();
+            cancelRetry = null;
+            const open = connection;
+            connection = null;
+            open?.close();
+            status = { state: "closed", refusal: undefined, attempt };
+        },
+    };
+}
+//# sourceMappingURL=chatSocket.js.map

package/dist/realtime/chatSocket.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"chatSocket.js","sourceRoot":"","sources":["../../src/realtime/chatSocket.ts"],"names":[],"mappings":"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"}

package/dist/realtime/frames.d.ts

@@ -0,0 +1,123 @@
+/**
+ * The stapel-chat WebSocket protocol, typed.
+ *
+ * This is a MIRROR of the module's own contract, not an invention:
+ * `stapel_chat/consumers.py` (`ChatConsumer`) and `stapel_chat/realtime.py`
+ * (`message_frame`) are the source, and `MODULE.md` §"Realtime protocol"
+ * states it in one line:
+ *
+ * ```
+ * client → server:  hello{last_seq} / send{body,attachments,reply_to} / ack{seq} / ping
+ * server → client:  welcome{server_seq} / message{…seq} / replay_done{up_to_seq} / error{code,message} / pong
+ * ```
+ *
+ * The WS surface is invisible to `schema.json` (OpenAPI describes HTTP), so
+ * these types cannot be generated today — the realtime spec (§8) parks the
+ * frame contract in the `events.json` family for later. Until then this file
+ * is the pair's declared mirror and `test/frames.test.ts` pins it against the
+ * shapes the consumer actually sends.
+ *
+ * Nothing here imports React or `@stapel/core`: it is plain protocol, so the
+ * future `@stapel/realtime` substrate can subsume it without dragging the UI.
+ */
+/**
+ * Widest resume gap the server replays inline (`consumers.REPLAY_LIMIT`).
+ * Past it the server answers `error{resync}` instead, and the client
+ * re-hydrates from the REST history. Mirrored here so the client can SAY that
+ * before the server has to.
+ */
+export declare const CHAT_WS_REPLAY_LIMIT = 500;
+/** `ChatConsumer.connect()` closes with this when `scope["user"]` is unset. */
+export declare const CHAT_WS_CLOSE_UNAUTHENTICATED = 4401;
+/** …and with this when the caller is not a participant of the conversation. */
+export declare const CHAT_WS_CLOSE_NOT_PARTICIPANT = 4403;
+/** Resume: replay everything after `last_seq`, then go live. */
+export interface ChatHelloFrame {
+    readonly type: "hello";
+    readonly last_seq: number;
+}
+/**
+ * Append a message over the socket.
+ *
+ * TYPED BUT NEVER SENT BY THIS CLIENT, on purpose. The frame is part of the
+ * module's contract, so a mirror that omitted it would be an incomplete
+ * mirror; but this pair posts messages over REST (`ChatApi.sendMessage`),
+ * where the answer is the persisted row and a refusal is a real error
+ * envelope. Over the socket a refusal is an `error` frame with a
+ * socket-local code (`empty` / `too_long` / `attachments_disabled` /
+ * `invalid_reply`) that is NOT in the module's error registry, so it has no
+ * i18n key and no remediation — the UI could not tell the person what went
+ * wrong. `createChatSocket` exposes no method that emits this.
+ */
+export interface ChatSendFrame {
+    readonly type: "send";
+    readonly body?: string;
+    readonly attachments?: readonly string[];
+    readonly reply_to?: string | null;
+}
+/** Delivery acknowledgement — the server tracks it, nothing depends on it. */
+export interface ChatAckFrame {
+    readonly type: "ack";
+    readonly seq: number;
+}
+/** Liveness probe; answered with `pong`. */
+export interface ChatPingFrame {
+    readonly type: "ping";
+}
+export type ChatClientFrame = ChatHelloFrame | ChatSendFrame | ChatAckFrame | ChatPingFrame;
+/** Answer to `hello`: the conversation's high-water mark right now. */
+export interface ChatWelcomeFrame {
+    readonly type: "welcome";
+    readonly conversation_id: string;
+    readonly server_seq: number;
+}
+/**
+ * A message, replayed or live — the same frame either way (that is what makes
+ * the overlap after a resume harmless: it is seq-deduped on both ends).
+ * Field-for-field `stapel_chat.realtime.message_frame`.
+ */
+export interface ChatMessageFrame {
+    readonly type: "message";
+    readonly message_id: string;
+    readonly conversation_id: string;
+    readonly sender_id: string | null;
+    readonly seq: number;
+    readonly kind: string;
+    readonly body: string;
+    readonly reply_to: string | null;
+    readonly attachments: readonly string[];
+    readonly created_at: string;
+}
+/** End of the replay window — everything up to `up_to_seq` has been sent. */
+export interface ChatReplayDoneFrame {
+    readonly type: "replay_done";
+    readonly up_to_seq: number;
+}
+/**
+ * A protocol-level refusal. `code` is a SOCKET-LOCAL vocabulary
+ * (`resync` / `bad_type` / the send-path codes), NOT a `error.<status>.<code>`
+ * key from the module's error registry — which is exactly why the only one
+ * this pair acts on is `resync`.
+ */
+export interface ChatErrorFrame {
+    readonly type: "error";
+    readonly code: string;
+    readonly message: string;
+}
+/** Answer to `ping`. */
+export interface ChatPongFrame {
+    readonly type: "pong";
+}
+export type ChatServerFrame = ChatWelcomeFrame | ChatMessageFrame | ChatReplayDoneFrame | ChatErrorFrame | ChatPongFrame;
+/** The one error code that means "stop replaying, re-read the journal". */
+export declare const CHAT_WS_RESYNC = "resync";
+/**
+ * Narrow one decoded server frame, or `null` for anything this build does not
+ * understand (an unknown `type`, a missing field, a `seq` that is not a
+ * number). Unknown is DROPPED, never coerced: a frame this client cannot read
+ * must not advance the seq cursor, or the gap it leaves is invisible.
+ */
+export declare function parseServerFrame(value: unknown): ChatServerFrame | null;
+/** Decode a socket payload (JSON text) into a frame, or `null`. */
+export declare function decodeServerFrame(data: unknown): ChatServerFrame | null;
+//# sourceMappingURL=frames.d.ts.map

package/dist/realtime/frames.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"frames.d.ts","sourceRoot":"","sources":["../../src/realtime/frames.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH;;;;;GAKG;AACH,eAAO,MAAM,oBAAoB,MAAM,CAAC;AAExC,+EAA+E;AAC/E,eAAO,MAAM,6BAA6B,OAAO,CAAC;AAClD,+EAA+E;AAC/E,eAAO,MAAM,6BAA6B,OAAO,CAAC;AAIlD,gEAAgE;AAChE,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IACvB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;CAC3B;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,WAAW,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACzC,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CACnC;AAED,8EAA8E;AAC9E,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,IAAI,EAAE,KAAK,CAAC;IACrB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;CACtB;AAED,4CAA4C;AAC5C,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AAED,MAAM,MAAM,eAAe,GACvB,cAAc,GACd,aAAa,GACb,YAAY,GACZ,aAAa,CAAC;AAIlB,uEAAuE;AACvE,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC;IACzB,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;IACjC,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;CAC7B;AAED;;;;GAIG;AACH,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC;IACzB,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;IACjC,QAAQ,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IAClC,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACjC,QAAQ,CAAC,WAAW,EAAE,SAAS,MAAM,EAAE,CAAC;IACxC,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;CAC7B;AAED,6EAA6E;AAC7E,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,IAAI,EAAE,aAAa,CAAC;IAC7B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;CAC5B;AAED;;;;;GAKG;AACH,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IACvB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B;AAED,wBAAwB;AACxB,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AAED,MAAM,MAAM,eAAe,GACvB,gBAAgB,GAChB,gBAAgB,GAChB,mBAAmB,GACnB,cAAc,GACd,aAAa,CAAC;AAElB,2EAA2E;AAC3E,eAAO,MAAM,cAAc,WAAW,CAAC;AAgBvC;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,OAAO,GAAG,eAAe,GAAG,IAAI,CAyDvE;AAED,mEAAmE;AACnE,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,OAAO,GAAG,eAAe,GAAG,IAAI,CAOvE"}