@vibefield/rosetta-room 0.0.0-stage → 0.1.0

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

@@ -0,0 +1,145 @@
+function firstStampOf(prompts, segments) {
+    for (const prompt of prompts)
+        if (prompt.at !== null)
+            return prompt.at;
+    for (const segment of segments) {
+        for (const row of segmentRows(segment))
+            if (row.at !== null)
+                return row.at;
+    }
+    return null;
+}
+function firstRowIdOf(prompts, segments) {
+    const prompt = prompts[0];
+    if (prompt !== undefined)
+        return prompt.row.timeline_id;
+    const segment = segments[0];
+    if (segment === undefined)
+        return null;
+    return segment.kind === "ledger" ? (segment.rows[0]?.timeline_id ?? null) : segment.row.timeline_id;
+}
+function segmentRows(segment) {
+    return segment.kind === "ledger" || segment.kind === "compaction" ? segment.rows : [segment.row];
+}
+/** A turn's own first row, for the sitting it belongs to. */
+function turnSitting(turn, indexOf) {
+    if (turn.prompt !== null)
+        return indexOf(turn.prompt.row);
+    const first = turn.segments[0];
+    return first === undefined ? 0 : indexOf(segmentRows(first)[0]);
+}
+/** Adjacent setting turns that share one compact configuration group. */
+function clusterGroups(turns, sittingOf) {
+    const groups = [];
+    for (const turn of turns) {
+        const current = groups.at(-1);
+        const previous = current?.at(-1);
+        const joins = current !== undefined &&
+            previous !== undefined &&
+            turn.clusteredWithPrevious &&
+            turn.prompt !== null &&
+            previous.prompt !== null &&
+            turn.prompt.setting !== null &&
+            previous.prompt.setting !== null &&
+            !turn.prompt.fromParent &&
+            !previous.prompt.fromParent &&
+            previous.segments.length === 0 &&
+            sittingOf(previous) === sittingOf(turn);
+        if (joins)
+            current.push(turn);
+        else
+            groups.push([turn]);
+    }
+    return groups;
+}
+/**
+ * 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 function documentPlan(turns, sittings) {
+    const indexByRow = new Map();
+    sittings.forEach((sitting, index) => {
+        for (const row of sitting.rows)
+            indexByRow.set(row.timeline_id, index);
+    });
+    const indexOf = (row) => indexByRow.get(row.timeline_id) ?? 0;
+    const sittingOf = (turn) => turnSitting(turn, indexOf);
+    const parts = [];
+    for (const group of clusterGroups(turns, sittingOf)) {
+        // Only the last turn of a cluster can carry an answer, by construction.
+        const turn = group[group.length - 1];
+        const prompts = group
+            .map((member) => member.prompt)
+            .filter((prompt) => prompt !== null);
+        const openIndex = prompts[0] === undefined ? null : indexOf(prompts[0].row);
+        // Cut the segments wherever the sitting changes under them.
+        const slices = [];
+        turn.segments.forEach((segment, at) => {
+            const index = indexOf(segmentRows(segment)[0]);
+            const last = slices.at(-1);
+            if (last !== undefined && last.index === index)
+                last.segments.push(segment);
+            else
+                slices.push({ index, segments: [segment], from: at });
+        });
+        const headSlice = turn.head === null ? -1 : slices.findIndex((slice) => turn.headIndex >= slice.from && turn.headIndex < slice.from + slice.segments.length);
+        // A head with no segments to sit above still belongs to the reply that
+        // reported it; it rides with the prompt rather than disappearing.
+        const headOnOpener = turn.head !== null && headSlice === -1;
+        if (slices.length === 0) {
+            parts.push({
+                key: turn.key,
+                sittingIndex: openIndex ?? 0,
+                turn,
+                prompts,
+                before: [],
+                after: [],
+                showHead: turn.head !== null,
+                firstRowId: firstRowIdOf(prompts, []),
+                at: firstStampOf(prompts, []),
+            });
+            continue;
+        }
+        slices.forEach((slice, at) => {
+            const opensWithPrompt = at === 0 && openIndex !== null && openIndex === slice.index;
+            const slicePrompts = at === 0 && (opensWithPrompt || openIndex === null) ? prompts : [];
+            const cut = Math.max(0, Math.min(turn.headIndex - slice.from, slice.segments.length));
+            const showHead = at === headSlice || (headOnOpener && at === 0);
+            parts.push({
+                key: `${turn.key}:${at}`,
+                sittingIndex: slice.index,
+                turn,
+                prompts: slicePrompts,
+                before: slice.segments.slice(0, cut),
+                after: slice.segments.slice(cut),
+                showHead,
+                firstRowId: firstRowIdOf(slicePrompts, slice.segments),
+                at: firstStampOf(slicePrompts, slice.segments),
+            });
+        });
+        // The prompt fell in an earlier sitting than every segment: it needs its
+        // own part so its pill and its panel are not filed under the reply's day.
+        if (openIndex !== null && slices[0].index !== openIndex) {
+            parts.splice(parts.length - slices.length, 0, {
+                key: `${turn.key}:opener`,
+                sittingIndex: openIndex,
+                turn,
+                prompts,
+                before: [],
+                after: [],
+                showHead: false,
+                firstRowId: firstRowIdOf(prompts, []),
+                at: firstStampOf(prompts, []),
+            });
+        }
+    }
+    const planned = sittings.map((sitting) => ({ sitting, parts: [] }));
+    for (const part of parts) {
+        const target = planned[part.sittingIndex] ?? planned[0];
+        if (target === undefined)
+            continue;
+        target.parts.push(part);
+    }
+    return planned.filter((entry) => entry.parts.length > 0);
+}

package/dist/components/transcript/fold-preference.d.ts

@@ -0,0 +1,17 @@
+import type { KeyValueStore } from "../../lib/room-storage.js";
+export interface FoldState {
+    readonly folded: boolean;
+    readonly revision: number;
+}
+/** One room's fold: its default, and the act that flips it. */
+export interface FoldPreference {
+    subscribe(listener: () => void): () => void;
+    snapshot(): FoldState;
+    toggle(): void;
+}
+export declare function createFoldPreference(store: KeyValueStore | null): FoldPreference;
+export declare function useFoldPreference(): {
+    folded: boolean;
+    revision: number;
+    toggle: () => void;
+};

