@vibefield/rosetta-room 0.0.0-stage → 0.1.0

package/dist/components/transcript/detail-parts.js

@@ -0,0 +1,295 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+// The heavier detail bodies — a change's diff, a question's options, a
+// report's findings, a produced document, an external call's fields, a
+// collaboration's participants.
+//
+// Split out of `LineDetail.tsx` only for size: the dispatcher there names one
+// renderer per `LedgerDetail` kind, and these are the ones long enough to
+// bury it. Every rule they obey is the same one — show what the ROW proved,
+// state absence rather than faking it, and cap what would otherwise become a
+// scroll trap inside the measure.
+import { useMemo, useState } from "react";
+import { FileIcon } from "@vibecook/mille-ui/icons";
+import { vibefieldIconTheme } from "@vibecook/mille-ui/icons/vibefield";
+import { canonicalText, commandDirectoryContext, commandPreviewText, diffstatText, resourceDisplay, splitPath, TASK_PREVIEW_LIMIT, taskDisplayRows, } from "../../lib/transcript/index.js";
+import { parseDiff } from "../file-viewer/diff/index.js";
+import { highlight, languageFor, PLAIN_TEXT } from "../file-viewer/syntax/index.js";
+import { useRoom } from "../../room-context.js";
+import { DirectoryGlyph } from "./glyphs.js";
+/** Q5 A's cap: the hunk that matters, where you are reading. */
+const DIFF_LINE_CAP = 12;
+/** A bounded list is a list; an unbounded one is a scroll trap in the measure. */
+export const LIST_CAP = 24;
+const SHELL = languageFor("command.sh") ?? PLAIN_TEXT;
+const LANGUAGE_FILE = {
+    bash: "command.sh",
+    bun: "command.js",
+    deno: "command.js",
+    fish: "command.sh",
+    javascript: "command.js",
+    js: "command.js",
+    lua: "command.lua",
+    node: "command.js",
+    nodejs: "command.js",
+    php: "command.php",
+    py: "command.py",
+    python: "command.py",
+    ruby: "command.rb",
+    sh: "command.sh",
+    shell: "command.sh",
+    sql: "command.sql",
+    sqlite3: "command.sql",
+    typescript: "command.ts",
+    ts: "command.ts",
+    zsh: "command.sh",
+};
+function namedLanguage(name) {
+    if (name === null)
+        return null;
+    const normalized = name.trim().toLowerCase();
+    const file = LANGUAGE_FILE[normalized] ?? "command." + normalized;
+    return languageFor(file);
+}
+function heredocLanguage(opener) {
+    const redirected = opener.match(/>\s*["']?([^\s"';&|]+)["']?\s+<<-?/);
+    if (redirected !== null) {
+        const fromTarget = languageFor(redirected[1]);
+        if (fromTarget !== null)
+            return fromTarget;
+    }
+    const interpreter = opener.match(/(?:^|[;&|]\s*)(?:env\s+)?(python(?:\d+(?:\.\d+)*)?|nodejs?|deno|bun|ruby|php|lua|bash|zsh|fish|sh|sqlite3)\b/i)?.[1];
+    if (interpreter === undefined)
+        return null;
+    return namedLanguage(interpreter.toLowerCase().replace(/^python.*$/, "python"));
+}
+/** A command is shell until a declared heredoc body begins. When its launcher
+ * or redirect target names a language, use the file viewer's grammar for that
+ * body and return to shell for the delimiter and anything after it. */
+function commandHighlight(text, language, code) {
+    if (code)
+        return highlight(text, namedLanguage(language) ?? PLAIN_TEXT);
+    const lines = text.split("\n");
+    const markerMatch = lines[0]?.match(/<<-?\s*(?:'([^']+)'|"([^"]+)"|([A-Za-z_][A-Za-z0-9_]*))/);
+    const embedded = markerMatch === undefined || markerMatch === null
+        ? null
+        : heredocLanguage(lines[0]);
+    if (markerMatch === undefined || markerMatch === null || embedded === null || lines.length < 2) {
+        return highlight(text, SHELL);
+    }
+    const marker = markerMatch[1] ?? markerMatch[2] ?? markerMatch[3];
+    const close = lines.findIndex((line, at) => at > 0 && line.trim() === marker);
+    const bodyEnd = close === -1 ? lines.length : close;
+    const out = [...highlight(lines[0], SHELL)];
+    if (bodyEnd > 1)
+        out.push(...highlight(lines.slice(1, bodyEnd).join("\n"), embedded));
+    if (close !== -1)
+        out.push(...highlight(lines.slice(close).join("\n"), SHELL));
+    return out;
+}
+function HighlightedCommand({ text, language, code, }) {
+    const lines = useMemo(() => commandHighlight(text, language, code), [code, language, text]);
+    return (_jsx("pre", { className: code ? "tr-diag tr-command__text" : "tr-command__text", "aria-label": text, children: _jsx("code", { children: lines.map((line, row) => (_jsx("span", { className: "tr-command__line", children: line.map((token, at) => token.kind === "plain" ? (_jsx("span", { children: token.text }, at)) : (_jsx("span", { "data-t": token.kind, children: token.text }, at))) }, row))) }) }));
+}
+export function PathList({ paths, total, onOpenPath, }) {
+    const shown = paths.slice(0, LIST_CAP);
+    const hasOpenablePath = onOpenPath !== undefined && shown.some((path) => path.read !== undefined);
+    return (_jsxs("ul", { className: "tr-paths", "data-openable": hasOpenablePath || undefined, children: [shown.map((path, at) => {
+                const openable = onOpenPath !== undefined && path.read !== undefined;
+                const name = splitPath(path.label).name || path.name || path.label;
+                const entryKind = path.resource.type === "directory" ? 1 : path.resource.type === "file" ? 0 : null;
+                const label = (_jsxs(_Fragment, { children: [entryKind !== null && (_jsx(FileIcon, { ariaLabel: `${name} ${entryKind === 1 ? "folder" : "file"}`, className: "tr-paths__icon", entry: { name, kind: entryKind }, expanded: false, theme: vibefieldIconTheme })), _jsx("span", { className: "name", children: name }), path.range !== undefined && _jsx("span", { className: "tr-paths__range", children: path.range })] }));
+                return (_jsx("li", { title: path.label, children: openable ? (_jsx("button", { type: "button", className: "tr-paths__file", title: path.label, "aria-label": `Open ${path.label}${path.range === undefined ? "" : `, ${path.range}`}`, onClick: () => onOpenPath?.(path), children: label })) : (_jsx("span", { className: "tr-paths__entry", children: label })) }, `${path.label}-${at}`));
+            }), total > shown.length && _jsxs("li", { className: "tr-more", children: ["\u2026 ", total - shown.length, " more"] })] }));
+}
+const TASK_STATUS_LABEL = {
+    pending: "pending",
+    in_progress: "in progress",
+    completed: "done",
+    failed: "failed",
+    cancelled: "cancelled",
+    unknown: "status unknown",
+};
+const TASK_CHANGE_LABEL = {
+    added: "added",
+    started: "started",
+    done: "done",
+    reopened: "reopened",
+    failed: "failed",
+    cancelled: "cancelled",
+    updated: "updated",
+};
+/** A task action opens to a three-row glimpse immediately after that action.
+ * The changed row stays last; the reader can disclose the complete board. */
+export function Tasks({ tasks, total, changedTaskId, change, }) {
+    const [showFull, setShowFull] = useState(false);
+    const all = useMemo(() => taskDisplayRows(tasks, changedTaskId, true), [tasks, changedTaskId]);
+    const shown = useMemo(() => (showFull ? all : taskDisplayRows(tasks, changedTaskId, false)), [all, changedTaskId, showFull, tasks]);
+    const canToggle = all.length > TASK_PREVIEW_LIMIT;
+    const unrecorded = Math.max(0, total - all.length);
+    return (_jsxs("ul", { className: "tr-tasks", "aria-label": "Task list", children: [shown.length === 0 && _jsx("li", { className: "tr-tasks__empty", children: "No tasks at this point" }), shown.map((task) => {
+                const status = task.status ?? "unknown";
+                const changed = task.task_id === changedTaskId ? change : null;
+                const metadata = [
+                    `#${task.task_id}`,
+                    task.owner === null ? null : task.owner,
+                    task.blocker_ids.length === 0
+                        ? null
+                        : `blocked by ${task.blocker_ids.map((id) => `#${id}`).join(", ")}`,
+                ].filter((item) => item !== null);
+                return (_jsxs("li", { className: "tr-task", "data-change": changed ?? undefined, "data-status": status, children: [_jsx("span", { "aria-label": TASK_STATUS_LABEL[status], className: "tr-task__check", role: "img", title: TASK_STATUS_LABEL[status] }), _jsx("span", { className: "tr-task__subject", title: task.subject ?? `Task #${task.task_id}`, children: task.subject ?? `Task #${task.task_id}` }), _jsx("span", { className: "tr-task__meta", children: metadata.join(" · ") }), changed !== null && _jsx("span", { className: "tr-task__delta", children: TASK_CHANGE_LABEL[changed] })] }, task.task_id));
+            }), canToggle && (_jsx("li", { className: "tr-tasks__toggle", children: _jsx("button", { type: "button", "aria-expanded": showFull, "aria-label": showFull ? "Show less" : `Show all ${total} tasks`, onClick: () => setShowFull((value) => !value), children: showFull ? "show less" : "show full tasks" }) })), showFull && unrecorded > 0 && (_jsxs("li", { className: "tr-more", children: ["\u2026 ", unrecorded, " more not recorded"] }))] }));
+}
+export function DiffLines({ delta }) {
+    const text = delta.diff === null ? "" : canonicalText(delta.diff);
+    if (text.trim() === "") {
+        return _jsx("p", { className: "tr-text tr-quiet", children: "no diff recorded" });
+    }
+    const parsed = parseDiff(text);
+    const rows = [];
+    let drawn = 0;
+    let total = 0;
+    for (const hunk of parsed.hunks) {
+        for (const line of hunk.lines) {
+            total += 1;
+            if (drawn >= DIFF_LINE_CAP)
+                continue;
+            drawn += 1;
+            const number = line.newNumber ?? line.oldNumber ?? "";
+            rows.push(_jsxs("div", { className: line.kind === "add" ? "add" : line.kind === "del" ? "del" : "ctx", children: [_jsx("span", { children: number }), _jsx("span", { children: line.kind === "add" ? "+" : line.kind === "del" ? "−" : " " }), _jsx("span", { children: line.text })] }, total));
+        }
+    }
+    // git said something this parser could not read as hunks — the honest
+    // answer is the stored text, still capped, rather than an empty frame.
+    if (rows.length === 0) {
+        const lines = text.split("\n");
+        total = lines.length;
+        lines.slice(0, DIFF_LINE_CAP).forEach((line, at) => {
+            rows.push(_jsxs("div", { className: "ctx", children: [_jsx("span", {}), _jsx("span", { children: " " }), _jsx("span", { children: line })] }, at));
+        });
+    }
+    return (_jsxs("div", { className: "tr-diff", children: [rows, total > DIFF_LINE_CAP && _jsxs("div", { className: "more", children: ["\u2026 ", total - DIFF_LINE_CAP, " more lines"] })] }));
+}
+export function DiffDetail({ deltas, diffstat, }) {
+    const stat = diffstatText(diffstat.added, diffstat.removed);
+    return (_jsxs(_Fragment, { children: [deltas.slice(0, 4).map((delta, at) => (_jsxs("div", { children: [_jsxs("div", { className: "tr-detail__bar", children: [_jsx("span", { className: "path", children: resourceDisplay(delta.path, {}) }), at === 0 && stat !== null && _jsx("span", { children: stat })] }), _jsx(DiffLines, { delta: delta })] }, at))), deltas.length > 4 && (_jsxs("p", { className: "tr-text tr-quiet", children: ["\u2026 ", deltas.length - 4, " more files in this change"] }))] }));
+}
+export function CommandList({ commands, code, }) {
+    const directory = commandDirectoryContext(commands);
+    return (_jsxs(_Fragment, { children: [directory !== null && (_jsxs("span", { "aria-label": directory.title, className: "tr-command-cwd", title: directory.title, children: [_jsx(DirectoryGlyph, {}), _jsx("bdi", { children: directory.label })] })), code ? (_jsx("div", { className: "tr-command-stack", children: commands.map((command, at) => (_jsx(CommandSource, { command: command, code: true }, at))) })) : (_jsxs("ul", { className: "tr-cmds", children: [commands.slice(0, LIST_CAP).map((command, at) => (_jsx(CommandSource, { command: command, code: false }, at))), commands.length > LIST_CAP && (_jsxs("li", { className: "tr-more", children: ["\u2026 ", commands.length - LIST_CAP, " more"] }))] }))] }));
+}
+function CommandSource({ command, code }) {
+    const { sessions } = useRoom();
+    const [full, setFull] = useState(null);
+    const [expanded, setExpanded] = useState(false);
+    const [loading, setLoading] = useState(false);
+    const [failed, setFailed] = useState(false);
+    const expandable = command.sourceTruncated && command.sessionId !== null && command.timelineId !== null;
+    const disclose = async () => {
+        if (expanded) {
+            setExpanded(false);
+            return;
+        }
+        if (!expandable || loading)
+            return;
+        if (full !== null) {
+            setExpanded(true);
+            return;
+        }
+        setLoading(true);
+        setFailed(false);
+        try {
+            const sessionId = command.sessionId;
+            const response = await sessions.run(sessionId, (client) => client.command(sessionId, command.timelineId));
+            setFull(response.command);
+            setExpanded(true);
+        }
+        catch {
+            setFailed(true);
+        }
+        finally {
+            setLoading(false);
+        }
+    };
+    const text = expanded && full !== null
+        ? full
+        : commandPreviewText(command.command, command.sourceTruncated);
+    const body = _jsx(HighlightedCommand, { code: code, language: command.language, text: text });
+    const more = expandable ? (_jsx("button", { "aria-expanded": expanded, className: "tr-command__more", type: "button", onClick: disclose, disabled: loading, children: loading
+            ? "loading full command…"
+            : failed
+                ? "couldn’t load · retry"
+                : expanded
+                    ? "show preview"
+                    : "show full command" })) : null;
+    return code ? (_jsxs("div", { className: "tr-command ah-syntax", "data-full": expanded || undefined, children: [body, more] })) : (_jsxs("li", { className: "tr-command ah-syntax", "data-full": expanded || undefined, children: [_jsx("span", { "aria-hidden": "true", className: "tr-command__prompt", children: ">_" }), body, more] }));
+}
+function answerText(question, answers) {
+    return answers
+        .filter((answer) => answer.question_id === question.id)
+        .flatMap((answer) => answer.values.map(canonicalText));
+}
+/** Conversation, so it opens by default: the questions with their options and
+ * the answer marked in primary ink. */
+export function Questions({ questions, answers, }) {
+    return (_jsx("dl", { className: "tr-kv", children: questions.map((question) => {
+            const chosen = answerText(question, answers);
+            const free = chosen.filter((value) => !question.options.some((option) => option.id === value || option.label === value));
+            return (_jsxs("div", { className: "tr-kv__pair", children: [_jsx("dt", { children: question.header ?? canonicalText(question.prompt) }), _jsxs("dd", { "data-prose": "", children: [question.options.length === 0
+                                ? chosen.join(" · ") || "no answer recorded"
+                                : question.options.map((option, at) => {
+                                    const picked = chosen.includes(option.id) || chosen.includes(option.label);
+                                    return (_jsxs("span", { children: [at > 0 && " · ", picked ? _jsxs("b", { children: [option.label, " (chosen)"] }) : option.label] }, option.id));
+                                }), free.length > 0 && question.options.length > 0 && (_jsxs("span", { children: [" · ", _jsx("b", { children: free.join(", ") })] }))] })] }, question.id));
+        }) }));
+}
+export function Findings({ findings, total }) {
+    return (_jsxs("dl", { className: "tr-kv", children: [findings.slice(0, LIST_CAP).map((finding, at) => (_jsxs("div", { className: "tr-kv__pair", children: [_jsx("dt", { children: finding.severity }), _jsxs("dd", { "data-prose": "", children: [_jsx("b", { children: finding.title }), finding.summary !== null && ` — ${canonicalText(finding.summary)}`, finding.resources.length > 0 && (_jsx("span", { className: "n", children: finding.resources.map((resource) => resourceDisplay(resource, {})).join(", ") }))] })] }, at))), total > findings.length && (_jsxs("div", { className: "tr-kv__pair", children: [_jsx("dt", {}), _jsxs("dd", { "data-prose": "", children: ["\u2026 ", total - findings.length, " more"] })] }))] }));
+}
+function displayText(value) {
+    switch (value.type) {
+        case "text":
+        case "number":
+            return value.value;
+        case "boolean":
+            return value.value ? "yes" : "no";
+        case "resource":
+            return resourceDisplay(value.value, {});
+        case "list":
+            return value.value
+                .map((item) => (item.type === "boolean" ? (item.value ? "yes" : "no") : item.value))
+                .join(", ");
+    }
+}
+export function Fields({ fields }) {
+    if (fields.length === 0)
+        return null;
+    return (_jsx("dl", { className: "tr-kv", children: fields.map((field, at) => (_jsxs("div", { className: "tr-kv__pair", children: [_jsx("dt", { children: field.label }), _jsx("dd", { "data-prose": "", children: displayText(field.value) })] }, at))) }));
+}
+function DocumentBlocks({ blocks }) {
+    return (_jsx(_Fragment, { children: blocks.map((block, at) => {
+            switch (block.type) {
+                case "field":
+                    return _jsx(Fields, { fields: [block.field] }, at);
+                case "list":
+                    return (_jsxs("ul", { className: "tr-paths", children: [block.heading !== null && _jsx("li", { className: "tr-more", children: block.heading }), block.items.slice(0, LIST_CAP).map((item, index) => (_jsx("li", { children: item.type === "boolean" ? (item.value ? "yes" : "no") : item.value }, index)))] }, at));
+                case "table":
+                    return (_jsxs("table", { className: "tr-dtable", children: [block.heading !== null && _jsx("caption", { children: block.heading }), _jsx("thead", { children: _jsx("tr", { children: block.columns.map((column, index) => (_jsx("th", { children: column }, index))) }) }), _jsx("tbody", { children: block.rows.slice(0, LIST_CAP).map((row, index) => (_jsx("tr", { children: row.map((cell, column) => (_jsx("td", { children: cell.type === "boolean" ? (cell.value ? "yes" : "no") : cell.value }, column))) }, index))) })] }, at));
+                case "section":
+                    return (_jsxs("div", { children: [_jsx("p", { className: "tr-text tr-quiet", children: block.heading }), _jsx(DocumentBlocks, { blocks: block.blocks })] }, at));
+            }
+        }) }));
+}
+export function Document({ document }) {
+    if (document.type === "member") {
+        return _jsx("p", { className: "tr-text", children: document.preview });
+    }
+    return (_jsxs(_Fragment, { children: [document.summary !== null && _jsx("p", { className: "tr-text", children: canonicalText(document.summary) }), _jsx(DocumentBlocks, { blocks: document.blocks }), document.resources.length > 0 && (_jsx(PathList, { paths: document.resources.map((resource) => ({
+                    label: resourceDisplay(resource, {}),
+                    dir: "",
+                    name: resourceDisplay(resource, {}),
+                    resource,
+                })), total: document.resources.length }))] }));
+}
+export function Participants({ participants, total, body, }) {
+    return (_jsxs(_Fragment, { children: [body !== null && _jsx("p", { className: "tr-text", children: body }), _jsxs("dl", { className: "tr-kv", children: [participants.slice(0, LIST_CAP).map((participant, at) => (_jsxs("div", { className: "tr-kv__pair", children: [_jsx("dt", { children: participant.name }), _jsx("dd", { "data-prose": "", children: [participant.role, participant.state].filter((piece) => piece !== null).join(" · ") })] }, at))), total > participants.length && (_jsxs("div", { className: "tr-kv__pair", children: [_jsx("dt", {}), _jsxs("dd", { "data-prose": "", children: ["\u2026 ", total - participants.length, " more"] })] }))] })] }));
+}

