@hanzo/rooms 0.1.0

package/dist/pane.js

@@ -0,0 +1,231 @@
+'use client';
+// What the column beside a conversation is holding, PER CONVERSATION.
+//
+// The store lives outside React for the reason `open.ts` gives: the router
+// mounts the rooms, so anything kept inside one is destroyed by a route change.
+// This differs from `open.ts` in the one way that matters — IT PERSISTS. A
+// selection is WHERE YOU ARE and a fresh document is rightly a fresh room; a
+// pane is WHAT YOU HAD OPEN, and losing four tabs to a reload is the reader
+// losing work rather than losing their place.
+//
+// ONE ENTRY PER CONVERSATION, not one blob holding them all. A blob is read in
+// full at boot and rewritten in full on every change, so ten conversations make
+// nine channels' tabs the cost of moving one tab in the tenth. Keyed
+// separately, both costs are proportional to the conversation you are actually
+// in, and a corrupt entry loses one pane rather than all of them.
+//
+// WHAT IS KEPT AND WHAT IS NOT. Tabs, the chosen tab and the pin survive a
+// reload because they are addresses and flags. Files picked off the reader's
+// own disk DO NOT: a file handle is an object URL, which the browser revokes
+// with the document that minted it, so a persisted row would come back as a
+// name pointing at nothing. A row that looks like a file and opens nothing is
+// worse than no row, so they are held for the session and no longer.
+import { useSyncExternalStore } from 'react';
+/** A pane nobody has touched. Shared, and never mutated — see `EMPTY` in
+ *  `open.ts` for why a fresh object per read is an infinite render. */
+const BARE = { tabs: [], at: null, pinned: true, held: [] };
+const where = (key) => `hanzo.pane.${key}`;
+/**
+ * The conversation a pane belongs to.
+ *
+ * THREE FIELDS AND NOT ONE, because `open.ts` already refuses to conflate them:
+ * an inbox room arrives over a transport and is keyed by it, a thread is a
+ * conversation the org has recorded, and an agent is who you are talking to
+ * before a thread exists. Prefixed so a room called `x` and a thread called `x`
+ * cannot land on one entry.
+ *
+ * `new` is a real answer and not a fallback: a room nobody has spoken in yet is
+ * somewhere a reader can open tabs, and they should still be there when the
+ * first turn mints a thread. It is the ONE key that several conversations pass
+ * through, which is the honest cost of not having an id to key on yet.
+ */
+export function channel(open) {
+    if (open.room)
+        return `room:${open.room}`;
+    if (open.thread)
+        return `thread:${open.thread}`;
+    if (open.agent)
+        return `agent:${open.agent}`;
+    return 'new';
+}
+// The panes this document has actually touched. A switch back reads from here
+// rather than re-parsing JSON, so moving between two conversations costs one
+// read each and nothing after that.
+const live = new Map();
+const listeners = new Set();
+function announce() {
+    for (const l of listeners)
+        l();
+}
+function subscribe(l) {
+    listeners.add(l);
+    return () => {
+        listeners.delete(l);
+    };
+}
+/**
+ * The pane for a conversation, reading it in the first time it is asked for.
+ *
+ * A BAD ENTRY IS DROPPED, NOT THROWN. Storage holds whatever an older build
+ * wrote, and one unparseable pane must not take the room down with it — the
+ * reader loses some tabs, which is what they would have had anyway.
+ */
+function read(key) {
+    const found = live.get(key);
+    if (found)
+        return found;
+    let pane = BARE;
+    try {
+        const raw = typeof window === 'undefined' ? null : window.localStorage.getItem(where(key));
+        if (raw) {
+            const kept = JSON.parse(raw);
+            const tabs = Array.isArray(kept.tabs)
+                ? kept.tabs.filter((t) => !!t && typeof t.id === 'string' && typeof t.url === 'string' && typeof t.title === 'string')
+                : [];
+            pane = {
+                tabs,
+                // A chosen tab that is no longer open is not a choice. Restoring one
+                // leaves the strip with nothing marked and the panel drawing a tab that
+                // is not in it.
+                at: tabs.some((t) => t.id === kept.at) ? kept.at : (tabs[0]?.id ?? null),
+                pinned: kept.pinned !== false,
+                held: [],
+            };
+        }
+    }
+    catch {
+        pane = BARE;
+    }
+    live.set(key, pane);
+    return pane;
+}
+/** The server renders no storage, so every pane starts bare there. Returning
+ *  the shared object keeps the snapshot stable across reads. */
+const onServer = () => BARE;
+function write(key, next) {
+    live.set(key, next);
+    try {
+        if (typeof window === 'undefined')
+            return;
+        const kept = { tabs: next.tabs, at: next.at, pinned: next.pinned };
+        window.localStorage.setItem(where(key), JSON.stringify(kept));
+    }
+    catch {
+        // A browser refusing to store — private mode, a full quota — is not a
+        // reason to refuse the change on screen. The pane stands for this document.
+    }
+    announce();
+}
+/** Applies a change to one conversation's pane. */
+function edit(key, change) {
+    write(key, change(read(key)));
+}
+/** The host and path of an address, which is as much as a title can honestly be. */
+export function name(url) {
+    try {
+        const u = new URL(url);
+        return u.host + (u.pathname === '/' ? '' : u.pathname);
+    }
+    catch {
+        return url;
+    }
+}
+/**
+ * An address as typed, made into one that can be opened.
+ *
+ * A bare host is `https`, because that is the web now; a loopback name is
+ * `http`, because nothing is listening on 443 of a laptop and offering a
+ * reader a URL that cannot connect is worse than guessing.
+ */
+export function address(typed) {
+    const t = typed.trim();
+    if (!t)
+        return '';
+    if (/^[a-z][a-z0-9+.-]*:/i.test(t))
+        return t;
+    return /^(localhost|127\.0\.0\.1|\[::1\])(:|\/|$)/i.test(t) ? `http://${t}` : `https://${t}`;
+}
+let minted = 0;
+const mint = (prefix) => `${prefix}${Date.now().toString(36)}${(minted++).toString(36)}`;
+/**
+ * Opens an address in this conversation, and chooses it.
+ *
+ * `called` is for the things that HAVE a name of their own — an answer's
+ * `index.html`, a file off the reader's disk — because their address is a blob
+ * and `name()` can read nothing useful out of one. Without it the host and path
+ * are the honest title.
+ */
+export function openTab(key, url, called) {
+    const at = address(url);
+    if (!at)
+        return;
+    edit(key, (was) => {
+        const leaf = { id: mint('t'), url: at, title: called || name(at) };
+        return { ...was, tabs: [...was.tabs, leaf], at: leaf.id };
+    });
+}
+/** Points an already-open tab somewhere else. */
+export function goTab(key, id, url) {
+    const at = address(url);
+    if (!at)
+        return;
+    edit(key, (was) => ({
+        ...was,
+        tabs: was.tabs.map((t) => (t.id === id ? { ...t, url: at, title: name(at) } : t)),
+    }));
+}
+/** Chooses an open tab. */
+export function pickTab(key, id) {
+    edit(key, (was) => (was.at === id ? was : { ...was, at: id }));
+}
+/**
+ * Shuts a tab.
+ *
+ * THE NEIGHBOUR IS THE ONE TO ITS RIGHT, falling back to its left — what every
+ * browser does, and the only choice that does not send the reader somewhere
+ * they were not looking. Closing the last tab leaves none chosen rather than
+ * refusing, because a pane with no tabs is a state this panel draws.
+ */
+export function shutTab(key, id) {
+    edit(key, (was) => {
+        const gone = was.tabs.findIndex((t) => t.id === id);
+        if (gone < 0)
+            return was;
+        const tabs = was.tabs.filter((t) => t.id !== id);
+        if (was.at !== id)
+            return { ...was, tabs };
+        return { ...was, tabs, at: (tabs[gone] ?? tabs[gone - 1])?.id ?? null };
+    });
+}
+/** Shows or hides the summary column beside this conversation's browser. */
+export function pin(key, on) {
+    edit(key, (was) => (was.pinned === on ? was : { ...was, pinned: on }));
+}
+/** Takes files from the reader's disk into this conversation. */
+export function hold(key, files) {
+    if (!files.length)
+        return;
+    const taken = files.map((f) => ({
+        id: mint('h'),
+        name: f.name,
+        size: f.size,
+        type: f.type,
+        href: URL.createObjectURL(f),
+    }));
+    edit(key, (was) => ({ ...was, held: [...was.held, ...taken] }));
+}
+/** Lets go of a file, and of the handle the browser minted for it. */
+export function drop(key, id) {
+    edit(key, (was) => {
+        const going = was.held.find((h) => h.id === id);
+        if (!going)
+            return was;
+        URL.revokeObjectURL(going.href);
+        return { ...was, held: was.held.filter((h) => h.id !== id) };
+    });
+}
+/** This conversation's pane, and it alone — a change to another redraws nothing
+ *  here, because the snapshot returned is that key's own object. */
+export function usePane(key) {
+    return useSyncExternalStore(subscribe, () => read(key), onServer);
+}