package/dist/components/transcript/fold-preference.js

@@ -0,0 +1,63 @@
+// §05 — the room's activity act: fold or open every run at once.
+//
+// The preference is per ROOM, not per run: the reader who wants the build log
+// gets it in one press and keeps it for the session that follows. It is stored
+// the way the project tints are — the room's storage, honestly priced: it is a
+// property of this machine's reader, so it does not travel until the store
+// does.
+//
+// The act sets the room's DEFAULT; every head follows it until pressed. It
+// is ONE store per room, not one state per caller, so each run's head reads it, draws
+// itself open or closed accordingly, and still folds or opens on its own
+// press (a press is an override; the next press of the act clears every
+// override). `data-fold` on the column remains for styling only.
+//
+// v2: the meaning changed with transcript-fold (2026-09-09). Before, "open"
+// unfolded the few runs past eight lines; now it opens every run in the
+// room, so the preference starts over, folded.
+import { useSyncExternalStore } from "react";
+import { useRoom } from "../../room-context.js";
+/** Under the room's storage prefix. */
+const STORE_KEY = "transcript.fold.v2";
+const SERVER_STATE = { folded: true, revision: 0 };
+export function createFoldPreference(store) {
+    /** Folded is the default: the ledger's closed sentence is the point. */
+    let folded = (() => {
+        try {
+            return store?.getItem(STORE_KEY) !== "off";
+        }
+        catch {
+            return true;
+        }
+    })();
+    let revision = 0;
+    let state = { folded, revision };
+    const listeners = new Set();
+    return {
+        subscribe(listener) {
+            listeners.add(listener);
+            return () => {
+                listeners.delete(listener);
+            };
+        },
+        snapshot: () => state,
+        toggle() {
+            folded = !folded;
+            revision += 1;
+            state = { folded, revision };
+            try {
+                store?.setItem(STORE_KEY, folded ? "on" : "off");
+            }
+            catch {
+                // storage refused; the preference holds for this run
+            }
+            for (const listener of listeners)
+                listener();
+        },
+    };
+}
+export function useFoldPreference() {
+    const { fold } = useRoom();
+    const value = useSyncExternalStore(fold.subscribe, fold.snapshot, () => SERVER_STATE);
+    return { ...value, toggle: fold.toggle };
+}

