tmux-ide 2.9.2 → 2.9.3

package/packages/contracts/src/__tests__/window-links.test.ts

@@ -1,243 +0,0 @@
-import {
-  WorkspaceWindowLinkSelectArgumentsSchemaZ,
-  WorkspaceWindowLinkUnlinkArgumentsSchemaZ,
-  WorkspacePaneSelectWithWindowLinkArgumentsSchemaZ,
-  WorkspacePaneSelectArgumentsSchemaZ,
-  WorkspaceMultiplexerIntentSchemaZ,
-} from "../workspace-multiplexer.ts";
-import { describe, expect, it } from "vitest";
-import {
-  WINDOW_LINK_MAX_LINKS,
-  WindowLinkTargetSchemaZ,
-  WindowLinkTopologySchemaZ,
-} from "../window-links.ts";
-import {
-  PaneStreamLayoutSnapshotV2FrameSchemaZ,
-  PaneStreamLayoutSnapshotFrameSchemaZ,
-  PaneStreamLayoutSnapshotV1FrameSchemaZ,
-  PaneStreamServerFrameSchemaZ,
-  PANE_STREAM_PROTOCOL_VERSION,
-} from "../pane-stream.ts";
-
-const linkId = (index: number) => `window-link.${index.toString(16).padStart(32, "0")}`;
-const topology = () => ({
-  liveSessionId: `live-session.${"a".repeat(20)}`,
-  linkRevision: 1,
-  activeLinkId: linkId(1),
-  links: [
-    { linkId: linkId(1), semanticWindowId: "window.one", displayIndex: 0 },
-    { linkId: linkId(2), semanticWindowId: "window.one", displayIndex: 1 },
-  ],
-});
-const layout = (window = "window.one", pane: string | null = "pane.one", currentWindow = true) => ({
-  type: "layout" as const,
-  semanticWindowId: window,
-  windowName: "shell",
-  currentWindow,
-  cols: 80,
-  rows: 24,
-  zoomed: false,
-  panes: [{ pane, left: 0, top: 0, width: 80, height: 24, active: true }],
-});
-const snapshot = () => ({
-  type: "layout-snapshot" as const,
-  topologyEpoch: 1,
-  layouts: [layout()],
-  windowLinks: topology(),
-});
-
-describe("window link contracts", () => {
-  it("allows multiple links sharing one unique backing and pane", () => {
-    expect(WindowLinkTopologySchemaZ.safeParse(topology()).success).toBe(true);
-    expect(PaneStreamLayoutSnapshotV2FrameSchemaZ.safeParse(snapshot()).success).toBe(true);
-    expect(
-      PaneStreamLayoutSnapshotV2FrameSchemaZ.safeParse({
-        ...snapshot(),
-        windowLinks: { ...topology(), activeLinkId: linkId(2) },
-      }).success,
-    ).toBe(true);
-  });
-
-  it("rejects duplicate handles/indexes and missing active links", () => {
-    const original = topology();
-    for (const invalid of [
-      { ...original, links: [original.links[0], { ...original.links[1], linkId: linkId(1) }] },
-      { ...original, links: [original.links[0], { ...original.links[1], displayIndex: 0 }] },
-      { ...original, activeLinkId: linkId(3) },
-      { ...original, links: [] },
-    ])
-      expect(WindowLinkTopologySchemaZ.safeParse(invalid).success).toBe(false);
-  });
-
-  it("bounds topology size and integer revisions/indexes", () => {
-    const links = Array.from({ length: WINDOW_LINK_MAX_LINKS }, (_, index) => ({
-      linkId: linkId(index + 1),
-      semanticWindowId: "window.one",
-      displayIndex: index,
-    }));
-    expect(WindowLinkTopologySchemaZ.safeParse({ ...topology(), links }).success).toBe(true);
-    expect(
-      WindowLinkTopologySchemaZ.safeParse({
-        ...topology(),
-        links: [
-          ...links,
-          {
-            linkId: linkId(WINDOW_LINK_MAX_LINKS + 1),
-            semanticWindowId: "window.one",
-            displayIndex: WINDOW_LINK_MAX_LINKS,
-          },
-        ],
-      }).success,
-    ).toBe(false);
-    for (const value of [-1, 0.5, Number.MAX_SAFE_INTEGER + 1, Infinity]) {
-      expect(
-        WindowLinkTopologySchemaZ.safeParse({ ...topology(), linkRevision: value }).success,
-      ).toBe(false);
-      expect(
-        WindowLinkTopologySchemaZ.safeParse({
-          ...topology(),
-          links: [{ ...links[0], displayIndex: value }],
-        }).success,
-      ).toBe(false);
-    }
-  });
-
-  it("accepts only opaque targets and rejects native or display action addresses", () => {
-    const target = {
-      liveSessionId: topology().liveSessionId,
-      linkId: linkId(1),
-      expectedSemanticWindowId: "window.one",
-      linkRevision: 0,
-    };
-    expect(WindowLinkTargetSchemaZ.safeParse(target).success).toBe(true);
-    for (const invalid of [
-      { ...target, linkId: "@0" },
-      { ...target, linkId: "/tmp/tmux/socket" },
-      { ...target, linkId: "window-link.abc" },
-      { ...target, liveSessionId: "$0" },
-      { ...target, expectedSemanticWindowId: "@0" },
-      { ...target, displayIndex: 0 },
-      { ...target, linkRevision: -1 },
-      { ...target, linkRevision: Number.MAX_SAFE_INTEGER + 1 },
-    ])
-      expect(WindowLinkTargetSchemaZ.safeParse(invalid).success).toBe(false);
-  });
-
-  it("requires a complete join and a matching active backing", () => {
-    const second = layout("window.two", "pane.two", false);
-    for (const invalid of [
-      { ...snapshot(), layouts: [layout("window.two")] },
-      { ...snapshot(), layouts: [layout(), second] },
-      {
-        ...snapshot(),
-        layouts: [layout("window.one", "pane.one", false), { ...second, currentWindow: true }],
-        windowLinks: {
-          ...topology(),
-          links: [
-            ...topology().links,
-            { linkId: linkId(3), semanticWindowId: "window.two", displayIndex: 2 },
-          ],
-        },
-      },
-    ])
-      expect(PaneStreamLayoutSnapshotV2FrameSchemaZ.safeParse(invalid).success).toBe(false);
-  });
-
-  it("preserves unique backing/pane and exactly-one-current invariants", () => {
-    for (const layouts of [
-      [layout(), layout()],
-      [layout(), layout("window.two", "pane.one", false)],
-      [layout("window.one", null)],
-      [{ ...layout(), semanticWindowId: null }],
-      [layout("window.one", "pane.one", false)],
-      [layout(), layout("window.two", "pane.two", true)],
-    ])
-      expect(
-        PaneStreamLayoutSnapshotV2FrameSchemaZ.safeParse({ ...snapshot(), layouts }).success,
-      ).toBe(false);
-  });
-
-  it("requires v2 topology and refuses the old v1 shape", () => {
-    const v1 = { type: "layout-snapshot", topologyEpoch: 1, layouts: [layout()] };
-    expect(PANE_STREAM_PROTOCOL_VERSION).toBe(2);
-    expect(PaneStreamLayoutSnapshotV1FrameSchemaZ.safeParse(v1).success).toBe(true);
-    expect(PaneStreamLayoutSnapshotFrameSchemaZ.safeParse(v1).success).toBe(false);
-    expect(PaneStreamLayoutSnapshotV2FrameSchemaZ.safeParse(v1).success).toBe(false);
-    expect(PaneStreamLayoutSnapshotFrameSchemaZ.safeParse(snapshot()).success).toBe(true);
-    expect(PaneStreamServerFrameSchemaZ.safeParse(snapshot()).success).toBe(true);
-    expect(
-      PaneStreamLayoutSnapshotV2FrameSchemaZ.safeParse({ ...snapshot(), unexpected: true }).success,
-    ).toBe(false);
-  });
-});
-
-describe("window link action arguments", () => {
-  const target = () => ({
-    liveSessionId: topology().liveSessionId,
-    linkId: linkId(1),
-    expectedSemanticWindowId: "window.one",
-    linkRevision: 1,
-  });
-
-  it("accepts opaque select/unlink targets and explicit-link pane selection", () => {
-    for (const schema of [
-      WorkspaceWindowLinkSelectArgumentsSchemaZ,
-      WorkspaceWindowLinkUnlinkArgumentsSchemaZ,
-    ]) {
-      expect(schema.safeParse({ workspaceName: "project", target: target() }).success).toBe(true);
-    }
-    expect(
-      WorkspacePaneSelectWithWindowLinkArgumentsSchemaZ.safeParse({
-        workspaceName: "project",
-        semanticPaneId: "pane.one",
-        windowLink: target(),
-      }).success,
-    ).toBe(true);
-  });
-
-  it("rejects native addresses, display indexes, command/force flags and unknown fields", () => {
-    for (const schema of [
-      WorkspaceWindowLinkSelectArgumentsSchemaZ,
-      WorkspaceWindowLinkUnlinkArgumentsSchemaZ,
-    ]) {
-      const args = { workspaceName: "project", target: target() };
-      for (const invalid of [
-        { ...args, target: "@0" },
-        { ...args, target: { ...target(), linkId: "@0" } },
-        { ...args, target: { ...target(), expectedSemanticWindowId: "@0" } },
-        { ...args, target: { ...target(), displayIndex: 0 } },
-        { ...args, target: { ...target(), runtimeSessionId: "$0" } },
-        { ...args, displayIndex: 0 },
-        { ...args, command: "kill-server" },
-        { ...args, force: true },
-        { ...args, socketPath: "/tmp/tmux/socket" },
-        { ...args, workspaceName: "" },
-      ])
-        expect(schema.safeParse(invalid).success).toBe(false);
-    }
-    const args = { workspaceName: "project", semanticPaneId: "pane.one", windowLink: target() };
-    for (const invalid of [
-      { ...args, semanticPaneId: "%0" },
-      { ...args, command: "select-pane -t %0" },
-      { ...args, windowLink: { ...target(), linkId: "project:0" } },
-      { workspaceName: "project", semanticPaneId: "pane.one" },
-    ])
-      expect(WorkspacePaneSelectWithWindowLinkArgumentsSchemaZ.safeParse(invalid).success).toBe(
-        false,
-      );
-  });
-
-  it("accepts registered link verbs and explicit-link pane selection", () => {
-    const args = { workspaceName: "project", target: target() };
-    for (const verb of ["workspace.window.link.select", "workspace.window.link.unlink"]) {
-      expect(WorkspaceMultiplexerIntentSchemaZ.safeParse({ verb, ...args }).success).toBe(true);
-    }
-    expect(
-      WorkspacePaneSelectArgumentsSchemaZ.safeParse({
-        workspaceName: "project",
-        semanticPaneId: "pane.one",
-        windowLink: target(),
-      }).success,
-    ).toBe(true);
-  });
-});

