[Bug]: Bare numeric author and labels URL filters crash the Pull Requests page

#!/bin/bash
# Run from an installed, disposable checkout at the reported baseline.
# Usage: PLAYWRIGHT_BROWSERS_PATH=<existing browser cache> ./repro.sh <checkout>
set -euo pipefail
checkout=$(cd "${1:?Pass a disposable checkout with dependencies installed}" && pwd -P)
script_dir=$(cd "$(dirname "$0")" && pwd -P)
fixture=$(mktemp -d "${TMPDIR:-/tmp}/numeric-search-repro.XXXXXX")
test_file="$checkout/apps/web/src/components/pullRequest/verifyNumericSearch.browser.test.tsx"
wire_file="$checkout/apps/web/test/numericEnvironment.ts"
if [[ -e "$test_file" || -e "$wire_file" ]]; then
  echo 'Refusing to overwrite an existing verification fixture.' >&2
  rmdir "$fixture"
  exit 2
fi
browsers=${PLAYWRIGHT_BROWSERS_PATH:-"$HOME/Library/Caches/ms-playwright"}
cleanup() { rm -f "$test_file" "$wire_file"; rm -rf "$fixture"; }
trap cleanup EXIT
mkdir -p "$fixture/fakehome" "$fixture/tmp" "$fixture/t3home"
cp "$script_dir/verifyNumericSearch.browser.test.tsx" "$fixture/test.tsx"
cp "$script_dir/numericEnvironment.ts" "$fixture/environment.ts"
cp "$fixture/test.tsx" "$test_file"
cp "$fixture/environment.ts" "$wire_file"
export HOME="$fixture/fakehome" TMPDIR="$fixture/tmp" T3CODE_HOME="$fixture/t3home"
export PLAYWRIGHT_BROWSERS_PATH="$browsers"
export PATH="$checkout/node_modules/.bin:$PATH"
printf 'REVISION %s\n' "$(git -C "$checkout" rev-parse HEAD)"
cd "$checkout/apps/web"
if env -u NODE_ENV vp test run src/components/pullRequest/verifyNumericSearch.browser.test.tsx --project browser --reporter verbose --silent=false > "$fixture/run.out" 2>&1; then
  cat "$fixture/run.out"
else
  cat "$fixture/run.out"
  exit 1
fi
for marker in \
 'CASE control author=ana real-page=healthy' \
 'CASE author=4089 real-page=root-error-boundary error=author.trim is not a function' \
 'CASE labels=4089 real-page=root-error-boundary error=search.labels.map is not a function' \
 'CASE author-recovery real-page=healthy' \
 'CASE labels-recovery real-page=healthy' \
 'CASE picker-reload real-page=healthy author-type=string' \
 'CASE cold-labels=4089 real-page=root-error-boundary error=search.labels.map is not a function'; do
  grep -Fq "$marker" "$fixture/run.out" || { printf 'Missing marker: %s\n' "$marker"; exit 1; }
done
printf '\nDEFECT PRESENT; textual control, numeric picker, quoted reload, and navigation recovery passed.\n'

import { createMemoryHistory } from "@tanstack/react-router";
import { DEFAULT_CLIENT_SETTINGS } from "@t3tools/contracts/settings";
import type * as Context from "effect/Context";
import { expect, it, vi } from "vite-plus/test";
import { page, userEvent } from "vite-plus/test/browser";
import "~/index.css";
import { AppRoot } from "~/AppRoot";
import { __setClientSettingsForTests } from "~/hooks/useSettings";
import { getRouter } from "~/router";
import { installFakeEnvironment, type FakeDriver } from "../../../test/numericEnvironment";
import { act, render } from "../../../test/render";

