@vibefield/rosetta-room 0.0.0-stage → 0.1.0

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

@@ -0,0 +1,14 @@
+import type { SessionRow } from "@vibefield/rosetta-protocol";
+export interface ThreadFocus {
+    readonly sessionId: string;
+    readonly timelineId: string;
+}
+export interface ThreadIndex {
+    readonly byId: ReadonlyMap<string, SessionRow>;
+    readonly childrenByParent: ReadonlyMap<string, readonly SessionRow[]>;
+}
+export declare function buildThreadIndex(sessions: readonly SessionRow[]): ThreadIndex;
+export declare function sessionContains(ancestorId: string, candidateId: string, sessions: ReadonlyMap<string, SessionRow>): boolean;
+/** The element id a row's element carries. Search results land on it. */
+export declare function messageDomId(sessionId: string, timelineId: string): string;
+export declare function subthreadTitle(session: SessionRow): string;

package/dist/components/transcript/thread-index.js

@@ -0,0 +1,40 @@
+export function buildThreadIndex(sessions) {
+    const byId = new Map(sessions.map((session) => [session.id, session]));
+    const childrenByParent = new Map();
+    for (const session of sessions) {
+        if (session.parent_session_id === null)
+            continue;
+        const children = childrenByParent.get(session.parent_session_id);
+        if (children)
+            children.push(session);
+        else
+            childrenByParent.set(session.parent_session_id, [session]);
+    }
+    for (const children of childrenByParent.values()) {
+        children.sort((left, right) => left.started_at - right.started_at || left.id.localeCompare(right.id));
+    }
+    return { byId, childrenByParent };
+}
+export function sessionContains(ancestorId, candidateId, sessions) {
+    let current = candidateId;
+    const visited = new Set();
+    while (current !== null && !visited.has(current)) {
+        if (current === ancestorId)
+            return true;
+        visited.add(current);
+        current = sessions.get(current)?.parent_session_id ?? null;
+    }
+    return false;
+}
+/** The element id a row's element carries. Search results land on it. */
+export function messageDomId(sessionId, timelineId) {
+    return `msg-${sessionId}-${timelineId}`;
+}
+export function subthreadTitle(session) {
+    if (session.title !== null)
+        return session.title;
+    if (session.summary !== null)
+        return session.summary;
+    const native = session.native_session_id.split("/").at(-1) ?? session.native_session_id;
+    return `Subagent ${native.length > 12 ? native.slice(-12) : native}`;
+}

package/dist/components/transcript/thread-navigation.d.ts

@@ -0,0 +1,5 @@
+/** Deep workers open at the column's full measure instead of adding rails. */
+export declare const ThreadNavigationContext: import("react").Context<{
+    readonly depth: number;
+    readonly open: ((sessionId: string) => void) | null;
+}>;

package/dist/components/transcript/thread-navigation.js

@@ -0,0 +1,3 @@
+import { createContext } from "react";
+/** Deep workers open at the column's full measure instead of adding rails. */
+export const ThreadNavigationContext = createContext({ depth: 0, open: null });

package/dist/components/transcript/timeline-meta-file-source.d.ts

@@ -0,0 +1,6 @@
+import type { TimelineMetaArtifact, TimelineMetaPlan } from "@vibefield/rosetta-protocol";
+import type { SessionLeases } from "../../lib/session-leases.js";
+import type { FileHandle, FileSource } from "../file-viewer/index.js";
+export declare function handleForTimelineMetaPlan(sessions: SessionLeases, sessionId: string, plan: TimelineMetaPlan): Promise<FileHandle>;
+export declare function handleForTimelineMetaArtifact(sessions: SessionLeases, sessionId: string, artifact: TimelineMetaArtifact): Promise<FileHandle>;
+export declare const timelineMetaFileSource: FileSource;

package/dist/components/transcript/timeline-meta-file-source.js