package/dist/components/transcript/disclosure-state.d.ts

@@ -0,0 +1,6 @@
+import type { ReactNode } from "react";
+export declare function DisclosureState({ children }: {
+    readonly children: ReactNode;
+}): import("react").JSX.Element;
+export declare function useRowDisclosure(key: string, initial?: boolean): [boolean, (value: boolean | ((open: boolean) => boolean)) => void];
+export declare function useGroupDisclosure(keys: readonly string[], revision: number): [boolean | undefined, (open: boolean) => void];

package/dist/components/transcript/disclosure-state.js

@@ -0,0 +1,32 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+// Session-local disclosure state survives an event moving into an older page's
+// activity group. It is deliberately separate from the room's fold preference.
+import { createContext, useCallback, useContext, useState, useSyncExternalStore } from "react";
+import { createDisclosureStore } from "./disclosure-store.js";
+const DisclosureContext = createContext(null);
+export function DisclosureState({ children }) {
+    const [store] = useState(createDisclosureStore);
+    return _jsx(DisclosureContext.Provider, { value: store, children: children });
+}
+const subscribeNothing = () => () => { };
+const noValue = () => undefined;
+export function useRowDisclosure(key, initial = false) {
+    const store = useContext(DisclosureContext);
+    const [fallback, setFallback] = useState(initial);
+    const read = useCallback(() => store?.row(key), [store, key]);
+    const saved = useSyncExternalStore(store?.subscribe ?? subscribeNothing, read, noValue);
+    const open = saved ?? fallback;
+    const setOpen = useCallback((value) => {
+        const next = typeof value === "function" ? value(store?.row(key) ?? fallback) : value;
+        if (store === null)
+            setFallback(next);
+        else
+            store.setRow(key, next);
+    }, [store, key, fallback]);
+    return [open, setOpen];
+}
+export function useGroupDisclosure(keys, revision) {
+    const store = useContext(DisclosureContext);
+    useSyncExternalStore(store?.subscribe ?? subscribeNothing, store?.version ?? (() => 0), () => 0);
+    return [store?.group(keys, revision), (open) => store?.setGroup(keys, open, revision)];
+}