package/packages/contracts/src/__tests__/workspace-changes-resource.test.ts

@@ -1,317 +0,0 @@
-import { describe, expect, it } from "vitest";
-import {
-  WORKSPACE_CHANGE_DIFF_RESOURCE_VERSION,
-  WORKSPACE_CHANGES_CATALOG_RESOURCE_VERSION,
-  WorkspaceChangeDiffEnvelopeV1SchemaZ,
-  WorkspaceChangeDiffResourceV1SchemaZ,
-  WorkspaceChangeEntrySchemaZ,
-  WorkspaceChangesCatalogEnvelopeV1SchemaZ,
-  WorkspaceChangesCatalogResourceV1SchemaZ,
-  WorkspaceDiffHunkSchemaZ,
-} from "../workspace-changes-resource.ts";
-
-const daemon = {
-  protocolVersion: 1,
-  productVersion: "2.8.0",
-  instanceId: "9bcf33b0-c837-4a94-b5e8-c0977f54464f",
-  startedAt: "2026-07-21T12:00:00.000Z",
-};
-
-const changeId = (token: string) => `change.${token.padEnd(16, "0")}`;
-const changesRev = (token: string) => `changes-rev.${token.padEnd(16, "0")}`;
-
-const modifiedUnstaged = {
-  id: changeId("mod"),
-  group: "unstaged" as const,
-  status: "modified" as const,
-  name: "app.tsx",
-  relativePath: "apps/desktop-renderer/app.tsx",
-  originPath: null,
-  binary: false,
-  additions: 12,
-  deletions: 3,
-};
-
-describe("workspace change entry", () => {
-  it("accepts modified, untracked, renamed, and binary entries", () => {
-    expect(WorkspaceChangeEntrySchemaZ.safeParse(modifiedUnstaged).success).toBe(true);
-    expect(
-      WorkspaceChangeEntrySchemaZ.safeParse({
-        id: changeId("unt"),
-        group: "untracked",
-        status: "untracked",
-        name: "scratch.md",
-        relativePath: "scratch.md",
-        originPath: null,
-        binary: false,
-        additions: 5,
-        deletions: 0,
-      }).success,
-    ).toBe(true);
-    expect(
-      WorkspaceChangeEntrySchemaZ.safeParse({
-        id: changeId("ren"),
-        group: "staged",
-        status: "renamed",
-        name: "renamed.ts",
-        relativePath: "src/renamed.ts",
-        originPath: "src/original.ts",
-        binary: false,
-        additions: 0,
-        deletions: 0,
-      }).success,
-    ).toBe(true);
-    expect(
-      WorkspaceChangeEntrySchemaZ.safeParse({
-        id: changeId("bin"),
-        group: "staged",
-        status: "modified",
-        name: "logo.png",
-        relativePath: "assets/logo.png",
-        originPath: null,
-        binary: true,
-        additions: null,
-        deletions: null,
-      }).success,
-    ).toBe(true);
-  });
-
-  it("rejects inconsistent group, status, origin, and count combinations", () => {
-    // untracked status must ride in the untracked group.
-    expect(
-      WorkspaceChangeEntrySchemaZ.safeParse({ ...modifiedUnstaged, status: "untracked" }).success,
-    ).toBe(false);
-    // renames must carry an origin path.
-    expect(
-      WorkspaceChangeEntrySchemaZ.safeParse({ ...modifiedUnstaged, status: "renamed" }).success,
-    ).toBe(false);
-    // a non-rename must not carry one.
-    expect(
-      WorkspaceChangeEntrySchemaZ.safeParse({ ...modifiedUnstaged, originPath: "src/other.ts" })
-        .success,
-    ).toBe(false);
-    // origin path cannot equal the current path.
-    expect(
-      WorkspaceChangeEntrySchemaZ.safeParse({
-        ...modifiedUnstaged,
-        status: "renamed",
-        group: "staged",
-        originPath: modifiedUnstaged.relativePath,
-      }).success,
-    ).toBe(false);
-    // binary entries cannot report line counts.
-    expect(
-      WorkspaceChangeEntrySchemaZ.safeParse({ ...modifiedUnstaged, binary: true }).success,
-    ).toBe(false);
-    // text entries must report line counts.
-    expect(
-      WorkspaceChangeEntrySchemaZ.safeParse({ ...modifiedUnstaged, additions: null }).success,
-    ).toBe(false);
-    // the name must be the basename of the display path.
-    expect(
-      WorkspaceChangeEntrySchemaZ.safeParse({ ...modifiedUnstaged, name: "wrong.tsx" }).success,
-    ).toBe(false);
-  });
-});
-
-describe("workspace changes catalog resource", () => {
-  const stagedTwin = {
-    ...modifiedUnstaged,
-    id: changeId("staged"),
-    group: "staged" as const,
-  };
-
-  const catalog = {
-    status: "ready" as const,
-    workspaceName: "tmux-ide",
-    revision: changesRev("gen1"),
-    branch: "main",
-    detached: false,
-    entries: [modifiedUnstaged, stagedTwin],
-    totalEntries: 2,
-    truncated: false,
-  };
-
-  it("accepts a catalog where one path appears in two different groups", () => {
-    expect(WorkspaceChangesCatalogResourceV1SchemaZ.safeParse(catalog).success).toBe(true);
-    expect(
-      WorkspaceChangesCatalogEnvelopeV1SchemaZ.safeParse({
-        version: WORKSPACE_CHANGES_CATALOG_RESOURCE_VERSION,
-        daemon,
-        resource: catalog,
-      }).success,
-    ).toBe(true);
-  });
-
-  it("rejects duplicate ids and duplicate paths within one group", () => {
-    expect(
-      WorkspaceChangesCatalogResourceV1SchemaZ.safeParse({
-        ...catalog,
-        entries: [modifiedUnstaged, { ...stagedTwin, id: modifiedUnstaged.id }],
-      }).success,
-    ).toBe(false);
-    expect(
-      WorkspaceChangesCatalogResourceV1SchemaZ.safeParse({
-        ...catalog,
-        entries: [modifiedUnstaged, { ...modifiedUnstaged, id: changeId("dup") }],
-      }).success,
-    ).toBe(false);
-  });
-
-  it("rejects a detached workspace that also names a branch", () => {
-    expect(
-      WorkspaceChangesCatalogResourceV1SchemaZ.safeParse({ ...catalog, detached: true }).success,
-    ).toBe(false);
-    expect(
-      WorkspaceChangesCatalogResourceV1SchemaZ.safeParse({
-        ...catalog,
-        branch: null,
-        detached: true,
-      }).success,
-    ).toBe(true);
-  });
-
-  it("rejects a truncation flag inconsistent with totalEntries", () => {
-    expect(
-      WorkspaceChangesCatalogResourceV1SchemaZ.safeParse({
-        ...catalog,
-        totalEntries: 40,
-        truncated: false,
-      }).success,
-    ).toBe(false);
-  });
-});
-
-describe("workspace change diff resource", () => {
-  const editHunk = {
-    header: "@@ -1,3 +1,4 @@",
-    oldStart: 1,
-    oldLines: 3,
-    newStart: 1,
-    newLines: 4,
-    lines: [
-      { kind: "context" as const, content: "unchanged", oldLine: 1, newLine: 1 },
-      { kind: "delete" as const, content: "removed", oldLine: 2, newLine: null },
-      { kind: "insert" as const, content: "added one", oldLine: null, newLine: 2 },
-      { kind: "insert" as const, content: "added two", oldLine: null, newLine: 3 },
-      { kind: "context" as const, content: "tail", oldLine: 3, newLine: 4 },
-    ],
-  };
-
-  const additionHunk = {
-    header: "@@ -0,0 +1,2 @@",
-    oldStart: 0,
-    oldLines: 0,
-    newStart: 1,
-    newLines: 2,
-    lines: [
-      { kind: "insert" as const, content: "first", oldLine: null, newLine: 1 },
-      { kind: "insert" as const, content: "second", oldLine: null, newLine: 2 },
-    ],
-  };
-
-  it("accepts hunks with consistent line numbering", () => {
-    expect(WorkspaceDiffHunkSchemaZ.safeParse(editHunk).success).toBe(true);
-    expect(WorkspaceDiffHunkSchemaZ.safeParse(additionHunk).success).toBe(true);
-  });
-
-  it("rejects hunks whose line numbers or counts do not line up", () => {
-    expect(
-      WorkspaceDiffHunkSchemaZ.safeParse({
-        ...editHunk,
-        lines: [{ ...editHunk.lines[0], oldLine: 5 }, ...editHunk.lines.slice(1)],
-      }).success,
-    ).toBe(false);
-    // oldLines claims one more old-side line than the hunk actually carries.
-    expect(WorkspaceDiffHunkSchemaZ.safeParse({ ...editHunk, oldLines: 4 }).success).toBe(false);
-    // an insert line cannot carry an old line number.
-    expect(
-      WorkspaceDiffHunkSchemaZ.safeParse({
-        ...additionHunk,
-        lines: [{ kind: "insert", content: "x", oldLine: 1, newLine: 1 }],
-        newLines: 1,
-      }).success,
-    ).toBe(false);
-    // content is a single line without control breaks.
-    expect(
-      WorkspaceDiffHunkSchemaZ.safeParse({
-        ...additionHunk,
-        lines: [{ kind: "insert", content: "a\nb", oldLine: null, newLine: 1 }],
-        newLines: 1,
-      }).success,
-    ).toBe(false);
-  });
-
-  it("accepts a ready diff envelope and enforces truncation accounting", () => {
-    const ready = {
-      status: "ready" as const,
-      workspaceName: "tmux-ide",
-      changesRevision: changesRev("gen1"),
-      changeId: changeId("mod"),
-      group: "unstaged" as const,
-      relativePath: "apps/desktop-renderer/app.tsx",
-      originPath: null,
-      hunks: [editHunk],
-      totalHunks: 1,
-      totalLines: 5,
-      truncated: false,
-    };
-    expect(
-      WorkspaceChangeDiffEnvelopeV1SchemaZ.safeParse({
-        version: WORKSPACE_CHANGE_DIFF_RESOURCE_VERSION,
-        daemon,
-        resource: ready,
-      }).success,
-    ).toBe(true);
-    // More hunks omitted than reported, yet truncated stays false.
-    expect(
-      WorkspaceChangeDiffResourceV1SchemaZ.safeParse({ ...ready, totalHunks: 6 }).success,
-    ).toBe(false);
-    // truncated true is required when lines are omitted.
-    expect(
-      WorkspaceChangeDiffResourceV1SchemaZ.safeParse({
-        ...ready,
-        totalLines: 40,
-        truncated: true,
-      }).success,
-    ).toBe(true);
-  });
-
-  it("accepts binary, too-large, and unavailable diff variants", () => {
-    const base = {
-      workspaceName: "tmux-ide",
-      changesRevision: changesRev("gen1"),
-      changeId: changeId("bin"),
-      group: "staged" as const,
-      relativePath: "assets/logo.png",
-      originPath: null,
-    };
-    expect(
-      WorkspaceChangeDiffResourceV1SchemaZ.safeParse({
-        status: "binary",
-        ...base,
-        oldBytes: 100,
-        newBytes: 220,
-      }).success,
-    ).toBe(true);
-    expect(
-      WorkspaceChangeDiffResourceV1SchemaZ.safeParse({
-        status: "too-large",
-        ...base,
-        totalBytes: 9_000_000,
-        limitBytes: 1_048_576,
-      }).success,
-    ).toBe(true);
-    expect(
-      WorkspaceChangeDiffResourceV1SchemaZ.safeParse({
-        status: "unavailable",
-        workspaceName: "tmux-ide",
-        changesRevision: changesRev("gen1"),
-        changeId: changeId("bin"),
-        reason: "change-not-found",
-        message: "stale",
-        retryable: false,
-      }).success,
-    ).toBe(true);
-  });
-});

