@vibefield/rosetta-room 0.0.0-stage → 0.1.0

package/dist/lib/hooks.js

@@ -0,0 +1,608 @@
+// The room's data spine: one meta subscription for who/what exists, REST for
+// figures, and one session subscription for the transcript being read. Every
+// hook reads through the port it is handed; none of them dials anything.
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { CursorExpiredError } from "@vibefield/rosetta-protocol";
+import { getActivityGridStartTimestamp, getViewerUtcOffsetMinutes } from "./model.js";
+import { conversationStart, readConversationPage } from "./transcript/history-window.js";
+import { EARLIER_FAILED_MESSAGE, EARLIER_PAGE_SIZE, earlierAboveOf, earlierState, initialEarlierModel, reduceEarlier, } from "./transcript/head-state.js";
+export function useMeta(catalog) {
+    const [feed, setFeed] = useState({
+        meta: null, snapshotVersion: 0,
+    });
+    const [status, setStatus] = useState("connecting");
+    const [error, setError] = useState(null);
+    useEffect(() => {
+        const sub = catalog.subscribeMeta({
+            onChange: (meta, source) => {
+                setFeed((previous) => ({
+                    meta,
+                    snapshotVersion: previous.snapshotVersion + (source === "snapshot" ? 1 : 0),
+                }));
+                setError(null);
+            },
+            onStatus: setStatus,
+            onError: setError,
+        });
+        return () => sub.close();
+    }, [catalog]);
+    return { ...feed, status, error };
+}
+/** The daemon's status surface. It answers from the daemon's first breath —
+ * before the projection is even readable — so it is the room's connectivity
+ * truth during a cold start. Polls fast through canonical publication and
+ * search preparation, then quietly once both are ready. */
+export function useDaemonStatus(catalog) {
+    const [connectionRevision, setConnectionRevision] = useState(0);
+    useEffect(() => catalog.onConnectionChange?.(() => setConnectionRevision((value) => value + 1)), [catalog]);
+    const [feed, setFeed] = useState({
+        connectionError: null,
+        canonicalReady: null,
+        searchReadiness: null,
+        ingest: null,
+        searchProgress: null,
+        startedAt: null,
+        uptimeMs: 0,
+        receivedAt: null,
+    });
+    useEffect(() => {
+        let cancelled = false;
+        let controller;
+        let timer;
+        let deadline;
+        const poll = async () => {
+            const request = new AbortController();
+            controller = request;
+            let delay = 1_000;
+            deadline = window.setTimeout(() => request.abort(), 5_000);
+            try {
+                const status = await catalog.status(request.signal);
+                if (cancelled)
+                    return;
+                setFeed({
+                    connectionError: null,
+                    canonicalReady: status.canonicalReady,
+                    searchReadiness: status.searchReadiness,
+                    ingest: status.ingest,
+                    searchProgress: status.searchProgress,
+                    startedAt: status.startedAt,
+                    uptimeMs: status.uptimeMs,
+                    receivedAt: Date.now(),
+                });
+                const phase = status.ingest?.phase;
+                // Keep search visible after canonical publication. Audit/consent are
+                // intentional pauses; an unanswered first request retries promptly.
+                const paused = phase === "metadata_ready" || phase === "awaiting_consent";
+                const complete = status.canonicalReady && status.searchReadiness === "ready";
+                delay = complete ? 30_000 : paused ? 2_500 : 500;
+            }
+            catch (error) {
+                if (!cancelled)
+                    setFeed((previous) => ({
+                        ...previous,
+                        connectionError: catalog.unavailable?.() ??
+                            (request.signal.aborted ? "Progress updates timed out. Reconnecting…" :
+                                error instanceof Error ? error.message : "Unable to reach the background service."),
+                    }));
+            }
+            finally {
+                window.clearTimeout(deadline);
+                if (!cancelled)
+                    timer = window.setTimeout(poll, delay);
+            }
+        };
+        void poll();
+        return () => {
+            cancelled = true;
+            controller?.abort();
+            window.clearTimeout(deadline);
+            window.clearTimeout(timer);
+        };
+    }, [catalog, connectionRevision]);
+    return feed;
+}
+/** Per-project heatmaps and contributions. These are global derived reads,
+ * so they begin only after the daemon's canonical publication gate. Four
+ * workers hydrate the list progressively; unbounded Promise.all here once
+ * launched two full-corpus queries per project and starved cold ingestion. */
+export function useProjectStats(catalog, projectIds, ready = false) {
+    const [stats, setStats] = useState(new Map());
+    const key = projectIds.join("\n");
+    useEffect(() => {
+        let cancelled = false;
+        const controller = new AbortController();
+        let timer;
+        const ids = key === "" ? [] : key.split("\n");
+        if (!ready || ids.length === 0) {
+            setStats(new Map());
+            return () => {
+                cancelled = true;
+                controller.abort();
+            };
+        }
+        async function loadAll() {
+            const sinceMs = getActivityGridStartTimestamp(Date.now());
+            const offsetMinutes = getViewerUtcOffsetMinutes();
+            // A host that answers every project at once is asked once.
+            if (catalog.projectStatsBatch !== undefined) {
+                let missing = true;
+                try {
+                    const answer = await catalog.projectStatsBatch(ids, { sinceMs, offsetMinutes }, controller.signal);
+                    missing = ids.some((id) => !answer.has(id));
+                    if (!cancelled) {
+                        setStats((current) => {
+                            const next = new Map(current);
+                            for (const id of ids) {
+                                const figures = answer.get(id);
+                                if (figures !== undefined)
+                                    next.set(id, figures);
+                            }
+                            return next;
+                        });
+                    }
+                }
+                catch {
+                    // as below: unfigured projects degrade honestly and earn a retry
+                }
+                if (cancelled)
+                    return;
+                timer = window.setTimeout(loadAll, missing ? 8_000 : 5 * 60_000);
+                return;
+            }
+            const queue = [...ids];
+            let failed = false;
+            async function worker() {
+                while (!cancelled) {
+                    const id = queue.shift();
+                    if (id === undefined)
+                        return;
+                    try {
+                        const figures = await catalog.projectStats(id, { sinceMs, offsetMinutes }, controller.signal);
+                        if (!cancelled) {
+                            setStats((current) => {
+                                const next = new Map(current);
+                                next.set(id, figures);
+                                return next;
+                            });
+                        }
+                    }
+                    catch {
+                        // an unfigured project degrades honestly — and earns a retry
+                        failed = true;
+                    }
+                }
+            }
+            await Promise.all(Array.from({ length: Math.min(4, ids.length) }, () => worker()));
+            if (cancelled)
+                return;
+            // A failed figure (a daemon mid-restart, a dropped socket) retries in
+            // seconds. Stable canonical figures need only a quiet periodic refresh.
+            timer = window.setTimeout(loadAll, failed ? 8_000 : 5 * 60_000);
+        }
+        loadAll();
+        return () => {
+            cancelled = true;
+            controller.abort();
+            window.clearTimeout(timer);
+        };
+    }, [catalog, key, ready]);
+    return stats;
+}
+/** The selected project's usage decomposition — per-model days and the
+ * hour-of-day profile, over the same 53-week window the heatmap draws. */
+export function useProjectUsage(catalog, projectId, ready = false) {
+    const [usage, setUsage] = useState(null);
+    useEffect(() => {
+        setUsage(null);
+        if (projectId === null || !ready)
+            return;
+        let cancelled = false;
+        const controller = new AbortController();
+        const load = () => {
+            catalog
+                .usage(projectId, {
+                sinceMs: getActivityGridStartTimestamp(Date.now()),
+                offsetMinutes: getViewerUtcOffsetMinutes(),
+            }, controller.signal)
+                .then((res) => {
+                if (!cancelled)
+                    setUsage(res);
+            })
+                .catch(() => {
+                // the summary panel degrades to what the heatmap alone can say
+            });
+        };
+        load();
+        const timer = setInterval(load, 60_000);
+        return () => {
+            cancelled = true;
+            controller.abort();
+            clearInterval(timer);
+        };
+    }, [catalog, projectId, ready]);
+    return usage;
+}
+export function useTimeline(sessions, sessionId) {
+    const [owner, setOwner] = useState(sessionId);
+    const [attempt, setAttempt] = useState(0);
+    const [error, setError] = useState(null);
+    const [tail, setTail] = useState([]);
+    const [windowStart, setWindowStart] = useState(null);
+    const [anchors, setAnchors] = useState(new Set());
+    const subscription = useRef(null);
+    const [timelineMeta, setTimelineMeta] = useState(null);
+    const [status, setStatus] = useState("connecting");
+    const [snapshotReady, setSnapshotReady] = useState(false);
+    const [watermark, setWatermark] = useState(null);
+    const sawSnapshot = useRef(false);
+    // The head of the document is a state machine, not a boolean: it holds a
+    // page beside the document until the reader pulls (§08, Q7 B). The ref is
+    // the authority so a listener firing between commits reduces against the
+    // current model; the state mirrors it for rendering.
+    const modelRef = useRef(initialEarlierModel());
+    const [model, setModel] = useState(modelRef.current);
+    const ctx = useMemo(() => ({
+        tailIds: new Set(tail.map((row) => row.timeline_id)),
+        pageSize: EARLIER_PAGE_SIZE,
+    }), [tail]);
+    // A pure mirror, so holdEarlier() called from a scroll frame reduces against
+    // the tail the reader can actually see.
+    const ctxRef = useRef(ctx);
+    ctxRef.current = ctx;
+    const apply = useCallback((action) => {
+        const previous = modelRef.current;
+        const next = reduceEarlier(previous, action, ctxRef.current);
+        if (next === previous)
+            return;
+        modelRef.current = next;
+        setModel(next);
+        // The head owns reveal intent and counts. Canonical values live only in
+        // the subscription, which patches held pages and visible history together.
+        if (next.older !== previous.older && next.older.length > 0) {
+            const sub = subscription.current;
+            const combined = [...new Map([...next.older, ...(sub?.entries() ?? [])]
+                    .map(row => [row.timeline_id, row])).values()].sort((a, b) => a.ordinal - b.ordinal);
+            const start = conversationStart(combined, next.cursor !== null);
+            // Live arrivals must never move the start forward and hide a visible run.
+            setWindowStart(previous => previous === null ? start : Math.min(previous, start ?? previous));
+            sub?.reveal(next.older);
+        }
+    }, []);
+    useEffect(() => {
+        setOwner(sessionId);
+        setError(null);
+        setTail([]);
+        setWindowStart(null);
+        setAnchors(new Set());
+        setTimelineMeta(null);
+        setWatermark(null);
+        setStatus("connecting");
+        setSnapshotReady(false);
+        sawSnapshot.current = false;
+        // A held page belongs to the session it was fetched for.
+        apply({ type: "reset" });
+        if (sessionId === null)
+            return;
+        let active = true;
+        let sub = null;
+        const lease = sessions.acquire(sessionId);
+        const start = (client) => {
+            sub = client.subscribeSession(sessionId, {
+                onReset: () => {
+                    if (!active)
+                        return;
+                    setTail([]);
+                    setWindowStart(null);
+                    setAnchors(new Set());
+                    setTimelineMeta(null);
+                    setSnapshotReady(false);
+                    setWatermark(null);
+                    setError(null);
+                    sawSnapshot.current = false;
+                    apply({ type: "reset" });
+                },
+                onSnapshot: (page) => {
+                    if (!active)
+                        return;
+                    setWindowStart(conversationStart(page.entries, page.cursor !== null));
+                    apply({ type: "snapshot", cursor: page.cursor });
+                },
+                onChange: (entries) => {
+                    if (!active)
+                        return;
+                    setTail(entries);
+                    setSnapshotReady(true);
+                    setError(null);
+                    if (!sawSnapshot.current) {
+                        sawSnapshot.current = true;
+                        // Everything in the snapshot is the past; the line goes after it.
+                        setWatermark(entries.length ? Math.max(...entries.map((entry) => entry.ordinal)) : null);
+                    }
+                },
+                onTimelineMetaChange: (meta) => { if (active)
+                    setTimelineMeta(meta); },
+                onStatus: (status) => {
+                    if (!active)
+                        return;
+                    setStatus(status);
+                    if (status === "closed")
+                        setError(previous => previous ?? "The message connection closed.");
+                },
+                onError: (error) => {
+                    if (!active)
+                        return;
+                    if (error.code === "cursor_expired")
+                        apply({ type: "expired", seq: modelRef.current.fetchSeq });
+                    else if (error.code !== "not_ready")
+                        setError(error.message);
+                },
+            });
+            subscription.current = sub;
+        };
+        // A port that answers at once subscribes in this effect, exactly as a
+        // bare client did; one that must ask first subscribes when it answers.
+        if (lease.client !== null)
+            start(lease.client);
+        else {
+            lease.ready.then((client) => {
+                if (active)
+                    start(client);
+            }, (error) => {
+                if (!active)
+                    return;
+                setStatus("closed");
+                setError(error instanceof Error ? error.message : "This session could not be opened.");
+            });
+        }
+        return () => {
+            active = false;
+            subscription.current = null;
+            sub?.close();
+            lease.release();
+        };
+    }, [sessions, sessionId, attempt, apply]);
+    const retry = useCallback(() => setAttempt(value => value + 1), []);
+    /** One fetch of the page above, held rather than inserted. */
+    const startFetch = useCallback(() => {
+        if (sessionId === null)
+            return;
+        const before = modelRef.current.fetchSeq;
+        apply({ type: "hold" });
+        const started = modelRef.current;
+        if (started.phase !== "fetching" || started.fetchSeq === before)
+            return;
+        const seq = started.fetchSeq;
+        const from = started.cursor;
+        const sub = subscription.current;
+        if (typeof from !== "string" || sub === null)
+            return;
+        void readConversationPage(async (cursor, limit) => {
+            if (subscription.current !== sub || modelRef.current.fetchSeq !== seq)
+                throw new DOMException("The session changed", "AbortError");
+            return sub.fetchPage(cursor, limit);
+        }, from, EARLIER_PAGE_SIZE).then((page) => {
+            if (subscription.current === sub)
+                apply({ type: "page", seq, entries: page.entries, cursor: page.cursor });
+        }, (error) => {
+            if (subscription.current !== sub)
+                return;
+            if (error instanceof CursorExpiredError)
+                apply({ type: "expired", seq });
+            else
+                apply({ type: "fail", seq, message: EARLIER_FAILED_MESSAGE });
+        });
+    }, [sessionId, apply]);
+    const revealEarlier = useCallback(() => apply({ type: "reveal" }), [apply]);
+    const dismissEarlierNotice = useCallback(() => apply({ type: "clearNotice" }), [apply]);
+    const loadEarlier = useCallback(() => {
+        startFetch();
+        apply({ type: "reveal" });
+    }, [startFetch, apply]);
+    const loadAnchor = useCallback(async (timelineId) => {
+        const sub = subscription.current;
+        if (sub === null)
+            return false;
+        setAnchors(previous => new Set([...previous, timelineId]));
+        try {
+            return await sub.loadEntry(timelineId);
+        }
+        catch (error) {
+            if (error instanceof DOMException && error.name === "AbortError")
+                return false;
+            throw error;
+        }
+    }, []);
+    const rows = useMemo(() => windowStart === null ? tail : tail.filter(row => row.ordinal >= windowStart || anchors.has(row.timeline_id)), [tail, windowStart, anchors]);
+    const earlier = useMemo(() => earlierState(model, ctx), [model, ctx]);
+    // Nothing in the protocol carries a per-session entry total — SessionRow has
+    // no count and TimelinePage returns only entries and a cursor — so the head
+    // line says the word without the number (§08: "when it is not, the word
+    // stands alone"). The arithmetic waits here for the day a total lands.
+    const earlierAbove = earlierAboveOf(null, rows.length);
+    // Effects replace the subscription after commit. Never render the old
+    // session's rows, metadata or readiness under the newly selected title.
+    const current = owner === sessionId;
+    return {
+        rows: current ? rows : [],
+        snapshotReady: current && snapshotReady,
+        error: current ? error : null,
+        retry,
+        timelineMeta: current ? timelineMeta : null,
+        status: current ? status : "connecting",
+        watermark: current ? watermark : null,
+        earlier: current ? earlier : { kind: "none" },
+        earlierNotice: current ? model.notice : null,
+        earlierAbove: current ? earlierAbove : null,
+        landed: current ? model.landing : null,
+        holdEarlier: startFetch,
+        revealEarlier,
+        retryEarlier: startFetch,
+        dismissEarlierNotice,
+        canLoadEarlier: current && earlier.kind !== "none",
+        loadEarlier,
+        loadAnchor,
+    };
+}
+/** Team conversation is distributed across member transcripts, so one parent
+ * document owns a small subscription set. Unlike ordinary Agent subthreads it
+ * is eager: delivered boundary messages belong in shared chronology even when
+ * no disclosure is open. */
+export function useTeamTimelines(sessions, sessionIds) {
+    const key = [...new Set(sessionIds)].sort().join("\n");
+    const ids = useMemo(() => (key === "" ? [] : key.split("\n")), [key]);
+    const records = useRef(new Map());
+    const [revision, setRevision] = useState(0);
+    useEffect(() => {
+        const wanted = new Set(ids);
+        for (const [id, record] of records.current) {
+            if (!wanted.has(id)) {
+                records.current.delete(id);
+                record.sub?.close();
+                record.release();
+            }
+        }
+        for (const id of ids) {
+            if (records.current.has(id))
+                continue;
+            const lease = sessions.acquire(id);
+            const record = {
+                sub: null,
+                history: null,
+                error: null,
+                release: () => lease.release(),
+            };
+            records.current.set(id, record);
+            const start = (client) => {
+                if (records.current.get(id) !== record)
+                    return;
+                record.sub = client.subscribeCollaboration(id, {
+                    onReset: () => {
+                        if (records.current.get(id) !== record)
+                            return;
+                        record.history = null;
+                        setRevision((value) => value + 1);
+                    },
+                    onChange: (history) => {
+                        if (records.current.get(id) !== record)
+                            return;
+                        record.history = history;
+                        record.error = null;
+                        setRevision((value) => value + 1);
+                    },
+                    onError: error => {
+                        if (records.current.get(id) !== record)
+                            return;
+                        record.error = error.message;
+                        setRevision(value => value + 1);
+                    },
+                    onStatus: status => {
+                        if (records.current.get(id) !== record || record.history !== null)
+                            return;
+                        if (status === "closed")
+                            record.error = "Could not load team messages";
+                        setRevision(value => value + 1);
+                    },
+                });
+            };
+            if (lease.client !== null)
+                start(lease.client);
+            else {
+                lease.ready.then(start, (error) => {
+                    if (records.current.get(id) !== record)
+                        return;
+                    record.error = error instanceof Error ? error.message : "Could not load team messages";
+                    setRevision(value => value + 1);
+                });
+            }
+        }
+        setRevision((value) => value + 1);
+    }, [sessions, ids]);
+    useEffect(() => () => {
+        const previous = [...records.current.values()];
+        records.current.clear();
+        previous.forEach((record) => {
+            record.sub?.close();
+            record.release();
+        });
+    }, []);
+    const retry = useCallback(() => {
+        for (const record of records.current.values()) {
+            if (record.history !== null && record.error === null)
+                continue;
+            record.error = null;
+            record.sub?.restart();
+        }
+        setRevision(value => value + 1);
+    }, []);
+    return useMemo(() => {
+        const rowsBySession = new Map();
+        const responseRuntimesBySession = new Map();
+        let historyReady = true;
+        let historyError = null;
+        for (const id of ids) {
+            const record = records.current.get(id);
+            const history = record?.history;
+            historyError ??= record?.error ?? null;
+            if (!history) {
+                historyReady = false;
+                continue;
+            }
+            rowsBySession.set(id, history.entries);
+            responseRuntimesBySession.set(id, history.response_runtimes);
+        }
+        return { rowsBySession, responseRuntimesBySession, historyReady, historyError, retry };
+    }, [ids, revision, retry]);
+}
+export const SEARCH_LIMIT = 200;
+/**
+ * One ranked search per settled query. The previous response stays on screen
+ * while its successor is in flight — a list that blanks on every keystroke
+ * reads as a search that keeps failing — and only the newest request may
+ * land: a superseded one is aborted and its late result ignored.
+ */
+export function useSearch(catalog, query, facets = {}) {
+    const [response, setResponse] = useState(null);
+    const [error, setError] = useState(null);
+    const [searching, setSearching] = useState(false);
+    const project = facets.project ?? null;
+    const kind = facets.kind ?? null;
+    const agent = facets.agent ?? null;
+    useEffect(() => {
+        const q = query.trim();
+        if (q === "") {
+            setResponse(null);
+            setError(null);
+            setSearching(false);
+            return;
+        }
+        const controller = new AbortController();
+        let cancelled = false;
+        setSearching(true);
+        const timer = setTimeout(() => {
+            catalog
+                .search({ q, limit: SEARCH_LIMIT, project, kind, agent }, controller.signal)
+                .then((res) => {
+                if (cancelled)
+                    return;
+                setResponse(res);
+                setError(null);
+            })
+                .catch((err) => {
+                if (cancelled)
+                    return;
+                setResponse(null);
+                setError(err instanceof Error ? err.message : String(err));
+            })
+                .finally(() => {
+                if (!cancelled)
+                    setSearching(false);
+            });
+        }, 180);
+        return () => {
+            cancelled = true;
+            clearTimeout(timer);
+            controller.abort();
+        };
+    }, [catalog, query, project, kind, agent]);
+    return { query: query.trim(), response, error, searching };
+}