package/dist/progress.d.ts

@@ -0,0 +1,46 @@
+import type { ReactNode } from 'react';
+import type { Session, SessionDetail } from '@hanzo/ai';
+/**
+ * What a run says about how far it has got.
+ *
+ * `pct` is ABSENT when unknown — never 0 — and `estimated` says whether the
+ * number was derived rather than reported by the run itself, which is a fact a
+ * reader is owed before they plan around it.
+ */
+export interface Progress {
+    /** 0–100. Absent means unknown. */
+    pct?: number;
+    /** The stage it is in — the coarse answer. */
+    phase?: string;
+    /** What it is doing inside that stage — the fine one. */
+    activity?: string;
+    /** When the run last said so, RFC3339. */
+    at?: string;
+    /** The percentage was derived, not self-reported. */
+    estimated?: boolean;
+}
+/**
+ * Read it off a session, whatever the SDK's type currently declares.
+ *
+ * The narrowing lives HERE and nowhere else — one cast at the boundary, in the
+ * one file that knows the shape — so the day `@hanzo/ai` declares the field,
+ * this function loses its cast and nothing else in the app changes.
+ *
+ * Every field is checked rather than trusted: this is a network response, and
+ * `pct` in particular is refused unless it is a finite number in range. A NaN
+ * reaching a width would render as a bar of no width, which is a zero again.
+ */
+export declare function progressOf(run: Session | SessionDetail | null | undefined): Progress | null;
+/**
+ * The bar.
+ *
+ * `role="progressbar"` with NO `aria-valuenow` is the standard way to say
+ * indeterminate, and `aria-busy` says the work is still going. Setting
+ * `aria-valuenow={0}` for an unknown percentage is the same lie in the
+ * accessibility tree that an empty fill would be on screen.
+ */
+export declare function Bar({ run, label, }: {
+    run: Session | SessionDetail | null | undefined;
+    /** Draw the phase and the percentage under the track. */
+    label?: boolean;
+}): ReactNode;

