[Bug]: Thread find counts hidden empty replies as matches #34983

#!/bin/sh
set -eu
# Run in an installed checkout at the documented commit. Browser binaries must already exist.
checkout=$(pwd)
tmp=$(mktemp -d "${VERIFY_SCRATCH:-${TMPDIR:-/tmp}}/thread-find-empty.XXXXXX")
export HOME="$tmp/fake-home" TMPDIR="$tmp/tmp" T3CODE_HOME="$tmp/t3-home"
mkdir -p "$HOME" "$TMPDIR" "$T3CODE_HOME"
export PATH="$checkout/node_modules/.bin:$PATH"
export VERIFY_FIXTURE="$checkout/apps/web/src/components/chat/zz-verify-empty.fixture.json"
server="$checkout/apps/server/src/orchestration-v2/zz-verify-empty.test.ts"
web="$checkout/apps/web/src/components/chat/zz-verify-empty.browser.test.tsx"
cleanup() { rm -f "$server" "$web" "$VERIFY_FIXTURE"; rm -rf "$tmp"; }
trap cleanup EXIT INT TERM
# Reuse only the baseline test's valid event/SQLite fixture builders.
sed '/^describe("V2 thread find"/,$d' "$checkout/apps/server/src/orchestration-v2/ThreadFind.test.ts" > "$server"
cat >> "$server" <<'SERVER'

import * as FS from "node:fs";
import * as Schema from "effect/Schema";
import { OrchestrationV2ProjectedTurnItemJson } from "@t3tools/contracts";
it.effect("verifies suppressed empty reply through production ThreadFind", () =>
  Effect.gen(function* () {
    const projection = yield* setup;
    const tool: OrchestrationV2TurnItem = {
      ...item("render", 0, ""), type: "dynamic_tool", toolName: "html_render", input: {},
      output: { htmlRender: { attachmentId: "visual", title: "Result", height: 120 } },
    };
    const controlRunId = RunId.make("run:control");
    yield* commit([run(threadId, controlRunId, 2)]);
    yield* putItems([tool, item("suppressed", 1, ""), { ...item("control", 2, ""), runId: controlRunId }]);
    const first = yield* projection.searchThread({ threadId, query: "empty" });
    const next = yield* projection.searchThread({ threadId, query: "empty", start: { entryId: "suppressed", occurrence: 0 }, offset: 1 });
    const wrapped = yield* projection.searchThread({ threadId, query: "empty", start: { entryId: "control", occurrence: 0 }, offset: 1 });
    assert.equal(first.totalMatches, 2);
    assert.equal(first.match?.entryId, "suppressed");
    assert.equal(next.totalMatches, 2);
    assert.equal(next.match?.entryId, "control");
    assert.equal(wrapped.match?.entryId, "suppressed");
    const snapshot = yield* projection.getThreadSnapshot(threadId);
    const rows = snapshot.projection.visibleTurnItems.map(row => ({ ...row, item: projectTurnItemForWire(row.item) }));
    const fixture = { first, next, wrapped, rows: Schema.encodeSync(Schema.Array(OrchestrationV2ProjectedTurnItemJson))(rows) };
    FS.writeFileSync(process.env.VERIFY_FIXTURE!, JSON.stringify(fixture, null, 2));
    console.log("SERVER " + JSON.stringify({ first, next, wrapped }));
  }).pipe(Effect.provide(layerTest)),
);

SERVER
cat > "$web" <<'WEB'

import { createRef, type ComponentProps } from "react";
import { EnvironmentId, ThreadId, OrchestrationV2ProjectedTurnItemJson } from "@t3tools/contracts";
import * as Schema from "effect/Schema";
import { Atom, AsyncResult } from "effect/reactivity";
import { expect, it, vi } from "vite-plus/test";
import { render, act } from "../../../test/render";
import { MessagesTimeline } from "./MessagesTimeline";
import { ThreadFindBar } from "./ThreadFindBar";
import { useThreadFind } from "./useThreadFind";
import { openThreadFind, closeThreadFind } from "./threadFindStore";
import { collectThreadFindRanges } from "./threadFindHighlights";
import { deriveMessagesTimelineRows } from "./MessagesTimeline.logic";
import { deriveTimelineEntriesFromVisibleTurnItems } from "../../session-logic";
import fixture from "./zz-verify-empty.fixture.json";
import "~/index.css";

// Replace only the network result atom with the actual result captured from SQLite/ThreadFind.
vi.mock(import("~/state/orchestration"), async (original) => {
  const actual = await original();
  const { Atom, AsyncResult } = await import("effect/reactivity");
  const { default: captured } = await import("./zz-verify-empty.fixture.json");
  const data = Atom.make(AsyncResult.success(captured.first));
  return { ...actual, orchestrationEnvironment: { ...actual.orchestrationEnvironment, threadFind: () => data } };
});