@@ -0,0 +1,55 @@
+// Lazy timeline_meta resources through the room's shared file viewer.
+// The metadata frame carries only safe canonical references; bytes are read
+// after the reader presses a plan or artifact row and then ride on the handle
+// so the viewer never repeats a mutable filesystem read.
+import { resolveKind } from "../file-viewer/index.js";
+const EXTENSION_BY_MEDIA_TYPE = new Map([
+    ["image/png", "png"],
+    ["image/jpeg", "jpg"],
+    ["image/gif", "gif"],
+    ["image/webp", "webp"],
+    ["image/avif", "avif"],
+    ["image/svg+xml", "svg"],
+    ["application/json", "json"],
+    ["text/markdown", "md"],
+    ["text/plain", "txt"],
+]);
+function nameWithType(name, mediaType) {
+    if (resolveKind(name).viewer.id !== "binary" || mediaType === null)
+        return name;
+    const extension = EXTENSION_BY_MEDIA_TYPE.get(mediaType.toLowerCase());
+    return extension === undefined ? name : `${name}.${extension}`;
+}
+function handle(key, name, path, bytes) {
+    return {
+        key,
+        name,
+        path,
+        size: bytes.byteLength,
+        ref: { type: "timeline-meta-file", bytes },
+    };
+}
+export async function handleForTimelineMetaPlan(sessions, sessionId, plan) {
+    const bytes = await sessions.run(sessionId, (client) => client.readPlan(sessionId, plan.source));
+    return handle(`timeline-meta:plan:${sessionId}:${plan.id}`, plan.name, null, bytes);
+}
+export async function handleForTimelineMetaArtifact(sessions, sessionId, artifact) {
+    const source = artifact.source;
+    if (source.type === "timeline_file") {
+        const bytes = await sessions.run(sessionId, (client) => client.readFileTarget(sessionId, source.timeline_id, source.target_index));
+        return handle(`timeline-meta:artifact:${sessionId}:${artifact.id}`, nameWithType(artifact.name, artifact.media_type), source.path, bytes);
+    }
+    const bytes = await sessions.run(sessionId, (client) => client.readAsset(source.asset));
+    return handle(`timeline-meta:artifact:${sessionId}:${artifact.id}`, nameWithType(artifact.name, artifact.media_type ?? source.asset.media_type), null, bytes);
+}
+export const timelineMetaFileSource = {
+    async read(file, signal) {
+        if (signal.aborted)
+            throw new DOMException("the file open was cancelled", "AbortError");
+        const payload = file.ref;
+        if (payload?.type !== "timeline-meta-file" || !(payload.bytes instanceof Uint8Array)) {
+            throw new Error("that timeline resource is no longer available");
+        }
+        return payload.bytes;
+    },
+};

package/dist/components/transcript/timeline-meta-state.d.ts

@@ -0,0 +1,12 @@
+import type { TimelineMeta, TimelineMetaTask, TimelineMetaWorkflow } from "@vibefield/rosetta-protocol";
+export declare const TIMELINE_META_KINDS: readonly ["tasks", "workflows", "plans", "artifacts"];
+export type TimelineMetaKind = (typeof TIMELINE_META_KINDS)[number];
+/** Archived running states do not prove work continued until the wall clock. */
+export declare function recordedTaskDuration(task: TimelineMetaTask): number | null;
+export declare function recordedWorkflowDuration(workflow: TimelineMetaWorkflow): number | null;
+/** Empty categories are not navigation: keep both their launcher and tab out
+ * of the focus order, and omit the entire control when the session has none. */
+export declare function availableTimelineMetaKinds(meta: TimelineMeta): TimelineMetaKind[];
+/** Live replacement frames can remove the open category. Keep the island on
+ * the first remaining category; close it only when no session work remains. */
+export declare function resolveTimelineMetaKind(active: TimelineMetaKind | null, available: readonly TimelineMetaKind[]): TimelineMetaKind | null;

package/dist/components/transcript/timeline-meta-state.js