package/dist/progress.js

@@ -0,0 +1,51 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Text, XStack, YStack } from '@hanzo/ui';
+/**
+ * Read it off a session, whatever the SDK's type currently declares.
+ *
+ * The narrowing lives HERE and nowhere else — one cast at the boundary, in the
+ * one file that knows the shape — so the day `@hanzo/ai` declares the field,
+ * this function loses its cast and nothing else in the app changes.
+ *
+ * Every field is checked rather than trusted: this is a network response, and
+ * `pct` in particular is refused unless it is a finite number in range. A NaN
+ * reaching a width would render as a bar of no width, which is a zero again.
+ */
+export function progressOf(run) {
+    const held = run?.progress;
+    if (!held || typeof held !== 'object')
+        return null;
+    const { pct, phase, activity, at, estimated } = held;
+    const out = {};
+    if (typeof pct === 'number' && Number.isFinite(pct) && pct >= 0 && pct <= 100)
+        out.pct = pct;
+    if (typeof phase === 'string' && phase)
+        out.phase = phase;
+    if (typeof activity === 'string' && activity)
+        out.activity = activity;
+    if (typeof at === 'string' && at)
+        out.at = at;
+    if (estimated === true)
+        out.estimated = true;
+    // A progress object saying nothing is nothing.
+    return out.pct === undefined && !out.phase && !out.activity ? null : out;
+}
+/** The words under the bar: the stage, then what it is doing in it. */
+const words = (p) => [p.phase, p.activity].filter(Boolean).join(' — ');
+/**
+ * The bar.
+ *
+ * `role="progressbar"` with NO `aria-valuenow` is the standard way to say
+ * indeterminate, and `aria-busy` says the work is still going. Setting
+ * `aria-valuenow={0}` for an unknown percentage is the same lie in the
+ * accessibility tree that an empty fill would be on screen.
+ */
+export function Bar({ run, label = true, }) {
+    const p = progressOf(run);
+    if (!p)
+        return null;
+    const said = words(p);
+    const known = p.pct !== undefined;
+    return (_jsxs(YStack, { gap: "$1", width: "100%", role: "progressbar", "aria-busy": !known, "aria-valuemin": 0, "aria-valuemax": 100, "aria-valuenow": p.pct, "aria-label": said || 'Progress', children: [_jsx(XStack, { height: 4, width: "100%", rounded: "$10", bg: "$edge", overflow: "hidden", children: known ? (_jsx(YStack, { height: 4, width: `${p.pct}%`, rounded: "$10", bg: "$ink" })) : null }), label && (said || known) ? (_jsxs(XStack, { gap: "$2", items: "baseline", minW: 0, children: [said ? (_jsx(Text, { fontSize: "$1", color: "$soft", numberOfLines: 1, shrink: 1, children: said })) : null, known ? (_jsxs(Text, { fontSize: "$1", color: "$soft", children: [p.estimated ? '~' : '', Math.round(p.pct), "%"] })) : null] })) : null] }));
+}

