@parlor/client 0.0.0-stage → 0.1.0

package/dist/react/chat/runtime.js

@@ -0,0 +1,928 @@
+import { CHAT_CHANNEL, CHAT_TAG, foldThread, HOSTS_TAG, isPromptTooLong, parseChatFrame, PROMPT_LIMIT_MESSAGE, } from "@parlor/chat";
+import { ActionError, asId, tagsOverlap, } from "@parlor/core";
+import { generateClientId } from "../../action-client.js";
+import { applyFrame, mergeSnapshot, NO_OPEN_TURNS, pruneOpen, } from "./open-turns.js";
+export const HOST_GRANTS_TAG = "parlor_auth_hosts";
+export const DEVICES_TAG = "parlor_auth_devices";
+const LINKED = { status: "linked" };
+const CHECKING = { status: "checking" };
+const READ_RETRY_BASE_MS = 1_000;
+const READ_RETRY_MAX_MS = 30_000;
+const ACTIVITY_PING_MS = 60_000;
+const UNFIXABLE_BY_RETRY = new Set([
+    "not_found",
+    "unauthenticated",
+    "forbidden",
+]);
+const retryable = (error) => !(error instanceof ActionError && UNFIXABLE_BY_RETRY.has(error.code));
+const mint = (kind) => asId(kind, generateClientId());
+const isActive = (turn) => turn.state === "queued" || turn.state === "running";
+const exceedsPromptLimit = (error) => error.issues?.some((issue) => issue.code === "too_big" && issue.path.join(".") === "prompt.text") ?? false;
+class NeedsDevice extends Error {
+    name = "NeedsDevice";
+}
+/** Prompts are signed with presence this long before the computer's deadline, for clock skew. */
+const PRESENCE_MARGIN_MS = 10 * 60_000;
+const LONGEST_TIMEOUT_MS = 2 ** 31 - 1;
+const readable = (error) => {
+    if (error instanceof NeedsDevice)
+        return error.message;
+    if (error instanceof Error && error.name === "NotAllowedError") {
+        return "Face ID or Touch ID was cancelled.";
+    }
+    if (!(error instanceof ActionError))
+        return "Could not reach the server.";
+    if (error.issues === undefined)
+        return error.message;
+    return exceedsPromptLimit(error)
+        ? PROMPT_LIMIT_MESSAGE
+        : "That message could not be sent. Try again.";
+};
+const bySeq = (a, b) => a.seq - b.seq;
+export function createChatRuntime(deps) {
+    const { calls, agentUi } = deps;
+    const listeners = new Set();
+    let threadId = deps.threadId === undefined ? undefined : asId("thread", deps.threadId);
+    let loaded = "no";
+    let thread;
+    let threads = [];
+    let olderThreads = [];
+    let moreThreads = false;
+    let hasOlder = false;
+    let loadingOlder = false;
+    let hosts = [];
+    let items = new Map();
+    let turns = [];
+    let open = NO_OPEN_TURNS;
+    let beforeLoad = [];
+    let draft = "";
+    let failure;
+    let chosen;
+    let sending = false;
+    let pendingSend;
+    let startedNew = false;
+    let connect = {
+        kind: "command",
+        command: `npx @parlor/agent-host connect ${deps.appOrigin}`,
+    };
+    let stopWatching;
+    let watched;
+    let running = false;
+    let channelOpen = false;
+    let staleAfterLoad = false;
+    let dirty = false;
+    const staleReads = new Set();
+    let unfixable = false;
+    let retryTimer;
+    let retryDelay = READ_RETRY_BASE_MS;
+    let lastPing;
+    let pingRefused = false;
+    let generation = 0;
+    let device;
+    let linkInfo;
+    let linking;
+    let linkBusy = false;
+    let linkError;
+    let linkExpired = false;
+    let linkTimer;
+    let presenceTimer;
+    let setup;
+    let afterSetup;
+    let explainers = 0;
+    const resends = new Map();
+    const answerIds = new Map();
+    const stopIds = new Map();
+    const refusedLast = (hostId, deviceId) => {
+        const last = [...turns].reverse().find((turn) => turn.agent.hostId === hostId);
+        if (last?.failure !== "device_rejected")
+            return false;
+        return [...items.values()].some((item) => item.turnId === last.turnId &&
+            item.kind === "prompt" &&
+            item.body.signed?.deviceId === deviceId);
+    };
+    /**
+     * When the computer behind `agentKey` wants this device's next prompt signed with presence:
+     * by its report, or now if it refused this device's last prompt, whatever the clocks say.
+     */
+    const presenceDueAt = (agentKey) => {
+        const deviceId = device?.id ?? linkInfo?.deviceId;
+        if (deviceId === undefined)
+            return undefined;
+        const hostId = agentKey.split("/")[0];
+        const due = hosts.find((host) => host.id === hostId)?.presenceDue?.[deviceId];
+        if (due === undefined)
+            return undefined;
+        return refusedLast(hostId, deviceId) ? 0 : due - PRESENCE_MARGIN_MS;
+    };
+    const choices = () => hosts.flatMap((host) => host.agents.map((agent) => ({
+        key: `${host.id}/${agent.id}`,
+        name: agent.name,
+        hostName: host.name,
+        online: host.online,
+        ready: agent.ready,
+        problem: agent.problem,
+    })));
+    const waitOn = (reason, hostId) => ({
+        reason,
+        hostId,
+        hostName: hosts.find((host) => host.id === hostId)?.name ?? "your computer",
+    });
+    const linkOf = () => {
+        if (!deps.auth?.linkState)
+            return LINKED;
+        const reporting = hosts.filter((host) => host.online && host.devices !== undefined);
+        if (reporting.length === 0)
+            return LINKED;
+        if (!linkInfo)
+            return CHECKING;
+        const { deviceId } = linkInfo;
+        if (linkInfo.pairing ||
+            linkInfo.vouched ||
+            (deviceId !== undefined &&
+                reporting.some((host) => host.devices?.includes(deviceId)))) {
+            return LINKED;
+        }
+        const listing = hosts.filter((host) => host.devices !== undefined);
+        return {
+            status: "unlinked",
+            hostName: reporting[0].name,
+            code: linking?.code,
+            qr: linking?.qr,
+            command: linking && `npx @parlor/agent-host link ${deps.appOrigin} ${linking.code}`,
+            expiresAt: linking?.expiresAt,
+            expired: linkExpired,
+            onlyComputer: listing.every((host) => host.devices.every((id) => id === deviceId)),
+            busy: linkBusy,
+            error: linkError,
+        };
+    };
+    const waitOf = () => {
+        const approving = turns.find(awaitsApproval);
+        if (approving)
+            return waitOn("approval", approving.agent.hostId);
+        const offline = turns.find((turn) => turn.state === "queued" &&
+            hosts.some((host) => host.id === turn.agent.hostId && !host.online));
+        return offline && waitOn("offline", offline.agent.hostId);
+    };
+    const compute = () => {
+        const agents = choices();
+        const wanted = chosen ??
+            (thread?.agent ? `${thread.agent.hostId}/${thread.agent.agentId}` : undefined);
+        const agent = agents.find((choice) => choice.key === wanted) ??
+            agents.find((choice) => choice.online && choice.ready) ??
+            agents[0];
+        const wait = loaded === "yes" && !sending ? waitOf() : undefined;
+        const due = agent && presenceDueAt(agent.key);
+        const status = loaded === "failed"
+            ? "unavailable"
+            : loaded === "no"
+                ? "loading"
+                : sending
+                    ? "sending"
+                    : wait
+                        ? "waiting"
+                        : turns.some(isActive) || open.turns.size > 0
+                            ? "running"
+                            : "idle";
+        return {
+            status,
+            wait,
+            thread,
+            threads: [
+                ...threads,
+                ...olderThreads.filter((older) => !threads.some((shown) => shown.id === older.id)),
+            ],
+            moreThreads,
+            hasOlder,
+            loadingOlder,
+            items: foldThread({
+                items: [...items.values()].sort(bySeq),
+                open: [...open.turns.values()],
+                turns,
+                confirmations: agentUi.confirmations.get().filter((c) => c.threadId === threadId),
+                deviceId: device?.id,
+            }),
+            hosts,
+            agents,
+            agent,
+            connect,
+            draft,
+            error: failure,
+            setup,
+            link: linkOf(),
+            presenceDue: due !== undefined && Date.now() >= due,
+        };
+    };
+    /** Re-emits once the chosen computer's presence deadline arrives, so the hint shows unprompted. */
+    const watchPresence = () => {
+        clearTimeout(presenceTimer);
+        presenceTimer = undefined;
+        const due = running && state.agent ? presenceDueAt(state.agent.key) : undefined;
+        if (due === undefined || state.presenceDue)
+            return;
+        presenceTimer = setTimeout(emit, Math.min(due - Date.now(), LONGEST_TIMEOUT_MS));
+    };
+    let state = compute();
+    const emit = () => {
+        state = compute();
+        watchPresence();
+        for (const listener of [...listeners])
+            listener();
+    };
+    const watch = () => {
+        if (watched === threadId)
+            return;
+        stopWatching?.();
+        watched = threadId;
+        stopWatching = threadId === undefined ? undefined : agentUi.watch(threadId);
+    };
+    const absorb = (page) => {
+        items = new Map(items);
+        for (const item of page.items)
+            items.set(item.id, item);
+        if (page.turns) {
+            const fresh = new Map(page.turns.map((turn) => [turn.turnId, turn]));
+            turns = [...turns.filter((turn) => !fresh.has(turn.turnId)), ...page.turns];
+        }
+        open = pruneOpen(open, items, turns);
+    };
+    const oldestSeq = () => items.size === 0
+        ? undefined
+        : Math.min(...[...items.values()].map((item) => item.seq));
+    const takeThreads = (snapshot) => {
+        threads = snapshot.threads;
+        if (olderThreads.length === 0)
+            moreThreads = snapshot.moreThreads === true;
+    };
+    const load = async (target) => {
+        const epoch = generation;
+        const snapshot = await calls.call("open", target ? { threadId: target } : {});
+        if (epoch !== generation)
+            return;
+        staleReads.clear();
+        takeThreads(snapshot);
+        hosts = snapshot.hosts;
+        const page = startedNew && target === undefined ? undefined : snapshot.page;
+        thread = page?.thread;
+        threadId = page?.thread?.id ?? target;
+        if (page) {
+            const oldest = oldestSeq();
+            absorb(page);
+            const first = page.items[0];
+            if (oldest === undefined || (first !== undefined && first.seq <= oldest)) {
+                hasOlder = page.hasMore;
+            }
+        }
+        open = mergeSnapshot(open, channelOpen && page ? page.open : []);
+        const replay = beforeLoad;
+        beforeLoad = [];
+        loaded = "yes";
+        retryDelay = READ_RETRY_BASE_MS;
+        for (const frame of replay) {
+            if (frame.threadId === threadId)
+                open = applyFrame(open, frame);
+        }
+        open = pruneOpen(open, items, turns);
+        watch();
+    };
+    const refreshLists = async () => {
+        const epoch = generation;
+        const fresh = await calls.call("open", {});
+        if (epoch !== generation || threadId !== undefined)
+            return;
+        takeThreads(fresh);
+        hosts = fresh.hosts;
+        emit();
+    };
+    const refreshHosts = async () => {
+        const fresh = await calls.call("hosts", {});
+        hosts = fresh;
+        emit();
+    };
+    const readLists = async () => {
+        if (threadId === undefined && !startedNew && draft.trim() === "") {
+            await load(undefined);
+            emit();
+        }
+        else
+            await refreshLists();
+    };
+    const staleReaders = {
+        lists: readLists,
+        hosts: refreshHosts,
+    };
+    const cancelRetry = () => {
+        if (retryTimer !== undefined)
+            globalThis.clearTimeout(retryTimer);
+        retryTimer = undefined;
+    };
+    const clearRetry = () => {
+        cancelRetry();
+        retryDelay = READ_RETRY_BASE_MS;
+    };
+    const scheduleRetry = () => {
+        if (!running || retryTimer !== undefined)
+            return;
+        const wait = retryDelay;
+        retryDelay = Math.min(retryDelay * 2, READ_RETRY_MAX_MS);
+        retryTimer = globalThis.setTimeout(() => {
+            retryTimer = undefined;
+            void mend();
+        }, wait);
+    };
+    const settled = () => {
+        if (!dirty && staleReads.size === 0)
+            clearRetry();
+    };
+    const rereadStale = async (kind) => {
+        const epoch = generation;
+        try {
+            await staleReaders[kind]();
+            staleReads.delete(kind);
+            settled();
+        }
+        catch (error) {
+            if (epoch !== generation)
+                return;
+            staleReads.add(kind);
+            if (retryable(error))
+                scheduleRetry();
+        }
+    };
+    let refreshing = false;
+    let refreshAgain = false;
+    const refresh = async () => {
+        if (refreshing) {
+            refreshAgain = true;
+            return;
+        }
+        refreshing = true;
+        try {
+            do {
+                refreshAgain = false;
+                if (loaded !== "yes" || threadId === undefined)
+                    break;
+                const epoch = generation;
+                const target = threadId;
+                if (turns.some(isActive)) {
+                    await load(target);
+                }
+                else {
+                    const lastSeq = Math.max(0, ...[...items.values()].map((item) => item.seq));
+                    const fresh = await calls.call("items", {
+                        threadId: target,
+                        afterSeq: lastSeq,
+                    });
+                    if (epoch !== generation)
+                        break;
+                    absorb({ items: fresh });
+                    const known = new Set(turns.map((turn) => turn.turnId));
+                    if (fresh.some((item) => !known.has(item.turnId)))
+                        await load(target);
+                }
+                dirty = false;
+                settled();
+                emit();
+            } while (refreshAgain);
+        }
+        catch (error) {
+            refreshAgain = false;
+            dirty = true;
+            if (retryable(error))
+                scheduleRetry();
+        }
+        finally {
+            refreshing = false;
+        }
+    };
+    const reporting = async (command) => {
+        try {
+            await command();
+        }
+        catch (error) {
+            failure = readable(error);
+            emit();
+            throw error;
+        }
+        if (failure !== undefined) {
+            failure = undefined;
+            emit();
+        }
+    };
+    const awaitsApproval = (turn) => {
+        if (!isActive(turn))
+            return false;
+        let waiting = false;
+        for (const item of [...items.values()].sort(bySeq)) {
+            if (item.turnId !== turn.turnId)
+                continue;
+            if (item.kind === "event" && item.body.event === "device_pending")
+                waiting = true;
+            else if (item.author !== "user")
+                waiting = false;
+        }
+        return waiting;
+    };
+    const deviceOf = async () => {
+        const found = await deps.auth?.device?.();
+        device = found ?? device;
+        return found;
+    };
+    const refreshLink = async () => {
+        if (!deps.auth?.linkState)
+            return;
+        try {
+            linkInfo = await deps.auth.linkState();
+        }
+        catch {
+            return;
+        }
+        if (linking && linking.deviceId !== linkInfo.deviceId)
+            linking = undefined;
+        emit();
+    };
+    const whenSetUp = async (action) => {
+        if (explainers > 0 &&
+            device === undefined &&
+            (await deps.auth?.deviceSetup?.()) === "needed") {
+            afterSetup = action;
+            setup = { step: "explain" };
+            emit();
+            return;
+        }
+        await action();
+    };
+    const signPrompt = async (prompt) => {
+        const own = await deviceOf();
+        if (!own)
+            return undefined;
+        const due = presenceDueAt(`${prompt.agent.hostId}/${prompt.agent.agentId}`);
+        return due !== undefined && Date.now() >= due
+            ? own.signPrompt(prompt, { presence: true })
+            : own.signPrompt(prompt);
+    };
+    const submit = async (attempt, agentKey, settle) => {
+        const [hostId, agentId] = agentKey.split("/");
+        const epoch = generation;
+        sending = true;
+        emit();
+        try {
+            await reporting(async () => {
+                const agent = { hostId: asId("host", hostId), agentId };
+                const signed = deps.auth?.device
+                    ? await signPrompt({
+                        threadId: attempt.threadId,
+                        turnId: attempt.turnId,
+                        agent,
+                        text: attempt.text,
+                    })
+                    : undefined;
+                await calls.call("send", {
+                    threadId: attempt.threadId,
+                    turnId: attempt.turnId,
+                    itemId: attempt.itemId,
+                    clientId: deps.clientId,
+                    prompt: { text: attempt.text, agent, ...(signed ? { signed } : {}) },
+                });
+                settle();
+                if (epoch !== generation)
+                    return;
+                startedNew = false;
+                threadId = attempt.threadId;
+                watch();
+                await load(threadId);
+            });
+        }
+        finally {
+            sending = false;
+            emit();
+        }
+    };
+    const activeTurn = () => [...turns].reverse().find(isActive);
+    const switchTo = (target, blank) => {
+        generation += 1;
+        threadId = target;
+        startedNew = blank;
+        thread = undefined;
+        items = new Map();
+        turns = [];
+        hasOlder = false;
+        open = NO_OPEN_TURNS;
+        beforeLoad = [];
+        pendingSend = undefined;
+        stopIds.clear();
+        answerIds.clear();
+        dirty = false;
+        staleReads.clear();
+        clearRetry();
+        watch();
+        if (blank && loaded === "yes") {
+            emit();
+            return;
+        }
+        loaded = "no";
+        emit();
+        void loadFirst().then(emit);
+    };
+    const runtime = {
+        subscribe(listener) {
+            listeners.add(listener);
+            return () => listeners.delete(listener);
+        },
+        get: () => state,
+        setDraft(text) {
+            draft = text;
+            emit();
+            announceActivity();
+        },
+        async send(text = draft) {
+            announceActivity();
+            const prompt = text.trim();
+            const target = state.agent;
+            if (!prompt || isPromptTooLong(prompt) || !target || sending || loaded !== "yes") {
+                return;
+            }
+            const retrying = pendingSend?.text === prompt &&
+                pendingSend.agent === target.key &&
+                pendingSend.openedIn === threadId;
+            const attempt = retrying && pendingSend
+                ? pendingSend
+                : (pendingSend = {
+                    text: prompt,
+                    agent: target.key,
+                    openedIn: threadId,
+                    threadId: threadId ?? mint("thread"),
+                    turnId: mint("turn"),
+                    itemId: mint("item"),
+                });
+            await whenSetUp(() => submit(attempt, target.key, () => {
+                pendingSend = undefined;
+                if (draft.trim() === prompt)
+                    draft = "";
+            }));
+        },
+        async loadOlder() {
+            const target = threadId;
+            const before = oldestSeq();
+            if (target === undefined || before === undefined || !hasOlder || loadingOlder)
+                return;
+            const epoch = generation;
+            loadingOlder = true;
+            emit();
+            try {
+                await reporting(async () => {
+                    const older = await calls.call("history", {
+                        threadId: target,
+                        beforeSeq: before,
+                    });
+                    if (epoch !== generation)
+                        return;
+                    absorb(older);
+                    hasOlder = older.hasMore;
+                });
+            }
+            finally {
+                loadingOlder = false;
+                emit();
+            }
+        },
+        async loadMoreThreads() {
+            const last = olderThreads.at(-1) ?? threads.at(-1);
+            if (!last || !moreThreads || loadingOlder)
+                return;
+            loadingOlder = true;
+            emit();
+            try {
+                await reporting(async () => {
+                    const next = await calls.call("threadsBefore", {
+                        before: { updatedAt: last.updatedAt, id: last.id },
+                    });
+                    olderThreads = [...olderThreads, ...next.threads];
+                    moreThreads = next.hasMore;
+                });
+            }
+            finally {
+                loadingOlder = false;
+                emit();
+            }
+        },
+        async resend(promptItemId) {
+            const prompt = state.items.find((item) => item.kind === "prompt" && item.id === promptItemId);
+            if (prompt?.kind !== "prompt" || sending || loaded !== "yes" || !threadId)
+                return;
+            const key = `${prompt.agent.hostId}/${prompt.agent.agentId}`;
+            let attempt = resends.get(prompt.id);
+            if (!attempt) {
+                attempt = {
+                    text: prompt.text,
+                    agent: key,
+                    openedIn: threadId,
+                    threadId,
+                    turnId: mint("turn"),
+                    itemId: mint("item"),
+                };
+                resends.set(prompt.id, attempt);
+            }
+            await whenSetUp(() => submit(attempt, key, () => resends.delete(prompt.id)));
+        },
+        async stop() {
+            const turn = activeTurn();
+            if (!turn || threadId === undefined)
+                return;
+            const itemId = stopIds.get(turn.turnId) ?? mint("item");
+            stopIds.set(turn.turnId, itemId);
+            const target = threadId;
+            await reporting(async () => {
+                await calls.call("cancel", { threadId: target, turnId: turn.turnId, itemId });
+                await refresh();
+            });
+        },
+        async answer(askId, choice, values) {
+            const ask = state.items.find((item) => item.kind === "ask" && item.id === askId);
+            if (!ask || ask.kind !== "ask" || ask.answer.state !== "open" || !threadId)
+                return;
+            if (ask.approval === "computer") {
+                throw new Error("This question is answered on your computer.");
+            }
+            const itemId = answerIds.get(askId) ?? mint("item");
+            answerIds.set(askId, itemId);
+            const target = threadId;
+            const toSign = {
+                threadId: target,
+                askId: ask.id,
+                choice,
+                ...(values ? { values } : {}),
+            };
+            await whenSetUp(() => reporting(async () => {
+                const found = deps.auth?.device ? await deviceOf() : undefined;
+                if (ask.approval === "presence" && !found) {
+                    throw new NeedsDevice("This question needs a device that can confirm it is you.");
+                }
+                const signed = await found?.signAnswer(toSign, {
+                    presence: ask.approval === "presence",
+                });
+                await calls.call("answer", {
+                    threadId: target,
+                    turnId: ask.turnId,
+                    itemId,
+                    answer: {
+                        askId: ask.id,
+                        choice,
+                        ...(values ? { values } : {}),
+                        ...(signed ? { signed } : {}),
+                    },
+                });
+                answerIds.delete(askId);
+                await refresh();
+            }));
+        },
+        async setUpDevice({ passkey }) {
+            if (setup === undefined || setup.step === "passkey")
+                return;
+            setup = { step: "passkey" };
+            emit();
+            try {
+                device = (await deps.auth?.device?.({ presence: passkey })) ?? device;
+            }
+            catch (error) {
+                if (error instanceof Error && error.name === "PresenceSetupCancelled") {
+                    setup = { step: "cancelled" };
+                    emit();
+                    return;
+                }
+                setup = undefined;
+                afterSetup = undefined;
+                failure = readable(error);
+                emit();
+                return;
+            }
+            const waiting = afterSetup;
+            setup = undefined;
+            afterSetup = undefined;
+            emit();
+            await waiting?.();
+        },
+        dismissSetup() {
+            setup = undefined;
+            afterSetup = undefined;
+            emit();
+        },
+        async startLink(options) {
+            if (!deps.auth?.startLink || linkBusy)
+                return;
+            linkBusy = true;
+            linkError = undefined;
+            emit();
+            try {
+                const started = await deps.auth.startLink(options);
+                linking = {
+                    deviceId: started.deviceId,
+                    code: started.code,
+                    qr: `${deps.appOrigin}/link#${new URLSearchParams({ d: started.deviceId, c: started.commitment })}`,
+                    expiresAt: started.expiresAt,
+                };
+                linkExpired = false;
+                clearTimeout(linkTimer);
+                linkTimer = setTimeout(() => {
+                    linking = undefined;
+                    linkExpired = true;
+                    emit();
+                }, Math.min(Math.max(0, Date.parse(started.expiresAt) - Date.now()), LONGEST_TIMEOUT_MS));
+                linkInfo = {
+                    vouched: false,
+                    pairing: false,
+                    ...linkInfo,
+                    deviceId: started.deviceId,
+                };
+            }
+            catch (error) {
+                linkError =
+                    error instanceof Error && error.name === "PresenceSetupCancelled"
+                        ? "Face ID or Touch ID was cancelled. Try again, or link without it."
+                        : readable(error);
+            }
+            finally {
+                linkBusy = false;
+                emit();
+            }
+        },
+        explainSetup() {
+            explainers += 1;
+            return () => {
+                explainers -= 1;
+                if (explainers === 0 && setup !== undefined)
+                    runtime.dismissSetup();
+            };
+        },
+        choose(agentKey) {
+            chosen = agentKey;
+            emit();
+        },
+        openThread(target) {
+            switchTo(target === undefined ? undefined : asId("thread", target), false);
+        },
+        newThread() {
+            switchTo(undefined, true);
+        },
+        start() {
+            running = true;
+            const detachChannel = deps.addChannel({
+                event: CHAT_CHANNEL,
+                opened: () => {
+                    channelOpen = true;
+                    if (loaded === "yes" && turns.some(isActive) && !refreshing)
+                        void refresh();
+                },
+                receive(data) {
+                    const frame = parseChatFrame(data);
+                    if (!frame)
+                        return;
+                    if (loaded === "no") {
+                        beforeLoad.push(frame);
+                        return;
+                    }
+                    if (loaded !== "yes" || frame.threadId !== threadId)
+                        return;
+                    open = applyFrame(open, frame);
+                    emit();
+                },
+                closed: () => {
+                    channelOpen = false;
+                },
+            });
+            const offTags = deps.onSyncTags((tags) => {
+                const mine = tags.some((tag) => tagsOverlap(tag, threadId === undefined ? [CHAT_TAG] : [CHAT_TAG, threadId]));
+                const computers = tags.some((tag) => tagsOverlap(tag, [HOSTS_TAG]) || tagsOverlap(tag, [HOST_GRANTS_TAG]));
+                if (tags.some((tag) => tagsOverlap(tag, [DEVICES_TAG])))
+                    void refreshLink();
+                if (loaded === "failed" && (mine || computers)) {
+                    cancelRetry();
+                    void loadFirst().then(emit);
+                }
+                else if (loaded === "no") {
+                    if (mine || computers)
+                        staleAfterLoad = true;
+                }
+                else {
+                    if (mine && threadId !== undefined)
+                        void refresh();
+                    else if (mine)
+                        void rereadStale("lists");
+                    if (computers)
+                        void rereadStale("hosts");
+                }
+            });
+            const offResume = deps.onResume(() => {
+                if (loaded === "failed") {
+                    if (!unfixable) {
+                        cancelRetry();
+                        void loadFirst().then(emit);
+                    }
+                }
+                else if (loaded === "no")
+                    staleAfterLoad = true;
+                else
+                    void refresh();
+            });
+            const offNegotiated = deps.onNegotiated((transport) => {
+                if (transport === "poll")
+                    announceActivity();
+            });
+            const offConfirmations = agentUi.confirmations.subscribe(emit);
+            emit();
+            announceActivity();
+            void initial();
+            return () => {
+                running = false;
+                channelOpen = false;
+                generation += 1;
+                clearRetry();
+                clearTimeout(presenceTimer);
+                presenceTimer = undefined;
+                clearTimeout(linkTimer);
+                linkTimer = undefined;
+                detachChannel();
+                offTags();
+                offResume();
+                offNegotiated();
+                offConfirmations();
+                stopWatching?.();
+                stopWatching = undefined;
+                watched = undefined;
+            };
+        },
+    };
+    async function mend() {
+        if (loaded === "failed")
+            await loadFirst();
+        else if (loaded === "yes") {
+            if (dirty)
+                await refresh();
+            for (const kind of [...staleReads])
+                await rereadStale(kind);
+        }
+        emit();
+    }
+    function announceActivity() {
+        if (!running || pingRefused || deps.transport() !== "poll")
+            return;
+        if (deps.isHidden?.() === true)
+            return;
+        const now = Date.now();
+        if (lastPing !== undefined && now - lastPing < ACTIVITY_PING_MS)
+            return;
+        lastPing = now;
+        calls.call("userActive", {}).catch((error) => {
+            if (error instanceof ActionError && error.code === "not_found")
+                pingRefused = true;
+        });
+    }
+    async function loadFirst() {
+        try {
+            await load(threadId);
+            unfixable = false;
+        }
+        catch (error) {
+            if (running) {
+                loaded = "failed";
+                unfixable = !retryable(error);
+                if (!unfixable)
+                    scheduleRetry();
+            }
+            return;
+        }
+        if (staleAfterLoad) {
+            staleAfterLoad = false;
+            await refresh();
+        }
+    }
+    async function initial() {
+        void deps.localHost.then((handle) => {
+            const authorizeHost = deps.auth?.authorizeHost;
+            if (!handle.available || !authorizeHost || !running)
+                return;
+            connect = {
+                kind: "here",
+                start: async () => {
+                    const own = await deps.auth?.device?.();
+                    const outcome = await handle.api.connect({
+                        appOrigin: deps.appOrigin,
+                        authorize: authorizeHost,
+                        ...(own ? { device: own.keys } : {}),
+                    });
+                    if (!outcome.connected)
+                        throw new Error(`Connecting failed: ${outcome.reason}`);
+                    await refreshHosts();
+                    await refreshLink();
+                },
+            };
+            emit();
+        });
+        void refreshLink();
+        await loadFirst();
+        announceActivity();
+        emit();
+    }
+    return runtime;
+}
+//# sourceMappingURL=runtime.js.map