import { describe, expect, it } from "vitest"; import type { AgentGUIConversationSummary } from "./agentGuiConversationModel"; import type { ConversationSection } from "../agentGuiNodeViewConversation"; import { conversationRailActiveOverlayCountsTowardTotal, conversationRailSectionActiveConversationId, conversationRailSectionHeaderVisibility, insertConversationRailSectionOverlay, conversationSummariesRenderEqual, isConversationRailInitialLoadPending, projectConversationRailMemberships, projectConversationRailSearchSections, projectConversationRailSectionsByExactKey, projectConversationRailSectionsWithActiveConversation, planRuntimeRailMembershipRefresh, projectRuntimeSectionsToConversationRailMemberships, projectConversationRailSectionsWithTransientConversations, resolveConversationRailActiveConversation } from "./agentGuiConversationRail"; import type { ConversationRailSectionMembership } from "./agentGuiConversationRail"; import { preserveConversationRailSectionTemplates } from "./agentGuiConversationRailSectionTemplates"; const railLabels = { sectionConversations: "Conversations", sectionPinned: "Pinned" }; describe("conversationRailSectionHeaderVisibility", () => { it("keeps one Pinned title and places Projects before Chats when every project is pinned", () => { const sections: ConversationSection[] = [ { id: "project:/pinned", items: [], kind: "project", label: "Pinned project", project: { id: "pinned-project", label: "Pinned project", path: "/pinned", pinnedAtUnixMs: 10, sectionKey: "project:/pinned" } }, { id: "conversations", items: [], kind: "conversations", label: "Chats", project: null } ]; expect(conversationRailSectionHeaderVisibility(sections, 0)).toEqual({ showPinnedHeader: true, showProjectsHeader: false }); expect(conversationRailSectionHeaderVisibility(sections, 1)).toEqual({ showPinnedHeader: false, showProjectsHeader: true }); }); }); describe("conversationRailSectionActiveConversationId", () => { it("projects selection only into the section that owns the row", () => { const first = section([conversation("first")])[0]!; const second = { ...first, id: "project:/second", items: [conversation("second")] }; expect( [first, second].map((railSection) => conversationRailSectionActiveConversationId({ activeConversation: null, activeConversationId: "second", section: railSection }) ) ).toEqual([null, "second"]); }); it("keeps a selected overlay active in its projected section", () => { const railSection = section([])[0]!; const activeConversation = conversation("historical"); expect( conversationRailSectionActiveConversationId({ activeConversation, activeConversationId: activeConversation.id, section: railSection }) ).toBe(activeConversation.id); }); }); function conversation( id: string, pinnedAtUnixMs: number | null = null ): AgentGUIConversationSummary { return { agentTargetId: "local:codex", cwd: "/workspace", id, pinnedAtUnixMs, provider: "codex", railSectionKey: "project:/workspace", status: "ready", title: id, updatedAtUnixMs: 1 }; } function section( items: readonly AgentGUIConversationSummary[] ): ConversationSection[] { return [ { id: "project:/workspace", items: [...items], kind: "project", label: "Workspace", project: { id: "workspace", label: "Workspace", path: "/workspace", pinnedAtUnixMs: 0, sectionKey: "project:/workspace" } } ]; } describe("isConversationRailInitialLoadPending", () => { it("blocks only while the first runtime membership page is unresolved", () => { expect( isConversationRailInitialLoadPending({ pending: true, runtimeSectionsEnabled: true, sections: null }) ).toBe(true); expect( isConversationRailInitialLoadPending({ pending: true, runtimeSectionsEnabled: true, sections: [] }) ).toBe(false); expect( isConversationRailInitialLoadPending({ pending: false, runtimeSectionsEnabled: true, sections: null }) ).toBe(false); }); }); function membership( items: readonly AgentGUIConversationSummary[] ): ConversationRailSectionMembership[] { return [ { id: "project:/workspace", kind: "project", project: section([])[0]?.project ?? null, sessionIds: items.map((item) => item.id) } ]; } describe("planRuntimeRailMembershipRefresh", () => { it("re-renders a row when its leading mention kind becomes available", () => { const plain = conversation("session-1"); expect( conversationSummariesRenderEqual(plain, { ...plain, titleLeadingMentionKind: "task" }) ).toBe(false); }); it("treats hydration of an already-loaded historical row as entity detail", () => { const recent = conversation("recent"); const historical = conversation("historical"); expect( planRuntimeRailMembershipRefresh({ loadedSections: membership([recent, historical]), next: [recent, historical], previous: [recent] }) ).toEqual({ kind: "none" }); }); it("ignores summary ordering changes", () => { const first = conversation("first"); const second = conversation("second"); expect( planRuntimeRailMembershipRefresh({ loadedSections: membership([first, second]), next: [second, first], previous: [first, second] }) ).toEqual({ kind: "none" }); }); it("refreshes for a newly discovered session outside loaded pages", () => { const recent = conversation("recent"); expect( planRuntimeRailMembershipRefresh({ loadedSections: membership([recent]), next: [conversation("brand-new"), recent], previous: [recent] }) ).toEqual({ kind: "refresh_pages", pageIds: ["project:/workspace"], reconcilingSessionIds: [], refreshSearch: false }); }); it("refreshes for removal and pin membership changes", () => { const first = conversation("first"); const second = conversation("second"); expect( planRuntimeRailMembershipRefresh({ loadedSections: membership([first, second]), next: [first], previous: [first, second] }) ).toEqual({ kind: "refresh_pages", pageIds: ["project:/workspace"], reconcilingSessionIds: [], refreshSearch: false }); expect( planRuntimeRailMembershipRefresh({ loadedSections: membership([first]), next: [conversation("first", 100)], previous: [first] }) ).toEqual({ kind: "refresh_pages", pageIds: ["project:/workspace", "pinned"], reconcilingSessionIds: [], refreshSearch: false }); }); it("ignores pending creation add and removal", () => { const recent = conversation("recent"); const pending = { ...conversation("pending"), pendingCreation: true }; expect( planRuntimeRailMembershipRefresh({ loadedSections: membership([recent]), next: [pending, recent], previous: [recent] }) ).toEqual({ kind: "none" }); expect( planRuntimeRailMembershipRefresh({ loadedSections: membership([recent]), next: [recent], previous: [pending, recent] }) ).toEqual({ kind: "none" }); }); it("does not treat selected detail hydration as rail membership", () => { const recent = conversation("recent"); expect( planRuntimeRailMembershipRefresh({ activeConversationId: "selected-historical", loadedSections: membership([recent]), next: [conversation("selected-historical"), recent], previous: [recent] }) ).toEqual({ kind: "none" }); }); it("refreshes and preserves display membership when pending creation becomes canonical", () => { const recent = conversation("recent"); const pending = { ...conversation("new-session"), pendingCreation: true }; expect( planRuntimeRailMembershipRefresh({ activeConversationId: "new-session", loadedSections: membership([recent]), next: [conversation("new-session"), recent], previous: [pending, recent] }) ).toEqual({ kind: "refresh_pages", pageIds: ["project:/workspace"], reconcilingSessionIds: ["new-session"], refreshSearch: false }); }); it("refreshes search only when a title changes under an active query", () => { const previous = conversation("session-1"); expect( planRuntimeRailMembershipRefresh({ loadedSections: membership([previous]), next: [{ ...previous, title: "Renamed" }], previous: [previous], searchActive: true }) ).toEqual({ kind: "refresh_pages", pageIds: [], reconcilingSessionIds: [], refreshSearch: true }); }); }); describe("projectRuntimeSectionsToConversationRailMemberships", () => { it("preserves the daemon-owned project section key", () => { const memberships = projectRuntimeSectionsToConversationRailMemberships({ sections: [ { hasMore: false, kind: "project", sectionKey: "project:authoritative", sessions: [], totalCount: 0, userProject: { createdAtUnixMs: 1, id: "project-1", label: "Workspace", path: "/workspace", pinnedAtUnixMs: 0, sectionKey: "project:authoritative", updatedAtUnixMs: 2 } } ] }); expect(memberships[0]?.project?.sectionKey).toBe("project:authoritative"); expect(memberships[0]?.project?.pinnedAtUnixMs).toBe(0); }); }); describe("projectConversationRailMemberships", () => { it("requires exact agreement between the session key and section key", () => { const exact = conversation("exact"); const conflicting = { ...conversation("conflicting"), railSectionKey: "conversations" }; const projected = projectConversationRailMemberships({ conversations: [exact, conflicting], labels: { sectionConversations: "Conversations", sectionPinned: "Pinned" }, sections: membership([exact, conflicting]) }); expect(projected[0]?.items.map((item) => item.id)).toEqual(["exact"]); }); it("reorders loaded ordinary rows from current turn sort times", () => { const previouslyRecent = { ...conversation("previously-recent"), sortTimeUnixMs: 100 }; const continuedHistorical = { ...conversation("continued-historical"), sortTimeUnixMs: 200 }; const projected = projectConversationRailMemberships({ conversations: [previouslyRecent, continuedHistorical], labels: railLabels, sections: membership([previouslyRecent, continuedHistorical]) }); expect(projected[0]?.items.map((item) => item.id)).toEqual([ "continued-historical", "previously-recent" ]); }); it("keeps ordinary row order stable when only streaming freshness changes", () => { const first = { ...conversation("first"), sortTimeUnixMs: 200, updatedAtUnixMs: 1 }; const second = { ...conversation("second"), sortTimeUnixMs: 100, updatedAtUnixMs: 2 }; const sections = membership([first, second]); const projected = projectConversationRailMemberships({ conversations: [ { ...first, updatedAtUnixMs: 3 }, { ...second, updatedAtUnixMs: 4 } ], labels: railLabels, sections }); expect(projected[0]?.items.map((item) => item.id)).toEqual([ "first", "second" ]); }); it("preserves daemon-owned pinned membership order", () => { const first = { ...conversation("pinned-first", 10), railSectionKey: "conversations", sortTimeUnixMs: 100 }; const second = { ...conversation("pinned-second", 20), railSectionKey: "conversations", sortTimeUnixMs: 200 }; const projected = projectConversationRailMemberships({ conversations: [first, second], labels: railLabels, sections: [ { id: "pinned", kind: "pinned", project: null, sessionIds: [first.id, second.id] } ] }); expect(projected[0]?.items.map((item) => item.id)).toEqual([ "pinned-first", "pinned-second" ]); }); }); describe("projectConversationRailSectionsWithTransientConversations", () => { const labels = { sectionConversations: "Conversations", sectionPinned: "Pinned" }; it("keeps every running canonical session visible while its page is stale", () => { const canonical = section([conversation("older")]); const project = canonical[0]?.project ?? null; const first = { ...conversation("running-1"), project, status: "working" as const, sortTimeUnixMs: 30, updatedAtUnixMs: 30 }; const second = { ...conversation("running-2"), project, status: "waiting" as const, sortTimeUnixMs: 20, updatedAtUnixMs: 20 }; const projected = projectConversationRailSectionsWithTransientConversations( { conversations: [first, second], labels, reconcilingSessionIds: [], sections: canonical } ); expect(projected[0]?.items.map((item) => item.id)).toEqual([ "running-1", "running-2", "older" ]); expect(projected[0]?.items.map((item) => item.projectionSource)).toEqual([ "runtime_overlay", "runtime_overlay", undefined ]); }); it("keeps pending rows out of project sections until exact membership arrives", () => { const canonical = section([conversation("canonical")]); const project = canonical[0]?.project ?? null; const first = { ...conversation("session-1"), project, projectionSource: "pending_activation" as const, railSectionKey: undefined, sortTimeUnixMs: 10, updatedAtUnixMs: 10 }; const second = { ...conversation("session-2"), project, projectionSource: "pending_activation" as const, railSectionKey: undefined, sortTimeUnixMs: 20, updatedAtUnixMs: 20 }; const projected = projectConversationRailSectionsWithTransientConversations( { conversations: [second, first], labels, reconcilingSessionIds: [], sections: canonical } ); expect(projected[0]?.items.map((item) => item.id)).toEqual(["canonical"]); expect(projected).toHaveLength(1); expect(canonical[0]?.items.map((item) => item.id)).toEqual(["canonical"]); }); it("keeps a canonicalized pending row visible until daemon membership reconciles", () => { const canonical = section([conversation("older")]); const project = canonical[0]?.project ?? null; const confirmed = { ...conversation("session-1"), project, sortTimeUnixMs: 20, updatedAtUnixMs: 20 }; const nextPending = { ...conversation("session-2"), project, projectionSource: "pending_activation" as const, railSectionKey: undefined, sortTimeUnixMs: 30, updatedAtUnixMs: 30 }; const projected = projectConversationRailSectionsWithTransientConversations( { conversations: [nextPending, confirmed], labels, reconcilingSessionIds: [confirmed.id], sections: canonical } ); expect(projected).toHaveLength(1); expect(projected[0]?.items.map((item) => item.id)).toEqual([ "session-1", "older" ]); }); }); describe("insertConversationRailSectionOverlay", () => { it("inserts an active overlay without reordering server rows", () => { expect( insertConversationRailSectionOverlay( "project", [ { ...conversation("server-first"), updatedAtUnixMs: 10 }, { ...conversation("server-second"), updatedAtUnixMs: 30 } ], { ...conversation("new-active"), updatedAtUnixMs: 20 } ).map((item) => item.id) ).toEqual(["new-active", "server-first", "server-second"]); }); }); describe("projectConversationRailSectionsWithActiveConversation", () => { const labels = { sectionConversations: "Conversations", sectionPinned: "Pinned" }; it("keeps canonical sections unchanged when the active row is loaded", () => { const active = conversation("active"); const sections = section([active]); const projected = projectConversationRailSectionsWithActiveConversation({ activeConversation: active, labels: railLabels, sections }); expect(projected.sections).toBe(sections); expect(projected.activeOverlay).toEqual({ conversation: { ...active, project: sections[0]?.project }, sectionId: "project:/workspace" }); }); it("reuses the active row when its project is render-equal to the section project", () => { const active = { ...conversation("active"), project: { id: "workspace", label: "Workspace", path: "/workspace", pinnedAtUnixMs: 0, sectionKey: "project:/workspace" } }; const projected = projectConversationRailSectionsWithActiveConversation({ activeConversation: active, labels: railLabels, sections: section([active]) }); expect(projected.activeOverlay?.conversation).toBe(active); }); it("uses the active row's exact key instead of its resolved project", () => { const active = { ...conversation("active"), project: { id: "workspace", label: "Workspace", path: "/workspace", pinnedAtUnixMs: 0, sectionKey: "project:/workspace" }, railSectionKey: "conversations" }; const sections = section([conversation("recent")]); const projected = projectConversationRailSectionsWithActiveConversation({ activeConversation: active, labels, sections }); expect(projected.activeOverlay?.conversation.id).toBe("active"); expect(projected.activeOverlay?.sectionId).toBe("conversations"); expect(projected.activeOverlay?.conversation.project).toBeNull(); expect(projected.sections.map((item) => item.id)).toEqual([ "project:/workspace", "conversations" ]); expect(sections[0]?.items.map((item) => item.id)).toEqual(["recent"]); }); it("creates an exact project overlay when its keyed section is not loaded", () => { const active = { ...conversation("active"), project: { id: "other", label: "Other", path: "/other", pinnedAtUnixMs: 0, sectionKey: "project:/other" }, railSectionKey: "project:/other" }; const projected = projectConversationRailSectionsWithActiveConversation({ activeConversation: active, labels, sections: section([conversation("recent")]) }); expect(projected.sections.map((item) => item.id)).toEqual([ "project:/workspace", "project:/other" ]); expect(projected.sections[1]?.items).toEqual([]); expect(projected.activeOverlay).toEqual({ conversation: active, sectionId: "project:/other" }); }); it("does not project an active row whose backend key is absent", () => { const active = { ...conversation("active"), railSectionKey: undefined }; const sections = section([conversation("recent")]); const projected = projectConversationRailSectionsWithActiveConversation({ activeConversation: active, labels, sections }); expect(projected).toEqual({ activeOverlay: null, sections }); }); }); describe("projectConversationRailSearchSections", () => { it("uses exact loaded membership and never infers missing membership from cwd", () => { const loaded = conversation("loaded"); const resolvedProject = section([])[0]?.project ?? null; const missing = { ...conversation("missing"), cwd: "/workspace/packages/app", project: resolvedProject, railSectionKey: "conversations" }; const groups = projectConversationRailSearchSections({ conversations: [loaded, missing], labels: { sectionConversations: "Conversations", sectionPinned: "Pinned" }, sections: section([loaded]) }); expect( groups.map((group) => [group.id, group.items.map((item) => item.id)]) ).toEqual([ ["project:/workspace", ["loaded"]], ["conversations", ["missing"]] ]); }); it("preserves pinned and authoritative section order", () => { const projectA = conversation("project-a"); const projectB = { ...conversation("project-b"), railSectionKey: "project:/b", project: { id: "b", label: "B", path: "/b", pinnedAtUnixMs: 0, sectionKey: "project:/b" } }; const pinned = { ...conversation("pinned"), pinnedAtUnixMs: 1, updatedAtUnixMs: 0 }; const groups = projectConversationRailSearchSections({ conversations: [projectA, projectB, pinned], labels: railLabels, sections: [ { id: "project:/b", kind: "project", label: "B", project: projectB.project, items: [] }, ...section([]) ] }); expect(groups.map((group) => group.id)).toEqual([ "pinned", "project:/b", "project:/workspace" ]); }); it("keeps every project template visible when search matches no rows", () => { const groups = projectConversationRailSearchSections({ conversations: [], labels: railLabels, sections: [ { id: "project:/b", kind: "project", label: "B", project: { id: "b", label: "B", path: "/b", pinnedAtUnixMs: 0, sectionKey: "project:/b" }, items: [] }, ...section([]), { id: "conversations", kind: "conversations", label: "Conversations", project: null, items: [] } ] }); expect(groups.map((group) => group.id)).toEqual([ "project:/b", "project:/workspace", "conversations" ]); expect(groups.every((group) => group.items.length === 0)).toBe(true); }); }); describe("projectConversationRailSectionsByExactKey", () => { it("orders pinned sessions, pinned projects, ordinary projects, then Chats without duplicating sessions", () => { const pinnedSession = { ...conversation("pinned-session", 100), project: null }; const pinnedProject = { id: "pinned-project", label: "Pinned project", path: "/pinned", pinnedAtUnixMs: 90, sectionKey: "project:/pinned" }; const ordinaryProject = { id: "ordinary-project", label: "Ordinary project", path: "/ordinary", pinnedAtUnixMs: 0, sectionKey: "project:/ordinary" }; const pinnedProjectSession = { ...conversation("pinned-project-session"), project: pinnedProject, railSectionKey: pinnedProject.sectionKey }; const groups = projectConversationRailSectionsByExactKey({ conversations: [pinnedProjectSession, pinnedSession], labels: railLabels, userProjects: [ordinaryProject, pinnedProject], includeEmptySections: true }); expect(groups.map((group) => group.id)).toEqual([ "pinned", "project:/pinned", "project:/ordinary", "conversations" ]); expect( groups.flatMap((group) => group.items.map((item) => item.id)) ).toEqual(["pinned-session", "pinned-project-session"]); }); it("uses only exact backend keys and keeps empty authoritative sections", () => { const projectSummary = { id: "workspace", label: "Workspace", path: "/workspace", pinnedAtUnixMs: 0, sectionKey: "project:/workspace" }; const exactProject = { ...conversation("exact-project"), project: projectSummary }; const conversations = { ...conversation("general"), cwd: "/workspace/nested", project: projectSummary, railSectionKey: "conversations" }; const missingKey = { ...conversation("missing-key"), project: projectSummary, railSectionKey: undefined }; const groups = projectConversationRailSectionsByExactKey({ conversations: [conversations, missingKey, exactProject], labels: railLabels, userProjects: [ { ...projectSummary, createdAtUnixMs: 1, updatedAtUnixMs: 1, lastUsedAtUnixMs: 1 }, { id: "empty", label: "Empty", path: "/empty", pinnedAtUnixMs: 0, sectionKey: "project:/empty", createdAtUnixMs: 1, updatedAtUnixMs: 1, lastUsedAtUnixMs: 1 } ], includeEmptySections: true }); expect( groups.map((group) => [group.id, group.items.map((item) => item.id)]) ).toEqual([ ["project:/workspace", ["exact-project"]], ["project:/empty", []], ["conversations", ["general"]] ]); }); it("keeps empty user-project templates when filtering loaded rows", () => { const groups = projectConversationRailSectionsByExactKey({ conversations: [], labels: railLabels, userProjects: [ { id: "workspace", label: "Workspace", path: "/workspace", pinnedAtUnixMs: 0, sectionKey: "project:/workspace" }, { id: "empty", label: "Empty", path: "/empty", pinnedAtUnixMs: 0, sectionKey: "project:/empty" } ], includeEmptySections: false }); expect(groups.map((group) => group.id)).toEqual([ "project:/workspace", "project:/empty", "conversations" ]); }); }); describe("preserveConversationRailSectionTemplates", () => { it("stable-partitions pinned projects before ordinary projects", () => { const groups = preserveConversationRailSectionTemplates({ labels: railLabels, sections: [], userProjects: [ { id: "ordinary", label: "Ordinary", path: "/ordinary", pinnedAtUnixMs: 0, sectionKey: "project:/ordinary" }, { id: "pinned", label: "Pinned project", path: "/pinned", pinnedAtUnixMs: 10, sectionKey: "project:/pinned" } ] }); expect(groups.map((group) => group.id)).toEqual([ "project:/pinned", "project:/ordinary", "conversations" ]); }); it("keeps project and conversations sections visible when membership is empty", () => { const groups = preserveConversationRailSectionTemplates({ labels: railLabels, sections: [], userProjects: [ { id: "workspace", label: "Workspace", path: "/workspace", pinnedAtUnixMs: 0, sectionKey: "project:/workspace", createdAtUnixMs: 1, updatedAtUnixMs: 1, lastUsedAtUnixMs: 1 } ] }); expect( groups.map((group) => [group.id, group.items.map((item) => item.id)]) ).toEqual([ ["project:/workspace", []], ["conversations", []] ]); }); it("preserves exact projected items without inferring missing membership", () => { const exact = conversation("exact"); const groups = preserveConversationRailSectionTemplates({ labels: railLabels, sections: section([exact]), userProjects: [ { id: "workspace", label: "Workspace", path: "/workspace", pinnedAtUnixMs: 0, sectionKey: "project:/workspace", createdAtUnixMs: 1, updatedAtUnixMs: 1, lastUsedAtUnixMs: 1 }, { id: "empty", label: "Empty", path: "/empty", pinnedAtUnixMs: 0, sectionKey: "project:/empty", createdAtUnixMs: 1, updatedAtUnixMs: 1, lastUsedAtUnixMs: 1 } ] }); expect( groups.map((group) => [group.id, group.items.map((item) => item.id)]) ).toEqual([ ["project:/workspace", ["exact"]], ["project:/empty", []], ["conversations", []] ]); }); it("drops project templates outside userProjects and keeps fixed sections", () => { const pinned = { ...conversation("pinned"), pinnedAtUnixMs: 2 }; const groups = preserveConversationRailSectionTemplates({ labels: railLabels, sections: [ { id: "pinned", kind: "pinned", label: "Pinned", project: null, items: [pinned] }, ...section([conversation("known")]), { id: "project:/removed", kind: "project", label: "Removed", project: { id: "removed", label: "Removed", path: "/removed", pinnedAtUnixMs: 0, sectionKey: "project:/removed" }, items: [ { ...conversation("removed"), railSectionKey: "project:/removed" } ] }, { id: "conversations", kind: "conversations", label: "Conversations", project: null, items: [] } ], userProjects: [ { id: "workspace", label: "Workspace", path: "/workspace", pinnedAtUnixMs: 0, sectionKey: "project:/workspace" } ] }); expect(groups.map((group) => group.id)).toEqual([ "pinned", "project:/workspace", "conversations" ]); }); }); describe("resolveConversationRailActiveConversation", () => { it("prefers the rail-projected selected entity over the controller copy", () => { const controllerActive = conversation("active"); const projectedActive = { ...controllerActive, project: { id: "workspace", label: "Workspace", path: "/workspace", pinnedAtUnixMs: 0, sectionKey: "project:/workspace" } }; expect( resolveConversationRailActiveConversation({ activeConversation: controllerActive, activeConversationId: controllerActive.id, conversations: [projectedActive] }) ).toBe(projectedActive); }); it("keeps the controller entity when the selected row is outside the filter", () => { const controllerActive = conversation("active"); expect( resolveConversationRailActiveConversation({ activeConversation: controllerActive, activeConversationId: controllerActive.id, conversations: [conversation("other")] }) ).toBe(controllerActive); }); }); describe("conversationRailActiveOverlayCountsTowardTotal", () => { it("does not count an active canonical entity when its section row is a runtime overlay", () => { const active = conversation("active"); expect( conversationRailActiveOverlayCountsTowardTotal({ activeConversation: active, matchesFilter: true, sectionItems: [{ ...active, projectionSource: "runtime_overlay" }] }) ).toBe(false); }); it("counts an active matching entity that is absent from the section", () => { expect( conversationRailActiveOverlayCountsTowardTotal({ activeConversation: conversation("active"), matchesFilter: true, sectionItems: [conversation("older")] }) ).toBe(true); }); });