@vibefield/rosetta-room 0.0.0-stage → 0.1.0

package/dist/fixtures/index.js

@@ -0,0 +1,292 @@
+import { advanceActivityOrder } from "../lib/activity-order.js";
+import { buildProjectViewModel, getActivityGridStartTimestamp, getCalendarDayKey } from "../lib/model.js";
+import { createTintDealer } from "../lib/tint.js";
+const MINUTE = 60_000;
+const HOUR = 60 * MINUTE;
+const DAY = 24 * HOUR;
+/* ── the rows ───────────────────────────────────────────────────────────── */
+const RUNTIMES = [["claude", "claude-code"], ["codex", "codex"]];
+/** [name, lifetime cost in USD, a scale for its daily tokens]. */
+const PROJECTS = [
+    ["vibe-field", 2840, 1_700_000],
+    ["rosetta", 1120, 850_000],
+    ["puppeteer", 760, 566_000],
+    ["infinite-canvas-engine", 690, 425_000],
+    ["ghosttea", 310, 340_000],
+    ["truffle", 120, 283_000],
+];
+/** [project, title, hours ago, runtime, tokens, messages, cost in USD]. */
+const SESSIONS = [
+    [0, "One frame for four views", 0.4, "claude", 8.2e6, 184, 21.4],
+    [0, "Godview's deck as a sheet", 2.2, "claude", 21e6, 512, 58.9],
+    [0, "DS landing fix-ups", 5.5, "codex", 4.1e6, 96, 9.8],
+    [0, "Spawn bloom review", 8.1, "claude", 13e6, 330, 33.1],
+    [0, "Chrome on the mat", 25, "claude", 18e6, 421, 47.5],
+    [0, "Edge tray notch and drawer", 28, "claude", 9.6e6, 207, 24.2],
+    [0, "Mesh board reader backoff", 31, "codex", 3.3e6, 75, 7.9],
+    [0, "Session glyphs, pass two", 34, "claude", 6.1e6, 140, 15.6],
+    [1, "The room as a package", 1.5, "claude", 5.2e6, 120, 13.0],
+    [1, "Grants on the direct plane", 50, "codex", 2.8e6, 64, 6.1],
+    [2, "Views behind injected ports", 72, "claude", 4.4e6, 98, 11.2],
+];
+const PROVENANCE = { agent_version: null, src_cursor: null, src_offset: null };
+const NO_USAGE = {
+    input: null, output: null, cache_read: null, cache_write: null, thinking: null, cache_write_1h: null,
+    web_searches: null, service_tier: null, route: null, billed_pico_usd: null, scope: "request", requests: null,
+};
+/** A 64-hex digest, the same for the same seed (FNV-1a over the whole seed,
+ * eight rounds). Not a content hash: the demo's members have no bytes. */
+function digestOf(seed) {
+    let hex = "";
+    for (let round = 0; hex.length < 64; round += 1) {
+        let hash = (0x811c9dc5 ^ round) >>> 0;
+        for (let i = 0; i < seed.length; i += 1) {
+            hash ^= seed.charCodeAt(i);
+            hash = Math.imul(hash, 0x01000193) >>> 0;
+        }
+        hex += hash.toString(16).padStart(8, "0");
+    }
+    return hex.slice(0, 64);
+}
+function member(seed) {
+    const digest = digestOf(seed);
+    return { url: `/api/assets/${digest}.webp`, digest, media_type: "image/webp", byte_len: 2048 };
+}
+/** An optimized image the room will draw: a member and its four renditions. */
+function image(id, seed, name, width, height) {
+    const full = member(seed);
+    return {
+        id, kind: "image", label: `[Image #${id}]`, name, media_type: "image/webp", byte_len: full.byte_len,
+        source: { type: "asset", asset: { ...full, image_variants: {
+                    rail: member(`${seed}:rail`), tile: member(`${seed}:tile`), tile2x: member(`${seed}:tile2x`), preview: member(`${seed}:preview`),
+                } } },
+        dimensions: { width, height }, message_ranges: [],
+    };
+}
+function transcript(sessionId, startedAt) {
+    const rows = [];
+    const add = (body, kind, model = null) => {
+        const ordinal = rows.length + 1;
+        rows.push({
+            timeline_id: `${sessionId}-t${ordinal}`, session_id: sessionId, ordinal,
+            group: { id: `${sessionId}-g${ordinal}`, kind, derivation: "native" },
+            response: null, block_index: null, native_id: null, parent_native_id: null,
+            at: startedAt + ordinal * 40_000, model, effort: null, body, parent_tool_native_id: null,
+            usage: NO_USAGE, provenance: PROVENANCE,
+        });
+    };
+    return {
+        rows,
+        user: (text, attachments = []) => add({ type: "user", text: { type: "inline", text }, attachments }, "human_turn"),
+        agent: (text) => add({ type: "agent", text: { type: "inline", text }, attachments: [], citations: [] }, "agent_cycle", "claude-opus-5-5"),
+        tool: (name, action, status = "succeeded") => add({ type: "tool_use", tool: {
+                correlation: { key: `${sessionId}-k${rows.length + 1}`, derivation: "native_id" },
+                native: { id: null, namespace: null, name, provider: null },
+                status: { value: status, basis: "native_state" },
+                action, attachments: [], failure: null, timing: null,
+            } }, "agent_cycle"),
+    };
+}
+const read = (path) => ({
+    type: "file_read", targets: [{ resource: { type: "file", path, resolved: true }, range: null, media_kind: null }],
+    outcome: { truncated: false },
+});
+const shell = (command, finished = true) => ({
+    type: "shell", command: { type: "inline", text: command }, source_truncated: false, cwd: null, timeout_ms: null,
+    background: false, outcome: finished ? { exit_code: 0, signal: null, process_id: null } : null,
+});
+/* ── the demo ───────────────────────────────────────────────────────────── */
+export function createRoomDemo(now = Date.now()) {
+    const runtimes = RUNTIMES.map(([id, kind]) => ({
+        id, kind, data_root: `~/.${id}`, enabled: true, account: null, config: null, skills: null,
+        versions_seen: null, discovered_at: now - 400 * DAY,
+    }));
+    const projects = PROJECTS.map(([name], i) => ({
+        id: `p${i}`, name, root_paths: [`/Users/demo/Projects/${name}`], git_repo: i < 4 ? `github.com/demo/${name}` : null,
+    }));
+    const sessions = SESSIONS.map(([project, title, hoursAgo, runtime], i) => {
+        const last = now - hoursAgo * HOUR;
+        return {
+            id: `s${i}`, native_session_id: `native-${runtime}-${i}`, runtime_id: runtime, project_id: `p${project}`,
+            cwd: `/Users/demo/Projects/${PROJECTS[project][0]}`, parent_session_id: null, delegation: null,
+            root_session_id: `s${i}`, role: "main", title, summary: null, started_at: last - 50 * MINUTE,
+            updated_at: last, activity: { first_at: last - 50 * MINUTE, last_at: last }, stream_state: "indexed",
+        };
+    });
+    // The figures: a year of days, quiet long ago and busy lately, per project.
+    const start = getActivityGridStartTimestamp(now);
+    const stats = new Map();
+    const usage = new Map();
+    PROJECTS.forEach(([, usd, scale], i) => {
+        const heat = [];
+        for (let d = 0, at = start; at <= now; d += 1, at += DAY) {
+            const seed = i * 3 + 1;
+            const tokens = Math.round(at > now - 40 * DAY ? ((d * 7 + seed) % 5 === 0 ? 0 : (8 + ((d * 13 + seed) % 23)) * scale)
+                : at > now - 120 * DAY ? ((d + seed) % 3 === 0 ? (2 + ((d * 5 + seed) % 9)) * scale * 0.6 : 0)
+                    : (d + seed) % 11 === 0 ? (1 + (d % 5)) * scale * 0.3 : 0);
+            heat.push({ day: getCalendarDayKey(at + DAY / 2), tokens, cost_micro_usd: Math.round(tokens * 2.4),
+                billed_micro_usd: null, unpriced_tokens: 0, unrecorded_output: 0, reported_cost_adjustment_micro_usd: 0 });
+        }
+        const contribution = SESSIONS.flatMap(([project, , , , tokens, messages, cost], s) => project !== i ? [] : [{ session_id: `s${s}`, project_id: `p${i}`, tokens, commits: 0, edits: 0, loc: 0, messages,
+                cost_micro_usd: Math.round(cost * 1e6), billed_micro_usd: null, unpriced_tokens: 0, unrecorded_output: 0,
+                reported_cost_adjustment_micro_usd: 0 }]);
+        stats.set(`p${i}`, { heat, contribution });
+        const spend = (tokens) => ({ cost_micro_usd: Math.round(tokens * 2.4), billed_micro_usd: null,
+            unpriced_tokens: 0, unrecorded_output: 0, reported_cost_adjustment_micro_usd: 0 });
+        const models = heat.filter((day) => day.tokens > 0).slice(-30).flatMap((day, k) => [
+            { day: day.day, model: "claude-opus-5-5", tokens: Math.round(day.tokens * 0.7), ...spend(day.tokens * 0.7) },
+            { day: day.day, model: k % 3 === 0 ? "gpt-5.4" : "claude-sonnet-4-5", tokens: Math.round(day.tokens * 0.3), ...spend(day.tokens * 0.3) },
+        ]);
+        const hours = [1, 10, 15, 16, 23].map((hour, k) => {
+            const tokens = Math.round((k + 2) * 4e6 * (usd / 2840));
+            return { hour, tokens, ...spend(tokens) };
+        });
+        usage.set(`p${i}`, { models, hours });
+    });
+    // Two transcripts: the conversation first, its activity one press away.
+    const timelines = new Map();
+    const one = transcript("s0", sessions[0].started_at);
+    one.user("Port the latest Godview look and rosetta's History view into the four-views frame, and fix the old flaws while we're there: the keys in the file pill, and the two plus buttons in the composer line.", [image("1", "frame-before", "frame-before.png", 1440, 900), image("2", "frame-after", "frame-after.png", 900, 1200)]);
+    one.agent("I'll read DESIGN.md and the composer record first, then capture Godview from the catalog and History from rosetta's own components, so the page shows each view as it really looks.");
+    one.tool("Read", read("DESIGN.md"));
+    one.tool("Read", read("draft/composer/compact.md"));
+    one.tool("WebSearch", { type: "web_search", query: "react context injected ports", allowed_domains: [], blocked_domains: [], outcome: { sources: [
+                { url: "https://github.com/facebook/react", title: "facebook/react" },
+                { url: "https://developer.mozilla.org/en-US/docs/Web/API", title: "Web APIs | MDN" },
+            ], total_count: 2 } });
+    one.tool("Bash", shell("pnpm exec vite --mode design"));
+    one.tool("Bash", shell("node capture.mjs --view godview --theme dark"));
+    one.agent("The frame has five places: the head, the line, the two edges and the corner. Every view keeps its interior. When you switch views, only the head's contents and the stage change.");
+    one.user("Show me the line with one plus.");
+    one.agent("The attach button retires. @ puts anything into the message, agents and things alike, and the clipboard notch stays the store. The create act is the view's own, and only Canvas draws it as a plus.");
+    one.tool("Bash", shell("node verify.mjs --states all", false), "running");
+    timelines.set("s0", one.rows);
+    const two = transcript("s8", sessions[8].started_at);
+    two.user("Extract the room into a package that dials nothing.");
+    two.agent("The room reads four ports now: the catalog, one session's body, the desktop and the asset source.");
+    two.agent("rosetta's own app is the first host, over its one client.");
+    timelines.set("s8", two.rows);
+    const status = {
+        canonicalReady: true, searchReadiness: "ready", searchProgress: null,
+        ingest: { phase: "live", runtimes: [], projects: [] }, startedAt: now - 6 * HOUR, uptimeMs: 6 * HOUR,
+    };
+    return { now, meta: { runtimes, projects, sessions }, status, stats, usage, timelines };
+}
+/* ── its ports ──────────────────────────────────────────────────────────── */
+const EMPTY_META = { tasks: [], workflows: [], plans: [], artifacts: [] };
+function textOf(row) {
+    return (row.body.type === "user" || row.body.type === "agent") && row.body.text?.type === "inline" ? row.body.text.text : "";
+}
+/** A tile drawn from the digest, so each image has its own colour. */
+function placeholderSvg(digest) {
+    const hue = Number.parseInt(digest.slice(0, 2), 16) * 1.4;
+    return `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 16 10"><rect width="16" height="10" fill="hsl(${hue.toFixed(0)} 55% 55%)"/><circle cx="11" cy="3.5" r="1.6" fill="hsl(${hue.toFixed(0)} 60% 85%)"/><path d="M0 10 6 4l4 4 2-2 4 4z" fill="hsl(${hue.toFixed(0)} 45% 35%)"/></svg>`;
+}
+/** The demo's addresses: every stored image is a drawn tile, inline. */
+export function demoAssets() {
+    return {
+        imageAssetUrl: (asset) => `data:image/svg+xml,${encodeURIComponent(placeholderSvg(asset.digest))}`,
+        attachmentAssetUrl: (asset) => asset.url,
+    };
+}
+function demoSessionClient(demo) {
+    const rowsOf = (sessionId) => demo.timelines.get(sessionId) ?? [];
+    const never = () => Promise.reject(new Error("The demo keeps no recorded file"));
+    return {
+        subscribeSession(sessionId, handlers) {
+            const rows = [...rowsOf(sessionId)];
+            let open = true;
+            queueMicrotask(() => {
+                if (!open)
+                    return;
+                handlers.onStatus?.("live");
+                handlers.onSnapshot?.({ entries: rows, cursor: null, watermark: "1" });
+                handlers.onChange?.(rows);
+                handlers.onTimelineMetaChange?.(EMPTY_META);
+            });
+            return {
+                entries: () => rows,
+                fetchPage: async () => ({ entries: [], cursor: null, watermark: "1" }),
+                reveal: () => { },
+                loadEntry: async (timelineId) => rows.some((row) => row.timeline_id === timelineId),
+                close: () => {
+                    open = false;
+                },
+            };
+        },
+        subscribeCollaboration: () => ({ close() { }, restart() { } }),
+        timelineEntry: async (sessionId, timelineId) => {
+            const row = rowsOf(sessionId).find((entry) => entry.timeline_id === timelineId);
+            if (row === undefined)
+                throw new Error("That message is not in the demo");
+            return row;
+        },
+        reportWork: async () => [],
+        command: async () => ({ command: "" }),
+        readFileTarget: never,
+        readPlan: never,
+        readTextAsset: never,
+        readAsset: async (asset) => new TextEncoder().encode(placeholderSvg(asset.digest)),
+    };
+}
+/** The demo's catalog: rows on subscribe, figures by project, and a search
+ * over the demo's own words. No boost: nothing here is still queued. */
+function demoCatalog(demo) {
+    return {
+        subscribeMeta(handlers) {
+            let open = true;
+            queueMicrotask(() => {
+                if (!open)
+                    return;
+                handlers.onStatus?.("live");
+                handlers.onChange?.(demo.meta, "snapshot");
+            });
+            return {
+                close: () => {
+                    open = false;
+                },
+            };
+        },
+        status: async () => demo.status,
+        projectStats: async (projectId) => demo.stats.get(projectId) ?? { heat: [], contribution: [] },
+        usage: async (projectId) => demo.usage.get(projectId) ?? { models: [], hours: [] },
+        dayUsage: async (projectId, day) => ({
+            day,
+            models: (demo.usage.get(projectId)?.models ?? []).filter((model) => model.day === day).flatMap((model) => [9, 14, 16, 22].map((hour) => ({ hour, model: model.model, tokens: Math.round(model.tokens / 4) }))),
+        }),
+        search: async (request) => {
+            const q = request.q.trim().toLowerCase();
+            const hits = [];
+            for (const [sessionId, rows] of demo.timelines) {
+                for (const row of rows) {
+                    const text = textOf(row);
+                    const at = text.toLowerCase().indexOf(q);
+                    if (q === "" || at < 0 || hits.length >= request.limit)
+                        continue;
+                    hits.push({ timeline_id: row.timeline_id, session_id: sessionId, kind: row.body.type, at: row.at,
+                        snippet: `${text.slice(Math.max(0, at - 40), at)}[${text.slice(at, at + q.length)}]${text.slice(at + q.length, at + q.length + 60)}`,
+                        score: 1 });
+                }
+            }
+            return { state: { readiness: "ready", progress: null, projection_epoch: null, revision: null }, hits };
+        },
+    };
+}
+/** Ports over the demo: a catalog, sessions and asset addresses. No host —
+ * a host that is a desktop adds its own `HostPort`. */
+export function createDemoPorts(demo = createRoomDemo()) {
+    const client = demoSessionClient(demo);
+    const sessions = { open: () => client, close: () => { } };
+    return { catalog: demoCatalog(demo), sessions, assets: demoAssets() };
+}
+/** The demo's projects as the room's columns draw them, for a harness that
+ * mounts a column on its own. */
+export function demoProjectViewModels(demo = createRoomDemo()) {
+    const kinds = new Map(demo.meta.runtimes.map((runtime) => [runtime.id, runtime.kind]));
+    const tints = createTintDealer(null);
+    return demo.meta.projects.map((project) => buildProjectViewModel(project, demo.meta.sessions, demo.stats.get(project.id), (id) => kinds.get(id) ?? id, demo.now, tints.projectTint));
+}
+/** The order the projects and sessions column would settle on for the demo. */
+export function demoActivityOrder(demo = createRoomDemo()) {
+    return advanceActivityOrder(null, demo.meta.sessions, { now: demo.now, live: false, bootstrapping: false });
+}

