[Bug]: Project content search accepts overlong queries then shows a generic schema error #34989

#!/bin/sh
# Run from a dependency-installed t3code checkout at the baseline (or pass its root).
# Uses the real browser dialog/hook/query/RPC encoder; the connected environment and transport are test fixtures.
set -eu
checkout=${1:-$(pwd)}
checkout=$(cd "$checkout" && pwd)
original_home=$HOME
fixture=$(mktemp -d "${TMPDIR:-/tmp}/content-search-verification.XXXXXX")
probe="$checkout/apps/web/src/components/search/zzverify-long-query.browser.test.tsx"
if [ -e "$probe" ]; then echo 'Refusing to overwrite existing probe' >&2; exit 2; fi
cleanup() { rm -f "$probe"; rm -rf "$fixture"; }
trap cleanup EXIT INT TERM
mkdir -p "$fixture/fake-home" "$fixture/tmp" "$fixture/t3home"
export PLAYWRIGHT_BROWSERS_PATH=${PLAYWRIGHT_BROWSERS_PATH:-$original_home/Library/Caches/ms-playwright}
export HOME="$fixture/fake-home" TMPDIR="$fixture/tmp" T3CODE_HOME="$fixture/t3home"
export PATH="$checkout/node_modules/.bin:$PATH"
cat > "$fixture/dialog.browser.test.tsx" <<'BROWSER_TEST'
import { EnvironmentId, ThreadId, WS_METHODS, WsRpcGroup } from "@t3tools/contracts";
import { RegistryContext } from "@effect/atom-react";
import * as Effect from "effect/Effect";
import * as Layer from "effect/Layer";
import * as Option from "effect/Option";
import * as Schema from "effect/Schema";
import * as Stream from "effect/Stream";
import * as SubscriptionRef from "effect/SubscriptionRef";
import { Atom, AtomRegistry } from "effect/reactivity";
import { RpcClient, RpcSerialization } from "effect/rpc";
import { expect, it, vi } from "vite-plus/test";
import { page } from "vite-plus/test/browser";
import * as EnvironmentRegistry from "../../../../../packages/client-runtime/src/connection/registry";
import * as EnvironmentSupervisor from "../../../../../packages/client-runtime/src/connection/supervisor";
import { AVAILABLE_CONNECTION_STATE, PrimaryConnectionTarget } from "@t3tools/client-runtime/connection";
import { createEnvironmentRpcQueryAtomFamily } from "@t3tools/client-runtime/state/runtime";
import { render } from "../../../test/render";
import { ProjectContentSearchDialog } from "./ProjectContentSearchDialog";

const observed = vi.hoisted(() => ({ sent: [] as number[], requested: [] as number[] }));
vi.mock("~/hooks/useActiveProjectTarget", () => ({
  useActiveProjectTarget: () => ({ environmentId: EnvironmentId.make("probe"), cwd: "/fixture", projectName: "fixture", threadRef: { environmentId: EnvironmentId.make("probe"), threadId: ThreadId.make("thread") } }),
}));
vi.mock("~/hooks/useTheme", () => ({ useRenderedAppearance: () => "light", useTheme: () => ({ theme: "t3-chat", resolvedTheme: "light", appearanceMode: "light" }) }));
vi.mock("~/state/filesystem", () => ({ useFilesystemReadAccess: () => ({ canReadFiles: true, isPending: false, error: null }) }));
vi.mock("~/state/session", async (original) => ({ ...(await original<typeof import("~/state/session")>()), readEnvironmentScope: () => true }));
vi.mock("~/state/projects", async () => {
  const target = new PrimaryConnectionTarget({ environmentId: EnvironmentId.make("probe"), label: "Probe", httpBaseUrl: "http://fixture.invalid", wsBaseUrl: "ws://fixture.invalid" });
  const layer = Layer.effect(EnvironmentRegistry.EnvironmentRegistry, Effect.gen(function* () {
    const serialization = yield* RpcSerialization.RpcSerialization;
    const protocol = yield* RpcClient.Protocol.make(Effect.fnUntraced(function* (writeResponse) {
      return {
        supportsAck: false, supportsTransferables: false, codecFor: serialization.codecFor,
        send: (clientId, request) => {
          if (request._tag !== "Request") return Effect.void;
          const payload = request.payload as { query: string };
          observed.sent.push(payload.query.length);
          return writeResponse(clientId, { _tag: "Exit", requestId: request.id, exit: { _tag: "Success", value: { matches: [{ path: "fixture.txt", lineNumber: 1, lineContent: "a".repeat(257), matchRanges: [{ start: 0, end: payload.query.length }] }], truncated: false } } });
        },
      };
    }));
    const client = yield* RpcClient.make(WsRpcGroup).pipe(Effect.provideService(RpcClient.Protocol, protocol));
    const supervisor = EnvironmentSupervisor.EnvironmentSupervisor.of({
      target, state: yield* SubscriptionRef.make({ ...AVAILABLE_CONNECTION_STATE, desired: true, network: "online", phase: "connected", attempt: 1, generation: 1 }),
      session: yield* SubscriptionRef.make(Option.some({ client })),
      prepared: yield* SubscriptionRef.make(Option.none()), connect: Effect.void, disconnect: Effect.void, retryNow: Effect.void,
    } as any);
    return EnvironmentRegistry.EnvironmentRegistry.of({
      run: (_id, effect) => Effect.provideService(effect, EnvironmentSupervisor.EnvironmentSupervisor, supervisor),
      followStream: (_id, stream) => Stream.provideService(stream, EnvironmentSupervisor.EnvironmentSupervisor, supervisor),
      stateChanges: () => SubscriptionRef.changes(supervisor.state),
    } as any);
  })).pipe(Layer.provide(RpcSerialization.layerJson));
  const family = createEnvironmentRpcQueryAtomFamily(Atom.runtime(layer), { label: "environment-data:projects:search-contents", tag: WS_METHODS.projectsSearchContents, staleTimeMs: 5000, idleTtlMs: 60000 });
  return { projectEnvironment: {}, projectContentSearch: (target) => { observed.requested.push(target.input.query.length); return family(target); } };
});

