@joinskips/brand 9.0.0-develop.147 → 9.0.0-develop.149

package/chat/chat/useSkipsChat.js

@@ -0,0 +1,498 @@
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
+import { AppState } from 'react-native';
+import { cableUrl, createTypingSignal, openCable, EMPTY_THREAD, pendingId, storedIds, withFailed, withoutMessage, withPending, withReceived, withReceivedAll, withSent, } from "../helpers/index.js";
+import { ChatApiError, ChatClient } from "./client.js";
+import { clearSession, loadSession, saveReadThrough, saveSession, SESSION_IDLE_MS, } from "./session.js";
+import { platformSocket, platformStore } from "./platform.js";
+import { ChatVerifier } from "./verify.js";
+// A handler of the app's that throws is the app's to fix. It is logged, and nothing it was told about changes.
+function tellApp(call) {
+    try {
+        call();
+    }
+    catch (error) {
+        console.error('member app handler failed', error);
+    }
+}
+function memberSession(member) {
+    const { contact, conversationId } = member;
+    return conversationId === null ? null : { contact, conversation: { id: conversationId } };
+}
+// A missed read receipt or typing signal changes nothing on the screen, and the next one goes out anyway.
+async function bestEffort(signal) {
+    try {
+        await signal;
+    }
+    catch {
+        // Let go.
+    }
+}
+const NOT_TYPING = { typing: false, count: 0 };
+const systemNow = () => Date.now();
+function heldLine(line) {
+    return { line, step: 'choosing', unreachable: false };
+}
+function openingLineFrom(opening) {
+    const text = opening?.trim() ?? '';
+    return { id: text.length > 0 ? pendingId() : null, text };
+}
+// The Skips App no longer serves the stored conversation (deleted, or the inbox changed).
+function isForgotten(error) {
+    return error instanceof ChatApiError && error.status === 404;
+}
+// The conversation's life on the page: pick up the one this browser already has or
+// open one when the first line goes out, keep the socket up, and send what the visitor
+// types. The opening line shows at once, pending, so the visitor sees it before Skips
+// has even been reached.
+export function useSkipsChat({ baseUrl, inboxIdentifier, careTeamName, pageAddress, fetchFn = fetch, createSocket = platformSocket, store: givenStore, opening, verifyUrl, idleMs = SESSION_IDLE_MS, ...changing }) {
+    const [store] = useState(() => givenStore ?? platformStore());
+    // What an app may hand over afresh on every render, read where it is needed, so a new but equal one never
+    // starts the conversation over.
+    const latest = useRef(changing);
+    useEffect(() => {
+        latest.current = changing;
+    });
+    const now = useCallback(() => (latest.current.now ?? systemNow)(), []);
+    const [openingLine] = useState(() => openingLineFrom(opening));
+    // Asked once, on the first render: this browser has no conversation in this inbox, so its visitor is welcomed.
+    const [welcomed] = useState(() => changing.member === undefined &&
+        verifyUrl !== undefined &&
+        loadSession(store, inboxIdentifier, now()) === null);
+    const [welcome, setWelcome] = useState(() => welcomed && openingLine.id !== null ? heldLine(openingLine.text) : null);
+    const [thread, setThread] = useState(() => openingLine.id === null || welcomed
+        ? EMPTY_THREAD
+        : withPending(EMPTY_THREAD, openingLine.id, openingLine.text, now()));
+    // Whether lines go straight to Skips: at once without a welcome, and once the visitor is through one.
+    const through = !welcomed || welcome?.step === 'through';
+    // The contact the code service made for the visitor, kept in the page for the conversation opened on it.
+    const contactRef = useRef(null);
+    const askingRef = useRef(false);
+    const [status, setStatus] = useState('starting');
+    // The live feed has dropped and is not back yet.
+    const [reconnecting, setReconnecting] = useState(false);
+    // The feed of this conversation has dropped at some point, so the one live now is not its first.
+    const droppedRef = useRef(false);
+    const [skipsTyping, setSkipsTyping] = useState(NOT_TYPING);
+    const sessionRef = useRef(null);
+    const sessionPromiseRef = useRef(null);
+    // A conversation this page started, which the member's app hears of once its first line is in.
+    const startedRef = useRef(null);
+    // Closes the live feed for good.
+    const closeFeedRef = useRef(null);
+    const idleTimerRef = useRef(undefined);
+    // When the visitor last used the chat, while there is a conversation on the page.
+    const lastUsedRef = useRef(null);
+    const client = useMemo(() => new ChatClient({ baseUrl, inboxIdentifier, careTeamName, fetchFn }), [baseUrl, careTeamName, fetchFn, inboxIdentifier]);
+    const verifier = useMemo(() => new ChatVerifier({ url: verifyUrl ?? '', fetchFn }), [fetchFn, verifyUrl]);
+    // The conversation leaves the page: no session to stamp, and nothing more from the feed.
+    const leave = useCallback(() => {
+        sessionRef.current = null;
+        closeFeedRef.current?.();
+        closeFeedRef.current = null;
+    }, []);
+    const endSharedSignIn = useCallback(async () => {
+        try {
+            await verifier.signOut();
+        }
+        catch (error) {
+            console.error('sign-out not sent', error);
+        }
+    }, [verifier]);
+    // Signed out: the conversation leaves the page first, so a tap that lands before the page goes cannot save the
+    // chat again, and what the tab kept goes with it.
+    const signOut = useCallback(() => {
+        leave();
+        lastUsedRef.current = null;
+        setReconnecting(false);
+        clearTimeout(idleTimerRef.current);
+        clearSession(store, inboxIdentifier);
+        // A visitor's sign-in the member app shares goes too, or the next visit would come straight back in. One the
+        // service does not take stays until it runs out. A member's sign-in is the app's own, so it stays.
+        if (verifyUrl !== undefined && !latest.current.member)
+            void endSharedSignIn();
+        latest.current.onSignedOut?.();
+    }, [endSharedSignIn, inboxIdentifier, leave, store, verifyUrl]);
+    // Signs the chat out if it has sat unused past its limit, and says whether it did. The timer below does the same
+    // while the page runs, but a phone stops a page's timers in the background, so the clock is asked too.
+    const signedOutIfIdle = useCallback(() => {
+        const last = lastUsedRef.current;
+        if (last === null || now() - last <= idleMs)
+            return false;
+        signOut();
+        return true;
+    }, [idleMs, now, signOut]);
+    // The visitor used the chat just now, so its idle limit starts again: for what the tab keeps, and for the
+    // conversation on the page. Left unused that long with the page still open, the chat signs itself out, so a
+    // conversation is not left readable on a screen nobody is at. A reply from Skips is not the visitor.
+    const used = useCallback(() => {
+        const session = sessionRef.current;
+        if (!session || latest.current.member || signedOutIfIdle())
+            return;
+        const at = now();
+        lastUsedRef.current = at;
+        saveSession(store, inboxIdentifier, session, at);
+        clearTimeout(idleTimerRef.current);
+        idleTimerRef.current = setTimeout(signOut, idleMs);
+    }, [idleMs, inboxIdentifier, now, signOut, signedOutIfIdle, store]);
+    const markSeen = useCallback((session) => {
+        void bestEffort(client.seen(session.contact, session.conversation));
+    }, [client]);
+    // The conversation fetched again when its live feed comes back. The feed is left as it is, and it is what keeps
+    // the conversation current, so a fetch that fails here is let go. A conversation the Skips App has forgotten leaves nothing to be signed
+    // in to.
+    const refresh = useCallback(async (session) => {
+        try {
+            const history = await client.listMessages(session.contact, session.conversation);
+            setThread((current) => withReceivedAll(current, history));
+            markSeen(session);
+        }
+        catch (error) {
+            if (isForgotten(error))
+                signOut();
+        }
+    }, [client, markSeen, signOut]);
+    // The conversation's live feed, which brings itself back after a drop, a silent one included (openCable).
+    const connect = useCallback((session) => {
+        const { id } = session.conversation;
+        closeFeedRef.current = openCable(cableUrl(baseUrl), [session.contact.pubsubToken], {
+            onEvent: (event) => {
+                if (event.conversationId !== id)
+                    return;
+                if (event.kind === 'message') {
+                    setThread((current) => withReceived(current, event.message));
+                    if (!event.message.mine)
+                        markSeen(session);
+                }
+                else if (event.kind === 'typing') {
+                    setSkipsTyping((current) => ({ typing: event.typing, count: current.count + 1 }));
+                }
+            },
+            onState: (state) => {
+                // A feed the chat closed itself, signing out or leaving the page, is not one to bring back.
+                if (sessionRef.current !== session)
+                    return;
+                if (state === 'down') {
+                    droppedRef.current = true;
+                    setReconnecting(true);
+                }
+                else if (state === 'live') {
+                    setReconnecting(false);
+                    // What Skips sent while the feed was down never comes over the new one. The first feed of a
+                    // conversation has nothing to catch up on.
+                    if (droppedRef.current)
+                        void refresh(session);
+                }
+            },
+            // The Skips App no longer takes the conversation's key, so there is nothing left to be signed in to.
+            onKeysRefused: signOut,
+        }, 
+        // The feed's own clock, for how long it has heard nothing.
+        { careTeamName, createSocket, now: systemNow });
+    }, [baseUrl, careTeamName, createSocket, markSeen, refresh, signOut]);
+    // One conversation per page, however many sends race for it.
+    const ensureSession = useCallback(() => {
+        if (sessionRef.current)
+            return Promise.resolve(sessionRef.current);
+        sessionPromiseRef.current ??= (async () => {
+            try {
+                const { member } = latest.current;
+                const contact = member?.contact ?? contactRef.current ?? (await client.createContact());
+                const conversation = await client.createConversation(contact, pageAddress);
+                startedRef.current = conversation.id;
+                const session = { contact, conversation };
+                sessionRef.current = session;
+                used();
+                connect(session);
+                return session;
+            }
+            finally {
+                sessionPromiseRef.current = null;
+            }
+        })();
+        return sessionPromiseRef.current;
+    }, [client, connect, pageAddress, used]);
+    // The member's conversation, or the one this browser already has, with its history. A forgotten one this
+    // browser kept is dropped.
+    const resume = useCallback(async () => {
+        const { member } = latest.current;
+        const stored = member ? memberSession(member) : loadSession(store, inboxIdentifier, now());
+        if (!stored)
+            return;
+        try {
+            const history = await client.listMessages(stored.contact, stored.conversation);
+            sessionRef.current = stored;
+            setThread((current) => withReceivedAll(current, history));
+            used();
+            markSeen(stored);
+            connect(stored);
+        }
+        catch (error) {
+            if (member || !isForgotten(error))
+                throw error;
+            clearSession(store, inboxIdentifier);
+        }
+    }, [client, connect, inboxIdentifier, markSeen, now, store, used]);
+    // The page before the oldest line on the screen. Once one comes back empty there is nothing older to ask for.
+    const [olderDone, setOlderDone] = useState(false);
+    const loadOlder = useCallback(async () => {
+        const session = sessionRef.current;
+        const before = storedIds(thread)[0];
+        if (!session || before === undefined || olderDone)
+            return;
+        try {
+            const older = await client.listMessages(session.contact, session.conversation, before);
+            if (!older.length)
+                setOlderDone(true);
+            setThread((current) => withReceivedAll(current, older));
+        }
+        catch {
+            // Scrolling up again asks again.
+        }
+    }, [client, olderDone, thread]);
+    // The care team sees the visitor typing, and stop when they send or clear the box.
+    const signal = useMemo(() => createTypingSignal((on) => {
+        const session = sessionRef.current;
+        if (session)
+            void bestEffort(client.typing(session.contact, session.conversation, on));
+    }), [client]);
+    useEffect(() => () => {
+        signal.stop();
+    }, [signal]);
+    const typed = useCallback((text) => {
+        signal.typed(text);
+    }, [signal]);
+    // The welcome follows the visitor's first line when it goes out again, so it stays the first line on the page.
+    const follow = useCallback((from, to) => {
+        setWelcome((current) => current?.step === 'through' && current.lineId === from ? { ...current, lineId: to } : current);
+    }, []);
+    const deliver = useCallback(async (id, text, picked = null) => {
+        let delivered;
+        try {
+            const session = await ensureSession();
+            delivered = { session, stored: await client.sendMessage(session.contact, session.conversation, text, picked) };
+        }
+        catch {
+            setThread((current) => withFailed(current, id));
+            return;
+        }
+        const { session, stored } = delivered;
+        setThread((current) => withSent(current, id, stored));
+        used();
+        // Told once the line is in, each on its own, so one handler that throws keeps neither the other nor the line.
+        const { member } = latest.current;
+        const conversationId = session.conversation.id;
+        if (startedRef.current === conversationId) {
+            startedRef.current = null;
+            tellApp(() => member?.onStarted?.(conversationId));
+        }
+        tellApp(() => member?.onSent?.(conversationId, stored));
+    }, [client, ensureSession, used]);
+    const start = useCallback(async () => {
+        try {
+            await resume();
+        }
+        catch {
+            setStatus('unreachable');
+            return;
+        }
+        setStatus('ready');
+        if (openingLine.id !== null && !welcomed) {
+            await deliver(openingLine.id, openingLine.text);
+        }
+    }, [deliver, openingLine, resume, welcomed]);
+    const tryAgain = useCallback(() => {
+        setStatus('starting');
+        void start();
+    }, [start]);
+    // A line, a photo or PDF, or both. Only the welcome's own line waits for it, and the welcome has no picker.
+    const send = useCallback(async (text, picked = null) => {
+        const trimmed = text.trim();
+        if (!through) {
+            setWelcome(heldLine(trimmed));
+            return;
+        }
+        signal.stop();
+        const id = pendingId();
+        setThread((current) => withPending(current, id, trimmed, now(), picked ?? undefined));
+        await deliver(id, trimmed, picked);
+    }, [deliver, now, signal, through]);
+    // One request to the code service at a time: a second press while one is out does nothing.
+    const ask = useCallback(async (request) => {
+        if (askingRef.current)
+            return;
+        askingRef.current = true;
+        try {
+            await request();
+        }
+        finally {
+            askingRef.current = false;
+        }
+    }, []);
+    const sendCode = useCallback((email) => ask(async () => {
+        try {
+            await verifier.requestCode(email);
+        }
+        catch {
+            setWelcome((current) => current && { ...current, unreachable: true });
+            return;
+        }
+        setWelcome((current) => current && {
+            line: current.line,
+            step: 'code',
+            email,
+            noMatch: false,
+            ranOut: false,
+            unreachable: false,
+            codes: (current.step === 'code' ? current.codes : 0) + 1,
+        });
+    }), [ask, verifier]);
+    // The visitor is through on the contact the service made with the email they proved is theirs. Their line goes
+    // to Skips on that contact, and every line after it.
+    const goThrough = useCallback(async (line, email, named, contact, signedIn = false) => {
+        contactRef.current = contact;
+        const id = pendingId();
+        setWelcome({ line, step: 'through', email, named, signedIn, unreachable: false, lineId: id });
+        setThread((current) => withPending(current, id, line, now()));
+        await deliver(id, line);
+    }, [deliver, now]);
+    // A sign-in this browser already has, from an earlier chat or the member app, takes the visitor straight through.
+    // Without one, or with the service not answering, they give their email, and the code step says if it is down.
+    const continueHere = useCallback((line) => {
+        void ask(async () => {
+            const signedIn = await verifier.signedIn().catch(() => null);
+            if (signedIn !== null) {
+                await goThrough(line, signedIn.email, false, signedIn.contact, true);
+                return;
+            }
+            setWelcome({ line, step: 'email', unreachable: false });
+        });
+    }, [ask, goThrough, verifier]);
+    // For the right code the service hands back the contact of a visitor the Skips App knows. One it does not know
+    // is asked their name first.
+    const checkCode = useCallback((step, code) => ask(async () => {
+        const { line, email, codes } = step;
+        let checked;
+        try {
+            checked = await verifier.checkCode(email, code);
+        }
+        catch {
+            setWelcome((current) => current && { ...current, unreachable: true });
+            return;
+        }
+        if (checked.result === 'noMatch') {
+            setWelcome({ ...step, noMatch: true, unreachable: false });
+        }
+        else if (checked.result === 'nameNeeded') {
+            setWelcome({ line, step: 'name', email, code, codes, unreachable: false });
+        }
+        else {
+            await goThrough(line, email, false, checked.contact);
+        }
+    }), [ask, goThrough, verifier]);
+    // The name goes back with the code that was right. A code that has run out since sends the visitor back to the
+    // code step for a new one.
+    const giveName = useCallback((step, name) => ask(async () => {
+        const { line, email, code, codes } = step;
+        let contact;
+        try {
+            contact = await verifier.checkCodeWithName(email, code, name);
+        }
+        catch {
+            setWelcome((current) => current && { ...current, unreachable: true });
+            return;
+        }
+        if (contact === null) {
+            setWelcome({
+                line,
+                step: 'code',
+                email,
+                noMatch: false,
+                ranOut: true,
+                codes,
+                unreachable: false,
+            });
+            return;
+        }
+        await goThrough(line, email, true, contact);
+    }), [ask, goThrough, verifier]);
+    // Nothing has been made for the email being changed: its code was never entered, or the Skips App does not know
+    // it and no name went back with the code. A request already out to the code service finishes first.
+    const changeEmail = useCallback((step) => {
+        if (askingRef.current)
+            return;
+        setWelcome({ line: step.line, step: 'email', email: step.email, unreachable: false });
+    }, []);
+    // A failed line goes out again as a fresh pending one.
+    const retry = useCallback(async (failed) => {
+        const id = pendingId();
+        follow(failed.id, id);
+        setThread((current) => withPending(withoutMessage(current, failed.id), id, failed.text, now(), failed.file));
+        await deliver(id, failed.text, failed.file ?? null);
+    }, [deliver, follow, now]);
+    const [choosing, setChoosing] = useState(null);
+    const [choiceFailed, setChoiceFailed] = useState(null);
+    // One answer only comes from the shared Choices, whose buttons are off while `choosing` is set. The answer is kept on the
+    // question first, so Skips reads it from there when the visitor's line arrives, and a reload shows the question
+    // answered. The line then passes the question, which takes its buttons away.
+    const choose = useCallback(async (question, answer) => {
+        const session = sessionRef.current;
+        if (!session)
+            return;
+        setChoosing(answer.value);
+        setChoiceFailed(null);
+        try {
+            await client.choose(session.contact, session.conversation, question.id, answer);
+        }
+        catch {
+            setChoiceFailed(question.id);
+            return;
+        }
+        finally {
+            setChoosing(null);
+        }
+        if (sessionRef.current !== session)
+            return;
+        await send(answer.title);
+    }, [client, send]);
+    // What is on the visitor's screen is read, so the header's chat button counts only the replies after it.
+    useEffect(() => {
+        if (sessionRef.current === null || latest.current.member)
+            return;
+        saveReadThrough(store, inboxIdentifier, Math.max(0, ...thread.messages.map((m) => m.id)));
+    }, [inboxIdentifier, store, thread]);
+    useEffect(() => {
+        void start();
+        return () => {
+            leave();
+            clearTimeout(idleTimerRef.current);
+        };
+    }, [leave, start]);
+    // A page or app brought back to the front is checked then, and not only at the visitor's next tap.
+    useEffect(() => {
+        const watching = AppState.addEventListener('change', signedOutIfIdle);
+        return () => {
+            watching.remove();
+        };
+    }, [signedOutIfIdle]);
+    return {
+        thread,
+        status,
+        send,
+        retry,
+        tryAgain,
+        reconnecting,
+        loadOlder,
+        typed,
+        stillHere: used,
+        welcome,
+        continueHere,
+        sendCode,
+        checkCode,
+        giveName,
+        changeEmail,
+        skipsTyping,
+        choose,
+        choosing,
+        choiceFailed,
+    };
+}