package/dist/lib/icons.d.ts

@@ -0,0 +1,21 @@
+export declare function SunGlyph(): import("react").JSX.Element;
+export declare function MoonGlyph(): import("react").JSX.Element;
+export declare function SearchGlyph(): import("react").JSX.Element;
+/** GitHub's monochrome mark from @lobehub/icons-static-svg v1.94.0,
+ * the same set as the bundled agent marks. */
+export declare function GitHubGlyph(): import("react").JSX.Element;
+/** Root and two branches — the worktree toggle, on mille's 16-unit grid. */
+export declare function TreeGlyph(): import("react").JSX.Element;
+/** Three ascending bars — the figures toggle. */
+export declare function StatsGlyph(): import("react").JSX.Element;
+export declare function ChevronGlyph(): import("react").JSX.Element;
+/** Copy — two sheets, the front one offset. */
+export declare function CopyGlyph(): import("react").JSX.Element;
+/** Leaving the app — an arrow out of a frame that is deliberately open on the
+ * side it leaves by. */
+export declare function ExternalGlyph(): import("react").JSX.Element;
+/** Four outward corners: let the current surface occupy the viewport. */
+export declare function FullscreenGlyph(): import("react").JSX.Element;
+/** The inverse fullscreen mark: four corners returning toward the centre. */
+export declare function ExitFullscreenGlyph(): import("react").JSX.Element;
+export declare function CloseGlyph(): import("react").JSX.Element;