it("observes 256 and 257 character input through the real dialog, hook, query family, and schema-aware RPC client", async () => {
  observed.sent.length = 0; observed.requested.length = 0;
  console.log("BROWSER=" + navigator.userAgent);
  const registry = AtomRegistry.make();
  await using screen = await render(<RegistryContext.Provider value={registry}><ProjectContentSearchDialog onOpenChange={() => {}} /></RegistryContext.Provider>);
  const input = page.getByRole("combobox");
  expect((input.element() as HTMLInputElement).maxLength).toBe(-1);
  await input.fill("a".repeat(256));
  await expect.element(page.getByText("1 results in 1 files")).toBeVisible();
  expect(observed.sent).toEqual([256]);
  console.log("CONTROL_256=" + JSON.stringify({ inputLength: (input.element() as HTMLInputElement).value.length, maxLength: (input.element() as HTMLInputElement).maxLength, text: screen.container.textContent, sent: [...observed.sent] }));
  await input.fill("a".repeat(257));
  await expect.element(page.getByText("Schema validation failed")).toBeVisible();
  await expect.element(page.getByText("Searching…")).not.toBeInTheDocument();
  expect((input.element() as HTMLInputElement).value).toHaveLength(257);
  expect(observed.requested).toContain(257);
  expect(observed.sent).toEqual([256]);
  console.log("FAILURE_257=" + JSON.stringify({ inputLength: (input.element() as HTMLInputElement).value.length, maxLength: (input.element() as HTMLInputElement).maxLength, text: screen.container.textContent, sent: [...observed.sent], searching: screen.container.textContent?.includes("Searching…"), alerts: document.querySelectorAll('[role="alert"]').length }));
  await input.fill("a".repeat(256));
  await expect.element(page.getByText("1 results in 1 files")).toBeVisible();
  console.log("RECOVERY_256=1 results in 1 files");
});
BROWSER_TEST
cp "$fixture/dialog.browser.test.tsx" "$probe"
cd "$checkout/apps/web"
if vp test run --project browser src/components/search/zzverify-long-query.browser.test.tsx --silent=false --reporter=verbose > "$fixture/result.out" 2>&1; then
  cat "$fixture/result.out"
else
  cat "$fixture/result.out"
  exit 2
fi
for marker in 'CONTROL_256=' 'FAILURE_257=' 'RECOVERY_256='; do
  if ! grep -q "$marker" "$fixture/result.out"; then echo "Missing evidence: $marker" >&2; exit 2; fi
done
printf '%s\n' 'RESULT: defect present; 257 characters show inline Schema validation failed before transport, 256 characters render a result, and shortening recovers.'