const environmentId = EnvironmentId.make("verify-environment");
const thread = { environmentId, threadId: ThreadId.make("thread:find") };
const key = "verify-environment:thread:find";
const rows = Schema.decodeUnknownSync(Schema.Array(OrchestrationV2ProjectedTurnItemJson))(fixture.rows);
const entries = deriveTimelineEntriesFromVisibleTurnItems({ visibleTurnItems: rows, optimisticMessages: [] });
const listRef = createRef<any>();
function Harness() {
  const find = useThreadFind({ thread, enabled: true });
  const props: Omit<ComponentProps<typeof MessagesTimeline>, "timelineEntries"> = {
    isWorking: false, listRef, latestRun: null, turnDiffSummaries: [], runs: [], routeThreadKey: key,
    onOpenThread: () => {}, supportsConversationRollback: false, onRevertToTurnCount: () => {},
    isRevertingCheckpoint: false, onImageExpand: () => {}, activeThreadEnvironmentId: environmentId,
    markdownCwd: undefined, resolvedTheme: "light", timestampFormat: "locale", workspaceRoot: undefined,
    anchorMessageId: null, onAnchorReady: () => {}, onAnchorSizeChanged: () => {},
    contentInsetEndAdjustment: 0, emptyPlaceholderInset: 0, liveFollowEnabled: true, onIsAtEndChange: () => {},
    renderHtmlRender: () => <div style={{height: 120}}>Rendered result</div>,
  };
  return <>
    <ThreadFindBar {...find.barProps} />
    <output data-selection>{find.timelineProps.activeFindMatch?.entryId ?? "none"}</output>
    <MessagesTimeline {...props} {...find.timelineProps} timelineEntries={entries} />
  </>;
}

it("real web find UI counts a suppressed empty reply and navigates to its blank body", async () => {
  closeThreadFind();
  const derived = deriveMessagesTimelineRows({ timelineEntries: entries, latestRun: null, isWorking: false, activeTurnStartedAt: null, turnDiffSummaries: [], supportsConversationRollback: false });
  expect(derived.find(row => row.id === "suppressed")).toMatchObject({ suppressEmptyResponse: true });
  expect(derived.find(row => row.id === "control")).toMatchObject({ suppressEmptyResponse: false });
  const container = document.createElement("div");
  container.style.cssText = "height: 700px; width: 900px; display: flex; flex-direction: column; position: relative";
  await using screen = await render(<Harness />, { container });
  await act(() => openThreadFind(key));
  await screen.getByRole("searchbox", { name: "Find in thread" }).fill("empty");
  await expect.element(screen.getByText("1/2", { exact: true })).toBeVisible();
  await vi.waitFor(() => expect(screen.container.querySelector("[data-selection]")?.textContent).toBe("suppressed"));
  const suppressedBody = () => screen.container.querySelector('[data-timeline-row-id="suppressed"] [data-thread-find-text]');
  const controlBody = () => screen.container.querySelector('[data-timeline-row-id="control"] [data-thread-find-text]');
  await vi.waitFor(() => expect(suppressedBody()).not.toBeNull());
  expect(suppressedBody()!.textContent).toBe("");
  await vi.waitFor(() => expect(controlBody()?.textContent).toBe("(empty response)"));
  expect(collectThreadFindRanges(screen.container, "empty").map(match => match.rowId)).toEqual(["control"]);
  // Observe the actual list method called by production useThreadFindNavigation.
  using scroll = vi.spyOn(listRef.current, "scrollToIndex");
  await screen.getByRole("button", { name: "Next match", exact: true }).click();
  await expect.element(screen.getByText("2/2", { exact: true })).toBeVisible();
  await vi.waitFor(() => expect(screen.container.querySelector("[data-selection]")?.textContent).toBe("control"));
  await screen.getByRole("button", { name: "Next match", exact: true }).click();
  await expect.element(screen.getByText("1/2", { exact: true })).toBeVisible();
  await vi.waitFor(() => expect(screen.container.querySelector("[data-selection]")?.textContent).toBe("suppressed"));
  const rowIndex = derived.findIndex(row => row.id === "suppressed");
  await vi.waitFor(() => expect(scroll).toHaveBeenCalledWith(expect.objectContaining({ index: rowIndex, animated: false })));
  expect(suppressedBody()!.textContent).toBe("");
  console.log("BROWSER environment: " + navigator.userAgent);
  console.log("BROWSER suppressed: count=1/2 selected=suppressed body=" + JSON.stringify(suppressedBody()!.textContent) + " matchingRanges=0 navigatedRowIndex=" + rowIndex);
  console.log("BROWSER control: count=2/2 selected=control body=" + JSON.stringify(controlBody()!.textContent) + " matchingRanges=1");
  closeThreadFind();
});

WEB
vp test run apps/server/src/orchestration-v2/zz-verify-empty.test.ts --maxWorkers=1 --silent=false --reporter=verbose
node -e 'const f=JSON.parse(require("node:fs").readFileSync(process.env.VERIFY_FIXTURE,"utf8")); console.log("SERVER observed: "+JSON.stringify({first:f.first,next:f.next,wrapped:f.wrapped}));'
cd "$checkout/apps/web"
vp test run --project browser src/components/chat/zz-verify-empty.browser.test.tsx --maxWorkers=1 --silent=false --reporter=verbose