@@ -0,0 +1,24 @@
+export const TIMELINE_META_KINDS = ["tasks", "workflows", "plans", "artifacts"];
+/** Archived running states do not prove work continued until the wall clock. */
+export function recordedTaskDuration(task) {
+    if (task.status === "in_progress" || task.started_at === null || task.terminal_at === null)
+        return null;
+    const duration = task.terminal_at - task.started_at;
+    return Number.isFinite(duration) && duration >= 0 ? duration : null;
+}
+export function recordedWorkflowDuration(workflow) {
+    const duration = workflow.duration_ms;
+    return duration !== null && Number.isFinite(duration) && duration >= 0 ? duration : null;
+}
+/** Empty categories are not navigation: keep both their launcher and tab out
+ * of the focus order, and omit the entire control when the session has none. */
+export function availableTimelineMetaKinds(meta) {
+    return TIMELINE_META_KINDS.filter((kind) => (meta[kind] ?? []).length > 0);
+}
+/** Live replacement frames can remove the open category. Keep the island on
+ * the first remaining category; close it only when no session work remains. */
+export function resolveTimelineMetaKind(active, available) {
+    if (active === null || available.includes(active))
+        return active;
+    return available[0] ?? null;
+}

package/dist/components/ui/ColumnHeading.d.ts

@@ -0,0 +1,27 @@
+export interface ColumnHeadingProps {
+    /** What this column is showing. Truncates with an ellipsis; the head keeps
+     * its band whatever the name's length. */
+    readonly name: string;
+    /**
+     * The §2.6 accent for the marker. `null` leaves the marker to inherit
+     * whatever `--tint` the surrounding surface sets — which is not the same
+     * as "no tint", and is how a head inside an already-tinted panel avoids
+     * naming the same colour twice.
+     */
+    readonly tint?: string | null;
+    /** A fact about the name, so it travels WITH it rather than sitting at the
+     * far end of the band. Omitted when the column has no honest count. */
+    readonly count?: number | null;
+    /** What the count counts, for its tooltip. */
+    readonly countTitle?: string | undefined;
+    /** Ids — paths, branches, shas — set in mono. The head keeps its size and
+     * weight; only the face changes. */
+    readonly mono?: boolean;
+    /**
+     * The name's tooltip. Defaults to the name, which is right whenever the
+     * name is the whole truth; pass the longer form when the head shows an
+     * abbreviation, or `null` for a name that needs no second telling.
+     */
+    readonly title?: string | null | undefined;
+}
+export declare function ColumnHeading({ name, tint, count, countTitle, mono, title, }: ColumnHeadingProps): import("react").JSX.Element;

package/dist/components/ui/ColumnHeading.js

@@ -0,0 +1,7 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+export function ColumnHeading({ name, tint = null, count = null, countTitle, mono = false, title, }) {
+    // `undefined` means "not specified", which is different from an explicit
+    // `null` asking for no tooltip at all.
+    const nameTitle = title === undefined ? name : title;
+    return (_jsxs("div", { className: "ah-colhead", children: [_jsx("i", { style: tint !== null ? { "--tint": tint } : undefined }), _jsx("strong", { className: mono ? "ah-idname" : undefined, title: nameTitle ?? undefined, children: name }), count !== null && (_jsx("span", { className: "ah-bubble", title: countTitle, children: count }))] }));
+}

package/dist/components/ui/ConfirmDialog.d.ts

@@ -0,0 +1,14 @@
+import type { ReactNode } from "react";
+export interface ConfirmDialogProps {
+    /** `null` when nothing is being asked. */
+    readonly question: {
+        readonly title: string;
+        readonly body: ReactNode;
+        /** What the confirming button says — a verb, not "OK". */
+        readonly confirm: string;
+        readonly destructive?: boolean;
+    } | null;
+    readonly onConfirm: () => void;
+    readonly onCancel: () => void;
+}
+export declare function ConfirmDialog({ question, onConfirm, onCancel }: ConfirmDialogProps): import("react").JSX.Element | null;

package/dist/components/ui/ConfirmDialog.js