vi.mock("../../../../../packages/client-runtime/src/connection/driver.ts", async (importOriginal) => {
  const [actual, { fakeDriver }, Layer] = await Promise.all([
    importOriginal<{readonly ConnectionDriver: Context.Key<unknown, FakeDriver>}>(),
    import("../../../test/numericEnvironment"), import("effect/Layer"),
  ]);
  return {...actual, layer: Layer.succeed(actual.ConnectionDriver, fakeDriver)};
});
vi.mock(import("~/rpc/requestLatencyState"), async original => ({
  ...(await original()), trackRpcRequestSent: () => {},
}));

it("observes the real route, filter selection, numeric URLs, and recovery", async () => {
  using environment = installFakeEnvironment([]);
  __setClientSettingsForTests({...DEFAULT_CLIENT_SETTINGS, onboardingCompletedAt: "2026-01-01T00:00:00Z"});
  localStorage.clear();
  const router = getRouter(createMemoryHistory({initialEntries: ["/pull-requests?author=4089"]}));
  await router.load();
  const container = document.createElement("div");
  container.style.cssText = "height:900px;width:1400px";
  // AppRoot owns the production router, so render must not add a second router.
  await using screen = await render(<AppRoot router={router}/>, {container, router:false});
  await expect.element(page.getByText("Could not load pull requests", {exact:false})).toBeVisible();
  await expect.element(page.getByRole("heading", {name:"Pull requests", exact:true})).toBeVisible();
  console.log("CASE cold-author=4089 real-page=healthy list=request-validation-error");
  await act(() => router.navigate({href:"/pull-requests?author=ana"}));
  await expect.element(page.getByText("Fixture PR by ana", {exact:true})).toBeVisible();
  console.log("CASE control author=ana real-page=healthy");
  await act(() => router.navigate({to:"/pull-requests",search:{involvement:"all",state:"open"}}));
  await expect.element(page.getByText("Fixture PR by 4089", {exact:true})).toBeVisible();
  await userEvent.click(page.getByRole("button", {name:/Filters/}));
  await userEvent.click(page.getByRole("menuitem", {name:/Author/}));
  await userEvent.click(page.getByRole("menuitemradio", {name:/4089/}));
  await vi.waitFor(() => expect(router.state.location.search.author).toBe("4089"));
  expect(router.state.location.href).toContain("author=%224089%22");
  await expect.element(page.getByText("Fixture PR by 4089", {exact:true})).toBeVisible();
  console.log(`CASE picker url=${router.state.location.href} author-type=${typeof router.state.location.search.author} real-page=healthy`);
  const serialized = router.state.location.href;
  const reloadRouter = getRouter(createMemoryHistory({initialEntries:[serialized]}));
  await reloadRouter.load();
  expect(reloadRouter.matchRoutes(reloadRouter.latestLocation).at(-1)?.search.author).toBe("4089");
  console.log("CASE picker-reparse author-type=string");
  await act(() => router.navigate({href:"/pull-requests?author=4089"}));
  await expect.element(page.getByRole("heading", {name:"Something went wrong."})).toBeVisible();
  expect(container.textContent).toContain("author.trim is not a function");
  await expect.element(page.getByText("Fixture PR by 4089", {exact:true})).not.toBeInTheDocument();
  console.log("CASE author=4089 real-page=root-error-boundary error=author.trim is not a function");
  await act(() => router.navigate({href:"/pull-requests?author=ana"}));
  await expect.element(page.getByText("Fixture PR by ana", {exact:true})).toBeVisible();
  console.log("CASE author-recovery real-page=healthy");
  await act(() => router.navigate({href:"/pull-requests?labels=4089"}));
  await expect.element(page.getByRole("heading", {name:"Something went wrong."})).toBeVisible();
  expect(container.textContent).toContain("search.labels.map is not a function");
  console.log("CASE labels=4089 real-page=root-error-boundary error=search.labels.map is not a function");
  await act(() => router.navigate({href:"/pull-requests?author=ana"}));
  await expect.element(page.getByText("Fixture PR by ana", {exact:true})).toBeVisible();
  console.log("CASE labels-recovery real-page=healthy");
});