package/dist/components/transcript/glyphs.d.ts

@@ -0,0 +1,15 @@
+import type { LedgerGlyph } from "../../lib/transcript/index.js";
+export declare function FamilyGlyph({ glyph }: {
+    readonly glyph: LedgerGlyph;
+}): import("react").JSX.Element;
+/** T-5's one hue: the act did not complete. Substitutes the family glyph. */
+export declare function FailGlyph(): import("react").JSX.Element;
+/** The disclosure, on the 12-unit grid the record drew it on. */
+export declare function LineChevron(): import("react").JSX.Element;
+/** Working directory — metadata for a command frame, not another ledger act. */
+export declare function DirectoryGlyph(): import("react").JSX.Element;
+/** The column head's activity act — fold or open every run at once (§05). */
+export declare function ActivityGlyph(): import("react").JSX.Element;
+/** Reasoning's line form (Q10 A, transcript-fold): three points — the one
+ * glyph the record did not draw, for the one verb it did not have. */
+export declare function ThoughtGlyph(): import("react").JSX.Element;

package/dist/components/transcript/glyphs.js

@@ -0,0 +1,47 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+const ROUND = { strokeLinecap: "round", strokeLinejoin: "round" };
+/** Every family glyph, on the record's own paths. */
+const PATHS = {
+    read: (_jsxs(_Fragment, { children: [_jsx("path", { d: "M4 2.5h5.5L13 6v7.5a1 1 0 0 1-1 1H4a1 1 0 0 1-1-1v-10a1 1 0 0 1 1-1z" }), _jsx("path", { d: "M9.5 2.5V6H13" })] })),
+    list: _jsx("path", { d: "M3 4.5h10M3 8h10M3 11.5h6" }),
+    search: (_jsxs(_Fragment, { children: [_jsx("circle", { cx: "7", cy: "7", r: "4.2" }), _jsx("path", { d: "m10.2 10.2 3.3 3.3" })] })),
+    web: (_jsxs(_Fragment, { children: [_jsx("circle", { cx: "8", cy: "8", r: "5.5" }), _jsx("path", { d: "M2.5 8h11M8 2.5c2.2 2.2 2.2 8.8 0 11M8 2.5c-2.2 2.2-2.2 8.8 0 11" })] })),
+    shell: (_jsxs(_Fragment, { children: [_jsx("path", { d: "m3 4.5 3.5 3.5L3 11.5" }), _jsx("path", { d: "M8.5 12h4.5" })] })),
+    delta: (_jsxs(_Fragment, { children: [_jsx("path", { d: "M5.5 2.5v5M3 5h5" }), _jsx("path", { d: "M8 12h5" })] })),
+    delegate: (_jsxs(_Fragment, { children: [_jsx("path", { d: "M4 2.5v6.5a2 2 0 0 0 2 2h7" }), _jsx("path", { d: "m10.5 8.5 2.5 2.5-2.5 2.5" })] })),
+    task: (_jsxs(_Fragment, { children: [_jsx("rect", { x: "3", y: "3", width: "10", height: "10", rx: "2" }), _jsx("path", { d: "m5.5 8 2 2 3.5-4" })] })),
+    question: (_jsxs(_Fragment, { children: [_jsx("circle", { cx: "8", cy: "8", r: "5.5" }), _jsx("path", { d: "M6.3 6.6a1.7 1.7 0 1 1 2.6 1.4c-.6.4-.9.7-.9 1.3" }), _jsx("path", { d: "M8 11.3v.1" })] })),
+    doc: (_jsxs(_Fragment, { children: [_jsx("rect", { x: "3", y: "2.5", width: "10", height: "11", rx: "1.5" }), _jsx("path", { d: "M5.5 6h5M5.5 8.5h5M5.5 11h3" })] })),
+    bell: (_jsxs(_Fragment, { children: [_jsx("path", { d: "M5 11V7.5a3 3 0 0 1 6 0V11l1 1H4z" }), _jsx("path", { d: "M6.8 13.5a1.3 1.3 0 0 0 2.4 0" })] })),
+    box: (_jsxs(_Fragment, { children: [_jsx("path", { d: "M2.5 5 8 2.5 13.5 5 8 7.5z" }), _jsx("path", { d: "M2.5 5v6L8 13.5l5.5-2.5V5M8 7.5v6" })] })),
+    plug: (_jsxs(_Fragment, { children: [_jsx("path", { d: "M6 2.5v3M10 2.5v3M4 5.5h8v2a4 4 0 0 1-8 0z" }), _jsx("path", { d: "M8 11.5v2" })] })),
+    flag: _jsx("path", { d: "M4 13.5V3h7l-1.5 2.5L11 8H4" }),
+    bolt: _jsx("path", { d: "M9 2 4 9h4l-1 5 5-7H8z" }),
+    sliders: (_jsxs(_Fragment, { children: [_jsx("path", { d: "M3 5h3M9 5h4M3 11h6M12 11h1" }), _jsx("circle", { cx: "7.5", cy: "5", r: "1.5" }), _jsx("circle", { cx: "10.5", cy: "11", r: "1.5" })] })),
+    clock: (_jsxs(_Fragment, { children: [_jsx("circle", { cx: "8", cy: "8", r: "5.5" }), _jsx("path", { d: "M8 5v3.2l2 1.3" })] })),
+    help: (_jsxs(_Fragment, { children: [_jsx("path", { d: "M6.3 6.6a1.7 1.7 0 1 1 2.6 1.4c-.6.4-.9.7-.9 1.3" }), _jsx("path", { d: "M8 11.3v.1" })] })),
+};
+export function FamilyGlyph({ glyph }) {
+    return (_jsx("svg", { viewBox: "0 0 16 16", fill: "none", stroke: "currentColor", strokeWidth: "1.5", ...ROUND, "aria-hidden": "true", children: PATHS[glyph] }));
+}
+/** T-5's one hue: the act did not complete. Substitutes the family glyph. */
+export function FailGlyph() {
+    return (_jsx("svg", { viewBox: "0 0 16 16", fill: "none", stroke: "currentColor", strokeWidth: "1.6", strokeLinecap: "round", "aria-hidden": "true", children: _jsx("path", { d: "m4.5 4.5 7 7M11.5 4.5l-7 7" }) }));
+}
+/** The disclosure, on the 12-unit grid the record drew it on. */
+export function LineChevron() {
+    return (_jsx("svg", { viewBox: "0 0 12 12", fill: "none", stroke: "currentColor", strokeWidth: "1.5", ...ROUND, "aria-hidden": "true", children: _jsx("path", { d: "M4.5 2.5 8 6 4.5 9.5" }) }));
+}
+/** Working directory — metadata for a command frame, not another ledger act. */
+export function DirectoryGlyph() {
+    return (_jsxs("svg", { viewBox: "0 0 16 16", fill: "none", stroke: "currentColor", strokeWidth: "1.4", ...ROUND, "aria-hidden": "true", children: [_jsx("path", { d: "M2.5 4.5h4l1.4 1.6h5.6v6.4a1 1 0 0 1-1 1h-9a1 1 0 0 1-1-1z" }), _jsx("path", { d: "M2.5 6.1V4a1 1 0 0 1 1-1h2.4l1.4 1.5" })] }));
+}
+/** The column head's activity act — fold or open every run at once (§05). */
+export function ActivityGlyph() {
+    return (_jsx("svg", { viewBox: "0 0 16 16", fill: "none", stroke: "currentColor", strokeWidth: "1.5", ...ROUND, "aria-hidden": "true", children: _jsx("path", { d: "M2.5 8h2.5l2-4.5 2 9 2-4.5h2.5" }) }));
+}
+/** Reasoning's line form (Q10 A, transcript-fold): three points — the one
+ * glyph the record did not draw, for the one verb it did not have. */
+export function ThoughtGlyph() {
+    return (_jsxs("svg", { viewBox: "0 0 16 16", fill: "currentColor", stroke: "none", "aria-hidden": "true", children: [_jsx("circle", { cx: "8", cy: "4.2", r: "1.1" }), _jsx("circle", { cx: "4.4", cy: "10.6", r: "1.1" }), _jsx("circle", { cx: "11.6", cy: "10.6", r: "1.1" })] }));
+}

