@gperezmz/bb-plugin-thread-glance 0.2.4 → 0.3.0

package/features/thread-list/model/settled.ts

@@ -0,0 +1,122 @@
+// Settled threads: which trees go behind their group's settled fold.
+// Worked out afresh on every build, so any activity unsettles a thread. Pure.
+import type { PluginSidebarThread } from "@get-bb/plugin-sdk/app";
+import type { SettleAfter } from "@/shared/preferences";
+import { isQuietThread } from "./state";
+import type { ThreadInfo, ThreadTree } from "./trees";
+
+const HOUR = 60 * 60 * 1000;
+
+/** How long a thread goes without activity before it settles, per Settle after choice. */
+export const SETTLE_AFTER_MS: Readonly<Record<Exclude<SettleAfter, "never">, number>> = {
+  "12h": 12 * HOUR,
+  "1d": 24 * HOUR,
+  "3d": 3 * 24 * HOUR,
+  "1w": 7 * 24 * HOUR,
+};
+
+/** A pull request's state, as bb's lookup reports it. */
+export type PullRequestState = "open" | "draft" | "merged" | "closed";
+
+/**
+ * What settling knows of a thread's pull request: its state, null when the
+ * thread has none, or `unknown` while a lookup it needs has not answered.
+ */
+export type PullRequestFact = PullRequestState | null | "unknown";
+
+/**
+ * Whether a thread's branch can carry a pull request worth looking up: it is
+ * on a branch other than its project's default. A default branch the lookup
+ * could not find (null) is no reason to skip one; one still being looked up
+ * (undefined) is, until it answers.
+ */
+export function needsPullRequestLookup(branch: string | null, defaultBranch: string | null | undefined): boolean {
+  return branch !== null && defaultBranch !== undefined && branch !== defaultBranch;
+}
+
+/** A thread's pull request fact, from its project's default branch and the lookups that answered. */
+export function pullRequestFact(
+  thread: Pick<PluginSidebarThread, "id" | "environment">,
+  defaultBranch: string | null | undefined,
+  answers: ReadonlyMap<string, PullRequestState | null>,
+): PullRequestFact {
+  const branch = thread.environment?.branchName ?? null;
+  if (branch === null) return null;
+  if (defaultBranch === undefined) return "unknown";
+  if (!needsPullRequestLookup(branch, defaultBranch)) return null;
+  const answer = answers.get(thread.id);
+  return answer === undefined ? "unknown" : answer;
+}
+
+export interface SettleInputs {
+  now: number;
+  settleAfter: SettleAfter;
+  /** Server stamps: when each thread last started and finished a turn. */
+  startedAt: Readonly<Record<string, number>>;
+  finishedAt: Readonly<Record<string, number>>;
+  pullRequestOf(thread: PluginSidebarThread): PullRequestFact;
+}
+
+/**
+ * A thread's own last activity: its creation, its last finish or failure
+ * (`latestAttentionAt`) and the server's stamps of its last start and
+ * finish. `updatedAt` is left out because opening or renaming a thread
+ * moves it too.
+ */
+export function lastActivityAt(
+  thread: Pick<PluginSidebarThread, "id" | "createdAt" | "latestAttentionAt">,
+  stamps: Pick<SettleInputs, "startedAt" | "finishedAt">,
+): number {
+  return Math.max(
+    thread.createdAt,
+    thread.latestAttentionAt,
+    stamps.startedAt[thread.id] ?? 0,
+    stamps.finishedAt[thread.id] ?? 0,
+  );
+}
+
+/**
+ * A settled thread: quiet as if no thread were open, not needing attention,
+ * not pinned, with no open pull request, and either its pull request merged
+ * or closed or its own last activity is older than the Settle after period.
+ * Hidden and archived threads take the same test.
+ */
+export function isSettledThread(info: ThreadInfo, inputs: SettleInputs): boolean {
+  const thread = info.thread;
+  if (!mightSettle(info)) return false;
+  const pullRequest = inputs.pullRequestOf(thread);
+  if (pullRequest === "unknown" || pullRequest === "open" || pullRequest === "draft") return false;
+  if (pullRequest === "merged" || pullRequest === "closed") return true;
+  if (inputs.settleAfter === "never") return false;
+  return inputs.now - lastActivityAt(thread, inputs) >= SETTLE_AFTER_MS[inputs.settleAfter];
+}
+
+/** A row's thread that settles once its pull request and activity allow: quiet as if none were open, needing no attention, not pinned. */
+function mightSettle(info: ThreadInfo): boolean {
+  const thread = info.thread;
+  if (thread.pinnedAt !== null || thread.isPinned) return false;
+  return isQuietThread(info.state, info.unread, false) && info.attentionFlags.size === 0;
+}
+
+/** A tree settles as one unit: when every thread in it is settled. */
+export function isSettledTree(tree: Pick<ThreadTree, "root" | "descendants">, inputs: SettleInputs): boolean {
+  return isSettledThread(tree.root, inputs) && tree.descendants.every((info) => isSettledThread(info, inputs));
+}
+
+/**
+ * The threads whose pull request settling has to look up: every thread that
+ * would settle but for its pull request, on a branch other than its
+ * project's default.
+ */
+export function pullRequestLookupIds(
+  infos: Iterable<ThreadInfo>,
+  defaultBranchOf: (thread: PluginSidebarThread) => string | null | undefined,
+): string[] {
+  const ids: string[] = [];
+  for (const info of infos) {
+    const thread = info.thread;
+    if (!mightSettle(info)) continue;
+    if (needsPullRequestLookup(thread.environment?.branchName ?? null, defaultBranchOf(thread))) ids.push(thread.id);
+  }
+  return ids;
+}

