@vibefield/rosetta-room 0.0.0-stage → 0.1.1

package/dist/lib/motion.js

@@ -0,0 +1,80 @@
+/** Shared timing for small, interruptible movements in the reading surfaces. */
+export const SETTLE_EASING = "cubic-bezier(0.22, 1, 0.36, 1)";
+export const REDUCED_MOTION_QUERY = "(prefers-reduced-motion: reduce)";
+export function prefersReducedMotion() {
+    return window.matchMedia(REDUCED_MOTION_QUERY).matches;
+}
+/** FLIP in scroll-content coordinates, so ordinary scrolling never looks like
+ * a reorder. Only rows crossing the viewport acquire animation layers. */
+export class ListMotion {
+    positions = new Map();
+    animations = new Map();
+    initialized = false;
+    update(container, reduced) {
+        // Read the current visual displacement before cancelling an interrupted
+        // transition. A second sort continues from the frame the reader sees.
+        const offsets = new Map();
+        for (const [key, { element }] of this.animations) {
+            const style = getComputedStyle(element);
+            offsets.set(key, {
+                y: style.transform === "none" ? 0 : new DOMMatrixReadOnly(style.transform).m42,
+                opacity: Number(style.opacity),
+            });
+        }
+        this.cancel();
+        const edge = container.getBoundingClientRect().top;
+        const top = container.scrollTop;
+        const bottom = top + container.clientHeight;
+        // Batch every layout read before starting any animations.
+        const rows = Array.from(container.querySelectorAll("[data-motion-key]"), (element) => {
+            const rect = element.getBoundingClientRect();
+            return {
+                element,
+                key: element.dataset.motionKey,
+                position: { top: rect.top - edge + top, height: rect.height },
+            };
+        });
+        for (const { element, key, position } of rows) {
+            const previous = this.positions.get(key);
+            const oldTop = previous === undefined ? position.top : previous.top + (offsets.get(key)?.y ?? 0);
+            const visibleAt = (y) => y + position.height >= top && y <= bottom;
+            const crossesViewport = visibleAt(oldTop) || visibleAt(position.top);
+            if (!this.initialized || reduced || !crossesViewport || position.height === 0)
+                continue;
+            // A row coming from thousands of entries away enters at the viewport
+            // edge instead of racing across an entire archive in a single frame.
+            const travel = container.clientHeight + position.height;
+            const delta = Math.max(-travel, Math.min(travel, oldTop - position.top));
+            const opacity = offsets.get(key)?.opacity ?? 1;
+            const frames = previous === undefined
+                ? [
+                    { opacity: 0, transform: "translateY(6px)" },
+                    { opacity: 1, transform: "none" },
+                ]
+                : Math.abs(delta) > 0.5 || opacity < 1
+                    ? [
+                        { transform: `translateY(${delta}px)`, opacity },
+                        { transform: "none", opacity: 1 },
+                    ]
+                    : null;
+            if (frames === null)
+                continue;
+            const animation = element.animate(frames, {
+                duration: previous === undefined ? 220 : 340,
+                easing: SETTLE_EASING,
+            });
+            this.animations.set(key, { element, animation });
+            animation.onfinish = () => {
+                if (this.animations.get(key)?.animation === animation)
+                    this.animations.delete(key);
+            };
+        }
+        this.positions = new Map(rows.map(({ key, position }) => [key, position]));
+        this.initialized = true;
+    }
+    cancel() {
+        for (const { animation } of this.animations.values())
+            animation.cancel();
+        this.animations.clear();
+    }
+}

package/dist/lib/room-storage.d.ts

@@ -0,0 +1,13 @@
+/** The two calls the room makes of a store; `localStorage` is one. */
+export interface KeyValueStore {
+    getItem(key: string): string | null;
+    setItem(key: string, value: string): void;
+}
+/** A host's store as the room uses it: every name under one prefix. */
+export interface RoomStorage extends KeyValueStore {
+    readonly prefix: string;
+}
+export declare const DEFAULT_STORAGE_PREFIX = "ah.";
+/** The browser's localStorage, or null where it cannot be reached. */
+export declare function browserStorage(): KeyValueStore | null;
+export declare function createRoomStorage(prefix: string, backend: KeyValueStore | null): RoomStorage;