package/dist/components/transcript/index.d.ts

@@ -0,0 +1,23 @@
+export { Anchor } from "./Anchor.js";
+export { DayMenu, DayPill, Sitting, markStuckPills, pillText } from "./DayPill.js";
+export { TranscriptDocument } from "./Document.js";
+export type { TranscriptDocumentProps } from "./Document.js";
+export { useTranscriptModel } from "./document-model.js";
+export type { TranscriptModel } from "./document-model.js";
+export { documentPlan } from "./document-plan.js";
+export type { PlannedSitting, TurnPart } from "./document-plan.js";
+export { Favicon, FaviconStack } from "./Favicon.js";
+export { useFoldPreference } from "./fold-preference.js";
+export { ActivityGlyph, FamilyGlyph, FailGlyph, LineChevron } from "./glyphs.js";
+export { HeadOfDocument, TopFade, sessionStartLabel } from "./HeadOfDocument.js";
+export { Ledger, Line } from "./Ledger.js";
+export { LineDetail, hasDetail } from "./LineDetail.js";
+export { GapMarker, Marker, Watermark } from "./Marker.js";
+export { Prompt } from "./Prompt.js";
+export { Prose, SegmentActs } from "./Prose.js";
+export { ReceiptPill } from "./ReceiptPill.js";
+export { ResponseHead } from "./ResponseHead.js";
+export { Subthread } from "./Subthread.js";
+export { Thinking } from "./Thinking.js";
+export { buildThreadIndex, messageDomId, sessionContains, subthreadTitle, } from "./thread-index.js";
+export type { ThreadFocus, ThreadIndex } from "./thread-index.js";