package/dist/components/transcript/disclosure-store.d.ts

@@ -0,0 +1,8 @@
+export declare function createDisclosureStore(): {
+    subscribe(listener: () => void): () => void;
+    version: () => number;
+    row: (key: string) => boolean | undefined;
+    setRow(key: string, open: boolean): void;
+    group(keys: readonly string[], revision: number): boolean | undefined;
+    setGroup(keys: readonly string[], open: boolean, revision: number): void;
+};

package/dist/components/transcript/disclosure-store.js

@@ -0,0 +1,31 @@
+export function createDisclosureStore() {
+    const rows = new Map();
+    const groups = new Map();
+    const listeners = new Set();
+    let sequence = 0;
+    const changed = () => { sequence += 1; for (const listener of listeners)
+        listener(); };
+    return {
+        subscribe(listener) { listeners.add(listener); return () => { listeners.delete(listener); }; },
+        version: () => sequence,
+        row: (key) => rows.get(key),
+        setRow(key, open) { if (rows.get(key) !== open) {
+            rows.set(key, open);
+            changed();
+        } },
+        group(keys, revision) {
+            let latest;
+            for (const key of keys) {
+                const value = groups.get(key);
+                if (value?.revision === revision && (latest === undefined || value.sequence > latest.sequence))
+                    latest = value;
+            }
+            return latest?.open;
+        },
+        setGroup(keys, open, revision) {
+            for (const key of keys)
+                groups.set(key, { open, revision, sequence: sequence + 1 });
+            changed();
+        },
+    };
+}