package/features/thread-list/model/share.ts

@@ -1,6 +1,6 @@
 // Structural sharing between two list views: whatever did not change keeps
 // the previous object, so memoized rows and groups skip their render. Pure.
-import type { GroupView, ListView, AttentionView, Row } from "./view";
+import type { GroupView, ListView, Row } from "./view";
 
 function isPlainObject(value: unknown): value is Record<string, unknown> {
   if (value === null || typeof value !== "object") return false;
@@ -86,11 +86,6 @@ function shareGroups(previousGroups: GroupView[], all: ReadonlyMap<string, Group
   return sameItems(previousGroups, result) ? previousGroups : result;
 }
 
-function shareAttention(previous: AttentionView | null, next: AttentionView | null): AttentionView | null {
-  if (previous === null || next === null) return next;
-  return shareFields(previous, next, { rows: shareRows(previous.rows, next.rows) });
-}
-
 /**
  * `next`, sharing every group and row that did not change since `previous`.
  * Groups match by id and rows by key, never by position. A group keeps its
@@ -100,7 +95,6 @@ export function shareView(previous: ListView | null, next: ListView): ListView {
   if (previous === null) return next;
   const all = new Map([...previous.groups, ...previous.more].map((group) => [group.descriptor.id, group]));
   return shareFields(previous, next, {
-    attention: shareAttention(previous.attention, next.attention),
     groups: shareGroups(previous.groups, all, next.groups),
     more: shareGroups(previous.more, all, next.more),
   });

package/features/thread-list/model/sort.ts

@@ -5,14 +5,13 @@ import type { SortDirection, SortField } from "@/shared/preferences";
 export interface SortOptions {
   field: SortField;
   direction: SortDirection;
-  workingFirst: boolean;
 }
 
 /** What a comparator needs to know about a root beyond the thread itself. */
 export interface SortKey {
   thread: PluginSidebarThread;
-  /** Largest `latestAttentionAt` over the family. */
-  familyAttention: number;
+  /** Largest `latestAttentionAt` over the tree. */
+  treeAttention: number;
 }
 
 function byCreated(a: SortKey, b: SortKey): number {
@@ -28,7 +27,7 @@ function byAlpha(a: SortKey, b: SortKey): number {
 }
 
 function byUpdated(a: SortKey, b: SortKey): number {
-  const diff = b.familyAttention - a.familyAttention;
+  const diff = b.treeAttention - a.treeAttention;
   if (diff !== 0) return diff;
   return byCreated(a, b);
 }
@@ -48,22 +47,12 @@ export function effectiveDirection(field: SortField, direction: SortDirection):
   return direction === "default" ? naturalDirection(field) : direction;
 }
 
-/**
- * The comparator for roots in a group. Working first keeps active threads on
- * top whatever the direction.
- */
+/** The comparator for roots in a group. */
 export function makeComparator(options: SortOptions): (a: SortKey, b: SortKey) => number {
   const field = effectiveSortField(options.field);
   const sign = effectiveDirection(field, options.direction) === naturalDirection(field) ? 1 : -1;
   const base = field === "alpha" ? byAlpha : field === "created" ? byCreated : byUpdated;
-  return (a, b) => {
-    if (field === "updated" && options.workingFirst) {
-      const aActive = a.thread.status === "active";
-      const bActive = b.thread.status === "active";
-      if (aActive !== bActive) return aActive ? -1 : 1;
-    }
-    return sign * base(a, b);
-  };
+  return (a, b) => sign * base(a, b);
 }
 
 /** Pinned order: pinSortKey, then pinnedAt desc, createdAt desc, id. */

package/features/thread-list/model/state.ts

@@ -271,26 +271,39 @@ export function hiddenThreadFlags(flags: ReadonlySet<Flag>): Set<Flag> {
   return kept;
 }
 
+/** Flags a hidden thread adds to its parent's child dot: what asks for you or failed, and offline. */
+const HIDDEN_DOT_FLAGS: ReadonlySet<Flag> = new Set<Flag>(["waits-on-you", "unread-failed", "queue-failed", "offline"]);
+
+/**
+ * The flags a thread adds to the child dot of the threads above it. A
+ * hidden thread adds only waits-on-you, failed, queued message failed and
+ * offline; which trees need attention reads `hiddenThreadFlags` instead,
+ * so this leaves it unchanged.
+ */
+export function dotFlagsOf(flags: ReadonlySet<Flag>, isHidden: boolean): Set<Flag> {
+  return isHidden ? new Set([...flags].filter((flag) => HIDDEN_DOT_FLAGS.has(flag))) : new Set(flags);
+}
+
 /** The most urgent flag, or null. */
 export function mostUrgent(flags: ReadonlySet<Flag>): Flag | null {
   return FLAG_ORDER.find((flag) => flags.has(flag)) ?? null;
 }
 
-/** The colour a child chip takes: only what asks for you, fails, or works. */
-export type ChipTone = "attention" | "destructive" | "working" | "neutral";
+/** The colour of a child dot, by the most urgent state among the descendants. */
+export type DotTone = "attention" | "destructive" | "working" | "unread";
 
-/** The tone of a chip whose most urgent rolled-up flag is `flag`. */
-export function chipTone(flag: Flag | null): ChipTone {
+export function dotTone(flag: Flag): DotTone {
   switch (flag) {
     case "waits-on-you":
+    case "offline":
       return "attention";
     case "unread-failed":
     case "queue-failed":
       return "destructive";
     case "working":
       return "working";
-    default:
-      return "neutral";
+    case "unread":
+      return "unread";
   }
 }
 

package/features/thread-list/model/toggles.ts

@@ -1,10 +1,10 @@
 // What a user's click on a chip, fold or header changes.
 // Pure: returns the preference patch and which auto-expand targets to drop.
 import type { Preferences } from "@/shared/preferences";
-import { ancestorsOf, type Family, type Forest } from "./families";
+import { ancestorsOf, type ThreadTree, type Forest } from "./trees";
 import { isGroupCollapsed, toggleGroupCollapse } from "./groups";
 import { isDoneUnseen } from "./state";
-import type { GroupView, OlderRow, ThreadRow } from "./view";
+import type { GroupView, OlderRow, SettledRow, ThreadRow } from "./view";
 
 export interface ToggleOutcome {
   patch: Partial<Preferences>;
@@ -29,36 +29,31 @@ export function toggleChip(row: ThreadRow, prefs: Preferences, forest: Forest):
     : openChildren(id, prefs);
 }
 
-/** Opens a parent's children, as its chip does: "+N more" in Needs attention and an auto-reveal's fold. */
+/** Opens a parent's children, as its chip does, from an auto-reveal's fold. */
 export function openChildren(parentId: string, prefs: Preferences): ToggleOutcome {
   return { patch: { expandedChildren: [...without(prefs.expandedChildren, parentId), parentId] }, drop: null };
 }
 
-export function toggleOlder(row: OlderRow, prefs: Preferences, group: GroupView | null, forest: Forest): ToggleOutcome {
+/** Opens or closes an open tree's "N more child threads" fold. */
+export function toggleOlder(row: OlderRow, prefs: Preferences, forest: Forest): ToggleOutcome {
   if (row.scope === "reveal") return openChildren(row.scopeId, prefs);
   if (!row.expanded) {
     return { patch: { expandedOlder: [...without(prefs.expandedOlder, row.scopeId), row.scopeId] }, drop: null };
   }
-  const patch = { expandedOlder: without(prefs.expandedOlder, row.scopeId) };
-  if (row.scope === "family") return { patch, drop: under(forest, row.scopeId) };
-  // Folding a group's older roots drops the targets that held it open.
-  const quietRoots = new Set<string>();
-  for (const family of forest.families) if (family.quietIgnoringOpen) quietRoots.add(family.root.thread.id);
-  const inGroup = new Set(group?.rootIds ?? []);
-  return {
-    patch,
-    drop: (id) => {
-      const family = forest.familyOf.get(id);
-      return family !== undefined && quietRoots.has(family.root.thread.id) && inGroup.has(family.root.thread.id);
-    },
-  };
+  return { patch: { expandedOlder: without(prefs.expandedOlder, row.scopeId) }, drop: under(forest, row.scopeId) };
+}
+
+/** Opens or closes a group's settled fold. */
+export function toggleSettled(row: SettledRow, prefs: Preferences): ToggleOutcome {
+  const rest = without(prefs.openSettledFolds, row.groupId);
+  return { patch: { openSettledFolds: row.expanded ? rest : [...rest, row.groupId] }, drop: null };
 }
 
 export function toggleGroup(group: GroupView, prefs: Preferences, forest: Forest): ToggleOutcome {
   const inGroup = new Set(group.rootIds);
   const dropGroup = (id: string) => {
-    const family = forest.familyOf.get(id);
-    return family !== undefined && inGroup.has(family.root.thread.id);
+    const tree = forest.treeOf.get(id);
+    return tree !== undefined && inGroup.has(tree.root.thread.id);
   };
   if (group.collapsed) {
     return {
@@ -78,19 +73,35 @@ export interface MarkAllRead {
   seen: string[];
 }
 
-/** Every unread thread in the families, descendants included. */
+/** Every unread thread in the trees, descendants included: Mark all read, and a root's Mark read for its tree. */
 export function markAllReadPlan(
-  families: readonly Family[],
+  trees: readonly ThreadTree[],
   context: { activeThreadId: string | null; finishedAt: Readonly<Record<string, number>>; seenAt: Readonly<Record<string, number>> },
 ): MarkAllRead {
   const read: string[] = [];
   const seen: string[] = [];
-  for (const family of families) {
-    for (const info of [family.root, ...family.descendants]) {
-      if (!info.unread || info.thread.isArchived) continue;
+  for (const tree of trees) {
+    for (const info of [tree.root, ...tree.descendants]) {
+      if (!info.unread) continue;
       read.push(info.thread.id);
       if (isDoneUnseen(info.thread, context)) seen.push(info.thread.id);
     }
   }
   return { read, seen };
 }
+
+/**
+ * What one row's Mark read marks: on a tree's root, every unread thread in
+ * the tree; on any other row, the thread alone.
+ */
+export function markReadPlanFor(
+  threadId: string,
+  forest: Pick<Forest, "infos" | "treeOf">,
+  context: { activeThreadId: string | null; finishedAt: Readonly<Record<string, number>>; seenAt: Readonly<Record<string, number>> },
+): MarkAllRead {
+  const tree = forest.treeOf.get(threadId);
+  if (tree !== undefined && tree.root.thread.id === threadId) return markAllReadPlan([tree], context);
+  const thread = forest.infos.get(threadId)?.thread;
+  if (thread === undefined) return { read: [threadId], seen: [] };
+  return { read: [threadId], seen: isDoneUnseen(thread, context) ? [threadId] : [] };
+}

package/features/thread-list/model/{families.ts → trees.ts}

@@ -1,8 +1,9 @@
-// Families: who attaches to whom, and what each family
+// Thread trees: who attaches to whom, and what each tree
 // carries. Pure.
 import type { PluginSidebarThread } from "@get-bb/plugin-sdk/app";
 import {
   computeState,
+  dotFlagsOf,
   hiddenThreadFlags,
   isQuietThread,
   isUnread,
@@ -14,11 +15,11 @@ import {
 } from "./state";
 import { attentionFlagsOf, isOrphanedFailure } from "./attention";
 import { compareCreationAscending } from "./sort";
-import { attentionNote, needsKindOf, rowNote, type RowNote } from "./notes";
+import { needsKindOf, rowNote, type RowNote } from "./notes";
 import type { ThreadNotes } from "@/shared/contract";
 import type { ChildAttention } from "@/shared/preferences";
 
-/** States that keep a child out of its family's older fold with `childAttention` `blocked`: working, setting up, background work. */
+/** States that keep a child out of an open tree's "N more child threads" fold with `childAttention` `blocked`: working, setting up, background work. */
 const RUNNING: ReadonlySet<StateKind> = new Set<StateKind>(["working", "background"]);
 
 /** Everything the list knows about one thread. */
@@ -28,16 +29,19 @@ export interface ThreadInfo {
   unread: boolean;
   /** Own flags; for hidden threads only waits-on-you and unread-failed. */
   flags: ReadonlySet<Flag>;
+  /** What it adds to the child dot of the threads above it (see `dotFlagsOf`). */
+  dotFlags: ReadonlySet<Flag>;
   /**
-   * The flags of this thread that make it need attention, for Needs attention, the
-   * counters and auto-reveal: a child counts less than a root.
+   * The flags of this thread that make it need attention, for collapsed
+   * groups, the counters, the need-you filter and auto-reveal: a child counts
+   * less than a root.
    */
   attentionFlags: Set<Flag>;
   /** Quiet test for the thread alone. */
   quiet: boolean;
   /**
    * A quiet thread, as if no thread were open: nothing to see behind a
-   * family's fold. A root, or any child when `childAttention` is
+   * tree's fold. A root, or any child when `childAttention` is
    * `everything`, takes the quiet test without the open thread's exemption.
    * Otherwise a child is quiet unless it runs or needs attention, so finishing
    * unread folds it; an archived child is always quiet. The fold reads this,
@@ -49,23 +53,25 @@ export interface ThreadInfo {
   parentId: string | null;
   /** Why it waits on you or failed, for the line under the row. */
   note: RowNote | null;
-  /** Why it needs attention, for the line under its row in Needs attention. */
-  attentionNote: RowNote | null;
 }
 
-/** What a thread's descendants add up to, for its chip and for folding. */
+/** What a thread's descendants add up to, for its chip, its child dot and folding. */
 export interface Subtree {
   /** Descendants, depth-first in creation order, hidden ones included. */
   descendants: ThreadInfo[];
   /** Union of the descendants' Needs attention flags and working, archived ones left out. */
   flags: ReadonlySet<Flag>;
-  /** Visible descendants: the chip's number. */
+  /** Union of the descendants' `dotFlags`, archived ones left out: the child dot. */
+  dotFlags: ReadonlySet<Flag>;
+  /** Visible descendants at any depth. */
   visibleCount: number;
+  /** Visible direct children: the chip's number. */
+  childCount: number;
   /** Every visible descendant is quiet, as if no thread were open, so the subtree adds nothing to see when folded. */
   quietIgnoringOpen: boolean;
 }
 
-export interface Family {
+export interface ThreadTree {
   root: ThreadInfo;
   /** Descendants, depth-first in creation order, hidden ones included. */
   descendants: ThreadInfo[];
@@ -73,11 +79,11 @@ export interface Family {
   descendantFlags: ReadonlySet<Flag>;
   /** The same over root and descendants (rollup, folder rows). */
   flags: ReadonlySet<Flag>;
-  /** Needs attention flags over root and descendants: what the section and its order read. */
+  /** Needs attention flags over root and descendants: the tree needs attention when any is set. */
   attentionFlags: ReadonlySet<Flag>;
   /** Visible descendants: the chip's number. */
   visibleDescendantCount: number;
-  /** Largest latestAttentionAt over the family. */
+  /** Largest latestAttentionAt over the tree. */
   latestAttentionAt: number;
   /** Every thread quiet and the active thread not in it. */
   quiet: boolean;
@@ -93,8 +99,8 @@ export interface Forest {
   infos: ReadonlyMap<string, ThreadInfo>;
   /** Visible child ids per parent id, creation order; hidden children included. */
   children: ReadonlyMap<string, readonly string[]>;
-  families: readonly Family[];
-  familyOf: ReadonlyMap<string, Family>;
+  trees: readonly ThreadTree[];
+  treeOf: ReadonlyMap<string, ThreadTree>;
   /** The rollup under every thread with a row, by thread id. */
   subtrees: ReadonlyMap<string, Subtree>;
 }
@@ -161,13 +167,13 @@ export function buildForest(inputs: ForestInputs): Forest {
       state,
       unread,
       flags: thread.isHidden ? hiddenThreadFlags(flags) : flags,
+      dotFlags: dotFlagsOf(flags, thread.isHidden),
       attentionFlags: new Set<Flag>(),
       quiet: isQuietThread(state, unread, isActive),
       quietIgnoringOpen: false,
       isActive,
       parentId: attachParent(thread, byId),
       note: rowNote(thread, inputs.notes?.[thread.id]),
-      attentionNote: null,
     });
   }
 
@@ -181,7 +187,6 @@ export function buildForest(inputs: ForestInputs): Forest {
         parent !== undefined &&
         isOrphanedFailure(info.thread, info.flags, { ...parent, finishedAt: inputs.finishedAt[parent.thread.id] }),
     });
-    info.attentionNote = attentionNote(info.thread, inputs.notes?.[info.thread.id], info.attentionFlags);
     info.quietIgnoringOpen =
       parent === undefined || mode === "everything"
         ? isQuietThread(info.state, info.unread, false)
@@ -192,7 +197,7 @@ export function buildForest(inputs: ForestInputs): Forest {
   const roots: ThreadInfo[] = [];
   for (const info of infos.values()) {
     if (info.parentId === null) {
-      // A hidden thread with no visible ancestor has no row and no family.
+      // A hidden thread with no visible ancestor has no row and no tree.
       if (!info.thread.isHidden) roots.push(info);
       continue;
     }
@@ -211,7 +216,9 @@ export function buildForest(inputs: ForestInputs): Forest {
     if (cached !== undefined) return cached;
     const descendants: ThreadInfo[] = [];
     const flags = new Set<Flag>();
+    const dotFlags = new Set<Flag>();
     let visibleCount = 0;
+    let childCount = 0;
     let quietIgnoringOpen = true;
     path.add(id);
     for (const childId of children.get(id) ?? []) {
@@ -222,22 +229,27 @@ export function buildForest(inputs: ForestInputs): Forest {
       if (!child.thread.isArchived) {
         for (const flag of child.attentionFlags) flags.add(flag);
         if (child.flags.has("working")) flags.add("working");
+        for (const flag of child.dotFlags) dotFlags.add(flag);
       }
       for (const flag of below.flags) flags.add(flag);
+      for (const flag of below.dotFlags) dotFlags.add(flag);
       if (child.thread.isHidden ? child.attentionFlags.size > 0 : !child.quietIgnoringOpen) quietIgnoringOpen = false;
-      if (!child.thread.isHidden) visibleCount += 1;
+      if (!child.thread.isHidden) {
+        visibleCount += 1;
+        childCount += 1;
+      }
       visibleCount += below.visibleCount;
       if (!below.quietIgnoringOpen) quietIgnoringOpen = false;
     }
     path.delete(id);
-    const subtree: Subtree = { descendants, flags, visibleCount, quietIgnoringOpen };
+    const subtree: Subtree = { descendants, flags, dotFlags, visibleCount, childCount, quietIgnoringOpen };
     subtrees.set(id, subtree);
     return subtree;
   };
   for (const id of infos.keys()) subtreeOf(id, new Set());
 
-  const families: Family[] = [];
-  const familyOf = new Map<string, Family>();
+  const trees: ThreadTree[] = [];
+  const treeOf = new Map<string, ThreadTree>();
   for (const root of roots) {
     const { descendants, flags: descendantFlags, visibleCount: visibleDescendantCount } = subtrees.get(root.thread.id)!;
     let latestAttentionAt = root.thread.latestAttentionAt;
@@ -254,7 +266,7 @@ export function buildForest(inputs: ForestInputs): Forest {
       } else {
         if (!info.quiet) quiet = false;
         // A child reads as its own fold does, so with `blocked` an unread child
-        // does not keep an old family out of the group's fold.
+        // does not keep an old tree out of the group's fold.
         if (!info.quietIgnoringOpen) quietIgnoringOpen = false;
       }
     }
@@ -266,7 +278,7 @@ export function buildForest(inputs: ForestInputs): Forest {
       }
       if (root.flags.has("working")) flags.add("working");
     }
-    const family: Family = {
+    const tree: ThreadTree = {
       root,
       descendants,
       descendantFlags,
@@ -278,11 +290,11 @@ export function buildForest(inputs: ForestInputs): Forest {
       quietIgnoringOpen,
       containsActive,
     };
-    families.push(family);
-    familyOf.set(root.thread.id, family);
-    for (const info of descendants) familyOf.set(info.thread.id, family);
+    trees.push(tree);
+    treeOf.set(root.thread.id, tree);
+    for (const info of descendants) treeOf.set(info.thread.id, tree);
   }
-  return { infos, children, families, familyOf, subtrees };
+  return { infos, children, trees, treeOf, subtrees };
 }
 
 /** Ids from `id` up to (not including) `stopAt`, nearest first. */