it("opens a fresh route using the numeric author URL serialized by the picker", async () => {
  using environment = installFakeEnvironment([]);
  __setClientSettingsForTests({...DEFAULT_CLIENT_SETTINGS, onboardingCompletedAt: "2026-01-01T00:00:00Z"});
  const router = getRouter(createMemoryHistory({initialEntries:["/pull-requests?author=%224089%22"]}));
  await router.load();
  await using screen = await render(<AppRoot router={router}/>, {router:false});
  await expect.element(page.getByText("Fixture PR by 4089", {exact:true})).toBeVisible();
  console.log("CASE picker-reload real-page=healthy author-type=string");
});

it("opens a fresh numeric labels URL at the root error boundary without needing rows", async () => {
  using environment = installFakeEnvironment([]);
  __setClientSettingsForTests({...DEFAULT_CLIENT_SETTINGS, onboardingCompletedAt: "2026-01-01T00:00:00Z"});
  const router = getRouter(createMemoryHistory({initialEntries:["/pull-requests?labels=4089"]}));
  await router.load();
  await using screen = await render(<AppRoot router={router}/>, {router:false});
  await expect.element(page.getByRole("heading", {name:"Something went wrong."})).toBeVisible();
  expect(screen.container.textContent).toContain("search.labels.map is not a function");
  console.log("CASE cold-labels=4089 real-page=root-error-boundary error=search.labels.map is not a function");
});

// An in-process environment for app render scenarios: a fetch stub for its HTTP API and a
// session that answers the shell, thread and config subscriptions from fixtures. Other RPCs
// stay pending so nothing retries on timers. Everything above the wire is the app's own.
import {
  AuthStandardClientScopes,
  PullRequestListInput,
  PullRequestListResult,
  PullRequestListStatsInput,
  SourceControlProviderKind,
  EnvironmentId,
  EventId,
  ExecutionEnvironmentDescriptor,
  MessageId,
  ORCHESTRATION_PROTOCOL_VERSION,
  ORCHESTRATION_V2_WS_METHODS,
  ProjectId,
  ProviderInstanceId,
  RunId,
  ServerConfig,
  ThreadId,
  TurnItemId,
  WS_METHODS,
  WsRpcGroup,
  type VcsStatusStreamEvent,
  type OrchestrationProjectShell,
  type OrchestrationV2Command,
  type OrchestrationV2ProjectedTurnItem,
  type OrchestrationV2Run,
  type OrchestrationV2ShellStreamItem,
  type OrchestrationV2ThreadProjection,
  type OrchestrationV2ThreadShell,
  type OrchestrationV2ThreadStreamItem,
  type OrchestrationV2TurnItem,
  type TerminalMetadataStreamEvent,
} from "@t3tools/contracts";
import type {
  ConnectionAttemptError,
  ConnectionCatalogEntry,
  EnvironmentConnectionLease,
  RouteCheck,
} from "@t3tools/client-runtime/connection";
import type { WsRpcProtocolClient } from "@t3tools/client-runtime/rpc";
import { DEFAULT_RESOLVED_KEYBINDINGS } from "@t3tools/shared/keybindings";
import { APP_VERSION } from "~/branding";
import * as DateTime from "effect/DateTime";
import * as Effect from "effect/Effect";
import * as Queue from "effect/Queue";
import type * as Scope from "effect/Scope";
import * as Schema from "effect/Schema";
import * as Stream from "effect/Stream";
import { RpcSchema } from "effect/rpc";

export const ENVIRONMENT_ID = EnvironmentId.make("environment-render");
export const PROJECT_ID = ProjectId.make("project-render");
const CODEX = ProviderInstanceId.make("codex");
const MODEL = { instanceId: CODEX, model: "gpt-5.4" };
const AT = DateTime.makeUnsafe("2026-03-17T19:12:28.000Z");