package/dist/host-inputs.d.ts

@@ -0,0 +1,231 @@
+import type { ReactNode } from "react";
+import type { SessionRow } from "@vibefield/rosetta-protocol";
+/** One row of a menu the room draws for its host. */
+export interface RoomMenuItem {
+    readonly key: string;
+    /** What leads the row — a mark the host draws. Never interactive. */
+    readonly mark?: ReactNode;
+    readonly label: ReactNode;
+    /** A second line under the label (a path, "asleep · 2 h"). */
+    readonly detail?: ReactNode;
+    /** At the row's right end ("here", a count, "last used"). */
+    readonly aside?: ReactNode;
+    /** The chosen one: drawn with the check. */
+    readonly checked?: boolean | undefined;
+    /** Drawn, not choosable; its `detail` says why. */
+    readonly disabled?: boolean | undefined;
+    /** One step in, under the row above it (a worktree under its checkout). */
+    readonly depth?: 0 | 1 | undefined;
+    /** The words a menu's filter matches. Absent: the row always shows. */
+    readonly filterText?: string | undefined;
+    readonly onSelect?: (() => void) | undefined;
+    /** The row's own act, drawn beside it (→ reaches it from the row): pressed,
+     * never a menu, and the rows close after it. */
+    readonly act?: RoomAct | undefined;
+}
+export interface RoomMenuGroup {
+    readonly key: string;
+    /** The group's head ("Starts in", a desktop's mark and name). */
+    readonly title?: ReactNode;
+    readonly items: readonly RoomMenuItem[];
+}
+/** A menu: groups of rows. The room opens it under the control that owns it,
+ * closes it on a choice, a press outside or Escape, and moves through its
+ * rows with the arrow keys while it is open. */
+export interface RoomMenu {
+    /** Its accessible name. */
+    readonly label: string;
+    readonly groups: readonly RoomMenuGroup[];
+    /** Past this many rows a filter heads the menu; its placeholder is
+     * `filterPlaceholder` ("Filter 34 folders"). Absent: never. */
+    readonly filterAfter?: number | undefined;
+    readonly filterPlaceholder?: string | undefined;
+    /** What the menu says with no rows to show. */
+    readonly empty?: ReactNode;
+}
+/** A host act, drawn as one of the room's own buttons in the slot that holds
+ * it. The room presses it and draws nothing about what it means. */
+export interface RoomAct {
+    readonly key: string;
+    /** Its accessible name and its tooltip. */
+    readonly label: string;
+    /** What the button shows: the host's glyph, its word, or both. */
+    readonly content: ReactNode;
+    /** The slot's one primary act, on the room's primary fill (② head only). */
+    readonly primary?: boolean | undefined;
+    readonly disabled?: boolean | undefined;
+    readonly onPress?: (() => void) | undefined;
+    /** The act opens these rows instead of pressing, wherever it sits (a
+     * menu row's own act excepted): drawn over the columns, so a row's act may
+     * open them as well as a head's. */
+    readonly menu?: RoomMenu | undefined;
+}
+/** A project row's host decorations (R2). None of them is interactive: the
+ * row is one button. */
+export interface RoomProjectRow {
+    /** Drawn at the start of the path line, before the path (a desktop's marks). */
+    readonly marks?: ReactNode;
+    /** A second line under the path (a disambiguation, "3 sessions on Studio"). */
+    readonly line?: ReactNode;
+    /** How many of the project's sessions are live now: above zero, the row's
+     * time slot says "n live" in the room's live ink. */
+    readonly live?: number | undefined;
+    /** H4 — an act at the row's end, before its time (pin, hide), or its rows.
+     * The row stays the selection: it becomes a box under one covering button,
+     * the act above it. */
+    readonly act?: RoomAct | undefined;
+}
+/** A section of a list (R3). Given a list's sections, the room draws them in
+ * the order given; a row two sections name is drawn in the first, and a row
+ * no section names is drawn in the section without `ids` — or nowhere, when
+ * every section names its rows (which is how a host filter hides rows). */
+export interface RoomSection {
+    readonly key: string;
+    /** Its head, in the host's words ("Live now"). Absent: no head. */
+    readonly title?: ReactNode;
+    /** Its rows. Absent: every row no other section names. */
+    readonly ids?: readonly string[] | undefined;
+    /** Whose order the rows keep. `host` (the default when `ids` is given): as
+     * `ids` lists them. `room`: the room's own — the ledger's rank switch, or a
+     * session list's days, with the day heads. A section without `ids` always
+     * keeps the room's. */
+    readonly order?: "host" | "room" | undefined;
+    /** A foot section: drawn folded, as one line of the host's words and the
+     * section's count, ending in `act` ("Show older"); the line opens and
+     * closes it. A folded section holding the selected row opens. */
+    readonly fold?: {
+        readonly label: ReactNode;
+        readonly act: string;
+        /** Absent: how many rows the section holds. */
+        readonly count?: number | undefined;
+    } | undefined;
+}
+/** A filter chip in a list's bar (R7): drawn as a button that opens its
+ * rows. The host filters — through the list's sections — and says what is
+ * chosen with `label`, `set` and a checked row. */
+export interface RoomFilter {
+    readonly key: string;
+    /** The chip at rest ("any desktop", or the chosen one's mark and name). */
+    readonly label: ReactNode;
+    /** Its accessible name ("Filter by desktop"). */
+    readonly accessibleLabel: string;
+    /** A choice is made: the chip wears the room's set look. */
+    readonly set?: boolean | undefined;
+    readonly menu: RoomMenu;
+}
+/** A session row's host decorations. */
+export interface RoomSessionRow {
+    /** The host's own key for the session. The room never reads it: it rides
+     * the selection (`RoomSelection.hostKey`) back out, untouched. */
+    readonly hostKey?: string | undefined;
+    /** Drawn in the row's id slot in place of the native id (the host's mark
+     * and the folder's path). Never interactive. */
+    readonly id?: ReactNode;
+    /** The id slot's tooltip. Absent with `id`: none. */
+    readonly idTitle?: string | undefined;
+    /** At the row's right end, before its time (Resume, Jump to): pressed, or
+     * opening its rows; the row itself stays the selection. */
+    readonly act?: RoomAct | undefined;
+    /** Where the act would be, when there is none: the reason, quiet. */
+    readonly reason?: ReactNode;
+}
+/** What ② knows when it asks for its head's acts. */
+export interface RoomProjectContext {
+    /** The folder ③ shows, by the host's key (R6), or null. */
+    readonly folder: string | null;
+}
+/** ④'s head: the host's acts, before the room's activity act, or the reason
+ * after the range. */
+export interface RoomHeadActs {
+    readonly acts?: readonly RoomAct[] | undefined;
+    readonly reason?: ReactNode;
+}
+/** One folder the host offers ③. */
+export interface RoomFolder {
+    /** The host's key — never a path: two machines spell paths alike. */
+    readonly key: string;
+    /** The folder: what the head names and what the worktree opens. */
+    readonly path: string;
+    /** In front of the path, in the head and in its row. */
+    readonly mark?: ReactNode;
+    /** Its row's words. Absent: the path, home-abbreviated. */
+    readonly label?: ReactNode;
+    /** Its row's second line (the branch, who works there). */
+    readonly detail?: ReactNode;
+    readonly aside?: ReactNode;
+    /** One step in, under the folder above it (a linked worktree). */
+    readonly depth?: 0 | 1 | undefined;
+    /** The head's caption while it is shown ("Studio · main"). Absent: git's. */
+    readonly caption?: string | undefined;
+    /** This folder cannot be opened here: ③ draws this, the host's honest
+     * state, instead of opening it. */
+    readonly elsewhere?: ReactNode;
+    /** H4 — an act on the folder's row, beside it ("Not part of this project"):
+     * pressed, never a menu; the list closes after it. */
+    readonly act?: RoomAct | undefined;
+}
+export interface RoomFolderGroup {
+    readonly key: string;
+    readonly title?: ReactNode;
+    readonly folders: readonly RoomFolder[];
+}
+/** ③'s folder list for one project: its head becomes the dropdown. */
+export interface RoomFolders {
+    readonly groups: readonly RoomFolderGroup[];
+    /** The folder ③ opens on while no session is chosen (the usual place).
+     * Absent: the room's own root. */
+    readonly initial?: string | undefined;
+    /** The folder a session ran in: ③ follows it when the session is chosen.
+     * Absent, or null for a session: the room's own root for its folder. */
+    readonly of?: ((session: SessionRow) => string | null | undefined) | undefined;
+    /** Past this many folders a filter heads the list. */
+    readonly filterAfter?: number | undefined;
+    readonly filterPlaceholder?: string | undefined;
+    /** ③ shows this folder now — the reader's pick or the session followed;
+     * null when it shows none of the host's. */
+    readonly onShow?: ((key: string | null) => void) | undefined;
+}
+/** ②'s head name, editable in place. */
+export interface RoomRename {
+    /** Commit a new name (trimmed, changed, not empty). A rejection keeps the
+     * field open and says why, in the error's own words. */
+    onRename(name: string): void | PromiseLike<void>;
+    /** The name's accessible name and tooltip as a control. Default: "Rename". */
+    readonly label?: string | undefined;
+}
+export interface RoomHostInputs {
+    /** R1 — a project's colour (any CSS colour). Absent, or null for a
+     * project: the room's own dealt tint. */
+    readonly projectTint?: ((projectId: string) => string | null | undefined) | undefined;
+    /** R2 — a project row's decorations. */
+    readonly projectRow?: ((projectId: string) => RoomProjectRow | null | undefined) | undefined;
+    /** R3 — ①'s sections. */
+    readonly projectSections?: readonly RoomSection[] | undefined;
+    /** R3 — ②'s sections, per project. */
+    readonly sessionSections?: ((projectId: string) => readonly RoomSection[] | null | undefined) | undefined;
+    /** R4 — a session row's decorations and host key. */
+    readonly sessionRow?: ((session: SessionRow) => RoomSessionRow | null | undefined) | undefined;
+    /** R5 — ②'s head acts, after the room's own; one may be `primary`. */
+    readonly projectActs?: ((projectId: string, context: RoomProjectContext) => readonly RoomAct[] | null | undefined) | undefined;
+    /** H4 — ②'s head name becomes editable on press: Enter commits, Escape (or
+     * leaving it) cancels, a failure is said where the name is. */
+    readonly projectRename?: ((projectId: string) => RoomRename | null | undefined) | undefined;
+    /** R5 — a card under ②'s head, above its list (suggestions). */
+    readonly projectCard?: ((projectId: string) => ReactNode) | undefined;
+    /** R5 — ④'s head, for the session it names. */
+    readonly sessionActs?: ((session: SessionRow) => RoomHeadActs | null | undefined) | undefined;
+    /** R6 — ③'s folders, per project. */
+    readonly folders?: ((projectId: string) => RoomFolders | null | undefined) | undefined;
+    /** R7 — ①'s chips, before the rank switch. */
+    readonly projectFilters?: readonly RoomFilter[] | undefined;
+    /** R7 — ②'s chips, per project. */
+    readonly sessionFilters?: ((projectId: string) => readonly RoomFilter[] | null | undefined) | undefined;
+    /** R9 — the address ②'s repository act opens. Absent, or undefined for a
+     * project: the room's own reading of `git_repo`; null: no act. */
+    readonly repositoryUrl?: ((projectId: string) => string | null | undefined) | undefined;
+}
+/** Only the host's inputs, picked out of the room's props. */
+export declare function hostInputsOf(props: RoomHostInputs): RoomHostInputs;
+export declare const HostInputsProvider: import("react").Provider<RoomHostInputs>;
+/** The host's inputs, as the room's parts read them; none outside a room. */
+export declare function useHostInputs(): RoomHostInputs;