package/dist/lib/room-storage.js

@@ -0,0 +1,40 @@
+// The room's few remembered preferences — recent searches, dealt project
+// tints, the site-icon setting, the fold — kept in the host's store under the
+// host's prefix. Nothing the room writes lands outside that prefix, and a
+// store that refuses (a private window, a blocked origin) costs the memory,
+// never the room.
+export const DEFAULT_STORAGE_PREFIX = "ah.";
+/** The browser's localStorage, or null where it cannot be reached. */
+export function browserStorage() {
+    try {
+        return window.localStorage;
+    }
+    catch {
+        return null;
+    }
+}
+export function createRoomStorage(prefix, backend) {
+    return {
+        prefix,
+        getItem(key) {
+            if (backend === null)
+                return null;
+            try {
+                return backend.getItem(`${prefix}${key}`);
+            }
+            catch {
+                return null;
+            }
+        },
+        setItem(key, value) {
+            if (backend === null)
+                return;
+            try {
+                backend.setItem(`${prefix}${key}`, value);
+            }
+            catch {
+                // refused: the preference holds for this run
+            }
+        },
+    };
+}

package/dist/lib/search-results.d.ts

@@ -0,0 +1,27 @@
+import type { SearchHit, SessionRow } from "@vibefield/rosetta-protocol";
+import type { ProjectViewModel } from "./model.js";
+export interface SessionSearchResult {
+    readonly session: SessionRow;
+    readonly hits: readonly SearchHit[];
+}
+export interface ProjectSearchResultGroup {
+    readonly project: ProjectViewModel;
+    readonly sessions: readonly SessionSearchResult[];
+    readonly hitCount: number;
+}
+export interface SearchResultCounts {
+    readonly matches: number;
+    readonly sessions: number;
+    readonly projects: number;
+}
+export interface SearchResultsViewModel {
+    readonly groups: readonly ProjectSearchResultGroup[];
+    readonly hitCountByProject: ReadonlyMap<string, number>;
+    readonly counts: SearchResultCounts;
+}
+/**
+ * Groups protocol search hits once for every UI consumer. A child-session hit
+ * belongs to its root thread in navigation; the hit keeps its own session id
+ * so opening it can expand and land inside the embedded subthread.
+ */
+export declare function createSearchResultsViewModel(hits: readonly SearchHit[], sessions: readonly SessionRow[], projectsById: ReadonlyMap<string, ProjectViewModel>): SearchResultsViewModel;

package/dist/lib/search-results.js