@@ -0,0 +1,22 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+// The one thing this room asks before doing.
+//
+// Reading history needs no confirmation and never gets one. Discarding a
+// file does: it destroys work that exists nowhere else, and git keeps no
+// reflog for a working-tree change. So the act names what it will destroy
+// and waits — which is the difference between a tool and a trap.
+//
+// Same material as the file viewer, one size down: this is the only other
+// thing in the room that covers it.
+import * as Dialog from "@radix-ui/react-dialog";
+import { useRoomOverlay, useRoomPortal } from "../../room-context.js";
+export function ConfirmDialog({ question, onConfirm, onCancel }) {
+    useRoomOverlay(question !== null);
+    const container = useRoomPortal();
+    if (question === null)
+        return null;
+    return (_jsx(Dialog.Root, { open: true, onOpenChange: (open) => !open && onCancel(), children: _jsxs(Dialog.Portal, { container: container, children: [_jsx(Dialog.Overlay, { className: "ah-layer ah-fileview__backdrop", "data-ah-fileview": true }), _jsxs(Dialog.Content, { className: "ah-layer ah-confirm", "aria-describedby": undefined, children: [_jsx(Dialog.Title, { className: "ah-confirm__title", children: question.title }), _jsx("div", { className: "ah-confirm__body", children: question.body }), _jsxs("div", { className: "ah-confirm__acts", children: [_jsx("button", { type: "button", className: "ah-confirm__cancel", onClick: onCancel, children: "Cancel" }), _jsx("button", { type: "button", className: "ah-confirm__go", "data-destructive": question.destructive === true ? "" : undefined, 
+                                    // The destructive act does NOT take focus on open: a reader who
+                                    // opens this and hits Return should cancel, not destroy.
+                                    onClick: onConfirm, children: question.confirm })] })] })] }) }));
+}

package/dist/components/ui/DialogShell.d.ts

@@ -0,0 +1,18 @@
+import type { KeyboardEventHandler, ReactNode } from "react";
+export interface DialogShellProps {
+    /** The accessible name. Rendered for screen readers only — the visible
+     * band beside it is the sighted reader's version of the same fact. */
+    readonly title: string;
+    readonly onClose: () => void;
+    /** Wider than the default, for a surface that holds two panes. */
+    readonly wide?: boolean;
+    /** Fill the application viewport while preserving the dialog's focus and
+     * accessibility mechanics. */
+    readonly fullscreen?: boolean;
+    /** In fullscreen, the first Escape restores the dialog instead of closing
+     * it. */
+    readonly onExitFullscreen?: () => void;
+    readonly onKeyDown?: KeyboardEventHandler<HTMLDivElement> | undefined;
+    readonly children: ReactNode;
+}
+export declare function DialogShell({ title, onClose, wide, fullscreen, onExitFullscreen, onKeyDown, children, }: DialogShellProps): import("react").JSX.Element;

package/dist/components/ui/DialogShell.js

@@ -0,0 +1,40 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+// The one modal surface this room has, and the only place its mechanics live.
+//
+// Two things open over the room now — one file, and one commit — and they
+// must be the same object to the reader: same material, same backdrop, same
+// receding stage, same Escape. Sharing the chrome is how that stays true
+// without either surface remembering to match the other.
+//
+// Radix owns what a modal must not get wrong: focus trap, focus restore,
+// Escape, scroll lock, `aria-modal`, the portal.
+import * as Dialog from "@radix-ui/react-dialog";
+import { useRef } from "react";
+import { useRoomOverlay, useRoomPortal } from "../../room-context.js";
+export function DialogShell({ title, onClose, wide = false, fullscreen = false, onExitFullscreen, onKeyDown, children, }) {
+    // These controlled dialogs have no Radix Trigger. Remember the actual
+    // opener so closing a message returns to its preview without scrolling.
+    const opener = useRef(document.activeElement instanceof HTMLElement ? document.activeElement : null);
+    // The room's root recedes while this is open; the dialog lands where the
+    // host asked the room's layers to go.
+    useRoomOverlay(true);
+    const container = useRoomPortal();
+    return (_jsx(Dialog.Root, { open: true, onOpenChange: (open) => !open && onClose(), children: _jsxs(Dialog.Portal, { container: container, children: [_jsx(Dialog.Overlay, { className: "ah-layer ah-fileview__backdrop", "data-ah-fileview": true }), _jsxs(Dialog.Content, { className: "ah-layer ah-fileview", "data-wide": wide ? "" : undefined, "data-fullscreen": fullscreen ? "" : undefined, "aria-describedby": undefined, onKeyDown: onKeyDown, 
+                    // Radix focuses the first tabbable child, which lights a focus ring
+                    // on a control nobody pressed. The dialog itself takes focus
+                    // instead — Escape and the focus trap still work, and Tab still
+                    // walks in.
+                    onOpenAutoFocus: (event) => {
+                        event.preventDefault();
+                        event.currentTarget?.focus();
+                    }, onCloseAutoFocus: (event) => {
+                        event.preventDefault();
+                        if (opener.current?.isConnected)
+                            opener.current.focus({ preventScroll: true });
+                    }, onEscapeKeyDown: (event) => {
+                        if (!fullscreen)
+                            return;
+                        event.preventDefault();
+                        onExitFullscreen?.();
+                    }, children: [_jsx(Dialog.Title, { className: "ah-visually-hidden", children: title }), children] })] }) }));
+}