package/dist/host-inputs.js

@@ -0,0 +1,35 @@
+// What a host may hand the room beyond its ports: its own colours, marks,
+// sections, acts, folders and filters, which the room DRAWS in its own
+// vocabulary and never interprets. Every one is optional, and with none of
+// them the room is exactly what rosetta's app shows — the reference host
+// passes none. The room stays unaware of what a host means by them: a host
+// key is passed through untouched, a host mark is drawn where it is put, and
+// a host act is pressed, never second-guessed.
+//
+// Ids are the room's own: a project's `ProjectRow.id`, a session's
+// `SessionRow.id`, as the host's catalog handed them in.
+import { createContext, useContext } from "react";
+/** Only the host's inputs, picked out of the room's props. */
+export function hostInputsOf(props) {
+    return {
+        projectTint: props.projectTint,
+        projectRow: props.projectRow,
+        projectSections: props.projectSections,
+        sessionSections: props.sessionSections,
+        sessionRow: props.sessionRow,
+        projectActs: props.projectActs,
+        projectCard: props.projectCard,
+        projectRename: props.projectRename,
+        sessionActs: props.sessionActs,
+        folders: props.folders,
+        projectFilters: props.projectFilters,
+        sessionFilters: props.sessionFilters,
+        repositoryUrl: props.repositoryUrl,
+    };
+}
+const HostInputsContext = createContext({});
+export const HostInputsProvider = HostInputsContext.Provider;
+/** The host's inputs, as the room's parts read them; none outside a room. */
+export function useHostInputs() {
+    return useContext(HostInputsContext);
+}

