@vibefield/rosetta-room 0.0.0-stage → 0.1.0

package/dist/components/git/co-author.js

@@ -0,0 +1,55 @@
+// Which agent a `Co-authored-by` trailer names.
+//
+// A trailer is free text someone's tool wrote, so this is recognition, not
+// lookup: it matches the addresses and names the coding agents actually sign
+// with, and answers `null` for anything it does not know. A wrong mark is
+// worse than no mark — it would attribute a person's commit to a machine —
+// so every rule here is a match on something an agent puts there on purpose,
+// never a guess from a name that merely looks automated.
+/** Ordered: the first match wins, so the specific addresses come before the
+ * looser name patterns. */
+const RULES = [
+    { kind: "claude-code", email: /@anthropic\.com$/ },
+    { kind: "claude-code", name: /\bclaude\b/ },
+    { kind: "codex", email: /^codex@|chatgpt@/ },
+    { kind: "codex", name: /\bcodex\b/ },
+    { kind: "cursor", email: /@cursor\.(com|sh)$/, },
+    { kind: "cursor", name: /\bcursor\b/ },
+    { kind: "github-copilot", email: /copilot@/ },
+    { kind: "github-copilot", name: /\bcopilot\b/ },
+    { kind: "gemini-cli", name: /\bgemini\b/ },
+    { kind: "opencode", name: /\bopencode\b/ },
+    { kind: "amp", email: /@ampcode\.com$/ },
+    { kind: "windsurf", name: /\bwindsurf\b/ },
+    { kind: "cline", name: /\bcline\b/ },
+    { kind: "grok", name: /\bgrok\b/ },
+    { kind: "kimi-code", name: /\bkimi\b/ },
+    { kind: "antigravity", name: /\bantigravity\b/ },
+    { kind: "devin", email: /@devin\.ai$/ },
+];
+/** The runtime kind this co-author is, or `null` when nothing recognises it —
+ * which is how a human co-author stays a human. */
+export function agentKindOf(author) {
+    const email = (author.email ?? "").toLowerCase();
+    const name = author.name.toLowerCase();
+    for (const rule of RULES) {
+        if (rule.email !== undefined && email !== "" && rule.email.test(email))
+            return rule.kind;
+        if (rule.name !== undefined && rule.name.test(name))
+            return rule.kind;
+    }
+    return null;
+}
+/** The agents credited on a commit, deduplicated by kind and in trailer
+ * order. Two trailers for one agent is one mark, because the row is saying
+ * WHICH agent, not how many times it signed. */
+export function creditedAgents(coAuthors) {
+    const seen = new Map();
+    for (const author of coAuthors) {
+        const kind = agentKindOf(author);
+        if (kind === null || seen.has(kind))
+            continue;
+        seen.set(kind, { kind, label: author.name });
+    }
+    return [...seen.values()];
+}

package/dist/components/git/git-file-source.d.ts

@@ -0,0 +1,18 @@
+import type { FileHandle, FileSource } from "../file-viewer/index.js";
+import type { DiffRequest, GitClient } from "./types.js";
+/** A handle for one side of one file's change. */
+export declare function diffHandle(request: DiffRequest, options: {
+    readonly root: string;
+    readonly label: string;
+}): FileHandle;
+/** Which side this handle is a view of, for the dialog's caption. */
+export declare function diffSideLabel(request: DiffRequest): string;
+/**
+ * A `FileSource` that answers with diffs.
+ *
+ * `read` is never called — every kind this source serves declares the
+ * `compare` payload — but the contract requires it, and throwing names the
+ * mistake rather than returning empty bytes that would render as a blank
+ * file.
+ */
+export declare function createGitFileSource(client: GitClient): FileSource;

package/dist/components/git/git-file-source.js

