Commit b69f8b5ff079cccc259bf2a001c2da2bc25d6892 | the-knife

author	Ishaan Kothari <ishaanko.mail@gmail.com> 2026-10-05 21:09:13-07:00
committer	GitHub <noreply@github.com> 2026-10-05 21:09:13-07:00
log	b69f8b5ff079cccc259bf2a001c2da2bc25d6892
tree	9533ca8235d9cc5a24f66bc887149671d3d7c229
parent	fec71c5ab4fd860331fb15ce37c15edf6db1c236
signature	Signed by PGP key B5690EEEBB952194

fix(server): probe project favicon candidates concurrently (#12543)

2 files changed, 143 insertions(+), 52 deletions(-)

apps
- server
  - src
    project
    ProjectFaviconResolver.test.ts
    ProjectFaviconResolver.ts

apps/server/src/project/ProjectFaviconResolver.test.ts+69

...	@@ -402,6 +402,75 @@ it.layer(layerTest)("ProjectFaviconResolverLive", (it) => {	...	@@ -402,6 +402,75 @@ it.layer(layerTest)("ProjectFaviconResolverLive", (it) => {
402	}),	402	}),
403	);	403	);
404		404
		405	it.effect("probes well-known candidates concurrently", () =>
		406	Effect.gen(function* () {
		407	const fileSystem = yield* FileSystem.FileSystem;
		408	const cwd = yield* makeTempDir;
		409	let inFlight = 0;
		410	let peakInFlight = 0;
		411	const resolver = yield* makeResolverWithFileSystem(
		412	FileSystem.FileSystem.of({
		413	...fileSystem,
		414	stat: (filePath) =>
		415	Effect.suspend(() => {
		416	inFlight += 1;
		417	peakInFlight = Math.max(peakInFlight, inFlight);
		418	return Effect.yieldNow.pipe(Effect.andThen(fileSystem.stat(filePath)));
		419	}).pipe(Effect.ensuring(Effect.sync(() => (inFlight -= 1)))),
		420	}),
		421	);
		422
		423	expect(yield* resolver.resolvePath(cwd)).toBeNull();
		424	expect(peakInFlight).toBeGreaterThan(1);
		425	}),
		426	);
		427
		428	it.effect("returns a found favicon without waiting for lower-ranked probes", () =>
		429	Effect.gen(function* () {
		430	const fileSystem = yield* FileSystem.FileSystem;
		431	const path = yield* Path.Path;
		432	const cwd = yield* makeTempDir;
		433	yield* writeTextFile(cwd, "favicon.svg", "<svg>root</svg>");
		434	const stuckPath = path.join(cwd, "favicon.ico");
		435	const resolver = yield* makeResolverWithFileSystem(
		436	FileSystem.FileSystem.of({
		437	...fileSystem,
		438	stat: (filePath) => (filePath === stuckPath ? Effect.never : fileSystem.stat(filePath)),
		439	}),
		440	);
		441
		442	expect(yield* resolver.resolvePath(cwd)).toBe(path.join(cwd, "favicon.svg"));
		443	}),
		444	);
		445
		446	it.effect("ignores a failing candidate that ranks below a found favicon", () =>
		447	Effect.gen(function* () {
		448	const fileSystem = yield* FileSystem.FileSystem;
		449	const path = yield* Path.Path;
		450	const cwd = yield* makeTempDir;
		451	yield* writeTextFile(cwd, "favicon.svg", "<svg>root</svg>");
		452	const failingPath = path.join(cwd, "favicon.ico");
		453	const resolver = yield* makeResolverWithFileSystem(
		454	FileSystem.FileSystem.of({
		455	...fileSystem,
		456	stat: (filePath) =>
		457	filePath === failingPath
		458	? Effect.fail(
		459	PlatformError.systemError({
		460	_tag: "PermissionDenied",
		461	module: "FileSystem",
		462	method: "stat",
		463	pathOrDescriptor: failingPath,
		464	}),
		465	)
		466	: fileSystem.stat(filePath),
		467	}),
		468	);
		469
		470	expect(yield* resolver.resolvePath(cwd)).toBe(path.join(cwd, "favicon.svg"));
		471	}),
		472	);
		473