package/dist/recent.d.ts

@@ -0,0 +1,67 @@
+export type Mode = 'chat' | 'dev';
+export interface Recent {
+    kind: Mode;
+    id: string;
+    title: string;
+    /** When it was last spoken in, as an ISO time. */
+    at: string;
+    /** When it began, as an ISO time. */
+    began: string;
+    status?: string;
+    project?: string;
+}
+export type Status = 'all' | 'running' | 'paused' | 'done' | 'error' | 'stopped';
+export type Since = 'any' | 'day' | 'week' | 'month';
+export type Group = 'date' | 'state' | 'project' | 'starred' | 'none';
+export type Sort = 'activity' | 'created' | 'title';
+/** How the list is narrowed, grouped and sorted. */
+export interface View {
+    status: Status;
+    since: Since;
+    group: Group;
+    sort: Sort;
+}
+export declare const PLAIN: View;
+export type Option<T> = {
+    id: T;
+    label: string;
+};
+export declare const SINCE: Option<Since>[];
+/** What each mode's menu offers, section by section, as Claude's Recents menu does. */
+export declare const MENUS: Record<Mode, {
+    status: Option<Status>[];
+    group: Option<Group>[];
+    sort: Option<Sort>[];
+}>;
+/** A kept view as this mode may hold it: anything a menu does not offer reads as the plain view's. */
+export declare function viewOf(mode: Mode, kept: unknown): View;
+/** Chat's conversations as rows. */
+export declare function chats(threads: {
+    id: string;
+    title?: string;
+    updatedAt?: string;
+}[]): Recent[];
+/** Dev's runs as rows. */
+export declare function runs(sessions: {
+    id: string;
+    title: string;
+    status: string;
+    project?: string;
+    repo?: string;
+    createdAt: string;
+    updatedAt: string;
+}[]): Recent[];
+/**
+ * The list as drawn: the rows the view and the words admit, sorted, and cut into
+ * headed groups in the order they read. A view grouped by None is one group with
+ * no heading.
+ */
+export declare function arrange(rows: Recent[], view: View, words: string, starred: Set<string>, now?: Date): {
+    title: string;
+    rows: Recent[];
+}[];
+/**
+ * How long ago a row was last active, as a list reads it at a glance: `now`,
+ * `12m`, `3h`, `2d`, `5w`, `4mo`, `2y`. '' for an instant that is not one.
+ */
+export declare function ago(at: string, now?: Date): string;

