@gperezmz/bb-plugin-thread-glance 0.1.2

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

@@ -0,0 +1,669 @@
+// The list view: groups, their counters and the flat rows
+// each one renders. Components draw this; they decide nothing. Pure.
+import type {
+  PluginSidebarProject,
+  PluginSidebarSection,
+  PluginSidebarThread,
+} from "@get-bb/plugin-sdk/app";
+import type { Preferences } from "@/shared/preferences";
+import { ancestorsOf, type Family, type Forest, type Subtree, type ThreadInfo } from "./families";
+import {
+  builtinGroup,
+  entityGroups,
+  groupIdForRoot,
+  isGroupCollapsed,
+  ORDER_PREFERENCE,
+  PINNED_GROUP_ID,
+  resolveGroupOrder,
+  THREADS_GROUP_ID,
+  type GroupDescriptor,
+} from "./groups";
+import { addCounters, countFamilies, EMPTY_COUNTERS, type Counters } from "./counters";
+import { comparePinned, effectiveSortField, makeComparator, type SortKey } from "./sort";
+import { mostUrgent, type Flag } from "./state";
+import type { Targets } from "./expansion";
+import { railsFor, type Rail } from "./layout";
+
+/** How many quiet roots stay in a group. */
+export const KEEP_QUIET = 5;
+/** How many quiet children stay in an expanded family. */
+export const KEEP_QUIET_CHILDREN = 3;
+
+export type ListFilter = "all" | "attention";
+
+export interface Chip {
+  count: number;
+  flag: Flag | null;
+  /** Every child shows: folded, the user expanded it; tree, it's open. */
+  expanded: boolean;
+  /** Harnesses among the visible children that differ from the parent's. */
+  providerIds: string[];
+}
+
+export interface ThreadRow {
+  type: "thread";
+  key: string;
+  info: ThreadInfo;
+  /** Visual depth: 0 for roots; 1 for every child in folded nesting. */
+  depth: number;
+  /** Grandchild or deeper in folded nesting: draws `↳`. */
+  nested: boolean;
+  /** Title of the thread this one attaches to, for tooltips and labels. */
+  parentTitle: string | null;
+  chip: Chip | null;
+  /** Guide rails by nesting level. */
+  rails: (Rail | null)[];
+  /** A hidden thread shown because it needs you or failed. */
+  hiddenBadge: boolean;
+  /** "In project X" when the thread is outside its family's group. */
+  crossGroupLabel: string | null;
+  /** Tree nesting: this parent row sticks at this level (0-3), or null. */
+  stickyLevel: number | null;
+  projectId: string;
+}
+
+export interface OlderRow {
+  type: "older";
+  key: string;
+  /** A group id, or a parent thread id for a family's fold. */
+  scopeId: string;
+  /** `reveal`: an auto-reveal left `count` children hidden ("+N more"). */
+  scope: "group" | "family" | "reveal";
+  count: number;
+  expanded: boolean;
+  depth: number;
+  rails: (Rail | null)[];
+}
+
+export interface EnvironmentRow {
+  type: "environment";
+  key: string;
+  environmentId: string;
+  label: string;
+  environmentProviderId: string | null;
+  projectId: string;
+  sectionId: string | null;
+  threadIds: string[];
+  collapsed: boolean;
+  flag: Flag | null;
+  depth: number;
+  rails: (Rail | null)[];
+}
+
+/** Under an opened chip that Needs attention leaves with nothing to show. */
+export interface EmptyRow {
+  type: "empty";
+  key: string;
+  /** The parent whose chip is open. */
+  scopeId: string;
+  depth: number;
+  rails: (Rail | null)[];
+}
+
+export const EMPTY_LEVEL_TEXT = "No child threads need attention";
+
+export type Row = ThreadRow | OlderRow | EnvironmentRow | EmptyRow;
+
+export interface GroupView {
+  descriptor: GroupDescriptor;
+  counters: Counters;
+  /** What the user stored. */
+  userCollapsed: boolean;
+  /** What is drawn: user collapse, unless a target opened it. */
+  collapsed: boolean;
+  hidden: boolean;
+  rows: Row[];
+  /** Every family root bucketed in the group, before filtering and folding. */
+  rootIds: string[];
+}
+
+export interface ListView {
+  groups: GroupView[];
+  /** Hidden groups, shown in the More popover. */
+  more: GroupView[];
+  moreCounters: Counters;
+  /** Resolved top-level order for the mode, for header drag. */
+  order: string[];
+  /** Threads span more than one host (the row's second line). */
+  multiHost: boolean;
+  /** Threads Needs attention would show for their own flags (the filter's badge). */
+  attentionCount: number;
+}
+
+export interface ViewInputs {
+  forest: Forest;
+  threads: readonly PluginSidebarThread[];
+  projects: readonly PluginSidebarProject[];
+  sections: readonly PluginSidebarSection[];
+  prefs: Preferences;
+  filter: ListFilter;
+  activeThreadId: string | null;
+  targets: Targets;
+}
+
+interface Context extends ViewInputs {
+  compare: (a: SortKey, b: SortKey) => number;
+  expandedChildren: ReadonlySet<string>;
+  collapsedChildren: ReadonlySet<string>;
+  expandedOlder: ReadonlySet<string>;
+  collapsedEnvironments: ReadonlySet<string>;
+  /** Parent ids on the path to a reveal target. */
+  revealPath: ReadonlySet<string>;
+  revealIds: ReadonlySet<string>;
+  /** The open thread and its ancestors. */
+  activePath: ReadonlySet<string>;
+  projectNames: ReadonlyMap<string, string>;
+  sectionNames: ReadonlyMap<string, string>;
+  subtreeAttention: Map<string, number>;
+}
+
+function titleOf(context: Context, id: string | null): string | null {
+  if (id === null) return null;
+  return context.forest.infos.get(id)?.thread.displayTitle ?? null;
+}
+
+function crossGroupLabel(context: Context, info: ThreadInfo, root: ThreadInfo): string | null {
+  const thread = info.thread;
+  const rootThread = root.thread;
+  if (info === root) return null;
+  switch (context.prefs.organizationMode) {
+    case "project":
+      if (thread.projectId === rootThread.projectId) return null;
+      return `In project ${context.projectNames.get(thread.projectId) ?? "another project"}`;
+    case "chronological":
+      if (thread.sectionId === rootThread.sectionId) return null;
+      return thread.sectionId === null
+        ? "In Threads"
+        : `In section ${context.sectionNames.get(thread.sectionId) ?? "another section"}`;
+    case "machine":
+      if ((thread.host?.id ?? null) === (rootThread.host?.id ?? null)) return null;
+      return thread.host === null ? "On no machine" : `On machine ${thread.host.name}`;
+  }
+}
+
+function threadRow(
+  context: Context,
+  info: ThreadInfo,
+  root: ThreadInfo,
+  options: { depth: number; nested: boolean; chip: Chip | null; stickyLevel?: number | null },
+): ThreadRow {
+  return {
+    type: "thread",
+    key: `thread:${info.thread.id}`,
+    info,
+    depth: options.depth,
+    nested: options.nested,
+    parentTitle: titleOf(context, info.parentId),
+    chip: options.chip,
+    rails: [],
+    hiddenBadge: info.thread.isHidden,
+    crossGroupLabel: crossGroupLabel(context, info, root),
+    stickyLevel: options.stickyLevel ?? null,
+    projectId: info.thread.projectId,
+  };
+}
+
+function matchesAttention(info: ThreadInfo): boolean {
+  return info.attention.size > 0;
+}
+
+/** The children of `parent` that get a row: hidden ones only when they need you or failed. */
+function eligibleChildren(context: Context, parentId: string): ThreadInfo[] {
+  return (context.forest.children.get(parentId) ?? [])
+    .map((id) => context.forest.infos.get(id)!)
+    .filter((info) => !info.thread.isHidden || info.attention.size > 0);
+}
+
+function subtreeOf(context: Context, id: string): Subtree {
+  return context.forest.subtrees.get(id)!;
+}
+
+/**
+ * The children of one parent that show in folded nesting. Each level
+ * folds on its own: its direct children only, and a child's own children wait
+ * for that child's chip. A child never shows without its parent, because the
+ * parent's level is the only place it is drawn.
+ */
+function foldedChildren(
+  context: Context,
+  parent: ThreadInfo,
+  depth: number,
+): { shown: ThreadInfo[]; older: OlderRow | null } {
+  const parentId = parent.thread.id;
+  const kids = eligibleChildren(context, parentId);
+  const holds = (kid: ThreadInfo, test: (info: ThreadInfo) => boolean) =>
+    test(kid) || subtreeOf(context, kid.thread.id).descendants.some(test);
+
+  if (context.filter === "attention") {
+    const shown = kids.filter((kid) => holds(kid, (info) => matchesAttention(info) || info.isActive));
+    return { shown, older: null };
+  }
+
+  const reveals = (kid: ThreadInfo) => context.revealIds.has(kid.thread.id) || context.revealPath.has(kid.thread.id);
+  const olderRow = (scope: "family" | "reveal", count: number, expanded: boolean): OlderRow | null =>
+    count > 0
+      ? {
+          type: "older",
+          key: `older:${scope}:${parentId}`,
+          scopeId: parentId,
+          scope,
+          count,
+          expanded,
+          depth,
+          rails: [],
+        }
+      : null;
+
+  if (!context.expandedChildren.has(parentId)) {
+    const shown = kids.filter(reveals);
+    // An auto-reveal says how much it left out.
+    const left = kids.filter((kid) => !reveals(kid) && !kid.thread.isHidden).length;
+    return { shown, older: shown.length > 0 ? olderRow("reveal", left, false) : null };
+  }
+
+  // The stable set reads `settled` for the child and everything under it, and
+  // ignores which thread is open and the reveal targets: they join afterwards
+  // and take no other row's place.
+  const quietTree = (kid: ThreadInfo) => kid.settled && subtreeOf(context, kid.thread.id).settled;
+  const stable = new Set<string>();
+  for (const kid of kids) if (kid.thread.isHidden || !quietTree(kid)) stable.add(kid.thread.id);
+  const recentQuiet = kids
+    .filter((kid) => !stable.has(kid.thread.id) && !kid.thread.isHidden)
+    .sort((a, b) => b.thread.createdAt - a.thread.createdAt)
+    .slice(0, KEEP_QUIET_CHILDREN);
+  for (const kid of recentQuiet) stable.add(kid.thread.id);
+  const olderExpanded = context.expandedOlder.has(parentId);
+  const kept = (kid: ThreadInfo) =>
+    stable.has(kid.thread.id) || reveals(kid) || context.activePath.has(kid.thread.id);
+  // Open, the fold still counts what it holds, so its row can close it again.
+  const folded = kids.filter((kid) => !kept(kid)).length;
+  const shown = olderExpanded ? kids : kids.filter(kept);
+  return { shown, older: olderRow("family", folded, olderExpanded) };
+}
+
+function subtreeAttention(context: Context, id: string): number {
+  const cached = context.subtreeAttention.get(id);
+  if (cached !== undefined) return cached;
+  context.subtreeAttention.set(id, context.forest.infos.get(id)?.thread.latestAttentionAt ?? 0);
+  let max = context.forest.infos.get(id)?.thread.latestAttentionAt ?? 0;
+  for (const child of context.forest.children.get(id) ?? []) {
+    max = Math.max(max, subtreeAttention(context, child));
+  }
+  context.subtreeAttention.set(id, max);
+  return max;
+}
+
+function environmentLabel(thread: PluginSidebarThread): string {
+  const environment = thread.environment;
+  if (environment === null) return "Environment";
+  if (environment.name) return environment.name;
+  if (environment.branchName) return environment.branchName;
+  if (environment.path) return environment.path.split(/[\\/]/).filter(Boolean).pop() ?? "Environment";
+  return "Environment";
+}
+
+type Unit = { info: ThreadInfo; rows: Row[]; flags: ReadonlySet<Flag> };
+
+/**
+ * Folds sibling units that share a worktree environment (2 or more) into a
+ * folder row. Off unless the environment grouping preference is on.
+ */
+function clusterEnvironments(context: Context, units: Unit[], depth: number): Row[] {
+  if (!context.prefs.environmentGrouping) return units.flatMap((unit) => unit.rows);
+  const counts = new Map<string, number>();
+  for (const unit of units) {
+    const environment = unit.info.thread.environment;
+    if (environment?.isWorktree === true && environment.id !== null) {
+      counts.set(environment.id, (counts.get(environment.id) ?? 0) + 1);
+    }
+  }
+  const rows: Row[] = [];
+  const emitted = new Set<string>();
+  for (const unit of units) {
+    const environment = unit.info.thread.environment;
+    const id = environment?.isWorktree === true ? environment.id : null;
+    if (id === null || (counts.get(id) ?? 0) < 2) {
+      rows.push(...unit.rows);
+      continue;
+    }
+    if (emitted.has(id)) continue;
+    emitted.add(id);
+    const members = units.filter((candidate) => candidate.info.thread.environment?.id === id);
+    const collapsed = context.collapsedEnvironments.has(id);
+    const flags = new Set<Flag>();
+    for (const member of members) for (const flag of member.flags) flags.add(flag);
+    rows.push({
+      type: "environment",
+      key: `environment:${id}:${unit.info.thread.id}`,
+      environmentId: id,
+      label: environmentLabel(unit.info.thread),
+      environmentProviderId: environment?.providerId ?? null,
+      projectId: unit.info.thread.projectId,
+      sectionId: unit.info.thread.sectionId,
+      threadIds: members.map((member) => member.info.thread.id),
+      collapsed,
+      flag: collapsed ? mostUrgent(flags) : null,
+      depth,
+      rails: [],
+    });
+    if (!collapsed) {
+      for (const member of members) {
+        for (const row of member.rows) rows.push({ ...row, depth: row.depth + 1 });
+      }
+    }
+  }
+  return rows;
+}
+
+/** Distinct child harnesses other than the parent's, at most three. */
+function childProviders(parent: ThreadInfo, descendants: readonly ThreadInfo[]): string[] {
+  const ids: string[] = [];
+  for (const info of descendants) {
+    const id = info.thread.providerId;
+    if (info.thread.isHidden || id === parent.thread.providerId || ids.includes(id)) continue;
+    ids.push(id);
+    if (ids.length === 3) break;
+  }
+  return ids;
+}
+
+/** The chip of a parent: its children's count, most urgent flag and harnesses. */
+function chipOf(context: Context, info: ThreadInfo, expanded: boolean): Chip | null {
+  const subtree = subtreeOf(context, info.thread.id);
+  const hasChildren =
+    subtree.visibleCount > 0 || subtree.descendants.some((descendant) => descendant.thread.isHidden && descendant.attention.size > 0);
+  if (!hasChildren) return null;
+  return {
+    count: subtree.visibleCount,
+    flag: mostUrgent(subtree.flags),
+    expanded,
+    providerIds: childProviders(info, subtree.descendants),
+  };
+}
+
+/** What a thread and everything under it carry, for an environment folder's glyph. */
+function rollupFlags(context: Context, info: ThreadInfo): Set<Flag> {
+  const flags = new Set<Flag>([...info.attention, ...subtreeOf(context, info.thread.id).flags]);
+  if (info.flags.has("working")) flags.add("working");
+  return flags;
+}
+
+/** The rows under `parent` in folded nesting: each shown child, then its own level. */
+function foldedLevel(context: Context, family: Family, parent: ThreadInfo, depth: number): Row[] {
+  const { shown, older } = foldedChildren(context, parent, depth);
+  const units: Unit[] = shown.map((info) => ({
+    info,
+    flags: rollupFlags(context, info),
+    rows: [
+      threadRow(context, info, family.root, {
+        depth,
+        nested: depth > 1,
+        // Expanded only when the user expanded it: an auto-reveal shows a
+        // chevron that still expands, and a "N more child threads" row.
+        chip: chipOf(context, info, context.expandedChildren.has(info.thread.id)),
+      }),
+      ...foldedLevel(context, family, info, depth + 1),
+    ],
+  }));
+  const rows = clusterEnvironments(context, units, depth);
+  if (older !== null) rows.push(older);
+  // An opened chip that the filter empties says so, instead of showing an open chevron over nothing.
+  if (context.filter === "attention" && shown.length === 0 && context.expandedChildren.has(parent.thread.id)) {
+    rows.push({ type: "empty", key: `empty:${parent.thread.id}`, scopeId: parent.thread.id, depth, rails: [] });
+  }
+  return rows;
+}
+
+function foldedFamilyRows(context: Context, family: Family): Row[] {
+  const root = family.root;
+  const chip = chipOf(context, root, context.expandedChildren.has(root.thread.id));
+  return [threadRow(context, root, root, { depth: 0, nested: false, chip }), ...foldedLevel(context, family, root, 1)];
+}
+
+/** Tree nesting: bb's tree, with chips on collapsed parents. */
+function treeRows(context: Context, family: Family, info: ThreadInfo, depth: number): Unit {
+  const id = info.thread.id;
+  const root = family.root;
+  const childIds = (context.forest.children.get(id) ?? []).filter((childId) => {
+    const child = context.forest.infos.get(childId)!;
+    return !child.thread.isHidden || child.attention.size > 0;
+  });
+  const subtree = subtreeOf(context, id);
+  let children = childIds.map((childId) => context.forest.infos.get(childId)!);
+  if (context.filter === "attention") {
+    children = children.filter((child) => {
+      const test = (candidate: ThreadInfo) => matchesAttention(candidate) || candidate.isActive;
+      return test(child) || subtreeOf(context, child.thread.id).descendants.some(test);
+    });
+  }
+  const open =
+    context.filter === "attention" ||
+    !context.collapsedChildren.has(id) ||
+    context.revealPath.has(id);
+  const chip: Chip | null =
+    childIds.length > 0
+      ? // Drawn closed when the filter leaves nothing under it.
+        { count: subtree.visibleCount, flag: mostUrgent(subtree.flags), expanded: open && children.length > 0, providerIds: childProviders(info, subtree.descendants) }
+      : null;
+  const ownRow = threadRow(context, info, root, {
+    depth,
+    nested: false,
+    chip,
+    stickyLevel: open && children.length > 0 && depth < 4 ? depth : null,
+  });
+  const ownFlags = rollupFlags(context, info);
+  if (!open || children.length === 0) return { info, rows: [ownRow], flags: ownFlags };
+  const keyed = children.map((child) => ({
+    child,
+    key: { thread: child.thread, familyAttention: subtreeAttention(context, child.thread.id) },
+  }));
+  keyed.sort((a, b) => context.compare(a.key, b.key));
+  const units = keyed.map(({ child }) => treeRows(context, family, child, depth + 1));
+  return { info, rows: [ownRow, ...clusterEnvironments(context, units, depth + 1)], flags: ownFlags };
+}
+
+function familyUnit(context: Context, family: Family): Unit {
+  if (context.prefs.nesting === "tree") return treeRows(context, family, family.root, 0);
+  return { info: family.root, rows: foldedFamilyRows(context, family), flags: family.flags };
+}
+
+/** needs-you, then failed, then offline, then unread, then the rest. */
+export function urgency(family: Family): number {
+  const flags = family.attentionFlags;
+  if (flags.has("needs-you")) return 0;
+  if (flags.has("unread-failed") || flags.has("queue-failed")) return 1;
+  if (flags.has("offline")) return 2;
+  if (flags.has("unread")) return 3;
+  return 4;
+}
+
+function buildGroup(
+  context: Context,
+  descriptor: GroupDescriptor,
+  families: Family[],
+  hidden: boolean,
+): GroupView | null {
+  const counters = countFamilies(families);
+  const userCollapsed = isGroupCollapsed(descriptor, context.prefs);
+  const hasTarget = families.some(
+    (family) =>
+      context.targets.has(family.root.thread.id) ||
+      family.descendants.some((info) => context.targets.has(info.thread.id)),
+  );
+  const collapsed = userCollapsed && !hasTarget;
+  const isPinned = descriptor.id === PINNED_GROUP_ID;
+
+  let kept = families;
+  if (context.filter === "attention") {
+    kept = families.filter((family) => family.attentionFlags.size > 0 || family.containsActive);
+    if (kept.length === 0) return null;
+  }
+
+  const sorted = [...kept];
+  if (context.filter === "attention") {
+    // Needs attention reads most urgent first.
+    sorted.sort(
+      (a, b) =>
+        urgency(a) - urgency(b) ||
+        context.compare(
+          { thread: a.root.thread, familyAttention: a.attention },
+          { thread: b.root.thread, familyAttention: b.attention },
+        ),
+    );
+  } else if (isPinned) {
+    sorted.sort((a, b) => comparePinned(a.root.thread, b.root.thread));
+  } else {
+    sorted.sort((a, b) =>
+      context.compare(
+        { thread: a.root.thread, familyAttention: a.attention },
+        { thread: b.root.thread, familyAttention: b.attention },
+      ),
+    );
+  }
+
+  let visible = sorted;
+  let older: OlderRow | null = null;
+  const foldable = !isPinned && context.filter === "all" && context.prefs.foldOlder;
+  if (foldable) {
+    // The fold reads `settled`, as if no thread were open. The open family
+    // joins afterwards when it sits behind the fold, and takes no other row's place.
+    const quietActive = sorted.filter((family) => family.settled && !family.root.thread.isArchived);
+    const keepQuiet = new Set(quietActive.slice(0, KEEP_QUIET));
+    const foldedFamilies = quietActive.filter((family) => !keepQuiet.has(family) && !family.containsActive);
+    if (foldedFamilies.length > 0) {
+      const opened =
+        context.expandedOlder.has(descriptor.id) ||
+        foldedFamilies.some(
+          (family) =>
+            context.targets.has(family.root.thread.id) ||
+            family.descendants.some((info) => context.targets.has(info.thread.id)),
+        );
+      const folded = new Set(foldedFamilies);
+      if (!opened) visible = sorted.filter((family) => !folded.has(family));
+      older = {
+        type: "older",
+        key: `older:group:${descriptor.id}`,
+        scopeId: descriptor.id,
+        scope: "group",
+        count: foldedFamilies.length,
+        expanded: opened,
+        depth: 0,
+        rails: [],
+      };
+    }
+  }
+
+  const units = visible.map((family) => familyUnit(context, family));
+  const clustered = clusterEnvironments(context, units, 0);
+  const rails = railsFor(clustered.map((row) => row.depth));
+  const rows = clustered.map((row, index) => ({ ...row, rails: rails[index]! }));
+  if (older !== null) rows.push(older);
+  return {
+    descriptor,
+    counters,
+    userCollapsed,
+    collapsed,
+    hidden,
+    rows,
+    rootIds: families.map((family) => family.root.thread.id),
+  };
+}
+
+export function buildListView(inputs: ViewInputs): ListView {
+  const { forest, prefs } = inputs;
+  const revealIds = new Set<string>();
+  const revealPath = new Set<string>();
+  for (const [id, kind] of inputs.targets) {
+    if (kind !== "reveal" || !forest.infos.has(id)) continue;
+    revealIds.add(id);
+    for (const ancestor of ancestorsOf(id, forest.infos)) revealPath.add(ancestor);
+  }
+  const activePath = new Set<string>();
+  if (inputs.activeThreadId !== null && forest.infos.has(inputs.activeThreadId)) {
+    activePath.add(inputs.activeThreadId);
+    for (const ancestor of ancestorsOf(inputs.activeThreadId, forest.infos)) activePath.add(ancestor);
+  }
+  const context: Context = {
+    ...inputs,
+    compare: makeComparator({
+      field: prefs.chronologicalSort,
+      direction: prefs.sortDirection,
+      workingFirst: prefs.workingFirst,
+    }),
+    expandedChildren: new Set(prefs.expandedChildren),
+    collapsedChildren: new Set(prefs.collapsedChildren),
+    expandedOlder: new Set(prefs.expandedOlder),
+    collapsedEnvironments: new Set(prefs.collapsedEnvironments),
+    revealIds,
+    revealPath,
+    activePath,
+    projectNames: new Map(inputs.projects.map((project) => [project.id, project.name])),
+    sectionNames: new Map(inputs.sections.map((section) => [section.id, section.name])),
+    subtreeAttention: new Map(),
+  };
+
+  const byGroup = new Map<string, Family[]>();
+  for (const family of forest.families) {
+    const id = groupIdForRoot(family.root.thread, {
+      mode: prefs.organizationMode,
+      projects: inputs.projects,
+    });
+    const list = byGroup.get(id) ?? [];
+    list.push(family);
+    byGroup.set(id, list);
+  }
+
+  const alphabetical = effectiveSortField(prefs.chronologicalSort) === "alpha";
+  const entities = entityGroups(
+    { mode: prefs.organizationMode, projects: inputs.projects, sections: inputs.sections, threads: inputs.threads },
+    alphabetical,
+  );
+  const descriptors = new Map<string, GroupDescriptor>(entities.map((group) => [group.id, group]));
+  descriptors.set(PINNED_GROUP_ID, builtinGroup(PINNED_GROUP_ID, inputs.projects));
+  descriptors.set(THREADS_GROUP_ID, builtinGroup(THREADS_GROUP_ID, inputs.projects));
+  const order = resolveGroupOrder(
+    prefs.organizationMode,
+    prefs[ORDER_PREFERENCE[prefs.organizationMode]],
+    entities.map((group) => group.id),
+  );
+  const hiddenIds = new Set(prefs.hiddenGroups);
+
+  const groups: GroupView[] = [];
+  const more: GroupView[] = [];
+  let moreCounters = EMPTY_COUNTERS;
+  for (const id of order) {
+    const descriptor = descriptors.get(id);
+    if (descriptor === undefined) continue;
+    const families = byGroup.get(id) ?? [];
+    // Pinned and the loose bucket appear only when they hold threads,
+    // except the loose bucket in custom-section mode, as in bb.
+    if (families.length === 0) {
+      if (id === PINNED_GROUP_ID) continue;
+      if (id === THREADS_GROUP_ID && prefs.organizationMode !== "chronological") continue;
+    }
+    const hidden = id !== PINNED_GROUP_ID && hiddenIds.has(id);
+    const view = buildGroup(context, descriptor, families, hidden);
+    if (view === null) continue;
+    if (hidden) {
+      more.push(view);
+      moreCounters = addCounters(moreCounters, view.counters);
+    } else {
+      groups.push(view);
+    }
+  }
+
+  const hosts = new Set<string>();
+  for (const thread of inputs.threads) if (thread.host !== null) hosts.add(thread.host.id);
+  let attentionCount = 0;
+  for (const family of forest.families) {
+    for (const info of [family.root, ...family.descendants]) {
+      if (!info.thread.isArchived && matchesAttention(info)) attentionCount += 1;
+    }
+  }
+  return { groups, more, moreCounters, order, multiHost: hosts.size > 1, attentionCount };
+}
+
+/** Every thread row in visual order, for keyboard and windowing. */
+export function threadRowsOf(rows: readonly Row[]): ThreadRow[] {
+  return rows.filter((row): row is ThreadRow => row.type === "thread");
+}

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

@@ -0,0 +1,27 @@
+// Row windowing. Pure helpers; the observer lives in a hook.
+
+export interface NavTarget {
+  threadId: string;
+  projectId: string;
+}
+
+/**
+ * The value of `data-sidebar-windowed-nav` for an off-screen chunk:
+ * `threadId:projectId` pairs in visual order, space-separated. This is an
+ * undocumented host contract in bb 0.43.4; a test pins it.
+ */
+export function windowedNavValue(targets: readonly NavTarget[]): string {
+  return targets.map((target) => `${target.threadId}:${target.projectId}`).join(" ");
+}
+
+/** Rows per windowed chunk. */
+export const CHUNK_SIZE = 25;
+
+/** Splits rows into fixed-size chunks, keeping their order. */
+export function chunk<T>(items: readonly T[], size = CHUNK_SIZE): T[][] {
+  const chunks: T[][] = [];
+  for (let index = 0; index < items.length; index += size) {
+    chunks.push(items.slice(index, index + size));
+  }
+  return chunks;
+}