const descriptor = {
  environmentId: ENVIRONMENT_ID,
  label: "Render scenarios",
  platform: { os: "linux", arch: "x64" },
  // A matching version, since a mismatch adds an update banner a typical user never sees.
  serverVersion: APP_VERSION,
  orchestrationProtocolVersion: ORCHESTRATION_PROTOCOL_VERSION,
  capabilities: { repositoryIdentity: true },
};
const auth = {
  policy: "loopback-browser",
  bootstrapMethods: ["one-time-token"],
  sessionMethods: ["browser-session-cookie"],
  sessionCookieName: "t3_session",
};

const baseServerConfig: ServerConfig = {
  ...Schema.decodeUnknownSync(ServerConfig)({
    environment: descriptor,
    auth,
    cwd: "/workspace/render",
    keybindingsConfigPath: "/workspace/.t3/keybindings.json",
    keybindings: [],
    issues: [],
    providers: [
      {
        instanceId: CODEX,
        driver: "codex",
        enabled: true,
        installed: true,
        version: "1.0.0",
        status: "ready",
        auth: { status: "authenticated" },
        checkedAt: "2026-03-17T19:12:28.000Z",
        models: [
          { slug: "gpt-5.4", name: "GPT-5.4", isCustom: false, capabilities: null },
          { slug: "gpt-5.5", name: "GPT-5.5", isCustom: false, capabilities: null },
        ],
      },
    ],
    availableEditors: [],
    observability: {
      logsDirectoryPath: "/workspace/.t3/logs",
      localTracingEnabled: false,
      otlpTracesEnabled: false,
      otlpMetricsEnabled: false,
    },
    settings: {},
    threadSnapshotPagination: true,
    threadResumeCompletionMarker: true,
    shellResumeCompletionMarker: true,
  }),
  keybindings: DEFAULT_RESOLVED_KEYBINDINGS,
};
// A server only leaves threads out of the shell when it serves their families.
const serverConfig = (): ServerConfig =>
  threads.some((thread) => thread.olderSettled)
    ? { ...baseServerConfig, shellThreadFamilies: true }
    : baseServerConfig;

const project: OrchestrationProjectShell = {
  id: PROJECT_ID,
  title: "render",
  workspaceRoot: "/workspace/render",
  repositoryIdentity: null,
  defaultModelSelection: null,
  scripts: [],
  createdAt: "2026-03-17T19:12:28.000Z",
  updatedAt: "2026-03-17T19:12:28.000Z",
};

const base = (threadId: ThreadId, runId: RunId, id: string, ordinal: number) => ({
  id: TurnItemId.make(id),
  threadId,
  runId,
  nodeId: null,
  providerThreadId: null,
  providerTurnId: null,
  nativeItemRef: null,
  parentItemId: null,
  ordinal,
  status: "completed" as const,
  title: null,
  startedAt: AT,
  completedAt: AT,
  updatedAt: AT,
});

function userItem(threadId: ThreadId, runId: RunId, id: string, ordinal: number, text: string) {
  return {
    ...base(threadId, runId, id, ordinal),
    type: "user_message",
    messageId: MessageId.make(id),
    text,
    attachments: [],
    inputIntent: "turn_start",
    createdBy: "user",
    creationSource: "web",
  } satisfies OrchestrationV2TurnItem;
}

export function assistantItem(
  threadId: ThreadId,
  runId: RunId,
  id: string,
  ordinal: number,
  text: string,
  streaming = false,
) {
  return {
    ...base(threadId, runId, id, ordinal),
    type: "assistant_message",
    messageId: MessageId.make(id),
    text,
    streaming,
    ...(streaming ? { status: "running" as const, completedAt: null } : {}),
  } satisfies OrchestrationV2TurnItem;
}

function run(threadId: ThreadId, id: RunId, ordinal: number, userMessageId: string) {
  return {
    id,
    threadId,
    ordinal,
    providerInstanceId: CODEX,
    modelSelection: MODEL,
    providerThreadId: null,
    userMessageId: MessageId.make(userMessageId),
    rootNodeId: null,
    activeAttemptId: null,
    status: "completed",
    requestedAt: AT,
    startedAt: AT,
    completedAt: AT,
    checkpointId: null,
    contextHandoffId: null,
  } satisfies OrchestrationV2Run;
}