package/dist/components/transcript/document-model.d.ts

@@ -0,0 +1,15 @@
+import type { SessionRow, TimelineEntry } from "@vibefield/rosetta-protocol";
+import type { DayEntry, DocumentOptions, Sitting, Turn } from "../../lib/transcript/index.js";
+import type { PlannedSitting } from "./document-plan.js";
+export interface TranscriptModel {
+    readonly turns: readonly Turn[];
+    readonly sittings: readonly Sitting[];
+    readonly days: readonly DayEntry[];
+    readonly plan: readonly PlannedSitting[];
+    /** `timeline_id` → the `timeline_id` whose element actually draws it. */
+    readonly representatives: ReadonlyMap<string, string>;
+    /** The row after a discontinuity → how many rows the page is missing. */
+    readonly gaps: ReadonlyMap<string, number>;
+}
+export declare function transcriptModel(rows: readonly TimelineEntry[], session: SessionRow | null, homeDirectory: string | null, now: number, options?: DocumentOptions): TranscriptModel;
+export declare function useTranscriptModel(rows: readonly TimelineEntry[], session: SessionRow | null, homeDirectory: string | null, now: number, options?: DocumentOptions): TranscriptModel;

package/dist/components/transcript/document-model.js

@@ -0,0 +1,104 @@
+// One derivation of the document, shared by the column and by every child run.
+//
+// The turns, the sittings, the day list and the plan that reconciles them are
+// all pure functions of the loaded rows; this hook memoises them together so
+// the column and the document can never be looking at two different documents.
+//
+// It also answers two questions the DOM asks:
+//
+//   · Which element DRAWS a given row? A fold collapses several rows into one
+//     line, so a search hit's `timeline_id` may have no element of its own.
+//     The representative map sends the landing to the element that contains it
+//     instead of failing to find one.
+//   · Where did the projection skip? Ordinals are contiguous in a loaded page,
+//     so a jump is a real absence — D33's data gap, stated rather than
+//     silently closed over.
+import { useMemo } from "react";
+import { dayList, documentTurns, sittings } from "../../lib/transcript/index.js";
+import { documentPlan } from "./document-plan.js";
+function buildRepresentatives(turns) {
+    const map = new Map();
+    const claim = (rows, by) => {
+        for (const row of rows)
+            map.set(row.timeline_id, by);
+    };
+    for (const turn of turns) {
+        if (turn.prompt !== null) {
+            claim(turn.prompt.rows, turn.prompt.row.timeline_id);
+            if (turn.prompt.commandOutputRow !== null && turn.prompt.setting === null) {
+                const id = turn.prompt.commandOutputRow.timeline_id;
+                map.set(id, id);
+            }
+        }
+        for (const segment of turn.segments) {
+            if (segment.kind === "compaction") {
+                claim(segment.rows, segment.row.timeline_id);
+                continue;
+            }
+            if (segment.kind === "ledger") {
+                for (const member of segment.members) {
+                    if (member.kind !== "line") {
+                        map.set(member.row.timeline_id, member.row.timeline_id);
+                        continue;
+                    }
+                    const key = member.line.rows[0]?.timeline_id;
+                    if (key !== undefined)
+                        claim(member.line.rows, key);
+                }
+                continue;
+            }
+            map.set(segment.row.timeline_id, segment.row.timeline_id);
+        }
+    }
+    return map;
+}
+function buildGaps(rows) {
+    const gaps = new Map();
+    const previousBySession = new Map();
+    for (const row of rows) {
+        const previous = previousBySession.get(row.session_id);
+        const missing = previous === undefined ? 0 : row.ordinal - previous - 1;
+        if (missing > 0)
+            gaps.set(row.timeline_id, missing);
+        previousBySession.set(row.session_id, row.ordinal);
+    }
+    return gaps;
+}
+export function transcriptModel(rows, session, homeDirectory, now, options = {}) {
+    // Sittings first: a run never straddles a pill, so the turns are cut at
+    // every sitting's first row (`cutBefore`) before they are folded.
+    const list = sittings(rows, now);
+    const gaps = buildGaps(rows);
+    const cutBefore = new Set([...(options.cutBefore ?? gaps.keys()), ...list
+            .slice(1)
+            .map((sitting) => sitting.rows[0]?.timeline_id)
+            .filter((id) => id !== undefined)]);
+    const turns = documentTurns(rows, {
+        ...options,
+        cutBefore,
+        context: { cwd: session?.cwd ?? null, home: homeDirectory },
+    });
+    return {
+        turns,
+        sittings: list,
+        days: dayList(list),
+        plan: documentPlan(turns, list),
+        representatives: buildRepresentatives(turns),
+        gaps,
+    };
+}
+export function useTranscriptModel(rows, session, homeDirectory, now, options = {}) {
+    const cwd = session?.cwd ?? null;
+    const sharedKey = [...(options.sharedCollaborationSessionIds ?? [])].sort().join("\u0000");
+    const cutKey = [...(options.cutBefore ?? [])].sort().join("\u0000");
+    return useMemo(() => {
+        const sharedCollaborationSessionIds = new Set(sharedKey === "" ? [] : sharedKey.split("\u0000"));
+        return transcriptModel(rows, session, homeDirectory, now, {
+            ...options,
+            sharedCollaborationSessionIds,
+        });
+        // `now` only names the day a stamp falls in; re-deriving the whole
+        // document on every clock tick would be a memo that never hits.
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [rows, cwd, homeDirectory, sharedKey, cutKey]);
+}

package/dist/components/transcript/document-plan.d.ts

@@ -0,0 +1,28 @@
+import type { Prompt, Segment, Sitting, Turn } from "../../lib/transcript/index.js";
+/** One drawn block: a slice of one turn, inside exactly one sitting. */
+export interface TurnPart {
+    readonly key: string;
+    readonly sittingIndex: number;
+    readonly turn: Turn;
+    /** The prompts this part opens with — several only for grouped settings. */
+    readonly prompts: readonly Prompt[];
+    /** Segments before the head (leading markers) and after it. */
+    readonly before: readonly Segment[];
+    readonly after: readonly Segment[];
+    /** T-4's eyebrow belongs to this part. */
+    readonly showHead: boolean;
+    /** The first row drawn here — the paging hook's landing contract. */
+    readonly firstRowId: string | null;
+    /** The first stamp under this part, for placing an unanchored child run. */
+    readonly at: number | null;
+}
+export interface PlannedSitting {
+    readonly sitting: Sitting;
+    readonly parts: readonly TurnPart[];
+}
+/**
+ * Fold turns and sittings into the sections the column draws. Sittings that
+ * end up with nothing drawable are dropped: a pill over an empty section would
+ * be a cut with nothing on the far side of it.
+ */
+export declare function documentPlan(turns: readonly Turn[], sittings: readonly Sitting[]): PlannedSitting[];