package/dist/recent.js

@@ -0,0 +1,161 @@
+// The Recents list as data: each mode's rows, the views a menu offers, and the
+// list a view makes of them. No React, so a spec reads it as it is.
+export const PLAIN = { status: 'all', since: 'any', group: 'date', sort: 'activity' };
+const STATUSES = [
+    { id: 'all', label: 'All' },
+    { id: 'running', label: 'Running' },
+    { id: 'paused', label: 'Paused' },
+    { id: 'done', label: 'Done' },
+    { id: 'error', label: 'Failed' },
+    { id: 'stopped', label: 'Stopped' },
+];
+export const SINCE = [
+    { id: 'any', label: 'Any time' },
+    { id: 'day', label: 'Today' },
+    { id: 'week', label: 'Past 7 days' },
+    { id: 'month', label: 'Past 30 days' },
+];
+/** What each mode's menu offers, section by section, as Claude's Recents menu does. */
+export const MENUS = {
+    chat: {
+        status: [],
+        group: [
+            { id: 'date', label: 'Date' },
+            { id: 'starred', label: 'Starred' },
+            { id: 'none', label: 'None' },
+        ],
+        sort: [
+            { id: 'activity', label: 'Activity' },
+            { id: 'title', label: 'Title' },
+        ],
+    },
+    dev: {
+        status: STATUSES,
+        group: [
+            { id: 'date', label: 'Date' },
+            { id: 'state', label: 'State' },
+            { id: 'project', label: 'Project' },
+            { id: 'none', label: 'None' },
+        ],
+        sort: [
+            { id: 'activity', label: 'Activity' },
+            { id: 'created', label: 'Created' },
+            { id: 'title', label: 'Title' },
+        ],
+    },
+};
+/** A kept view as this mode may hold it: anything a menu does not offer reads as the plain view's. */
+export function viewOf(mode, kept) {
+    const k = (kept && typeof kept === 'object' ? kept : {});
+    const m = MENUS[mode];
+    const pick = (v, from, fallback) => from.find((o) => o.id === v)?.id ?? fallback;
+    return {
+        status: pick(k.status, m.status, PLAIN.status),
+        since: pick(k.since, SINCE, PLAIN.since),
+        group: pick(k.group, m.group, PLAIN.group),
+        sort: pick(k.sort, m.sort, PLAIN.sort),
+    };
+}
+/** Chat's conversations as rows. */
+export function chats(threads) {
+    return threads.map((t) => ({ kind: 'chat', id: t.id, title: t.title || 'Untitled', at: t.updatedAt ?? '', began: t.updatedAt ?? '' }));
+}
+/** Dev's runs as rows. */
+export function runs(sessions) {
+    return sessions.map((r) => ({
+        kind: 'dev',
+        id: r.id,
+        title: r.title || 'Untitled run',
+        at: r.updatedAt || r.createdAt,
+        began: r.createdAt,
+        status: r.status,
+        project: r.project || r.repo?.split('/').pop() || '',
+    }));
+}
+const DAY = 86_400_000;
+const SPAN = { any: Infinity, day: DAY, week: 7 * DAY, month: 30 * DAY };
+const STATE = { running: 'Running', paused: 'Paused', done: 'Done', error: 'Failed', stopped: 'Stopped' };
+/** The date headings, in the order they read. */
+const DAYS = ['Today', 'Yesterday', 'Past 7 days', 'Past 30 days', 'Older'];
+/** Which date heading an instant falls under, counted in the reader's own days. */
+function day(at, now) {
+    const t = new Date(at);
+    if (Number.isNaN(t.getTime()))
+        return 'Older';
+    const midnight = new Date(now.getFullYear(), now.getMonth(), now.getDate()).getTime();
+    if (t.getTime() >= midnight)
+        return 'Today';
+    if (t.getTime() >= midnight - DAY)
+        return 'Yesterday';
+    if (t.getTime() >= midnight - 7 * DAY)
+        return 'Past 7 days';
+    if (t.getTime() >= midnight - 30 * DAY)
+        return 'Past 30 days';
+    return 'Older';
+}
+const newest = (a, b) => (a < b ? 1 : a > b ? -1 : 0);
+/**
+ * The list as drawn: the rows the view and the words admit, sorted, and cut into
+ * headed groups in the order they read. A view grouped by None is one group with
+ * no heading.
+ */
+export function arrange(rows, view, words, starred, now = new Date()) {
+    const w = words.trim().toLowerCase();
+    const kept = rows.filter((r) => (!w || r.title.toLowerCase().includes(w)) &&
+        (view.status === 'all' || r.status === view.status) &&
+        (view.since === 'any' || now.getTime() - new Date(r.at).getTime() <= SPAN[view.since]));
+    kept.sort((a, b) => view.sort === 'title' ? a.title.localeCompare(b.title) : view.sort === 'created' ? newest(a.began, b.began) : newest(a.at, b.at));
+    const headOf = (r) => {
+        switch (view.group) {
+            case 'date':
+                return day(view.sort === 'created' ? r.began : r.at, now);
+            case 'state':
+                return STATE[r.status ?? ''] ?? 'Other';
+            case 'project':
+                return r.project || 'No project';
+            case 'starred':
+                return starred.has(r.id) ? 'Starred' : 'Others';
+            default:
+                return '';
+        }
+    };
+    const groups = [];
+    for (const r of kept) {
+        const title = headOf(r);
+        const g = groups.find((one) => one.title === title);
+        if (g)
+            g.rows.push(r);
+        else
+            groups.push({ title, rows: [r] });
+    }
+    if (view.group === 'starred')
+        groups.sort((a, b) => (a.title === 'Starred' ? -1 : b.title === 'Starred' ? 1 : 0));
+    if (view.group === 'date')
+        groups.sort((a, b) => DAYS.indexOf(a.title) - DAYS.indexOf(b.title));
+    return groups;
+}
+/**
+ * How long ago a row was last active, as a list reads it at a glance: `now`,
+ * `12m`, `3h`, `2d`, `5w`, `4mo`, `2y`. '' for an instant that is not one.
+ */
+export function ago(at, now = new Date()) {
+    const t = new Date(at).getTime();
+    if (Number.isNaN(t))
+        return '';
+    const m = Math.max(0, Math.floor((now.getTime() - t) / 60_000));
+    if (m < 1)
+        return 'now';
+    if (m < 60)
+        return `${m}m`;
+    const h = Math.floor(m / 60);
+    if (h < 24)
+        return `${h}h`;
+    const d = Math.floor(h / 24);
+    if (d < 7)
+        return `${d}d`;
+    if (d < 30)
+        return `${Math.floor(d / 7)}w`;
+    if (d < 365)
+        return `${Math.floor(d / 30)}mo`;
+    return `${Math.floor(d / 365)}y`;
+}