@@ -0,0 +1,53 @@
+// The adapter between the git column and the file viewer — the only file that
+// knows both what a `GitClient` is and what a `FileSource` is.
+//
+// The viewer shows one file. A diff is one file with two versions, so the
+// same dialog serves both: the column hands it a handle whose `ref` names the
+// side of the index to diff against, and the viewer neither knows nor asks
+// where the text came from.
+const isGitRef = (value) => value !== null && typeof value === "object" && "request" in value;
+/** A handle for one side of one file's change. */
+export function diffHandle(request, options) {
+    const name = request.path.slice(request.path.lastIndexOf("/") + 1);
+    return {
+        // The side is part of the identity: the staged and unstaged halves of one
+        // file are two different documents, and switching between them must
+        // remount rather than reuse the last read.
+        key: `${options.root}#${request.sha ?? (request.staged === true ? "index" : "worktree")}#${request.path}`,
+        name,
+        path: `${options.root}/${request.path}`,
+        // A diff's size is not the file's size, and the viewer's byte limits are
+        // about what it must decode. git's output is bounded host-side.
+        size: 0,
+        ref: { request },
+    };
+}
+/** Which side this handle is a view of, for the dialog's caption. */
+export function diffSideLabel(request) {
+    if (request.sha !== undefined)
+        return request.sha.slice(0, 7);
+    return request.staged === true ? "staged" : "unstaged";
+}
+/**
+ * A `FileSource` that answers with diffs.
+ *
+ * `read` is never called — every kind this source serves declares the
+ * `compare` payload — but the contract requires it, and throwing names the
+ * mistake rather than returning empty bytes that would render as a blank
+ * file.
+ */
+export function createGitFileSource(client) {
+    return {
+        read() {
+            return Promise.reject(new Error("a diff is read through compare(), not read()"));
+        },
+        async compare(handle) {
+            if (!isGitRef(handle.ref))
+                throw new Error("that file is no longer in the change set");
+            const answer = await client.diff(handle.ref.request);
+            if (answer.error !== null)
+                throw new Error(answer.error);
+            return { unified: answer.text };
+        },
+    };
+}

package/dist/components/git/git-host.d.ts

@@ -0,0 +1,24 @@
+import type { GitClient } from "./types.js";
+export interface GitConnection {
+    readonly client: GitClient;
+    /** The root the process behind this client is serving. */
+    readonly root: string;
+    readonly generation: number;
+    dispose(): void;
+}
+/** Connect the git half only after `worktree-host` has accepted the paired
+ * generation. Disposal closes the port and rejects every pending request. */
+export declare function connectGitClient(port: MessagePort, root: string, generation: number): GitConnection;
+export type Refresh = () => void;
+/**
+ * Poll one read off a client.
+ *
+ * `read` must be stable. The value is `null` until the first answer, and a
+ * failed read keeps the last good value rather than blanking the column —
+ * a repository mid-rebase answers nothing for a moment, and that is not a
+ * reason to tell the reader their work disappeared.
+ */
+export declare function useGitRead<T>(connection: GitConnection | null, read: (client: GitClient) => Promise<T>, refreshKey: number): {
+    value: T | null;
+    refresh: Refresh;
+};

package/dist/components/git/git-host.js