@@ -0,0 +1,83 @@
+import { projectKey } from "./model.js";
+import { compareSessionActivity } from "./session-activity.js";
+function compareSessionResults(left, right) {
+    return (right.hits.length - left.hits.length ||
+        compareSessionActivity(left.session, right.session));
+}
+function compareProjectGroups(left, right) {
+    return (right.hitCount - left.hitCount ||
+        left.project.row.name.localeCompare(right.project.row.name) ||
+        left.project.row.id.localeCompare(right.project.row.id));
+}
+/** Resolve navigation from the authoritative parent chain. `root_session_id`
+ * remains a useful fallback for an orphaned retained child, but an immediate
+ * parent must never masquerade as a top-level thread for a nested hit. */
+function navigationRoot(session, sessions) {
+    let current = session;
+    const visited = new Set();
+    while (current.parent_session_id !== null && !visited.has(current.id)) {
+        visited.add(current.id);
+        const parent = sessions.get(current.parent_session_id);
+        if (!parent)
+            return sessions.get(session.root_session_id) ?? null;
+        current = parent;
+    }
+    return current.parent_session_id === null ? current : null;
+}
+/**
+ * Groups protocol search hits once for every UI consumer. A child-session hit
+ * belongs to its root thread in navigation; the hit keeps its own session id
+ * so opening it can expand and land inside the embedded subthread.
+ */
+export function createSearchResultsViewModel(hits, sessions, projectsById) {
+    const sessionById = new Map(sessions.map((session) => [session.id, session]));
+    const hitsBySessionId = new Map();
+    for (const hit of hits) {
+        const hitSession = sessionById.get(hit.session_id);
+        if (!hitSession)
+            continue;
+        const rootSession = navigationRoot(hitSession, sessionById);
+        if (!rootSession)
+            continue;
+        const sessionHits = hitsBySessionId.get(rootSession.id);
+        if (sessionHits)
+            sessionHits.push(hit);
+        else
+            hitsBySessionId.set(rootSession.id, [hit]);
+    }
+    const sessionsByProjectId = new Map();
+    for (const [sessionId, sessionHits] of hitsBySessionId) {
+        const session = sessionById.get(sessionId);
+        if (!session)
+            continue;
+        const projectId = projectKey(session);
+        if (!projectsById.has(projectId))
+            continue;
+        const projectSessions = sessionsByProjectId.get(projectId);
+        const result = { session, hits: sessionHits };
+        if (projectSessions)
+            projectSessions.push(result);
+        else
+            sessionsByProjectId.set(projectId, [result]);
+    }
+    const groups = [];
+    for (const [projectId, projectSessions] of sessionsByProjectId) {
+        const project = projectsById.get(projectId);
+        if (!project)
+            continue;
+        const sortedSessions = projectSessions.sort(compareSessionResults);
+        groups.push({
+            project,
+            sessions: sortedSessions,
+            hitCount: sortedSessions.reduce((total, result) => total + result.hits.length, 0),
+        });
+    }
+    groups.sort(compareProjectGroups);
+    const hitCountByProject = new Map(groups.map((group) => [group.project.row.id, group.hitCount]));
+    const counts = {
+        matches: groups.reduce((total, group) => total + group.hitCount, 0),
+        sessions: groups.reduce((total, group) => total + group.sessions.length, 0),
+        projects: groups.length,
+    };
+    return { groups, hitCountByProject, counts };
+}

package/dist/lib/search-sheet.d.ts