package/dist/components/transcript/index.js

@@ -0,0 +1,22 @@
+// The transcript's public door. `components/Transcript.tsx` keeps the column
+// itself (its props are App.tsx's contract); everything the column is made of
+// lives here.
+export { Anchor } from "./Anchor.js";
+export { DayMenu, DayPill, Sitting, markStuckPills, pillText } from "./DayPill.js";
+export { TranscriptDocument } from "./Document.js";
+export { useTranscriptModel } from "./document-model.js";
+export { documentPlan } from "./document-plan.js";
+export { Favicon, FaviconStack } from "./Favicon.js";
+export { useFoldPreference } from "./fold-preference.js";
+export { ActivityGlyph, FamilyGlyph, FailGlyph, LineChevron } from "./glyphs.js";
+export { HeadOfDocument, TopFade, sessionStartLabel } from "./HeadOfDocument.js";
+export { Ledger, Line } from "./Ledger.js";
+export { LineDetail, hasDetail } from "./LineDetail.js";
+export { GapMarker, Marker, Watermark } from "./Marker.js";
+export { Prompt } from "./Prompt.js";
+export { Prose, SegmentActs } from "./Prose.js";
+export { ReceiptPill } from "./ReceiptPill.js";
+export { ResponseHead } from "./ResponseHead.js";
+export { Subthread } from "./Subthread.js";
+export { Thinking } from "./Thinking.js";
+export { buildThreadIndex, messageDomId, sessionContains, subthreadTitle, } from "./thread-index.js";

package/dist/components/transcript/message-file-source.d.ts

@@ -0,0 +1,15 @@
+import type { CanonicalText } from "@vibefield/rosetta-protocol";
+import type { AttachmentFact } from "../../lib/transcript/index.js";
+import type { FileHandle, FileSource } from "../file-viewer/types.js";
+export interface FullMessage {
+    readonly key: string;
+    readonly role: "user" | "agent";
+    /** Generated context can name its reading view without changing authorship. */
+    readonly title?: string | undefined;
+    readonly text: string;
+    readonly recordedText?: CanonicalText | null | undefined;
+    readonly attachments?: readonly AttachmentFact[] | undefined;
+}
+/** A full canonical member, or a snapshot of complete inline text. */
+export declare function handleForMessage(message: FullMessage): FileHandle;
+export declare const messageFileSource: FileSource;

package/dist/components/transcript/message-file-source.js