@@ -0,0 +1,130 @@
+// The renderer's git client over the git half of a paired worktree
+// connection. Port ownership and generation arbitration live in
+// `worktree-host`; this module only turns one already-accepted port into a
+// disposable request/response client.
+import { useCallback, useEffect, useState } from "react";
+/** A read that has not been asked for in this long is asked again. Slow on
+ * purpose: this is a repository someone else is editing, and the room is a
+ * reader that must not turn into a poller. */
+const POLL_MS = 4_000;
+/** A `GitClient` over one port. Requests are correlated by id; the port has a
+ * single consumer, so the id space is local and monotonic. */
+function connect(port) {
+    let nextId = 0;
+    let disposed = false;
+    const waiting = new Map();
+    const onMessage = (event) => {
+        const reply = event.data;
+        if (typeof reply?.id !== "number")
+            return;
+        const settle = waiting.get(reply.id);
+        if (settle === undefined)
+            return;
+        waiting.delete(reply.id);
+        if (reply.ok === true)
+            settle.resolve(reply.value);
+        else
+            settle.reject(new Error(reply.error ?? "the git command failed"));
+    };
+    const rejectWaiting = (message) => {
+        const error = new Error(message);
+        for (const request of waiting.values())
+            request.reject(error);
+        waiting.clear();
+    };
+    const onMessageError = () => rejectWaiting("the git connection closed");
+    port.addEventListener("message", onMessage);
+    port.addEventListener("messageerror", onMessageError);
+    port.start();
+    const call = (op, args) => new Promise((resolve, reject) => {
+        if (disposed) {
+            reject(new Error("the git connection closed"));
+            return;
+        }
+        const id = (nextId += 1);
+        waiting.set(id, {
+            resolve: (value) => resolve(value),
+            reject,
+        });
+        try {
+            port.postMessage({ id, op, args });
+        }
+        catch (error) {
+            waiting.delete(id);
+            reject(error instanceof Error ? error : new Error("the git connection closed"));
+        }
+    });
+    const client = {
+        branch: () => call("branch"),
+        status: () => call("status"),
+        log: () => call("log"),
+        diff: (request) => call("diff", request),
+        commitFiles: (sha) => call("commitFiles", sha),
+        stage: (paths) => call("stage", paths),
+        unstage: (paths) => call("unstage", paths),
+        discard: (paths) => call("discard", paths),
+    };
+    return {
+        client,
+        dispose: () => {
+            if (disposed)
+                return;
+            disposed = true;
+            port.removeEventListener("message", onMessage);
+            port.removeEventListener("messageerror", onMessageError);
+            rejectWaiting("the git connection closed");
+            port.close();
+        },
+    };
+}
+/** Connect the git half only after `worktree-host` has accepted the paired
+ * generation. Disposal closes the port and rejects every pending request. */
+export function connectGitClient(port, root, generation) {
+    const connected = connect(port);
+    return {
+        client: connected.client,
+        root,
+        generation,
+        dispose: connected.dispose,
+    };
+}
+/**
+ * Poll one read off a client.
+ *
+ * `read` must be stable. The value is `null` until the first answer, and a
+ * failed read keeps the last good value rather than blanking the column —
+ * a repository mid-rebase answers nothing for a moment, and that is not a
+ * reason to tell the reader their work disappeared.
+ */
+export function useGitRead(connection, read, refreshKey) {
+    const [value, setValue] = useState(null);
+    const [tick, setTick] = useState(0);
+    const refresh = useCallback(() => setTick((n) => n + 1), []);
+    useEffect(() => {
+        if (connection === null) {
+            setValue(null);
+            return;
+        }
+        let cancelled = false;
+        const run = () => {
+            void read(connection.client)
+                .then((next) => {
+                if (!cancelled)
+                    setValue(next);
+            })
+                .catch(() => {
+                // A read that failed is not news the column can act on; the next
+                // tick will try again, and the last good answer stays on screen.
+            });
+        };
+        run();
+        const timer = window.setInterval(run, POLL_MS);
+        return () => {
+            cancelled = true;
+            window.clearInterval(timer);
+        };
+        // `read` is a stable module-level function per call site.
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [connection, tick, refreshKey]);
+    return { value, refresh };
+}

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

@@ -0,0 +1,10 @@
+export { ChangeTree } from "./ChangeTree.js";
+export { creditedAgents } from "./co-author.js";
+export { CommitViewer } from "./CommitViewer.js";
+export { createGitFileSource, diffHandle } from "./git-file-source.js";
+export { useGitRead } from "./git-host.js";
+export { changeShapeOf, GitChanges } from "./GitChanges.js";
+export { GitHistory } from "./GitHistory.js";
+export { buildPathTree, filesUnder } from "./path-tree.js";
+export { sessionFilePaths } from "./session-files.js";
+export type { BranchFacts, CoAuthor, Commit, CommitFile, GitClient, StatusEntry, StatusLetter, } from "./types.js";

package/dist/components/git/index.js

@@ -0,0 +1,12 @@
+// The git half of column ③ — what the repository has not recorded yet, and
+// what it has. The column that hosts these lives in `components/worktree`,
+// because files, changes and history are three views of one checkout.
+export { ChangeTree } from "./ChangeTree.js";
+export { creditedAgents } from "./co-author.js";
+export { CommitViewer } from "./CommitViewer.js";
+export { createGitFileSource, diffHandle } from "./git-file-source.js";
+export { useGitRead } from "./git-host.js";
+export { changeShapeOf, GitChanges } from "./GitChanges.js";
+export { GitHistory } from "./GitHistory.js";
+export { buildPathTree, filesUnder } from "./path-tree.js";
+export { sessionFilePaths } from "./session-files.js";

package/dist/components/git/path-tree.d.ts

@@ -0,0 +1,23 @@
+/** A directory whose only child is another directory is drawn as one row —
+ * `crates/store/src` rather than three rows deep. The design record refuses
+ * this for column ③ (a walked tree's "only one child" is a claim about the
+ * walk); here it is safe, because the set is closed and git named all of it. */
+export interface TreeRow {
+    readonly kind: "directory" | "file";
+    /** What the row shows: a file's name, or a folder's collapsed path. */
+    readonly label: string;
+    /** Full workspace-relative path. Directories carry theirs too, so a folder
+     * can be acted on as the set of files beneath it. */
+    readonly path: string;
+    readonly depth: number;
+}
+/**
+ * Build the subtree over `paths`.
+ *
+ * Directories sort before files and both sort naturally, which is the order
+ * mille draws column ③ in — two lists of the same repository that disagreed
+ * about order would be two lists.
+ */
+export declare function buildPathTree(paths: readonly string[]): readonly TreeRow[];
+/** Every file at or beneath `row` — what acting on a folder row acts on. */
+export declare function filesUnder(rows: readonly TreeRow[], row: TreeRow): readonly string[];

package/dist/components/git/path-tree.js

@@ -0,0 +1,73 @@
+// Paths → a subtree, which is the shape the design record asks for:
+// "Each group is a *subtree*, not a filtered list — a folder survives when
+// anything inside it survives — so a path a reader learned in one view still
+// holds in the other."
+//
+// Pure, and deliberately not mille: mille walks a real directory, and these
+// rows are a set of paths git named. They wear the same geometry so the two
+// columns read as one repository, and they do not pretend to be the same
+// component.
+const node = () => ({ children: new Map(), files: [] });
+/**
+ * Build the subtree over `paths`.
+ *
+ * Directories sort before files and both sort naturally, which is the order
+ * mille draws column ③ in — two lists of the same repository that disagreed
+ * about order would be two lists.
+ */
+export function buildPathTree(paths) {
+    const root = node();
+    for (const path of paths) {
+        const segments = path.split("/").filter((s) => s !== "");
+        if (segments.length === 0)
+            continue;
+        let current = root;
+        for (const segment of segments.slice(0, -1)) {
+            let next = current.children.get(segment);
+            if (next === undefined) {
+                next = node();
+                current.children.set(segment, next);
+            }
+            current = next;
+        }
+        current.files.push(segments[segments.length - 1]);
+    }
+    const collator = new Intl.Collator(undefined, { numeric: true, sensitivity: "base" });
+    const rows = [];
+    const walk = (current, prefix, depth) => {
+        const directories = [...current.children.entries()].sort((a, b) => collator.compare(a[0], b[0]));
+        for (const [name, child] of directories) {
+            // Collapse a chain of single-child directories into one row.
+            let label = name;
+            let path = prefix === "" ? name : `${prefix}/${name}`;
+            let inner = child;
+            while (inner.files.length === 0 && inner.children.size === 1) {
+                const [onlyName, onlyChild] = [...inner.children.entries()][0];
+                label = `${label}/${onlyName}`;
+                path = `${path}/${onlyName}`;
+                inner = onlyChild;
+            }
+            rows.push({ kind: "directory", label, path, depth });
+            walk(inner, path, depth + 1);
+        }
+        for (const name of [...current.files].sort(collator.compare)) {
+            rows.push({
+                kind: "file",
+                label: name,
+                path: prefix === "" ? name : `${prefix}/${name}`,
+                depth,
+            });
+        }
+    };
+    walk(root, "", 0);
+    return rows;
+}
+/** Every file at or beneath `row` — what acting on a folder row acts on. */
+export function filesUnder(rows, row) {
+    if (row.kind === "file")
+        return [row.path];
+    const prefix = `${row.path}/`;
+    return rows
+        .filter((candidate) => candidate.kind === "file" && candidate.path.startsWith(prefix))
+        .map((candidate) => candidate.path);
+}

package/dist/components/git/session-files.d.ts

@@ -0,0 +1,9 @@
+import type { TimelineEntry } from "@vibefield/rosetta-protocol";
+/**
+ * Workspace-relative paths this session's file-change actions named.
+ *
+ * Absolute paths are made relative to `root` so they match what git prints;
+ * a path outside the root is dropped rather than shown against the wrong
+ * repository.
+ */
+export declare function sessionFilePaths(entries: readonly TimelineEntry[], root: string | null): ReadonlySet<string>;

package/dist/components/git/session-files.js

@@ -0,0 +1,50 @@
+// Which files the open session touched.
+//
+// The one fact a general git client cannot show, and the reason a git column
+// belongs in a room about agent sessions. It is derived from the timeline the
+// room is already reading — every `file_change` tool action names a path — so
+// it costs no new request and no new table.
+//
+// Until the typed tool projection ships, the daemon answers no `file_change`
+// actions at all and this returns an empty set. That draws NO marks, which is
+// the honest state: "we cannot say" and "this session touched nothing" look
+// the same here, and neither of them is a lie about a file.
+/** `path` on a `ResourceRef`, if that is what this value is. */
+function refPath(value) {
+    if (value === null || typeof value !== "object")
+        return null;
+    const path = value.path;
+    return typeof path === "string" && path !== "" ? path : null;
+}
+/**
+ * Workspace-relative paths this session's file-change actions named.
+ *
+ * Absolute paths are made relative to `root` so they match what git prints;
+ * a path outside the root is dropped rather than shown against the wrong
+ * repository.
+ */
+export function sessionFilePaths(entries, root) {
+    const out = new Set();
+    if (root === null)
+        return out;
+    const prefix = root.endsWith("/") ? root : `${root}/`;
+    for (const entry of entries) {
+        const body = entry.body;
+        if (body?.type !== "tool_use")
+            continue;
+        const action = body.tool?.action;
+        if (action?.type !== "file_change")
+            continue;
+        // Both the changed path and a move's destination count as touched.
+        const change = action;
+        for (const candidate of [refPath(change.path), refPath(change.destination)]) {
+            if (candidate === null)
+                continue;
+            if (candidate.startsWith(prefix))
+                out.add(candidate.slice(prefix.length));
+            else if (!candidate.startsWith("/"))
+                out.add(candidate);
+        }
+    }
+    return out;
+}

package/dist/components/git/types.d.ts

@@ -0,0 +1,92 @@
+/** git's own status letter, per slot. `?` is untracked and `U` unmerged. */
+export type StatusLetter = "M" | "A" | "D" | "R" | "C" | "T" | "?" | "U";
+/**
+ * One path's status, with BOTH of git's slots kept.
+ *
+ * A file with staged changes and further unstaged edits is genuinely in both
+ * groups, with a different diff in each. Collapsing the pair into one letter
+ * is right for a row decoration and wrong for a list you commit from.
+ */
+export interface StatusEntry {
+    /** Workspace-relative, POSIX separators — what git prints. */
+    readonly path: string;
+    /** Where a rename came from. */
+    readonly original: string | null;
+    /** The index against HEAD: what `git commit` would record. */
+    readonly index: StatusLetter | null;
+    /** The working tree against the index: what is not staged yet. */
+    readonly worktree: StatusLetter | null;
+}
+export interface BranchFacts {
+    readonly name: string | null;
+    readonly upstream: string | null;
+    /** Commits this branch has that its upstream does not. `null` when there
+     * is no upstream to compare against — which is not zero. */
+    readonly ahead: number | null;
+    readonly behind: number | null;
+}
+/** Someone git records as having co-written a commit. For this room that is
+ * usually the agent that wrote it — the one thing a `Co-authored-by` trailer
+ * says that nothing else in the room can. */
+export interface CoAuthor {
+    readonly name: string;
+    readonly email: string | null;
+}
+export interface Commit {
+    readonly sha: string;
+    readonly short: string;
+    readonly subject: string;
+    readonly author: string;
+    readonly timestampMs: number;
+    readonly merge: boolean;
+    readonly coAuthors: readonly CoAuthor[];
+    /** `null` on a branch with no upstream: the row draws no mark rather than
+     * claiming a commit is unpushed when nothing can know. */
+    readonly pushed: boolean | null;
+    readonly added: number;
+    readonly deleted: number;
+    readonly files: number;
+}
+/** One file inside a commit. */
+export interface CommitFile {
+    readonly path: string;
+    /** Where a rename came from. */
+    readonly original: string | null;
+    readonly status: StatusLetter;
+    /** `null` for a binary file, which has no line count. */
+    readonly added: number | null;
+    readonly deleted: number | null;
+}
+/** Which side of the index a diff is taken from. */
+export interface DiffRequest {
+    readonly path: string;
+    readonly staged?: boolean;
+    /** A commit's diff, rather than the working tree's. */
+    readonly sha?: string;
+}
+/** The two views the column offers, which are the two views git has. */
+export type GitView = "changes" | "history";
+/** Everything the fx-host will answer. Every read resolves to a value with
+ * its own `error` field; only the write acts reject. */
+export interface GitClient {
+    branch(): Promise<BranchFacts>;
+    status(): Promise<{
+        entries: readonly StatusEntry[];
+        error: string | null;
+    }>;
+    log(): Promise<{
+        commits: readonly Commit[];
+        error: string | null;
+    }>;
+    diff(request: DiffRequest): Promise<{
+        text: string;
+        error: string | null;
+    }>;
+    commitFiles(sha: string): Promise<{
+        files: readonly CommitFile[];
+        error: string | null;
+    }>;
+    stage(paths: readonly string[]): Promise<void>;
+    unstage(paths: readonly string[]): Promise<void>;
+    discard(paths: readonly string[]): Promise<void>;
+}

package/dist/components/git/types.js

@@ -0,0 +1,9 @@
+// What column ⑤ is a view of.
+//
+// The column is scoped to the REPOSITORY, like every other git client — and
+// the files this session touched wear a mark. The design record's §8 offered
+// the opposite (a column scoped to one session, Q4's "keep or kill"); this
+// keeps the idea it was after and drops the filter, because a list that hides
+// the other twenty changed files is not a thing you can commit from, and the
+// session attribution is the one fact GitHub Desktop could never show.
+export {};

package/dist/components/projects/ProjectActivitySparkline.d.ts

@@ -0,0 +1,6 @@
+export interface ProjectActivitySparklineProps {
+    readonly values: readonly number[];
+    readonly accessibleLabel?: string;
+}
+/** Compact bar sparkline for a project's recent token buckets. */
+export declare function ProjectActivitySparkline({ values, accessibleLabel, }: ProjectActivitySparklineProps): import("react").JSX.Element;

package/dist/components/projects/ProjectActivitySparkline.js

@@ -0,0 +1,12 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/** Compact bar sparkline for a project's recent token buckets. */
+export function ProjectActivitySparkline({ values, accessibleLabel = "Token activity over the last 30 days", }) {
+    const peak = values.reduce((maximum, value) => Math.max(maximum, Number.isFinite(value) ? value : 0), 0);
+    return (_jsx("div", { className: "ah-project-activity-sparkline", role: "img", "aria-label": accessibleLabel, children: values.map((rawValue, bucketIndex) => {
+            const value = Number.isFinite(rawValue) ? Math.max(0, rawValue) : 0;
+            const height = value === 0 || peak === 0
+                ? "1px"
+                : `${Math.max(12, Math.round((value / peak) * 100))}%`;
+            return (_jsx("i", { "data-zero": value === 0 ? "" : undefined, style: { "--h": height } }, bucketIndex));
+        }) }));
+}

package/dist/components/projects/ProjectList.d.ts

@@ -0,0 +1,25 @@
+import type { ProjectBackfill, RuntimeBackfill } from "@vibefield/rosetta-protocol";
+import type { ProjectViewModel } from "../../lib/model.js";
+import type { ArrangedSection } from "../../lib/sections.js";
+export interface ProjectListProps {
+    /** Projects in display order; sorting and filtering belong to the container. */
+    readonly projects: readonly ProjectViewModel[];
+    /** A deliberate sort choice establishes a fresh view. */
+    readonly orderScope?: string;
+    readonly selectedProjectId: string | null;
+    readonly maximumLifetimeCost: number;
+    readonly homeDirectory: string | null;
+    readonly currentTimestamp: number;
+    /** A backfill is running: unfinished projects cook rather than lie. */
+    readonly ingestActive: boolean;
+    readonly runtimes?: readonly RuntimeBackfill[] | undefined;
+    /** The daemon's per-project backfill fold, keyed by project id. */
+    readonly projectBackfills: ReadonlyMap<string, ProjectBackfill>;
+    /** The list itself is still being censused — only the ready may claim
+     * emptiness, so the empty state yields to the section's veil. */
+    readonly pending: boolean;
+    readonly onProjectSelect: (projectId: string) => void;
+    /** The host's sections (R3), arranged; null draws the one run it always did. */
+    readonly sections?: readonly ArrangedSection<ProjectViewModel>[] | null | undefined;
+}
+export declare function ProjectList({ projects, orderScope, selectedProjectId, maximumLifetimeCost, homeDirectory, currentTimestamp, ingestActive, runtimes, projectBackfills, pending, onProjectSelect, sections, }: ProjectListProps): import("react").JSX.Element;