package/dist/components/ui/EmptyState.d.ts

@@ -0,0 +1,10 @@
+import type { CSSProperties, ReactNode } from "react";
+export interface EmptyStateProps {
+    readonly title: ReactNode;
+    readonly description: ReactNode;
+    readonly children?: ReactNode;
+    readonly className?: string;
+    readonly style?: CSSProperties;
+}
+/** Consistent empty-state copy and spacing for room columns and lists. */
+export declare function EmptyState({ title, description, children, className, style, }: EmptyStateProps): import("react").JSX.Element;

package/dist/components/ui/EmptyState.js

@@ -0,0 +1,6 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/** Consistent empty-state copy and spacing for room columns and lists. */
+export function EmptyState({ title, description, children, className, style, }) {
+    const classes = className ? `ah-empty ${className}` : "ah-empty";
+    return (_jsxs("div", { className: classes, style: style, children: [children, _jsx("strong", { children: title }), _jsx("p", { children: description })] }));
+}

package/dist/components/ui/ListSummaryHeader.d.ts

@@ -0,0 +1,9 @@
+import type { ReactNode } from "react";
+export interface ListSummaryHeaderProps {
+    readonly label: ReactNode;
+    readonly count: number;
+    readonly singularNoun: string;
+    readonly pluralNoun?: string;
+}
+/** Compact replacement for an expanded summary panel while a list is filtered. */
+export declare function ListSummaryHeader({ label, count, singularNoun, pluralNoun, }: ListSummaryHeaderProps): import("react").JSX.Element;

package/dist/components/ui/ListSummaryHeader.js

@@ -0,0 +1,6 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/** Compact replacement for an expanded summary panel while a list is filtered. */
+export function ListSummaryHeader({ label, count, singularNoun, pluralNoun = `${singularNoun}s`, }) {
+    const noun = count === 1 ? singularNoun : pluralNoun;
+    return (_jsx("div", { className: "ah-meta", children: _jsxs("div", { className: "ah-meta__head", children: [_jsx("span", { className: "ah-eyebrow", children: label }), _jsxs("span", { className: "ah-caption tnum", children: [count, " ", noun] })] }) }));
+}

package/dist/components/ui/ListToolbar.d.ts

@@ -0,0 +1,6 @@
+import type { ReactNode } from "react";
+export interface ListToolbarProps {
+    readonly children: ReactNode;
+}
+/** Controls bar above a scrollable column list. */
+export declare function ListToolbar({ children }: ListToolbarProps): import("react").JSX.Element;

package/dist/components/ui/ListToolbar.js

@@ -0,0 +1,5 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/** Controls bar above a scrollable column list. */
+export function ListToolbar({ children }) {
+    return (_jsx("div", { className: "ah-listbar", children: children }));
+}

package/dist/components/ui/ResultGroupHeader.d.ts

@@ -0,0 +1,9 @@
+import type { ReactNode } from "react";
+export interface ResultGroupHeaderProps {
+    readonly label: ReactNode;
+    readonly count: number;
+    readonly tint: string;
+    readonly countLabel?: string;
+}
+/** Header for one grouped set of search results. */
+export declare function ResultGroupHeader({ label, count, tint, countLabel, }: ResultGroupHeaderProps): import("react").JSX.Element;