export interface FakeThread {
  /** Makes this a side chat of that thread. */
  readonly sideChatOf?: ThreadId;
  /** Makes this an older settled thread the shell leaves out; only its family read returns it. */
  readonly olderSettled?: true;
  readonly id: ThreadId;
  readonly title: string;
  readonly runs: ReadonlyArray<OrchestrationV2Run>;
  readonly items: ReadonlyArray<OrchestrationV2TurnItem>;
}

/** A thread of `turns` user prompts, each answered in markdown with a list and inline code. */
export function threadWithHistory(name: string, turns: number): FakeThread {
  const id = ThreadId.make(name);
  const runs: OrchestrationV2Run[] = [];
  const items: OrchestrationV2TurnItem[] = [];
  for (let turn = 0; turn < turns; turn++) {
    const runId = RunId.make(`${name}-run-${turn}`);
    runs.push(run(id, runId, turn + 1, `${name}-user-${turn}`));
    items.push(
      userItem(id, runId, `${name}-user-${turn}`, turn * 2, `${name}: question ${turn}`),
      assistantItem(
        id,
        runId,
        `${name}-assistant-${turn}`,
        turn * 2 + 1,
        `Answer ${turn} for ${name}.\n\n- checked \`Sidebar.tsx\`\n- ran the tests\n\n` +
          "The width is now `clamp(next, MIN_WIDTH, MAX_WIDTH)`, so the layout no longer jumps.",
      ),
    );
  }
  return { id, title: `Thread ${name}`, runs, items };
}

function shellOf(thread: FakeThread): OrchestrationV2ThreadShell {
  const latest = thread.runs.at(-1);
  return {
    id: thread.id,
    projectId: PROJECT_ID,
    title: thread.title,
    providerInstanceId: CODEX,
    modelSelection: MODEL,
    runtimeMode: "full-access",
    interactionMode: "default",
    branch: "main",
    worktreePath: null,
    activeProviderThreadId: null,
    lineage: {
      rootThreadId: thread.sideChatOf ?? thread.id,
      parentThreadId: thread.sideChatOf ?? null,
      relationshipToParent: null,
      ...(thread.sideChatOf ? { sideChat: true } : {}),
    },
    forkedFrom: null,
    createdBy: "user",
    creationSource: "web",
    latestRunId: latest?.id ?? null,
    activeRunId: null,
    // Idle reads as waiting on the user, which shows a per-second duration in the sidebar.
    status: latest ? "completed" : "idle",
    pendingRuntimeRequest: null,
    latestVisibleMessage: null,
    latestUserMessageAt: AT,
    hasActionableProposedPlan: false,
    itemCount: thread.items.length,
    visibleItemCount: thread.items.length,
    createdAt: AT,
    updatedAt: AT,
    archivedAt: null,
    settledOverride: thread.olderSettled ? "settled" : null,
    settledAt: thread.olderSettled ? AT : null,
    lastVisitedAt: AT,
    deletedAt: null,
  };
}

function projectionOf(thread: FakeThread): OrchestrationV2ThreadProjection {
  const shell = shellOf(thread);
  const visibleTurnItems: OrchestrationV2ProjectedTurnItem[] = thread.items.map(
    (item, position) => ({
      position,
      visibility: "local",
      sourceThreadId: thread.id,
      sourceItemId: item.id,
      item,
    }),
  );
  return {
    thread: {
      id: shell.id,
      projectId: shell.projectId,
      title: shell.title,
      providerInstanceId: shell.providerInstanceId,
      modelSelection: shell.modelSelection,
      runtimeMode: shell.runtimeMode,
      interactionMode: shell.interactionMode,
      branch: shell.branch,
      worktreePath: shell.worktreePath,
      activeProviderThreadId: null,
      lineage: shell.lineage,
      forkedFrom: null,
      createdBy: "user",
      creationSource: "web",
      createdAt: AT,
      updatedAt: AT,
      archivedAt: null,
      settledOverride: shell.settledOverride,
      settledAt: shell.settledAt,
      lastVisitedAt: AT,
      deletedAt: null,
    },
    runs: [...thread.runs],
    attempts: [],
    nodes: [],
    subagents: [],
    providerSessions: [],
    providerThreads: [],
    providerTurns: [],
    runtimeRequests: [],
    messages: [],
    plans: [],
    turnItems: [...thread.items],
    checkpointScopes: [],
    checkpoints: [],
    contextHandoffs: [],
    contextTransfers: [],
    visibleTurnItems,
    updatedAt: AT,
  };
}