package/chat/chat/verify.d.ts

@@ -0,0 +1,35 @@
+import { type ContactSession } from './client.ts';
+export interface ChatVerifierOptions {
+    url: string;
+    fetchFn?: typeof fetch;
+}
+export declare const CODE_LENGTH = 6;
+export declare const NO_MATCH = 401;
+interface ContactMade {
+    result: 'contact';
+    contact: ContactSession;
+}
+interface NameNeeded {
+    result: 'nameNeeded';
+}
+interface NoMatch {
+    result: 'noMatch';
+}
+export type CodeCheck = ContactMade | NameNeeded | NoMatch;
+export interface SignedIn {
+    email: string;
+    contact: ContactSession;
+}
+export declare class ChatVerifier {
+    private readonly url;
+    private readonly fetchFn;
+    constructor({ url, fetchFn }: ChatVerifierOptions);
+    private post;
+    requestCode(email: string): Promise<void>;
+    private check;
+    signedIn(): Promise<SignedIn | null>;
+    signOut(): Promise<void>;
+    checkCode(email: string, code: string): Promise<CodeCheck>;
+    checkCodeWithName(email: string, code: string, name: string): Promise<ContactSession | null>;
+}
+export {};

package/chat/chat/verify.js

@@ -0,0 +1,84 @@
+// The step that proves a visitor reads the email they gave: a code is sent to it, and for the
+// right code the service makes their contact and hands it back, in the inbox their conversation
+// belongs in. The Skips App takes a contact in those inboxes only from that service, which holds
+// their keys. A visitor the Skips App does not know is asked for a name first: the service then
+// says so, leaves the code good, and makes the contact when the same code comes back with a name.
+import { ChatApiError, contactSessionFrom, isRecord } from "./client.js";
+export const CODE_LENGTH = 6;
+function isCode(code) {
+    return code.length === CODE_LENGTH && /^\d+$/.test(code);
+}
+// The service answers 401 for a code that is wrong, late, used or unknown, and says no more.
+export const NO_MATCH = 401;
+function asksForName(body) {
+    return isRecord(body) && body.name_needed === true;
+}
+export class ChatVerifier {
+    url;
+    fetchFn;
+    constructor({ url, fetchFn = fetch }) {
+        this.url = url.replace(/\/$/, '');
+        this.fetchFn = fetchFn;
+    }
+    post(path, body) {
+        // Called detached: window.fetch throws when any other object is its this.
+        const { fetchFn } = this;
+        return fetchFn(`${this.url}${path}`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json', Accept: 'application/json' },
+            body: JSON.stringify(body),
+        });
+    }
+    async requestCode(email) {
+        const response = await this.post('/code', { email });
+        if (!response.ok)
+            throw new ChatApiError(response.status, 'the code was not sent');
+    }
+    // An entry that is not a code cannot match, so it is not sent and does not use up a try. With a name the
+    // service makes the contact whoever the visitor is, so its asking for one again is an answer in another shape.
+    async check(email, code, name) {
+        if (!isCode(code))
+            return { result: 'noMatch' };
+        const response = await this.post('/check', name === undefined ? { email, code } : { name, email, code });
+        if (response.status === NO_MATCH)
+            return { result: 'noMatch' };
+        if (!response.ok)
+            throw new ChatApiError(response.status, 'the code was not checked');
+        const body = await response.json().catch(() => null);
+        if (name === undefined && asksForName(body))
+            return { result: 'nameNeeded' };
+        const contact = contactSessionFrom(body);
+        if (!contact)
+            throw new ChatApiError(response.status, 'unexpected contact shape');
+        return { result: 'contact', contact };
+    }
+    // The service reads the sign-in from a cookie the page cannot see, and answers NO_MATCH when there is none it takes.
+    async signedIn() {
+        const response = await this.post('/session', {});
+        if (response.status === NO_MATCH)
+            return null;
+        if (!response.ok)
+            throw new ChatApiError(response.status, 'the sign-in was not checked');
+        const body = await response.json().catch(() => null);
+        const contact = contactSessionFrom(body);
+        if (!contact || !isRecord(body) || typeof body.email !== 'string') {
+            throw new ChatApiError(response.status, 'unexpected contact shape');
+        }
+        return { email: body.email, contact };
+    }
+    // Ends the sign-in the service keeps for this browser, which the member app shares.
+    async signOut() {
+        const response = await this.post('/signout', {});
+        if (!response.ok)
+            throw new ChatApiError(response.status, 'the sign-out was not sent');
+    }
+    // The contact of a visitor the Skips App knows, or word that it needs their name.
+    checkCode(email, code) {
+        return this.check(email, code);
+    }
+    // The contact of a visitor who was asked for their name, or null if the code no longer matches.
+    async checkCodeWithName(email, code, name) {
+        const checked = await this.check(email, code, name);
+        return checked.result === 'contact' ? checked.contact : null;
+    }
+}