package/dist/components/ui/ResultGroupHeader.js

@@ -0,0 +1,5 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/** Header for one grouped set of search results. */
+export function ResultGroupHeader({ label, count, tint, countLabel, }) {
+    return (_jsxs("div", { className: "ah-group", style: { "--tint": tint }, children: [_jsx("i", { "aria-hidden": "true" }), label, _jsx("span", { className: "ah-hitcount", "aria-label": countLabel ?? `${count} ${count === 1 ? "result" : "results"}`, children: count })] }));
+}

package/dist/components/ui/SegmentedControl.d.ts

@@ -0,0 +1,16 @@
+import type { ReactNode } from "react";
+export interface SegmentedControlOption<Value extends string> {
+    readonly value: Value;
+    readonly label: ReactNode;
+    readonly accessibleLabel?: string;
+    readonly disabled?: boolean;
+}
+export interface SegmentedControlProps<Value extends string> {
+    readonly value: Value;
+    readonly options: readonly SegmentedControlOption<Value>[];
+    readonly accessibleLabel: string;
+    readonly onValueChange: (value: Value) => void;
+    readonly className?: string;
+}
+/** A controlled, mutually exclusive group of pressed buttons. */
+export declare function SegmentedControl<Value extends string>({ value, options, accessibleLabel, onValueChange, className, }: SegmentedControlProps<Value>): import("react").JSX.Element;

package/dist/components/ui/SegmentedControl.js

@@ -0,0 +1,9 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/** A controlled, mutually exclusive group of pressed buttons. */
+export function SegmentedControl({ value, options, accessibleLabel, onValueChange, className, }) {
+    const classes = className ? `ah-seg ${className}` : "ah-seg";
+    return (_jsx("div", { className: classes, role: "group", "aria-label": accessibleLabel, children: options.map((option) => {
+            const isSelected = option.value === value;
+            return (_jsx("button", { type: "button", className: isSelected ? "is-on" : "", "aria-label": option.accessibleLabel, "aria-pressed": isSelected, disabled: option.disabled, onClick: () => onValueChange(option.value), children: option.label }, option.value));
+        }) }));
+}

package/dist/components/ui/SummaryMetric.d.ts

@@ -0,0 +1,13 @@
+export interface SummaryMetricProps {
+    readonly label: string;
+    readonly value: number | null;
+    /** Currency values arrive in micro-USD, as they do everywhere in the app. */
+    readonly unit?: "number" | "usd";
+    readonly estimated?: boolean;
+    readonly lowerBound?: boolean;
+    readonly unknown?: boolean;
+    readonly emptyValue?: string;
+    readonly title?: string;
+}
+/** Every summary figure shares the same digits, unit, and coverage slots. */
+export declare function SummaryMetric({ label, value, unit, estimated, lowerBound, unknown, emptyValue, title, }: SummaryMetricProps): import("react").JSX.Element;

package/dist/components/ui/SummaryMetric.js

@@ -0,0 +1,10 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { fmtCompactNumber } from "../../lib/format.js";
+import { fmtUsd } from "../../lib/spend.js";
+/** Every summary figure shares the same digits, unit, and coverage slots. */
+export function SummaryMetric({ label, value, unit = "number", estimated = false, lowerBound = false, unknown = false, emptyValue = "—", title, }) {
+    const figure = unknown || value === null ? null
+        : unit === "usd" ? fmtUsd(value) : fmtCompactNumber(value);
+    const description = unknown ? `Loading ${label}…` : title;
+    return (_jsxs("div", { className: "ah-stat", title: description, role: "group", "aria-label": description ?? label, children: [_jsxs("b", { children: [figure === null ? unknown ? "—" : emptyValue : `${estimated ? "~" : ""}${figure.n}`, figure !== null && (figure.u || lowerBound) && (_jsx("small", { children: `${figure.u}${lowerBound ? "+" : ""}` }))] }), _jsx("span", { children: label })] }));
+}

package/dist/components/ui/Veil.d.ts