package/dist/rooms.d.ts

@@ -0,0 +1,131 @@
+/**
+ * A room as Team keeps it: a channel, a direct message, or a room bound to work.
+ *
+ * `direct` is the distinction the sidebar draws — a channel anyone in the org
+ * can read against a conversation between two people — so it decides the sigil
+ * and the section rather than a guess from the name.
+ *
+ * `space` is half of a room's address: two spaces of one org may each hold a
+ * room called #general, so the pair identifies one and the id alone does not.
+ * It is also the box a file goes in — `/v1/team/files/{space}` is addressed by
+ * space, never by room. The field is the server's own name for it
+ * (apps/team/room.go, teamRoom.Space).
+ */
+export interface TeamRoom {
+    id: string;
+    space: string;
+    name: string;
+    topic?: string;
+    desc?: string;
+    direct: boolean;
+    private: boolean;
+    visibility?: 'public' | 'org' | 'private';
+    orgId?: string;
+    archived: boolean;
+    members: string[];
+    count?: number;
+    /**
+     * What the room is FOR — "standing" for one meant to outlive any task,
+     * "bound" for one opened for a single piece of work. Absent reads standing.
+     * It is intent, not state: whether the room is open now is `archived`.
+     */
+    life?: string;
+    /**
+     * What the room is ABOUT, each a "<kind>:<ref>" — "repo:hanzoai/cloud",
+     * "issue:1010". References, never copies: the app that owns a project is the
+     * one that can resolve it.
+     */
+    bindings?: string[];
+}
+/**
+ * The key the workspace selects a room by, and puts in the address:
+ * `team:<space>/<id>`. Both halves, because a room id is unique within a space
+ * and not across the org. Prefixed rather than hashed, because a key a person
+ * can read in a URL is one they can report in a bug.
+ */
+export declare const teamKey: (room: Pick<TeamRoom, 'space' | 'id'>) => string;
+/** The address a key names, or null for a key that is not a room's. */
+export declare function roomKey(key: string | null): {
+    space: string;
+    id: string;
+} | null;
+/** The page a key opens on: Home, carrying it as the `?room=` that
+ *  `app/(app)/home/_workspace.tsx` reads on arrival. */
+export declare const roomHref: (key: string) => string;
+/** Asks the platform again. The list held stays on screen until it answers. */
+export declare function reloadRooms(): void;
+/**
+ * The org's real rooms, from Team, and the way to add one.
+ *
+ * `/v1/team/rooms` is the org's own list and answers only a validated
+ * principal. An archived room is not drawn: it is a room the org closed, and a
+ * sidebar that lists them makes leaving one meaningless.
+ *
+ * NULL IS UNKNOWN AND IT IS NOT EMPTY. Three states, and the caller owes a
+ * sentence for each: `null` while nothing is known, `[]` for an org that
+ * genuinely has no rooms, and `wrong` for a service that answered no. A list is
+ * never fabricated to cover any of them.
+ *
+ * `open` posts a room and HOLDS the row the platform answered with: a 201 is
+ * the stored room, so every view carries it from that moment and the reader can
+ * step into it without a second read. The caller is not added to a room by the
+ * server, so it names its own members.
+ */
+export declare function useTeamRooms(): {
+    rooms: TeamRoom[] | null;
+    wrong: unknown;
+    reload: () => void;
+    open: (room: {
+        name: string;
+        space?: string;
+        members: string[];
+    }) => Promise<TeamRoom>;
+};
+/** The room with that id, or undefined for none open. */
+export declare function roomOf(rooms: TeamRoom[] | null, id: string | null): TeamRoom | undefined;
+/**
+ * One thing somebody said in a room.
+ *
+ * `author` is the team ACCOUNT that wrote it, not a name: what to call somebody
+ * is the roster's answer (`roster.ts`), and copying it onto every message is
+ * how the two come to disagree. `text` is plain — the platform stores the
+ * client's markup and reduces it on the way out, so nothing here parses HTML.
+ */
+export interface RoomMessage {
+    id: string;
+    room: string;
+    author: string;
+    text: string;
+    /** Unix MILLIseconds, which is what the platform stamps. */
+    createdOn: number;
+}
+/**
+ * A room's conversation, and the way to add to it.
+ *
+ * READ AND WRITE IN ONE HOOK, because they are one question — a pane that can
+ * show a room and not answer in it is a directory — and because the poller and
+ * the sender then cannot disagree about what the room holds.
+ *
+ * THE ROOM IS POLLED, every two seconds while it is open and the tab is
+ * showing. The team plane has no push a browser can read but its transactor
+ * socket, which is a binary protocol rather than a line; a read costs a few
+ * hundred milliseconds and nothing on the server past the space's own
+ * messages, so half a request a second per open room is the honest price of
+ * seeing an answer land. Each read carries its own AbortController, and the
+ * cleanup aborts the one in flight and stops the clock — on unmount, and when
+ * the room or its space changes.
+ *
+ * `send` posts and answers the row the platform stored: a 201 is the message,
+ * with its id and stamp, so the hook holds it at once and the next poll finds
+ * the same id and keeps one. Nothing the platform did not accept is ever held.
+ *
+ * `space` is half a room's address (two spaces of one org may each hold a room
+ * with one id), so both calls carry it and a room with neither reads empty
+ * rather than guessing.
+ */
+export declare function useRoomMessages(room: string | null, space: string | undefined): {
+    messages: RoomMessage[];
+    failed: unknown;
+    send: (text: string) => Promise<RoomMessage>;
+    reload: () => void;
+};