const json = (body: unknown, status = 200) =>
  new Response(JSON.stringify(body), { status, headers: { "content-type": "application/json" } });

// Keyed by thread id: a live thread subscription's queue, for pushing events to it.
const threadSubscribers = new Map<string, Queue.Queue<OrchestrationV2ThreadStreamItem>>();
let terminalMetadataSubscriber: Queue.Queue<TerminalMetadataStreamEvent> | null = null;
let threads: ReadonlyArray<FakeThread> = [];
let dispatched: OrchestrationV2Command[] = [];
let acceptCommands = false;
let sequence = 1;
let vcsStatusSubscriber: Queue.Queue<VcsStatusStreamEvent> | null = null;

const subscribe = <A>(first: ReadonlyArray<A>, register?: (queue: Queue.Queue<A>) => () => void) =>
  Stream.unwrap(
    Effect.gen(function* () {
      const queue = yield* Queue.unbounded<A>();
      yield* Queue.offerAll(queue, first);
      if (register) {
        const unregister = register(queue);
        yield* Effect.addFinalizer(() => Effect.sync(unregister));
      }
      return Stream.fromQueue(queue);
    }),
  );


const fixtureEntries = ["ana", "4089"].map((login, i) => ({
  provider: SourceControlProviderKind.make("github"), host: "github.com",
  projectId: PROJECT_ID, projectTitle: "render", repository: "acme/web",
  number: i + 1, title: `Fixture PR by ${login}`, url: `https://github.com/acme/web/pull/${i + 1}`,
  author: { login, name: null, avatarUrl: null }, headBranch: "feature", baseBranch: "main",
  state: "open", isDraft: false, mergeability: "mergeable", additions: 1, deletions: 0,
  createdAt: "2026-01-01T00:00:00Z", updatedAt: "2026-01-01T00:00:00Z",
  viewerReviewRequested: false, labels: [{name: "4089", color: null}],

}));
const fixtureProviders = [{host: "github.com", kind: SourceControlProviderKind.make("github"),
  configured: true, searchesOnHost: true, projectCount: 1, projectIds: [PROJECT_ID], detail: null}];