@@ -0,0 +1,31 @@
+/** A full canonical member, or a snapshot of complete inline text. */
+export function handleForMessage(message) {
+    const name = `${message.title ?? (message.role === "user" ? "User prompt" : "Agent reply")}.md`;
+    const member = message.recordedText?.type === "member" ? message.recordedText : null;
+    if (member !== null)
+        return {
+            key: `message:${message.key}:${member.asset.digest}`,
+            name,
+            path: null,
+            size: member.byte_len,
+            ref: member.asset,
+        };
+    const bytes = new TextEncoder().encode(message.text);
+    return {
+        key: `message:${message.key}`,
+        name,
+        path: null,
+        size: bytes.byteLength,
+        ref: { type: "transcript-message", bytes },
+    };
+}
+export const messageFileSource = {
+    async read(handle, signal) {
+        signal.throwIfAborted();
+        const payload = handle.ref;
+        if (payload?.type !== "transcript-message" || !(payload.bytes instanceof Uint8Array)) {
+            throw new Error("This message is no longer available");
+        }
+        return payload.bytes;
+    },
+};

package/dist/components/transcript/message-preview.d.ts

@@ -0,0 +1,9 @@
+export declare const MESSAGE_PREVIEW_CHARACTERS = 2400;
+export declare const MESSAGE_PREVIEW_LINES = 32;
+export interface MessageExcerpt {
+    readonly text: string;
+    readonly omitted: boolean;
+}
+export declare function messageExcerpt(text: string, budget?: number): MessageExcerpt;
+/** Character counts stay meaningful for prose, source code and CJK text. */
+export declare function messageCharacterCount(text: string): number;

package/dist/components/transcript/message-preview.js