@@ -0,0 +1,7 @@
+export interface VeilProps {
+    /** One label line, e.g. "preparing · 2,314 of 5,912 sessions". */
+    readonly label: string;
+    /** 0..1 fills the meter; null renders the meter idling at a sliver. */
+    readonly progress: number | null;
+}
+export declare function Veil({ label, progress }: VeilProps): import("react").JSX.Element;

package/dist/components/ui/Veil.js

@@ -0,0 +1,5 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+export function Veil({ label, progress }) {
+    const width = progress === null ? "8%" : `${Math.min(100, Math.max(2, progress * 100)).toFixed(1)}%`;
+    return (_jsxs("div", { className: "ah-veil", role: "status", "aria-label": label, children: [_jsx("div", { className: "ah-meter", children: _jsx("i", { style: { width } }) }), _jsx("span", { className: "ah-veil__label", children: label })] }));
+}

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

@@ -0,0 +1,20 @@
+export { ColumnHeading } from "./ColumnHeading.js";
+export type { ColumnHeadingProps } from "./ColumnHeading.js";
+export { ConfirmDialog } from "./ConfirmDialog.js";
+export type { ConfirmDialogProps } from "./ConfirmDialog.js";
+export { DialogShell } from "./DialogShell.js";
+export type { DialogShellProps } from "./DialogShell.js";
+export { EmptyState } from "./EmptyState.js";
+export type { EmptyStateProps } from "./EmptyState.js";
+export { ListSummaryHeader } from "./ListSummaryHeader.js";
+export type { ListSummaryHeaderProps } from "./ListSummaryHeader.js";
+export { ListToolbar } from "./ListToolbar.js";
+export type { ListToolbarProps } from "./ListToolbar.js";
+export { SummaryMetric } from "./SummaryMetric.js";
+export type { SummaryMetricProps } from "./SummaryMetric.js";
+export { ResultGroupHeader } from "./ResultGroupHeader.js";
+export type { ResultGroupHeaderProps } from "./ResultGroupHeader.js";
+export { SegmentedControl } from "./SegmentedControl.js";
+export type { SegmentedControlOption, SegmentedControlProps, } from "./SegmentedControl.js";
+export { Veil } from "./Veil.js";
+export type { VeilProps } from "./Veil.js";

package/dist/components/ui/index.js

@@ -0,0 +1,10 @@
+export { ColumnHeading } from "./ColumnHeading.js";
+export { ConfirmDialog } from "./ConfirmDialog.js";
+export { DialogShell } from "./DialogShell.js";
+export { EmptyState } from "./EmptyState.js";
+export { ListSummaryHeader } from "./ListSummaryHeader.js";
+export { ListToolbar } from "./ListToolbar.js";
+export { SummaryMetric } from "./SummaryMetric.js";
+export { ResultGroupHeader } from "./ResultGroupHeader.js";
+export { SegmentedControl } from "./SegmentedControl.js";
+export { Veil } from "./Veil.js";

package/dist/components/worktree/WorktreeColumn.d.ts

@@ -0,0 +1,22 @@
+import type { RoomFolder, RoomMenu } from "../../host-inputs.js";
+export interface WorktreeColumnProps {
+    /** The selected project's first root path, from rosettad. */
+    readonly projectRoot: string | null;
+    /** The project's §2.6 accent, following it across the room. */
+    readonly tint: string | null;
+    readonly homeDirectory: string | null;
+    /** Paths the open session touched, workspace-relative. */
+    readonly sessionPaths: ReadonlySet<string>;
+    readonly currentTimestamp: number;
+    /** The room's receipt line, so an act is never silent. */
+    readonly onReceipt: (text: string) => void;
+    readonly requestError: string | null;
+    readonly onRetry: () => void;
+    /** R6: the host's folders — the head becomes their dropdown, and a folder
+     * the host marks elsewhere draws its honest state instead of opening. */
+    readonly folders?: {
+        readonly menu: RoomMenu;
+        readonly shown: RoomFolder | null;
+    } | null | undefined;
+}
+export declare function WorktreeColumn({ projectRoot, tint, homeDirectory, sessionPaths, currentTimestamp, onReceipt, requestError, onRetry, folders, }: WorktreeColumnProps): import("react").JSX.Element;