const handlers: Record<string, (input: never) => unknown> = {
  [WS_METHODS.pullRequestsList]: (raw: unknown) => Effect.try({
    try: () => {
      const input = Schema.decodeUnknownSync(PullRequestListInput)(raw);
      const entries = input.involvement === "reviewing" || input.involvement === "authored" ? [] :
        fixtureEntries.filter(row => !input.filters?.author || row.author.login === input.filters.author);
      return Schema.decodeUnknownSync(PullRequestListResult)({viewers: {"github.com": "viewer"},
        providers: fixtureProviders, entries, errors: [], truncated: false, nextCursors: {}});
    }, catch: error => error as Error,
  }),
  [WS_METHODS.pullRequestsListStats]: (raw: unknown) => Effect.try({
    try: () => { Schema.decodeUnknownSync(PullRequestListStatsInput)(raw); return {stats: []}; },
    catch: error => error as Error,
  }),
  [WS_METHODS.pullRequestsFilterOptions]: () => Effect.succeed({authors: fixtureEntries.map(e => e.author), labels: [{name:"4089",color:null}], references: []}),

  // Recorded, and accepted only when the scenario asks, since a pending command holds every
  // later command on its thread. Accepted commands' events never arrive.
  [ORCHESTRATION_V2_WS_METHODS.dispatchCommand]: (command: OrchestrationV2Command) =>
    Effect.suspend(() => {
      dispatched.push(command);
      return acceptCommands ? Effect.succeed({ sequence: sequence + 1 }) : Effect.never;
    }),
  [WS_METHODS.subscribeTerminalMetadata]: () =>
    subscribe<TerminalMetadataStreamEvent>([{ type: "snapshot", terminals: [] }], (queue) => {
      terminalMetadataSubscriber = queue;
      return () => {
        if (terminalMetadataSubscriber === queue) terminalMetadataSubscriber = null;
      };
    }),
  [ORCHESTRATION_V2_WS_METHODS.subscribeShell]: () =>
    subscribe<OrchestrationV2ShellStreamItem>([
      {
        kind: "snapshot",
        snapshot: {
          schemaVersion: 1,
          snapshotSequence: sequence,
          projects: [project],
          threads: threads.filter((thread) => !thread.olderSettled).map(shellOf),
          archivedThreads: [],
        },
      },
      { kind: "synchronized" },
    ]),
  [ORCHESTRATION_V2_WS_METHODS.subscribeThread]: (input: { readonly threadId: ThreadId }) => {
    const thread = threads.find((candidate) => candidate.id === input.threadId);
    if (!thread) return Stream.never;
    return subscribe<OrchestrationV2ThreadStreamItem>(
      [
        { kind: "snapshot", snapshotSequence: sequence, projection: projectionOf(thread) },
        { kind: "synchronized" },
      ],
      (queue) => {
        threadSubscribers.set(thread.id, queue);

        // A replaced subscription closes after its successor registers.
        return () => {
          if (threadSubscribers.get(thread.id) === queue) threadSubscribers.delete(thread.id);
        };
      },
    );
  },
  [ORCHESTRATION_V2_WS_METHODS.getThreadFamily]: (input: { readonly threadId: ThreadId }) => {
    const rootOf = (thread: FakeThread) => thread.sideChatOf ?? thread.id;
    const requested = threads.find((candidate) => candidate.id === input.threadId);
    return Effect.succeed({
      snapshotSequence: sequence,
      threads: requested
        ? threads.filter((thread) => rootOf(thread) === rootOf(requested)).map(shellOf)
        : [],
    });
  },
  [WS_METHODS.subscribeVcsStatus]: () =>
    subscribe<VcsStatusStreamEvent>([], (queue) => {
      vcsStatusSubscriber = queue;
      return () => {
        if (vcsStatusSubscriber === queue) vcsStatusSubscriber = null;
      };
    }),
  [WS_METHODS.subscribeServerConfig]: () =>
    subscribe([{ version: 1 as const, type: "snapshot" as const, config: serverConfig() }]),
};

// Unanswered calls stay pending, like a server that has not replied yet.
const client = new Proxy(handlers, {
  get: (target, method: string) =>
    target[method] ??
    (() => {
      const rpc = WsRpcGroup.requests.get(method);
      return rpc && RpcSchema.isStreamSchema(rpc.successSchema) ? Stream.never : Effect.never;
    }),
});

const session: EnvironmentConnectionLease["session"] = {
  client: client as unknown as WsRpcProtocolClient,
  initialConfig: Effect.sync(serverConfig),
  subscribeServerConfig: () =>
    subscribe([{ version: 1 as const, type: "snapshot" as const, config: serverConfig() }]),
  ready: Effect.void,
  probe: Effect.void,
  inboundFrames: Effect.succeed(0),
  closed: Effect.never,
};