@@ -0,0 +1,46 @@
+// Bound the text handed to the transcript's Markdown renderer. The component
+// can lower this budget further to fit the available reading width; the full
+// message is kept separately and is only rendered in the file viewer.
+export const MESSAGE_PREVIEW_CHARACTERS = 2400;
+export const MESSAGE_PREVIEW_LINES = 32;
+export function messageExcerpt(text, budget = MESSAGE_PREVIEW_CHARACTERS) {
+    let end = Math.min(text.length, Math.max(0, budget), MESSAGE_PREVIEW_CHARACTERS);
+    let lines = 1;
+    for (let at = 0; at < end; at += 1) {
+        if (text[at] === "\n" && ++lines > MESSAGE_PREVIEW_LINES) {
+            end = at;
+            break;
+        }
+    }
+    if (end === text.length)
+        return { text, omitted: false };
+    // Prefer a paragraph or line boundary near the end of the allowance.
+    // Otherwise keep the last whole word. Never split a UTF-16 surrogate pair.
+    const prefix = text.slice(0, end);
+    const paragraph = prefix.lastIndexOf("\n\n");
+    const line = prefix.lastIndexOf("\n");
+    const word = Math.max(prefix.lastIndexOf(" "), prefix.lastIndexOf("\t"));
+    const boundary = [paragraph, line, word].find((at) => at >= end * 0.75);
+    if (boundary !== undefined)
+        end = boundary;
+    if (end > 0 && /[\uD800-\uDBFF]/.test(text[end - 1]))
+        end -= 1;
+    let excerpt = text.slice(0, end).trimEnd();
+    // Do not finish on a heading or an empty fence whose content is omitted.
+    // Keep a heading-only introduction when it is all that fits.
+    const dangling = /(?:^|\n) {0,3}(?:#{1,6}\s+[^\n]*|`{3,}[^\n]*|~{3,}[^\n]*)$/;
+    for (let match = dangling.exec(excerpt); match !== null && match.index > 0; match = dangling.exec(excerpt)) {
+        const before = excerpt.slice(0, match.index).trimEnd();
+        if (before === "")
+            break;
+        excerpt = before;
+    }
+    return { text: excerpt, omitted: true };
+}
+/** Character counts stay meaningful for prose, source code and CJK text. */
+export function messageCharacterCount(text) {
+    let count = 0;
+    for (const _character of text)
+        count += 1;
+    return count;
+}

package/dist/components/transcript/read-file-source.d.ts

@@ -0,0 +1,7 @@
+import type { PathFact } from "../../lib/transcript/index.js";
+import type { SessionLeases } from "../../lib/session-leases.js";
+import type { FileHandle, FileSource } from "../file-viewer/index.js";
+/** Resolve and read one exact canonical target before opening the viewer. */
+export declare function handleForReadPath(sessions: SessionLeases, path: PathFact, previewBytes?: Uint8Array, name?: string): Promise<FileHandle | null>;
+/** Stable by construction: `useFileContent` treats source identity as a read. */
+export declare const transcriptReadFileSource: FileSource;

package/dist/components/transcript/read-file-source.js

@@ -0,0 +1,34 @@
+// Canonical transcript file targets through the shared file-viewer seam.
+//
+// A transcript path is evidence, not authority. The renderer therefore sends
+// only the session id, timeline id and target index back to rosettad. The
+// daemon re-reads the canonical row, resolves the path recorded there and
+// returns a bounded payload. The bytes ride on the handle so opening the
+// dialog does not issue a second filesystem read against a file that may have
+// changed between requests.
+/** Resolve and read one exact canonical target before opening the viewer. */
+export async function handleForReadPath(sessions, path, previewBytes, name) {
+    const address = path.read;
+    if (address === undefined || path.resource.type !== "file")
+        return null;
+    const bytes = previewBytes ?? await sessions.run(address.sessionId, (client) => client.readFileTarget(address.sessionId, address.timelineId, address.targetIndex));
+    return {
+        key: `read:${address.sessionId}:${address.timelineId}:${address.targetIndex}`,
+        name: name || path.name || "file",
+        path: path.resource.path,
+        size: bytes.byteLength,
+        ref: { type: "transcript-read", bytes },
+    };
+}
+/** Stable by construction: `useFileContent` treats source identity as a read. */
+export const transcriptReadFileSource = {
+    async read(handle, signal) {
+        if (signal.aborted)
+            throw new DOMException("the file open was cancelled", "AbortError");
+        const payload = handle.ref;
+        if (payload?.type !== "transcript-read" || !(payload.bytes instanceof Uint8Array)) {
+            throw new Error("that recorded file is no longer available");
+        }
+        return payload.bytes;
+    },
+};

package/dist/components/transcript/reader-context.d.ts

@@ -0,0 +1,13 @@
+import type { ReactNode } from "react";
+export declare const ReaderModeProvider: import("react").Provider<boolean>;
+/** True inside the reader: parts that open something draw as plain text. */
+export declare function useReaderMode(): boolean;
+export declare const MatchTermsProvider: import("react").Provider<readonly string[]>;
+/** The words the reader marks, lower-cased; none outside a reader. */
+export declare function useMatchTerms(): readonly string[];
+/** A query's words as the index matches them: each word on its own, a phrase
+ * in quotes as one. */
+export declare function matchTermsOf(query: string | null | undefined): readonly string[];
+/** Marks every term in a run of text. Strings are marked; anything already
+ * drawn (an image link) is kept as it is. */
+export declare function markTerms(content: ReactNode, terms: readonly string[]): ReactNode;

package/dist/components/transcript/reader-context.js

@@ -0,0 +1,55 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+// What the reader (PK3, `TranscriptReader`) tells the document it holds:
+// that it is read-only, and the words its search matched, marked where the
+// reply and the prompt say them. Only the reader provides either; the room
+// marks a landing by its line and never by its words, so with no provider
+// nothing here changes anything.
+import { createContext, Fragment, useContext } from "react";
+const ReaderModeContext = createContext(false);
+export const ReaderModeProvider = ReaderModeContext.Provider;
+/** True inside the reader: parts that open something draw as plain text. */
+export function useReaderMode() {
+    return useContext(ReaderModeContext);
+}
+const MatchTermsContext = createContext([]);
+export const MatchTermsProvider = MatchTermsContext.Provider;
+/** The words the reader marks, lower-cased; none outside a reader. */
+export function useMatchTerms() {
+    return useContext(MatchTermsContext);
+}
+/** A query's words as the index matches them: each word on its own, a phrase
+ * in quotes as one. */
+export function matchTermsOf(query) {
+    if (query === null || query === undefined)
+        return [];
+    const terms = [];
+    for (const match of query.matchAll(/"([^"]*)"|(\S+)/g)) {
+        const term = (match[1] ?? match[2] ?? "").replace(/"/g, "").trim().toLowerCase();
+        if (term !== "" && !terms.includes(term))
+            terms.push(term);
+    }
+    // The longest first, so a phrase wins over a word inside it.
+    return terms.sort((left, right) => right.length - left.length);
+}
+function escape(term) {
+    return term.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function markText(value, pattern) {
+    const parts = value.split(pattern);
+    if (parts.length === 1)
+        return value;
+    // split() with one capture group puts every match at an odd index.
+    return parts.map((part, at) => at % 2 === 1 ? _jsx("mark", { className: "tr-match", children: part }, at) : _jsx(Fragment, { children: part }, at));
+}
+/** Marks every term in a run of text. Strings are marked; anything already
+ * drawn (an image link) is kept as it is. */
+export function markTerms(content, terms) {
+    if (terms.length === 0)
+        return content;
+    const pattern = new RegExp(`(${terms.map(escape).join("|")})`, "gi");
+    if (typeof content === "string")
+        return markText(content, pattern);
+    if (!Array.isArray(content))
+        return content;
+    return content.map((part, at) => typeof part === "string" ? _jsx(Fragment, { children: markText(part, pattern) }, `m${at}`) : part);
+}

package/dist/components/transcript/reading-identity.d.ts

@@ -0,0 +1,2 @@
+import type { ReadingSitting } from "./activity-plan.js";
+export declare function retainReadingIdentity(previous: readonly ReadingSitting[], next: readonly ReadingSitting[]): ReadingSitting[];

package/dist/components/transcript/reading-identity.js

@@ -0,0 +1,52 @@
+import { activityRowKey } from "./activity-plan.js";
+/** Prefer the largest surviving overlap, with one owner per old key. Inserting
+ * older rows must not remount an existing sitting, fold, or attachment rail.
+ * Real splits/merges keep the best surviving owner; row disclosure state is
+ * independently keyed by canonical identity. No historical rows are retained. */
+function retainedKeys(previous, next) {
+    const owner = new Map();
+    for (const group of previous)
+        for (const row of group.rows)
+            owner.set(activityRowKey(row), group.key);
+    const matches = next.flatMap((group, index) => {
+        const counts = new Map();
+        for (const row of group.rows) {
+            const key = owner.get(activityRowKey(row));
+            if (key !== undefined)
+                counts.set(key, (counts.get(key) ?? 0) + 1);
+        }
+        return [...counts].map(([key, count]) => ({ index, key, count }));
+    }).sort((a, b) => b.count - a.count || a.index - b.index);
+    const assigned = new Map();
+    const used = new Set();
+    for (const match of matches) {
+        if (assigned.has(match.index) || used.has(match.key))
+            continue;
+        assigned.set(match.index, match.key);
+        used.add(match.key);
+    }
+    return next.map((group, index) => {
+        const saved = assigned.get(index);
+        if (saved !== undefined)
+            return saved;
+        let key = group.key;
+        while (used.has(key))
+            key += ":split";
+        used.add(key);
+        return key;
+    });
+}
+export function retainReadingIdentity(previous, next) {
+    const sittingKeys = retainedKeys(previous.map(x => ({ ...x.sitting, key: x.renderKey ?? x.sitting.key })), next.map(x => x.sitting));
+    return next.map(({ sitting, blocks }, index) => {
+        const old = previous.find(x => (x.renderKey ?? x.sitting.key) === sittingKeys[index]);
+        const groups = blocks.filter(block => block.kind === "activity");
+        const keys = retainedKeys(old?.blocks.filter(block => block.kind === "activity") ?? [], groups);
+        let groupIndex = 0;
+        return {
+            sitting,
+            renderKey: sittingKeys[index],
+            blocks: blocks.map(block => block.kind === "activity" ? { ...block, key: keys[groupIndex++] } : block),
+        };
+    });
+}

package/dist/components/transcript/scroll-to-row.d.ts

@@ -0,0 +1,2 @@
+/** Scroll only the transcript, never its overflow-hidden room ancestors. */
+export declare function scrollRowTo(scroller: HTMLElement, element: HTMLElement, block: "center" | "nearest"): void;

package/dist/components/transcript/scroll-to-row.js

@@ -0,0 +1,13 @@
+/** Scroll only the transcript, never its overflow-hidden room ancestors. */
+export function scrollRowTo(scroller, element, block) {
+    const frame = scroller.getBoundingClientRect();
+    const rect = element.getBoundingClientRect();
+    const top = rect.top - frame.top + scroller.scrollTop;
+    if (block === "center") {
+        scroller.scrollTop = top - Math.max(0, (scroller.clientHeight - rect.height) / 2);
+    }
+    else if (rect.top < frame.top)
+        scroller.scrollTop = top;
+    else if (rect.bottom > frame.bottom)
+        scroller.scrollTop = top - (scroller.clientHeight - rect.height);
+}