@@ -0,0 +1,119 @@
+import type { SearchHit, SearchReadiness, SessionRow } from "@vibefield/rosetta-protocol";
+import type { ProjectViewModel } from "./model.js";
+import type { SearchResultCounts, SearchResultsViewModel, SessionSearchResult } from "./search-results.js";
+/** The canonical wire kinds the sheet lets the reader narrow to. `any` sends
+ * no `kind`; the two named ones are exactly what search indexes (prompts and
+ * replies, decided 2026-09-09) — the vocabulary a reader thinks in: what I
+ * asked, what it said. */
+export type SearchKindFilter = "any" | "user" | "agent";
+export type SearchScopeFilter = "everywhere" | "project";
+export interface SearchFilters {
+    readonly scope: SearchScopeFilter;
+    readonly kind: SearchKindFilter;
+    /** A runtime family (`claude-code`, `codex`, …), or null for every agent. */
+    readonly agent: string | null;
+}
+export declare const DEFAULT_SEARCH_FILTERS: SearchFilters;
+export declare const KIND_FILTER_OPTIONS: readonly {
+    value: SearchKindFilter;
+    label: string;
+}[];
+export interface SheetHead {
+    readonly type: "head";
+    readonly key: string;
+    readonly project: ProjectViewModel;
+    readonly session: SessionRow;
+    readonly hitCount: number;
+}
+export interface SheetOption {
+    readonly type: "option";
+    readonly key: string;
+    /** The DOM id `aria-activedescendant` points at. */
+    readonly id: string;
+    /** The option's position among options only — heads are not walkable. */
+    readonly index: number;
+    readonly project: ProjectViewModel;
+    /** The navigable root session (a child hit lands inside its parent). */
+    readonly session: SessionRow;
+    readonly hit: SearchHit;
+}
+export type SheetLine = SheetHead | SheetOption;
+export interface SheetLines {
+    readonly lines: readonly SheetLine[];
+    readonly options: readonly SheetOption[];
+}
+export declare function optionDomId(hit: SearchHit): string;
+/** One session's hits in reading order: by time when the source reported one,
+ * then by id, so the stepper walks the transcript downward. */
+export declare function hitsInReadingOrder(hits: readonly SearchHit[]): SearchHit[];
+/**
+ * Flattens the grouped result model into the lines the sheet draws: one
+ * sticky head per session, its hits beneath in reading order. Project is
+ * folded into the head's breadcrumb rather than being a level of its own —
+ * three levels of nesting in a 640px sheet is a tree, and a tree is not
+ * something you scan.
+ */
+export declare function buildSheetLines(model: SearchResultsViewModel | null): SheetLines;
+/** Find the session result that owns a hit, for the stepper. */
+export declare function sessionResultOf(model: SearchResultsViewModel, rootSessionId: string): SessionSearchResult | null;
+export type CursorKey = "ArrowDown" | "ArrowUp" | "Home" | "End" | "PageDown" | "PageUp";
+export declare function isCursorKey(key: string): key is CursorKey;
+/** APG listbox arithmetic: no wrap, clamped at both ends, a page of eight. */
+export declare function moveCursor(active: number, key: CursorKey, count: number, page?: number): number;
+/** Jump to the first option of the next session (or of the previous one):
+ * VS Code's sticky separators and Raycast's sections both give the keyboard a
+ * way past a long group without holding an arrow. Clamps at the ends. */
+export declare function moveSection(active: number, direction: 1 | -1, options: readonly SheetOption[]): number;
+/**
+ * The snippet as the sheet prints it: whitespace collapsed to one line of
+ * prose, and every home-rooted path shortened to `~/…` — the ledger row's own
+ * rule, so a path reads the same in a result as it does in the transcript.
+ * The `[` `]` match markers survive untouched for `parseSnippet`.
+ */
+export declare function cleanSnippet(snippet: string, home: string | null): string;
+/** Who said it, in the room's own words. */
+export declare function kindWord(kind: string, agentLabel: string): string;
+/** When the matched message was written: the clock alone inside today, the
+ * day and clock inside the year, the day and year beyond it; a dash when the
+ * source never said. Every part is tabular by the stylesheet. */
+export declare function hitWhen(at: number | null, nowMs: number): string;
+/** A session's name for a breadcrumb: its title, its summary, or — for a
+ * session nobody named — the first eight characters of its native id, which
+ * the caller sets in mono. `mono` says which happened. */
+export declare function sessionCrumb(session: SessionRow): {
+    text: string;
+    mono: boolean;
+};
+/** `43 matches · 12 sessions · 4 projects` — the numbers, never the word
+ * "results", which hides its own reach (design record §06). */
+export declare function countSentence(counts: SearchResultCounts): string;
+export interface SheetStateInput {
+    readonly query: string;
+    readonly error: string | null;
+    readonly readiness: SearchReadiness | null;
+    readonly progress: {
+        documents_done: number;
+        documents_total: number;
+    } | null;
+    readonly canonicalReady: boolean | null;
+    readonly ingestPaused: boolean;
+    readonly counts: SearchResultCounts | null;
+    readonly limit: number;
+}
+/**
+ * The one sentence in the sheet's foot. Degraded is Tuesday here (design
+ * record §09): a building index says so with a number, an error says what
+ * happened, and a full page says it is the first page.
+ */
+export declare function stateSentence(input: SheetStateInput): string;
+/** Under the room's storage prefix. */
+export declare const RECENT_QUERIES_KEY = "search.recent";
+export declare const RECENT_QUERIES_CAP = 8;
+export interface RecentStore {
+    getItem(key: string): string | null;
+    setItem(key: string, value: string): void;
+}
+export declare function readRecentQueries(store: RecentStore | null): string[];
+/** Most recent first, exact duplicates folded, capped. */
+export declare function rememberQuery(store: RecentStore | null, query: string): string[];
+export declare function forgetQuery(store: RecentStore | null, query: string): string[];