package/dist/index.d.ts

@@ -0,0 +1,18 @@
+export { HistoryRoom } from "./HistoryRoom.js";
+export type { HistoryRoomHandle, HistoryRoomProps, HistoryRoomSearch, RoomInset, RoomSelection, RoomTarget, } from "./HistoryRoom.js";
+/** What a host may hand the room beyond its ports (all optional). */
+export type { RoomAct, RoomFilter, RoomFolder, RoomFolderGroup, RoomFolders, RoomHeadActs, RoomHostInputs, RoomMenu, RoomMenuGroup, RoomMenuItem, RoomProjectContext, RoomProjectRow, RoomRename, RoomSection, RoomSessionRow, } from "./host-inputs.js";
+/** The reader (PK3): one session's transcript, read-only, at a line. */
+export { TranscriptReader } from "./TranscriptReader.js";
+export type { ReaderAddress, TranscriptReaderProps } from "./TranscriptReader.js";
+export type { AssetSource, AssetUrl, CatalogPort, CatalogSearch, CatalogStatus, Closable, CollaborationFeed, FigureWindow, GitFacts, GitWorktree, HostPort, InstalledBrowser, RoomPorts, SessionClient, SessionFeed, SessionPort, WorktreeFileActionRequest, WorktreeFileActionResult, WorktreeHostEvent, WorktreeHostPort, WorktreeOpenResult, } from "./ports.js";
+export type { SummaryTab } from "./room-context.js";
+export type { ProjectStats } from "./lib/model.js";
+export type { KeyValueStore } from "./lib/room-storage.js";
+export { DEFAULT_STORAGE_PREFIX } from "./lib/room-storage.js";
+/** A host that holds rosetta's own StatusResponse reads it with this. */
+export { catalogStatusOf } from "./lib/catalog-status.js";
+export { AgentMark, agentLabel } from "./lib/agents.js";
+export { lastActive } from "./lib/format.js";
+export { hasPrimaryModifier, shortcutLabel } from "./components/search/shortcut.js";
+export { MoonGlyph, SunGlyph } from "./lib/icons.js";

