@devries-cameron20 / t3code Mirror · read-only / commits / 30a405bbc1
Fork 0

The best way to control Claude Code, Codex and more from any computer or phone

Mirrored from https://github.com/Camo67/t3code.git

Synced Nov 22, 18:15 UTC

test(web): restore project settings permission tests deleted in the test snap (#24011)

Theo Browne committed Oct 23, 2026 at 03:17 UTC 30a405bbc1eb78720aaacd0049b97a44a3f2e8b0
2 files changed +556 -2
apps/web/src/components/settings/ProjectSettingsPanel.browser.test.tsx new
+554
@@ -0,0 +1,554 @@
1 +import { RegistryContext } from "@effect/atom-react";
2 +import type {
3 + DeleteProjectInput,
4 + UpdateProjectInput,
5 +} from "@t3tools/client-runtime/state/projects";
6 +import {
7 + AuthOrchestrationOperateScope,
8 + AuthSettingsWriteScope,
9 + DEFAULT_SERVER_SETTINGS,
10 + EnvironmentId,
11 + ProjectId,
12 + ProviderInstanceId,
13 + type AuthEnvironmentScope,
14 + type AuthSessionState,
15 +} from "@t3tools/contracts";
16 +import { DEFAULT_CLIENT_SETTINGS } from "@t3tools/contracts/settings";
17 +import { DEFAULT_RESOLVED_KEYBINDINGS } from "@t3tools/shared/keybindings";
18 +import {
19 + createMemoryHistory,
20 + createRootRoute,
21 + createRoute,
22 + createRouter,
23 + RouterProvider,
24 +} from "@tanstack/react-router";
25 +import * as Cause from "effect/Cause";
26 +import { AsyncResult, Atom } from "effect/reactivity";
27 +import { describe, expect, it, vi } from "vite-plus/test";
28 +import { page, userEvent } from "vite-plus/test/browser";
29 +
30 +import { act, render, type Screen } from "../../../test/render";
31 +import type { Project } from "../../types";
32 +
33 +type SessionResult = AsyncResult.AsyncResult<AuthSessionState, Error>;
34 +const state = vi.hoisted(() => ({
35 + sessions: new Map<EnvironmentId, Atom.Writable<SessionResult>>(),
36 + projects: [] as Project[],
37 + update:
38 + vi.fn<
39 + (request: {
40 + environmentId: EnvironmentId;
41 + input: UpdateProjectInput;
42 + }) => Promise<AsyncResult.Success<void>>
43 + >(),
44 + delete:
45 + vi.fn<
46 + (request: {
47 + environmentId: EnvironmentId;
48 + input: DeleteProjectInput;
49 + }) => Promise<AsyncResult.Success<void>>
50 + >(),
51 + confirm: vi.fn<() => Promise<boolean>>(),
52 + releaseUploads: vi.fn(),
53 + clearDraft: vi.fn(),
54 + toast: vi.fn(),
55 +}));
56 +
57 +// Session grants come from the server; each test drives them through these atoms.
58 +vi.mock(import("@t3tools/client-runtime/state/session"), async (original) => {
59 + const actual = await original();
60 + return {
61 + ...actual,
62 + createEnvironmentSessionAtoms: ((
63 + ...args: Parameters<typeof actual.createEnvironmentSessionAtoms>
64 + ) => ({
65 + ...actual.createEnvironmentSessionAtoms(...args),
66 + sessionStateAtom: (id: EnvironmentId) => state.sessions.get(id)!,
67 + })) as typeof actual.createEnvironmentSessionAtoms,
68 + };
69 +});
70 +vi.mock(import("~/state/environments"), async (original) => ({
71 + ...(await original()),
72 + useEnvironments: (() => ({ environments })) as never,
73 + usePrimaryEnvironmentId: () => primaryId,
74 +}));
75 +vi.mock(import("~/state/entities"), async (original) => ({
76 + ...(await original()),
77 + useProjects: (() => state.projects) as never,
78 + useThreadShells: () => [],
79 + waitForProjectRemoval: async () => true,
80 +}));
81 +vi.mock(import("~/state/projects"), async (original) => {
82 + const actual = await original();
83 + return {
84 + ...actual,
85 + projectEnvironment: {
86 + ...actual.projectEnvironment,
87 + update: "update",
88 + delete: "delete",
89 + } as unknown as typeof actual.projectEnvironment,
90 + };
91 +});
92 +vi.mock(import("~/state/use-atom-command"), async (original) => ({
93 + ...(await original()),
94 + useAtomCommand: ((command: "update" | "delete") => state[command]) as never,
95 +}));
96 +vi.mock(import("~/hooks/useSettings"), async (original) => ({
97 + ...(await original()),
98 + useClientSettings: ((selector?: (settings: typeof DEFAULT_CLIENT_SETTINGS) => unknown) =>
99 + selector ? selector(DEFAULT_CLIENT_SETTINGS) : DEFAULT_CLIENT_SETTINGS) as never,
100 +}));
101 +vi.mock(import("~/localApi"), async (original) => ({
102 + ...(await original()),
103 + readLocalApi: (() => ({ dialogs: { confirm: state.confirm } })) as never,
104 +}));
105 +vi.mock(import("~/lib/composerDraftUploads"), async (original) => ({
106 + ...(await original()),
107 + releaseProjectDraftUploads: state.releaseUploads,
108 +}));
109 +// No toaster is mounted in these tests; the guard's error toast is read at this seam.
110 +vi.mock(import("../ui/toast"), async (original) => {
111 + const actual = await original();
112 + return { ...actual, toastManager: { ...actual.toastManager, add: state.toast } };
113 +});
114 +// These sections have separate data sources and their own tests.
115 +vi.mock(import("./ProjectDefaultsSettings"), async (original) => ({
116 + ...(await original()),
117 + ProjectDefaultsSettings: (() => null) as never,
118 +}));
119 +vi.mock(import("./ProjectActionsSettings"), async (original) => ({
120 + ...(await original()),
121 + ProjectActionsSettings: (() => null) as never,
122 +}));
123 +
124 +vi.mock(import("../files/projectFilesQueryState"), async (original) => ({
125 + ...(await original()),
126 + getProjectFileQueryAtom: () => missingProjectFile,
127 +}));
128 +
129 +import { useComposerDraftStore } from "../../composerDraftStore";
130 +import { appAtomRegistry } from "../../rpc/atomRegistry";
131 +import { buildSidebarProjectSnapshots } from "../../sidebarProjectGrouping";
132 +import { ProjectSettingsPanel } from "./ProjectSettingsPanel";
133 +import { ProjectsSettings } from "./ProjectsSettings";
134 +import { SettingsScopeProvider } from "./SettingsScopeContext";
135 +import { validateSettingsScopeSearch, type SettingsScopeSearch } from "./settingsScope";
136 +import { retainSettingsScope, validateSettingsRouteSearch } from "./settingsScopeNavigation";
137 +
138 +const primaryId = EnvironmentId.make("primary");
139 +const remoteId = EnvironmentId.make("remote");
140 +const instanceId = ProviderInstanceId.make("codex");
141 +const environments = [primaryId, remoteId].map((environmentId) => ({
142 + environmentId,
143 + label: environmentId,
144 + connection: { phase: "connected" },
145 + serverConfig: {
146 + keybindings: DEFAULT_RESOLVED_KEYBINDINGS,
147 + settings: DEFAULT_SERVER_SETTINGS,
148 + environment: { platform: { machine: "server" } },
149 + },
150 +}));
151 +const session = (scopes: ReadonlyArray<AuthEnvironmentScope>): AuthSessionState => ({
152 + authenticated: true,
153 + scopes,
154 + auth: {
155 + policy: "remote-reachable",
156 + bootstrapMethods: ["one-time-token"],
157 + sessionMethods: ["bearer-access-token"],
158 + sessionCookieName: "t3_session",
159 + },
160 +});
161 +const writable = () => AsyncResult.success(session([AuthOrchestrationOperateScope]));
162 +const missingProjectFile = Atom.make(AsyncResult.initial<never, never>());
163 +
164 +function deferred<T>() {
165 + let resolve!: (value: T) => void;
166 + const promise = new Promise<T>((complete) => {
167 + resolve = complete;
168 + });
169 + return { promise, resolve };
170 +}
171 +
172 +function setup() {
173 + vi.clearAllMocks();
174 + state.sessions.clear();
175 + for (const id of [primaryId, remoteId])
176 + state.sessions.set(id, Atom.make<SessionResult>(writable()).pipe(Atom.keepAlive));
177 + state.projects = [primaryId, remoteId].map((environmentId) => ({
178 + id: ProjectId.make(`project-${environmentId}`),
179 + environmentId,
180 + title: "Shared repo",
181 + workspaceRoot: `/work/${environmentId}`,
182 + repositoryIdentity: {
183 + canonicalKey: "github.com/example/shared-repo",
184 + locator: {
185 + source: "git-remote",
186 + remoteName: "origin",
187 + remoteUrl: "https://github.com/example/shared-repo.git",
188 + },
189 + },
190 + defaultModelSelection: { instanceId, model: "gpt-5-codex" },
191 + createdAt: "2026-01-01T00:00:00.000Z",
192 + updatedAt: "2026-01-01T00:00:00.000Z",
193 + scripts: [],
194 + }));
195 + state.update.mockImplementation(async ({ environmentId, input }) => {
196 + const { projectId, ...updates } = input;
197 + const patch = Object.fromEntries(
198 + Object.entries(updates).filter(([, value]) => value !== undefined),
199 + ) as Partial<Project>;
200 + state.projects = state.projects.map((project) =>
201 + project.environmentId === environmentId && project.id === projectId
202 + ? { ...project, ...patch }
203 + : project,
204 + );
205 + return AsyncResult.success(undefined);
206 + });
207 + state.delete.mockResolvedValue(AsyncResult.success(undefined));
208 + state.confirm.mockResolvedValue(true);
209 + useComposerDraftStore.setState({ clearProjectDraftThreadId: state.clearDraft });
210 +}
211 +
212 +function projectKey() {
213 + return buildSidebarProjectSnapshots({
214 + projects: state.projects,
215 + settings: DEFAULT_CLIENT_SETTINGS,
216 + primaryEnvironmentId: primaryId,
217 + resolveEnvironmentLabel: (id) => id,
218 + })[0]!.projectKey;
219 +}
220 +
221 +async function mountPanel(search: Omit<SettingsScopeSearch, "project"> = {}) {
222 + const key = projectKey();
223 + const rootRoute = createRootRoute();
224 + const settingsRoute = createRoute({
225 + getParentRoute: () => rootRoute,
226 + path: "settings",
227 + validateSearch: validateSettingsRouteSearch,
228 + search: { middlewares: [retainSettingsScope] },
229 + });
230 + const projectsRoute = createRoute({
231 + getParentRoute: () => settingsRoute,
232 + path: "projects",
233 + component: () => (
234 + <ProjectSettingsPanel
235 + projectKey={key}
236 + environmentId={search.machine ? EnvironmentId.make(search.machine) : null}
237 + checkoutKey={search.checkout ?? null}
238 + />
239 + ),
240 + });
241 + const query = new URLSearchParams({ project: key });
242 + for (const [name, value] of Object.entries(search)) {
243 + if (value !== undefined) query.set(name, value);
244 + }
245 + const router = createRouter({
246 + routeTree: rootRoute.addChildren([settingsRoute.addChildren([projectsRoute])]),
247 + history: createMemoryHistory({ initialEntries: [`/settings/projects?${query}`] }),
248 + });
249 + await router.load();
250 + await using stack = new AsyncDisposableStack();
251 + const screen = stack.use(
252 + // The panel's own route tree validates settings search params, which the default router lacks.
253 + await render(
254 + <RegistryContext.Provider value={appAtomRegistry}>
255 + <RouterProvider router={router} />
256 + </RegistryContext.Provider>,
257 + { router: false },
258 + ),
259 + );
260 + await vi.waitFor(() => expect(nameInput(screen)).not.toBeNull());
261 + stack.move();
262 + return { ...screen, router };
263 +}
264 +
265 +async function mountSettings(search: SettingsScopeSearch) {
266 + const searchParams = new URLSearchParams(
267 + Object.entries(search).flatMap(([key, value]) => (value === undefined ? [] : [[key, value]])),
268 + );
269 + const route = createRootRoute({
270 + validateSearch: validateSettingsScopeSearch,
271 + component: () => (
272 + <SettingsScopeProvider
273 + search={route.useSearch()}
274 + onChange={(next) => void router.navigate({ to: "/settings/projects", search: () => next })}
275 + >
276 + <ProjectsSettings />
277 + </SettingsScopeProvider>
278 + ),
279 + });
280 + const router = createRouter({
281 + routeTree: route,
282 + history: createMemoryHistory({
283 + initialEntries: [`/settings/projects?${searchParams.toString()}`],
284 + }),
285 + });
286 + await router.load();
287 + // The settings route tree above validates scope search params, which the default router lacks.
288 + const screen = await render(
289 + <RegistryContext.Provider value={appAtomRegistry}>
290 + <RouterProvider router={router} />
291 + </RegistryContext.Provider>,
292 + { router: false },
293 + );
294 + return { ...screen, router };
295 +}
296 +
297 +const nameInput = (screen: Screen) =>
298 + screen.container.querySelector<HTMLInputElement>('[aria-label="Project name"]')!;
299 +const removeCheckout = (screen: Screen, root: string) =>
300 + screen.container.querySelector<HTMLButtonElement>(`[aria-label="Remove checkout ${root}"]`)!;
301 +const removeAll = (screen: Screen) =>
302 + [...screen.container.querySelectorAll("button")].find((button) =>
303 + button.textContent?.includes("Remove all entries"),
304 + )!;
305 +
306 +async function grant(id: EnvironmentId, result: SessionResult) {
307 + await act(async () => appAtomRegistry.set(state.sessions.get(id)!, result));
308 +}
309 +
310 +async function rename(screen: Screen, title: string) {
311 + await userEvent.fill(nameInput(screen), title);
312 + await userEvent.keyboard("{Enter}");
313 +}
314 +
315 +// The recheck reports the denial by toast; seeing it proves the recheck ran.
316 +async function expectProjectAccessDeniedToast(title: string) {
317 + await vi.waitFor(() =>
318 + expect(state.toast).toHaveBeenCalledWith(
319 + expect.objectContaining({
320 + type: "error",
321 + title,
322 + description: "This connection cannot change projects in remote.",
323 + }),
324 + ),
325 + );
326 + expect(state.toast).toHaveBeenCalledOnce();
327 +}
328 +
329 +describe("project settings permissions", () => {
330 + it("disables shared edits when any member lacks project access", async () => {
331 + setup();
332 + await grant(remoteId, AsyncResult.success(session([AuthSettingsWriteScope])));
333 + await using screen = await mountPanel();
334 +
335 + expect(nameInput(screen).disabled).toBe(true);
336 + expect(removeAll(screen).disabled).toBe(true);
337 + expect(screen.container.textContent).toContain(
338 + "Shared settings require permission to change every checkout in this group.",
339 + );
340 + expect(state.update).not.toHaveBeenCalled();
341 + });
342 +
343 + it("renames every member when all have project access without settings access", async () => {
344 + setup();
345 + await using screen = await mountPanel();
346 + await rename(screen, "Renamed");
347 + expect(state.update.mock.calls.map(([request]) => request.environmentId)).toEqual([
348 + primaryId,
349 + remoteId,
350 + ]);
351 + expect(nameInput(screen).value).toBe("Renamed");
352 + });
353 +
354 + it("stops before the next member if its grant is revoked during an earlier update", async () => {
355 + setup();
356 + const firstUpdate = deferred<AsyncResult.Success<void>>();
357 + state.update.mockReturnValueOnce(firstUpdate.promise);
358 + await using screen = await mountPanel();
359 + await rename(screen, "Renamed");
360 + expect(state.update).toHaveBeenCalledOnce();
361 +
362 + await grant(remoteId, AsyncResult.success(session([])));
363 + await act(async () => {
364 + firstUpdate.resolve(AsyncResult.success(undefined));
365 + await firstUpdate.promise;
366 + });
367 + await expectProjectAccessDeniedToast("Failed to rename project");
368 + expect(state.update).toHaveBeenCalledOnce();
369 + expect(state.update.mock.calls[0]![0].environmentId).toBe(primaryId);
370 + });
371 +
372 + it("disables removal for a checkout whose project grant is missing", async () => {
373 + setup();
374 + await grant(remoteId, AsyncResult.success(session([])));
375 + await using screen = await mountPanel();
376 + expect(removeCheckout(screen, "/work/remote").disabled).toBe(true);
377 + expect(removeCheckout(screen, "/work/primary").disabled).toBe(false);
378 + });
379 +
380 + it("removes a writable checkout while removal of the mixed group stays denied", async () => {
381 + setup();
382 + await grant(remoteId, AsyncResult.success(session([])));
383 + await using screen = await mountPanel();
384 + const initialHref = screen.router.state.location.href;
385 + expect(removeAll(screen).disabled).toBe(true);
386 +
387 + await userEvent.click(removeCheckout(screen, "/work/primary"));
388 + await vi.waitFor(() => expect(state.delete).toHaveBeenCalledOnce());
389 + expect(state.delete).toHaveBeenCalledWith({
390 + environmentId: primaryId,
391 + input: { projectId: state.projects[0]!.id, force: true },
392 + });
393 + await vi.waitFor(() => expect(state.releaseUploads).toHaveBeenCalledOnce());
394 + expect(state.clearDraft).toHaveBeenCalledOnce();
395 + expect(screen.router.state.location.href).toBe(initialHref);
396 + });
397 +
398 + it("rechecks every removal target after confirmation before deleting or clearing drafts", async () => {
399 + setup();
400 + const confirmed = deferred<boolean>();
401 + state.confirm.mockReturnValueOnce(confirmed.promise);
402 + await using screen = await mountPanel();
403 + await userEvent.click(removeAll(screen));
404 + expect(state.confirm).toHaveBeenCalledOnce();
405 +
406 + await grant(remoteId, AsyncResult.success(session([])));
407 + await act(async () => {
408 + confirmed.resolve(true);
409 + await confirmed.promise;
410 + });
411 + await expectProjectAccessDeniedToast("Failed to remove project");
412 + expect(state.delete).not.toHaveBeenCalled();
413 + expect(state.releaseUploads).not.toHaveBeenCalled();
414 + expect(state.clearDraft).not.toHaveBeenCalled();
415 + });
416 +
417 + it("does not save an edit whose grant was revoked mid-edit, and recovers when restored", async () => {
418 + setup();
419 + await using screen = await mountPanel();
420 + await userEvent.fill(nameInput(screen), "Renamed");
421 + await grant(remoteId, AsyncResult.success(session([])));
422 + // Chromium takes focus off a newly disabled input without firing blur. Send the
423 + // focusout so the save attempt runs and hits the same recheck as a real blur.
424 + await act(async () => {
425 + nameInput(screen).dispatchEvent(new FocusEvent("focusout", { bubbles: true }));
426 + });
427 + await expectProjectAccessDeniedToast("Failed to rename project");
428 + expect(state.update).not.toHaveBeenCalled();
429 + expect(nameInput(screen).disabled).toBe(true);
430 +
431 + await grant(remoteId, writable());
432 + expect(nameInput(screen).disabled).toBe(false);
433 + await rename(screen, "Recovered");
434 + await vi.waitFor(() => expect(state.update).toHaveBeenCalledTimes(2));
435 + expect(nameInput(screen).value).toBe("Recovered");
436 + });
437 +
438 + it.each([
439 + ["loading", () => AsyncResult.initial<AuthSessionState, Error>(), false],
440 + [
441 + "failed",
442 + () => AsyncResult.failure<AuthSessionState, Error>(Cause.fail(new Error("Disconnected"))),
443 + false,
444 + ],
445 + ["refreshing", () => AsyncResult.waiting(writable()), true],
446 + ] as const)(
447 + "uses the current grant while a member's session is %s",
448 + async (_state, result, allowed) => {
449 + setup();
450 + await grant(remoteId, result());
451 + await using screen = await mountPanel();
452 + expect(nameInput(screen).disabled).toBe(!allowed);
453 + if (!allowed) return;
454 + await rename(screen, "Renamed");
455 + expect(state.update).toHaveBeenCalledTimes(2);
456 + },
457 + );
458 +});
459 +
460 +describe("project settings scope", () => {
461 + const environmentMenu = () => page.getByRole("button", { name: /^Environment scope:/ });
462 + const primaryOption = () => page.getByRole("menuitemradio", { name: /^primary/ });
463 + const remoteOption = () => page.getByRole("menuitemradio", { name: /^remote/ });
464 +
465 + it("offers every environment while no project is selected", async () => {
466 + setup();
467 + state.projects = state.projects.filter((project) => project.environmentId === primaryId);
468 + await using _screen = await mountSettings({});
469 +
470 + await userEvent.click(environmentMenu());
471 + await expect.element(primaryOption()).toBeVisible();
472 + await expect.element(remoteOption()).toBeVisible();
473 + });
474 +
475 + it("offers only the selected project's checkout environments", async () => {
476 + setup();
477 + state.projects = state.projects.filter((project) => project.environmentId === primaryId);
478 + await using _screen = await mountSettings({ project: projectKey() });
479 +
480 + await expect.element(page.getByRole("textbox", { name: "Project name" })).toBeVisible();
481 + await userEvent.click(environmentMenu());
482 + await expect.element(primaryOption()).toBeVisible();
483 + await expect.element(remoteOption()).not.toBeInTheDocument();
484 + });
485 +
486 + it("keeps an unknown project recoverable from any environment", async () => {
487 + setup();
488 + state.projects = state.projects.filter((project) => project.environmentId === primaryId);
489 + await using screen = await mountSettings({ project: "removed-project" });
490 +
491 + await userEvent.click(environmentMenu());
492 + await expect.element(primaryOption()).toBeVisible();
493 + await expect.element(remoteOption()).toBeVisible();
494 + await userEvent.click(remoteOption());
495 + await vi.waitFor(() =>
496 + expect(screen.router.state.location.search).toEqual({
497 + project: "removed-project",
498 + machine: remoteId,
499 + }),
500 + );
501 + });
502 +
503 + it.each([
504 + [undefined, "This project has no checkout on this environment."],
505 + [
506 + "removed-checkout",
507 + "This checkout is no longer available in the selected project and environment.",
508 + ],
509 + ])("recovers a stale environment link with checkout %s", async (checkout, message) => {
510 + setup();
511 + state.projects = state.projects.filter((project) => project.environmentId === primaryId);
512 + const key = projectKey();
513 + await using screen = await mountSettings({
514 + project: key,
515 + machine: remoteId,
516 + ...(checkout ? { checkout } : {}),
517 + });
518 +
519 + await expect.element(page.getByText(message, { exact: true })).toBeVisible();
520 + await expect.element(page.getByRole("button", { name: /^Project scope:/ })).toBeVisible();
521 + await expect
522 + .element(page.getByRole("button", { name: "Environment scope: remote" }))
523 + .toBeVisible();
524 + await userEvent.click(page.getByRole("button", { name: "Show all environments" }));
525 +
526 + await expect
527 + .element(page.getByRole("textbox", { name: "Project name" }))
528 + .toHaveValue("Shared repo");
529 + expect(screen.router.state.location.search).toEqual({ project: key });
530 + await expect
531 + .element(page.getByRole("button", { name: "Environment scope: All environments" }))
532 + .toBeVisible();
533 + await expect.element(page.getByText(message, { exact: true })).not.toBeInTheDocument();
534 + await expect
535 + .element(page.getByRole("button", { name: "Remove project", exact: true }))
536 + .toBeEnabled();
537 + });
538 +});
539 +
540 +it("returns to the project overview after removal, clearing the selection but keeping the environment", async () => {
541 + setup();
542 + state.projects = [state.projects[1]!];
543 + await using screen = await mountPanel({ machine: remoteId, checkout: "remote:/work/remote" });
544 + const removeProject = [...screen.container.querySelectorAll("button")].find(
545 + (button) => button.textContent === "Remove project",
546 + )!;
547 +
548 + await userEvent.click(removeProject);
549 +
550 + await vi.waitFor(() => {
551 + expect(screen.router.state.location.pathname).toBe("/settings/projects");
552 + expect(screen.router.state.location.search).toEqual({ machine: remoteId });
553 + });
554 +});
apps/web/src/reactCompilerCoverage.test.ts
+2 -2
@@ -18,8 +18,8 @@ const webSourceFiles = NodeFS.readdirSync(NodePath.join(repoRoot, "apps/web/src"
18 .filter((file) => !file.endsWith(".gen.ts"))
19 .map((file) => `apps/web/src/${file}`);
20
21 -// ChatView is ~9k lines. Compiling it takes ~9s on a fast machine and passes the
22 -// 15s project timeout on loaded CI runners.
21 +// ChatView is ~9k lines. Compiling it takes ~9s on a fast machine and can pass the
22 +// 15s project limit on loaded CI runners, so slow files get a 60s limit below.
23 const slowFiles = new Set(["apps/web/src/components/ChatView.tsx"]);
24
25 const compile = async (file: string) => {