package/chat/helpers/cable.d.ts

@@ -0,0 +1,34 @@
+import { type ChatEvent } from './cableFrames.ts';
+export declare const STALE_MS = 10000;
+export declare const FIRST_RETRY_MS = 1000;
+export declare const MAX_RETRY_MS = 30000;
+export type CableState = 'connecting' | 'live' | 'down';
+export interface CableOptions {
+    careTeamName: string;
+    createSocket: (url: string) => Socket;
+    now: () => number;
+}
+export interface CableHandlers {
+    onEvent: (event: ChatEvent) => void;
+    onState: (state: CableState) => void;
+    onKeysRefused: () => void;
+}
+/** The socket address for a Skips App origin, such as https://app.joinskips.com. */
+export declare const cableUrl: (origin: string) => string;
+/** The wait before the nth reconnect, doubling up to MAX_RETRY_MS. */
+export declare const retryDelay: (attempt: number) => number;
+export interface SocketMessage {
+    data: unknown;
+}
+export interface Socket extends Pick<WebSocket, 'send' | 'close'> {
+    onopen: ((event: unknown) => void) | null;
+    onmessage: ((event: SocketMessage) => void) | null;
+    onclose: ((event: unknown) => void) | null;
+    onerror: ((event: unknown) => void) | null;
+}
+/**
+ * Opens the feed for the member's keys, the Skips App's pubsub tokens, on sockets the app makes with createSocket.
+ * now is the app's clock, which the stale check reads.
+ * Returns a function that closes it for good.
+ */
+export declare function openCable(url: string, keys: string[], handlers: CableHandlers, { careTeamName, createSocket, now }: CableOptions): () => void;