package/dist/index.js

@@ -0,0 +1,14 @@
+// @vibefield/rosetta-room — rosetta's History room behind injected ports. A host hands
+// it a catalog, a way to open one session's body, an asset source and, on a
+// desktop, a host port; the room dials nothing itself. See README.md.
+export { HistoryRoom } from "./HistoryRoom.js";
+/** The reader (PK3): one session's transcript, read-only, at a line. */
+export { TranscriptReader } from "./TranscriptReader.js";
+export { DEFAULT_STORAGE_PREFIX } from "./lib/room-storage.js";
+/** A host that holds rosetta's own StatusResponse reads it with this. */
+export { catalogStatusOf } from "./lib/catalog-status.js";
+// Parts a host's own shell may reuse, so it reads like the room it holds.
+export { AgentMark, agentLabel } from "./lib/agents.js";
+export { lastActive } from "./lib/format.js";
+export { hasPrimaryModifier, shortcutLabel } from "./components/search/shortcut.js";
+export { MoonGlyph, SunGlyph } from "./lib/icons.js";

package/dist/lib/activity-details.d.ts

@@ -0,0 +1,23 @@
+import type { CalendarHeatmapCellData, CalendarHeatmapData } from "../components/charts/types.js";
+export interface ActivityRun {
+    readonly start: string;
+    readonly end: string;
+    readonly length: number;
+}
+export interface ActivityDetails {
+    readonly calendar: CalendarHeatmapData;
+    readonly days: readonly CalendarHeatmapCellData[];
+    readonly start: string;
+    readonly end: string;
+    readonly total: number | null;
+    readonly recordedDayCount: number;
+    readonly activeDayCount: number;
+    readonly longestStreak: number;
+    readonly busiestDay: CalendarHeatmapCellData | null;
+    readonly runs: readonly ActivityRun[];
+    readonly bestRun: ActivityRun | null;
+    readonly currentRun: ActivityRun | null;
+}
+/** The full available history uses the same daily cells as the small calendar.
+ * Missing/future days never become measured zeroes or average denominators. */
+export declare function createActivityDetails(data: CalendarHeatmapData, today: string): ActivityDetails;