package/dist/lib/icons.js

@@ -0,0 +1,49 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+// The room's own glyphs, drawn on mille's 16-unit grid at stroke 1.5 (or the
+// strip's 24-grid where the proto drew them there) — transcribed from
+// protos/agent-history-proto.
+export function SunGlyph() {
+    return (_jsxs("svg", { viewBox: "0 0 16 16", fill: "none", stroke: "currentColor", strokeWidth: "1.5", strokeLinecap: "round", "aria-hidden": "true", children: [_jsx("circle", { cx: "8", cy: "8", r: "3" }), _jsx("path", { d: "M8 1v1M8 14v1M1 8h1M14 8h1M3.05 3.05l.7.7M12.25 12.25l.7.7M3.05 12.95l.7-.7M12.25 3.75l.7-.7" })] }));
+}
+export function MoonGlyph() {
+    return (_jsx("svg", { viewBox: "0 0 16 16", fill: "none", stroke: "currentColor", strokeWidth: "1.5", strokeLinecap: "round", strokeLinejoin: "round", "aria-hidden": "true", children: _jsx("path", { d: "M13.6 9.1A5.8 5.8 0 0 1 6.9 2.4a5.8 5.8 0 1 0 6.7 6.7Z" }) }));
+}
+export function SearchGlyph() {
+    return (_jsxs("svg", { viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "1.9", strokeLinecap: "round", "aria-hidden": "true", children: [_jsx("circle", { cx: "10.8", cy: "10.8", r: "6.3" }), _jsx("path", { d: "m15.4 15.4 4.1 4.1" })] }));
+}
+/** GitHub's monochrome mark from @lobehub/icons-static-svg v1.94.0,
+ * the same set as the bundled agent marks. */
+export function GitHubGlyph() {
+    return (_jsx("svg", { viewBox: "0 0 24 24", fill: "currentColor", fillRule: "evenodd", "aria-hidden": "true", children: _jsx("path", { d: "M12 0c6.63 0 12 5.276 12 11.79-.001 5.067-3.29 9.567-8.175 11.187-.6.118-.825-.25-.825-.56 0-.398.015-1.665.015-3.242 0-1.105-.375-1.813-.81-2.181 2.67-.295 5.475-1.297 5.475-5.822 0-1.297-.465-2.344-1.23-3.169.12-.295.54-1.503-.12-3.125 0 0-1.005-.324-3.3 1.209a11.32 11.32 0 00-3-.398c-1.02 0-2.04.133-3 .398-2.295-1.518-3.3-1.209-3.3-1.209-.66 1.622-.24 2.83-.12 3.125-.765.825-1.23 1.887-1.23 3.169 0 4.51 2.79 5.527 5.46 5.822-.345.294-.66.81-.765 1.577-.69.31-2.415.81-3.495-.973-.225-.354-.9-1.223-1.845-1.209-1.005.015-.405.56.015.781.51.28 1.095 1.327 1.23 1.666.24.663 1.02 1.93 4.035 1.385 0 .988.015 1.916.015 2.196 0 .31-.225.664-.825.56C3.303 21.374-.003 16.867 0 11.791 0 5.276 5.37 0 12 0z" }) }));
+}
+/** Root and two branches — the worktree toggle, on mille's 16-unit grid. */
+export function TreeGlyph() {
+    return (_jsxs("svg", { viewBox: "0 0 16 16", fill: "none", stroke: "currentColor", strokeWidth: "1.5", strokeLinecap: "round", strokeLinejoin: "round", "aria-hidden": "true", children: [_jsx("path", { d: "M4.3 4.6v6.9" }), _jsx("path", { d: "M4.3 7.6h3.3M4.3 11.5h3.3" }), _jsx("circle", { cx: "4.3", cy: "3.2", r: "1.5", fill: "currentColor", stroke: "none" }), _jsx("circle", { cx: "9.3", cy: "7.6", r: "1.5", fill: "currentColor", stroke: "none" }), _jsx("circle", { cx: "9.3", cy: "11.5", r: "1.5", fill: "currentColor", stroke: "none" })] }));
+}
+/** Three ascending bars — the figures toggle. */
+export function StatsGlyph() {
+    return (_jsxs("svg", { viewBox: "0 0 16 16", fill: "none", stroke: "currentColor", strokeWidth: "1.5", strokeLinecap: "round", "aria-hidden": "true", children: [_jsx("path", { d: "M3.7 12.1V9.3" }), _jsx("path", { d: "M8 12.1V6.5" }), _jsx("path", { d: "M12.3 12.1V4.1" })] }));
+}
+export function ChevronGlyph() {
+    return (_jsx("svg", { viewBox: "0 0 12 12", fill: "none", "aria-hidden": "true", children: _jsx("path", { d: "M4.5 2.5 8 6 4.5 9.5", stroke: "currentColor", strokeWidth: "1.5", strokeLinecap: "round", strokeLinejoin: "round" }) }));
+}
+/** Copy — two sheets, the front one offset. */
+export function CopyGlyph() {
+    return (_jsxs("svg", { viewBox: "0 0 16 16", fill: "none", stroke: "currentColor", strokeWidth: "1.5", strokeLinecap: "round", strokeLinejoin: "round", "aria-hidden": "true", children: [_jsx("rect", { x: "5.5", y: "5.5", width: "8", height: "8", rx: "2" }), _jsx("path", { d: "M10.5 3.5v-.5a1.5 1.5 0 0 0-1.5-1.5H4A1.5 1.5 0 0 0 2.5 3v5A1.5 1.5 0 0 0 4 9.5h.5" })] }));
+}
+/** Leaving the app — an arrow out of a frame that is deliberately open on the
+ * side it leaves by. */
+export function ExternalGlyph() {
+    return (_jsxs("svg", { viewBox: "0 0 16 16", fill: "none", stroke: "currentColor", strokeWidth: "1.5", strokeLinecap: "round", strokeLinejoin: "round", "aria-hidden": "true", children: [_jsx("path", { d: "M13 9.5V13a1.5 1.5 0 0 1-1.5 1.5H3A1.5 1.5 0 0 1 1.5 13V4.5A1.5 1.5 0 0 1 3 3h3.5" }), _jsx("path", { d: "M9.5 1.5h5v5" }), _jsx("path", { d: "m14.5 1.5-6.5 6.5" })] }));
+}
+/** Four outward corners: let the current surface occupy the viewport. */
+export function FullscreenGlyph() {
+    return (_jsx("svg", { viewBox: "0 0 16 16", fill: "none", stroke: "currentColor", strokeWidth: "1.5", strokeLinecap: "round", strokeLinejoin: "round", "aria-hidden": "true", children: _jsx("path", { d: "M6 2.5H2.5V6M10 2.5h3.5V6M6 13.5H2.5V10M10 13.5h3.5V10" }) }));
+}
+/** The inverse fullscreen mark: four corners returning toward the centre. */
+export function ExitFullscreenGlyph() {
+    return (_jsx("svg", { viewBox: "0 0 16 16", fill: "none", stroke: "currentColor", strokeWidth: "1.5", strokeLinecap: "round", strokeLinejoin: "round", "aria-hidden": "true", children: _jsx("path", { d: "M2.5 6H6V2.5M13.5 6H10V2.5M2.5 10H6v3.5M13.5 10H10v3.5" }) }));
+}
+export function CloseGlyph() {
+    return (_jsx("svg", { viewBox: "0 0 16 16", fill: "none", stroke: "currentColor", strokeWidth: "1.6", strokeLinecap: "round", "aria-hidden": "true", children: _jsx("path", { d: "m4.5 4.5 7 7M11.5 4.5l-7 7" }) }));
+}