package/packages/contracts/src/__tests__/workspace-changes-view.test.ts

@@ -1,122 +0,0 @@
-import { describe, expect, it } from "vitest";
-import type { WorkspaceChangeEntry } from "../workspace-changes-resource.ts";
-import {
-  filterWorkspaceChanges,
-  flattenWorkspaceChangesView,
-  groupWorkspaceChanges,
-  moveWorkspaceChangeSelection,
-  summarizeWorkspaceChanges,
-} from "../workspace-changes-view.ts";
-
-const changeId = (token: string) => `change.${token.padEnd(16, "0")}`;
-
-const entries: WorkspaceChangeEntry[] = [
-  {
-    id: changeId("b-unstaged"),
-    group: "unstaged",
-    status: "modified",
-    name: "b.ts",
-    relativePath: "src/b.ts",
-    originPath: null,
-    binary: false,
-    additions: 4,
-    deletions: 1,
-  },
-  {
-    id: changeId("a-unstaged"),
-    group: "unstaged",
-    status: "modified",
-    name: "a.ts",
-    relativePath: "src/a.ts",
-    originPath: null,
-    binary: false,
-    additions: 2,
-    deletions: 2,
-  },
-  {
-    id: changeId("staged"),
-    group: "staged",
-    status: "added",
-    name: "new.ts",
-    relativePath: "src/new.ts",
-    originPath: null,
-    binary: false,
-    additions: 10,
-    deletions: 0,
-  },
-  {
-    id: changeId("binary"),
-    group: "untracked",
-    status: "untracked",
-    name: "logo.png",
-    relativePath: "assets/logo.png",
-    originPath: null,
-    binary: true,
-    additions: null,
-    deletions: null,
-  },
-];
-
-describe("workspace changes view projection", () => {
-  it("groups entries and sorts each group by path", () => {
-    const grouped = groupWorkspaceChanges(entries);
-    expect(grouped.staged.map((e) => e.name)).toEqual(["new.ts"]);
-    expect(grouped.unstaged.map((e) => e.name)).toEqual(["a.ts", "b.ts"]);
-    expect(grouped.untracked.map((e) => e.name)).toEqual(["logo.png"]);
-  });
-
-  it("summarizes counts and line totals, ignoring binary counts", () => {
-    expect(summarizeWorkspaceChanges(entries)).toEqual({
-      staged: 1,
-      unstaged: 2,
-      untracked: 1,
-      total: 4,
-      additions: 16,
-      deletions: 3,
-      binary: 1,
-    });
-  });
-
-  it("filters by group and by case-insensitive path query", () => {
-    expect(filterWorkspaceChanges(entries, { group: "unstaged" }).length).toBe(2);
-    expect(filterWorkspaceChanges(entries, { query: "LOGO" }).map((e) => e.name)).toEqual([
-      "logo.png",
-    ]);
-    expect(filterWorkspaceChanges(entries, { group: "staged", query: "b.ts" }).length).toBe(0);
-    expect(filterWorkspaceChanges(entries, {}).length).toBe(entries.length);
-  });
-
-  it("flattens to group headers followed by their changes", () => {
-    const view = flattenWorkspaceChangesView({ entries });
-    expect(view.rows.map((r) => (r.kind === "group" ? `#${r.group}` : r.entry!.name))).toEqual([
-      "#staged",
-      "new.ts",
-      "#unstaged",
-      "a.ts",
-      "b.ts",
-      "#untracked",
-      "logo.png",
-    ]);
-    // Header rows carry their group's count and are not selectable.
-    const header = view.rows.find((r) => r.kind === "group" && r.group === "unstaged")!;
-    expect(header.count).toBe(2);
-    expect(header.selectable).toBe(false);
-  });
-
-  it("omits a group header when its filtered set is empty", () => {
-    const view = flattenWorkspaceChangesView({ entries, filter: { group: "staged" } });
-    expect(view.rows.every((r) => r.group === "staged")).toBe(true);
-    expect(view.rows.filter((r) => r.kind === "group")).toHaveLength(1);
-  });
-
-  it("moves the selection across change rows, skipping headers", () => {
-    const rows = flattenWorkspaceChangesView({ entries }).rows;
-    const staged = changeId("staged");
-    const firstUnstaged = changeId("a-unstaged");
-    expect(moveWorkspaceChangeSelection(rows, null, "down")).toBe(staged);
-    // Stepping down from the last staged change lands on the first unstaged one.
-    expect(moveWorkspaceChangeSelection(rows, staged, "down")).toBe(firstUnstaged);
-    expect(moveWorkspaceChangeSelection(rows, staged, "up")).toBe(staged);
-    expect(moveWorkspaceChangeSelection([], null, "down")).toBeNull();
-  });
-});