/** Stands in for client-runtime's ConnectionDriver: every connection opens the session above. */
export const fakeDriver = {
  connect: (
    entry: ConnectionCatalogEntry,
  ): Effect.Effect<EnvironmentConnectionLease, ConnectionAttemptError, Scope.Scope> =>
    Effect.succeed({
      prepared: {
        environmentId: ENVIRONMENT_ID,
        label: descriptor.label,
        httpBaseUrl: window.location.origin,
        socketUrl: window.location.origin.replace(/^http/, "ws"),
        httpAuthorization: null,
        target: entry.target,
      },
      session,
    }),
  preflight: () => Effect.succeed(true),
  checkHost: () => Effect.succeed<RouteCheck>("unchecked"),
};
export type FakeDriver = typeof fakeDriver;

const realFetch = globalThis.fetch;
const encodedDescriptor = Schema.encodeSync(ExecutionEnvironmentDescriptor)(
  Schema.decodeUnknownSync(ExecutionEnvironmentDescriptor)(descriptor),
);

/** Serves the environment's HTTP API and these threads until disposed. */
export function installFakeEnvironment(
  fixtures: ReadonlyArray<FakeThread>,
  options?: { readonly acceptCommands?: boolean },
): Disposable {
  threads = fixtures;
  dispatched = [];
  acceptCommands = options?.acceptCommands === true;
  globalThis.fetch = async (input, init) => {
    const url = new URL(input instanceof Request ? input.url : String(input), window.location.href);
    if (url.origin !== window.location.origin) return realFetch(input, init);
    if (url.pathname === "/.well-known/t3/environment") return json(encodedDescriptor);
    if (url.pathname === "/api/auth/session") {
      return json({
        authenticated: true,
        auth,
        scopes: AuthStandardClientScopes,
        sessionMethod: "browser-session-cookie",
        expiresAt: "2099-01-01T00:00:00.000Z",
      });
    }
    // Snapshot endpoints fall back to the socket, which serves the same fixtures.
    if (/^\/(api|oauth|\.well-known)\//.test(url.pathname)) return json({}, 404);
    return realFetch(input, init);
  };
  return {
    [Symbol.dispose]: () => {
      globalThis.fetch = realFetch;
      threads = [];
      dispatched = [];
      acceptCommands = false;
    },
  };
}

/** Commands the app dispatched to the environment, oldest first. */
export function dispatchedCommands(): ReadonlyArray<OrchestrationV2Command> {
  return dispatched;
}

type ThreadEvent = Extract<OrchestrationV2ThreadStreamItem, { readonly kind: "event" }>["event"];

export async function emitTerminalMetadata(event: TerminalMetadataStreamEvent): Promise<void> {
  if (terminalMetadataSubscriber === null) throw new Error("No terminal metadata subscription");
  await Effect.runPromise(Queue.offer(terminalMetadataSubscriber, event));
}

/** Whether the app holds a live subscription to the thread, so events reach it. */
export function isThreadSubscribed(threadId: ThreadId): boolean {
  return threadSubscribers.has(threadId);
}

/** Delivers one domain event, such as a run or turn-item update, to the thread's subscription. */
export async function emitThreadEvent(
  threadId: ThreadId,
  event: Pick<ThreadEvent, "type" | "payload">,
): Promise<void> {
  const queue = threadSubscribers.get(threadId);
  if (!queue) throw new Error(`No live subscription for ${threadId}`);
  sequence += 1;
  await Effect.runPromise(
    Queue.offer(queue, {
      kind: "event",
      sequence,
      event: { ...event, id: EventId.make(`event-${sequence}`), threadId, occurredAt: AT },
    } as OrchestrationV2ThreadStreamItem),
  );
}

export function runningRun(threadId: ThreadId, id: string, ordinal: number, userMessageId: string) {
  return {
    ...run(threadId, RunId.make(id), ordinal, userMessageId),
    status: "running" as const,
    completedAt: null,
  };
}

export { userItem };

export async function emitVcsStatus(event: VcsStatusStreamEvent): Promise<void> {
  if (vcsStatusSubscriber === null) throw new Error("No VCS status subscription");
  await Effect.runPromise(Queue.offer(vcsStatusSubscriber, event));
}