405	it.effect("preserves icon source read failures", () =>	474	it.effect("preserves icon source read failures", () =>
406	Effect.gen(function* () {	475	Effect.gen(function* () {
407	const fileSystem = yield* FileSystem.FileSystem;	476	const fileSystem = yield* FileSystem.FileSystem;

apps/server/src/project/ProjectFaviconResolver.ts+74-52

 @@ -11,6 +11,7 @@ import * as Context from "effect/Context";
 import * as Duration from "effect/Duration";
 import * as Effect from "effect/Effect";
 import * as Exit from "effect/Exit";
+import * as Fiber from "effect/Fiber";
 import * as FileSystem from "effect/FileSystem";
 import * as Layer from "effect/Layer";
 import * as Option from "effect/Option";
 @@ -21,8 +22,8 @@ import * as Schema from "effect/Schema";
 import * as WorkspacePaths from "../workspace/WorkspacePaths.ts";
 import * as T3ProjectFileLoader from "./T3ProjectFileLoader.ts";
-// Resolution walks up to 12 well-known paths plus 7 source files, so a miss
+// Resolution probes 21 well-known paths plus 7 source files, so a miss
-// costs ~20 filesystem probes. AssetAccess resolves on every project-favicon
+// costs ~30 filesystem probes. AssetAccess resolves on every project-favicon
 // asset URL, and a project's icon does not move, so the answer is cached.
 const FAVICON_CACHE_CAPACITY = 512;
 const FAVICON_POSITIVE_CACHE_TTL = Duration.minutes(10);
 @@ -205,6 +206,69 @@ export const make = Effect.gen(function* () {
     return null;
   });
+  // Reads one source file and resolves the icon it declares, if any.
+  const findIconFromSource = Effect.fn("ProjectFaviconResolver.findIconFromSource")(function* (
+    projectCwd: string,
+    sourceFile: string,
+  ): Effect.fn.Return<string | null, ProjectFaviconResolutionError> {
+    const sourcePath = yield* workspacePaths
+      .resolveRelativePathWithinRoot({
+        workspaceRoot: projectCwd,
+        relativePath: sourceFile,
+      })
+      .pipe(
+        Effect.mapError(
+          (cause) =>
+            new ProjectFaviconResolutionError({
+              operation: "resolve-path",
+              workspaceRoot: projectCwd,
+              relativePath: sourceFile,
+              cause,
+            }),
+        ),
+      );
+    const source = yield* optionOnNotFound(fileSystem.readFileString(sourcePath.absolutePath)).pipe(
+      Effect.mapError(
+        (cause) =>
+          new ProjectFaviconResolutionError({
+            operation: "read-source",
+            workspaceRoot: projectCwd,
+            relativePath: sourceFile,
+            absolutePath: sourcePath.absolutePath,
+            cause,
+          }),
+      ),
+    );
+    if (Option.isNone(source)) {
+      return null;
+    }
+    const href = extractIconHref(source.value);
+    if (!href) {
+      return null;
+    }
+    return yield* findExistingFile(projectCwd, resolveIconHref(href), "workspace");
+  });
+  // Starts every probe at once and returns the first hit in list order. A miss
+  // costs one round of filesystem latency instead of one per probe, which
+  // matters when the disk is slow. Fibers are joined in order, so a hit returns
+  // without waiting for lower-ranked probes (the scope interrupts them), and a
+  // failure surfaces only when no earlier probe found a file.
+  const firstInOrder = <A>(
+    items: ReadonlyArray<A>,
+    probe: (item: A) => Effect.Effect<string | null, ProjectFaviconResolutionError>,
+  ) =>
+    Effect.gen(function* () {
+      const fibers = yield* Effect.forEach(items, (item) => Effect.forkScoped(probe(item)));
+      for (const fiber of fibers) {
+        const found = yield* Fiber.join(fiber);
+        if (found) {
+          return found;
+        }
+      }
+      return null;
+    }).pipe(Effect.scoped);
   const resolvePathUncached = Effect.fn("ProjectFaviconResolver.resolvePathUncached")(function* (
     cwd: string,
     faviconPath?: string,
 @@ -241,58 +305,16 @@ export const make = Effect.gen(function* () {
       }
     }
-    for (const candidate of FAVICON_CANDIDATES) {
+    const wellKnown = yield* firstInOrder(FAVICON_CANDIDATES, (candidate) =>
-      const existing = yield* findExistingFile(projectCwd, [candidate], "workspace");
+      findExistingFile(projectCwd, [candidate], "workspace"),
-      if (existing) {
+    );
-        return existing;
+    if (wellKnown) {
-      }
+      return wellKnown;
-    }
-    for (const sourceFile of ICON_SOURCE_FILES) {
-      const sourcePath = yield* workspacePaths
-        .resolveRelativePathWithinRoot({
-          workspaceRoot: projectCwd,
-          relativePath: sourceFile,
-        })
-        .pipe(
-          Effect.mapError(
-            (cause) =>
-              new ProjectFaviconResolutionError({
-                operation: "resolve-path",
-                workspaceRoot: projectCwd,
-                relativePath: sourceFile,
-                cause,
-              }),
-          ),
-        );
-      const source = yield* optionOnNotFound(
-        fileSystem.readFileString(sourcePath.absolutePath),
-      ).pipe(
-        Effect.mapError(
-          (cause) =>
-            new ProjectFaviconResolutionError({
-              operation: "read-source",
-              workspaceRoot: projectCwd,
-              relativePath: sourceFile,
-              absolutePath: sourcePath.absolutePath,
-              cause,
-            }),
-        ),
-      );
-      if (Option.isNone(source)) {
-        continue;
-      }
-      const href = extractIconHref(source.value);
-      if (!href) {
-        continue;
-      }
-      const existing = yield* findExistingFile(projectCwd, resolveIconHref(href), "workspace");
-      if (existing) {
-        return existing;
-      }
     }
-    return null;
+    return yield* firstInOrder(ICON_SOURCE_FILES, (sourceFile) =>
+      findIconFromSource(projectCwd, sourceFile),
+    );
   });
   const faviconCache = yield* Cache.makeWith<string, string | null, ProjectFaviconResolutionError>(