package/dist/lib/search-sheet.js

@@ -0,0 +1,282 @@
+export const DEFAULT_SEARCH_FILTERS = {
+    scope: "everywhere",
+    kind: "any",
+    agent: null,
+};
+export const KIND_FILTER_OPTIONS = [
+    { value: "any", label: "prompts and replies" },
+    { value: "user", label: "prompts" },
+    { value: "agent", label: "replies" },
+];
+export function optionDomId(hit) {
+    return `ah-sheet-opt-${hit.session_id}-${hit.timeline_id}`;
+}
+/** One session's hits in reading order: by time when the source reported one,
+ * then by id, so the stepper walks the transcript downward. */
+export function hitsInReadingOrder(hits) {
+    return [...hits].sort((a, b) => (a.at ?? Number.MAX_SAFE_INTEGER) - (b.at ?? Number.MAX_SAFE_INTEGER) ||
+        a.timeline_id.localeCompare(b.timeline_id));
+}
+/**
+ * Flattens the grouped result model into the lines the sheet draws: one
+ * sticky head per session, its hits beneath in reading order. Project is
+ * folded into the head's breadcrumb rather than being a level of its own —
+ * three levels of nesting in a 640px sheet is a tree, and a tree is not
+ * something you scan.
+ */
+export function buildSheetLines(model) {
+    if (model === null)
+        return { lines: [], options: [] };
+    const lines = [];
+    const options = [];
+    for (const group of model.groups) {
+        for (const result of group.sessions) {
+            lines.push({
+                type: "head",
+                key: `head:${result.session.id}`,
+                project: group.project,
+                session: result.session,
+                hitCount: result.hits.length,
+            });
+            for (const hit of hitsInReadingOrder(result.hits)) {
+                const option = {
+                    type: "option",
+                    key: `opt:${hit.session_id}:${hit.timeline_id}`,
+                    id: optionDomId(hit),
+                    index: options.length,
+                    project: group.project,
+                    session: result.session,
+                    hit,
+                };
+                options.push(option);
+                lines.push(option);
+            }
+        }
+    }
+    return { lines, options };
+}
+/** Find the session result that owns a hit, for the stepper. */
+export function sessionResultOf(model, rootSessionId) {
+    for (const group of model.groups) {
+        for (const result of group.sessions) {
+            if (result.session.id === rootSessionId)
+                return result;
+        }
+    }
+    return null;
+}
+export function isCursorKey(key) {
+    return (key === "ArrowDown" ||
+        key === "ArrowUp" ||
+        key === "Home" ||
+        key === "End" ||
+        key === "PageDown" ||
+        key === "PageUp");
+}
+/** APG listbox arithmetic: no wrap, clamped at both ends, a page of eight. */
+export function moveCursor(active, key, count, page = 8) {
+    if (count <= 0)
+        return -1;
+    const last = count - 1;
+    const from = active < 0 ? -1 : Math.min(active, last);
+    switch (key) {
+        case "ArrowDown":
+            return Math.min(last, from + 1);
+        case "ArrowUp":
+            return Math.max(0, from - 1);
+        case "Home":
+            return 0;
+        case "End":
+            return last;
+        case "PageDown":
+            return Math.min(last, Math.max(0, from) + page);
+        case "PageUp":
+            return Math.max(0, from - page);
+    }
+}
+/** Jump to the first option of the next session (or of the previous one):
+ * VS Code's sticky separators and Raycast's sections both give the keyboard a
+ * way past a long group without holding an arrow. Clamps at the ends. */
+export function moveSection(active, direction, options) {
+    if (options.length === 0)
+        return -1;
+    const from = active < 0 ? 0 : Math.min(active, options.length - 1);
+    // Every index read here stays inside options: from is clamped to it, the
+    // walk down stops above 0, and the walk up below options.length.
+    const sessionAt = (index) => options[index].session.id;
+    const current = sessionAt(from);
+    if (direction === 1) {
+        for (let i = from + 1; i < options.length; i += 1) {
+            if (sessionAt(i) !== current)
+                return i;
+        }
+        return options.length - 1;
+    }
+    // Up: the head of this session if we are not already on it, else the
+    // head of the session before.
+    let head = from;
+    while (head > 0 && sessionAt(head - 1) === current)
+        head -= 1;
+    if (head !== from)
+        return head;
+    if (head === 0)
+        return 0;
+    const previous = sessionAt(head - 1);
+    let start = head - 1;
+    while (start > 0 && sessionAt(start - 1) === previous)
+        start -= 1;
+    return start;
+}
+/* ── the words on a row ────────────────────────────────────────────────── */
+/**
+ * The snippet as the sheet prints it: whitespace collapsed to one line of
+ * prose, and every home-rooted path shortened to `~/…` — the ledger row's own
+ * rule, so a path reads the same in a result as it does in the transcript.
+ * The `[` `]` match markers survive untouched for `parseSnippet`.
+ */
+export function cleanSnippet(snippet, home) {
+    let text = snippet.replace(/\s+/g, " ").trim();
+    if (home !== null && home !== "" && home !== "/") {
+        const escaped = home.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+        text = text.replace(new RegExp(`(^|[^\\w~])${escaped}(?=/|\\b)`, "g"), "$1~");
+    }
+    return text;
+}
+/** Who said it, in the room's own words. */
+export function kindWord(kind, agentLabel) {
+    switch (kind) {
+        case "user":
+            return "you";
+        case "agent":
+            return agentLabel;
+        case "tool_use":
+            return "activity";
+        case "thinking":
+            return "thinking";
+        case "summary":
+            return "summary";
+        case "notice":
+            return "notice";
+        case "collaboration":
+            return "team";
+        default:
+            return kind;
+    }
+}
+const DAY_MS = 86_400_000;
+function startOfDay(ms) {
+    const d = new Date(ms);
+    d.setHours(0, 0, 0, 0);
+    return d.getTime();
+}
+/** When the matched message was written: the clock alone inside today, the
+ * day and clock inside the year, the day and year beyond it; a dash when the
+ * source never said. Every part is tabular by the stylesheet. */
+export function hitWhen(at, nowMs) {
+    if (at === null)
+        return "—";
+    const d = new Date(at);
+    const p = (v) => String(v).padStart(2, "0");
+    const clock = `${p(d.getHours())}:${p(d.getMinutes())}`;
+    const today = startOfDay(nowMs);
+    if (at >= today && at < today + DAY_MS)
+        return clock;
+    const day = d.toLocaleDateString("en-GB", { day: "numeric", month: "short" });
+    if (d.getFullYear() === new Date(nowMs).getFullYear())
+        return `${day} · ${clock}`;
+    return `${day} ${d.getFullYear()}`;
+}
+/** A session's name for a breadcrumb: its title, its summary, or — for a
+ * session nobody named — the first eight characters of its native id, which
+ * the caller sets in mono. `mono` says which happened. */
+export function sessionCrumb(session) {
+    if (session.title !== null)
+        return { text: session.title, mono: false };
+    if (session.summary !== null)
+        return { text: session.summary, mono: false };
+    return { text: session.native_session_id.slice(0, 8), mono: true };
+}
+function plural(n, one, many = `${one}s`) {
+    return `${n.toLocaleString("en-US")} ${n === 1 ? one : many}`;
+}
+/** `43 matches · 12 sessions · 4 projects` — the numbers, never the word
+ * "results", which hides its own reach (design record §06). */
+export function countSentence(counts) {
+    return [
+        plural(counts.matches, "match", "matches"),
+        plural(counts.sessions, "session"),
+        plural(counts.projects, "project"),
+    ].join(" · ");
+}
+/**
+ * The one sentence in the sheet's foot. Degraded is Tuesday here (design
+ * record §09): a building index says so with a number, an error says what
+ * happened, and a full page says it is the first page.
+ */
+export function stateSentence(input) {
+    if (input.error !== null)
+        return `search failed · ${input.error}`;
+    if (input.ingestPaused)
+        return "transcript import paused · search covers what was read";
+    if (input.readiness !== null && input.readiness !== "ready") {
+        if (input.readiness === "failed") {
+            return input.canonicalReady ? "search unavailable" : "history is being imported";
+        }
+        if (input.progress !== null && input.progress.documents_total > 0) {
+            const pct = Math.floor((100 * input.progress.documents_done) / input.progress.documents_total);
+            return `indexing · ${pct}% · ${input.progress.documents_done.toLocaleString("en-US")} of ${input.progress.documents_total.toLocaleString("en-US")} messages · results are partial`;
+        }
+        if (input.readiness === "building") {
+            return input.canonicalReady ? "search is being prepared" : "history is being imported";
+        }
+        return `search is ${input.readiness.replace("-", " ")} · results may be partial`;
+    }
+    if (input.counts === null || input.query === "")
+        return "";
+    const sentence = countSentence(input.counts);
+    return input.counts.matches >= input.limit
+        ? `first ${input.limit} matches · narrow the search to see the rest`
+        : sentence;
+}
+/* ── what was searched before ──────────────────────────────────────────── */
+/** Under the room's storage prefix. */
+export const RECENT_QUERIES_KEY = "search.recent";
+export const RECENT_QUERIES_CAP = 8;
+export function readRecentQueries(store) {
+    if (store === null)
+        return [];
+    try {
+        const raw = store.getItem(RECENT_QUERIES_KEY);
+        if (raw === null)
+            return [];
+        const parsed = JSON.parse(raw);
+        if (!Array.isArray(parsed))
+            return [];
+        return parsed.filter((q) => typeof q === "string" && q.trim() !== "");
+    }
+    catch {
+        return [];
+    }
+}
+function writeRecent(store, queries) {
+    if (store !== null) {
+        try {
+            store.setItem(RECENT_QUERIES_KEY, JSON.stringify(queries));
+        }
+        catch {
+            // A browser that refuses storage refuses the memory, not the search.
+        }
+    }
+    return queries;
+}
+/** Most recent first, exact duplicates folded, capped. */
+export function rememberQuery(store, query) {
+    const q = query.trim();
+    if (q === "")
+        return readRecentQueries(store);
+    const rest = readRecentQueries(store).filter((r) => r !== q);
+    return writeRecent(store, [q, ...rest].slice(0, RECENT_QUERIES_CAP));
+}
+export function forgetQuery(store, query) {
+    return writeRecent(store, readRecentQueries(store).filter((r) => r !== query));
+}

package/dist/lib/sections.d.ts

@@ -0,0 +1,19 @@
+import type { RoomSection } from "../host-inputs.js";
+export interface ArrangedSection<T> {
+    readonly section: RoomSection;
+    /** Its place among the sections given, which the list's motion keys on. */
+    readonly index: number;
+    /** Its rows, in the order they are drawn. */
+    readonly rows: readonly T[];
+    /** Whose order they keep: `room` draws a session list's day heads. */
+    readonly order: "host" | "room";
+}
+/**
+ * The rows each section draws. A row two sections name is drawn in the
+ * first; a row no section names goes to the first section without `ids`, or
+ * nowhere when every section names its own — so a host filter hides rows by
+ * naming fewer. Ids the room does not hold are skipped.
+ */
+export declare function arrangeSections<T>(sections: readonly RoomSection[], rowsInRoomOrder: readonly T[], idOf: (row: T) => string): ArrangedSection<T>[];
+/** How many rows a folded section says it holds: the host's figure, or its rows. */
+export declare function foldCount<T>(arranged: ArrangedSection<T>): number;