refactor(server): detach PR lookup stacks instead of a custom cache

apps/server/src/git/GitManager.ts

@@ -1,4 +1,3 @@
-import * as LookupResultCache from "./LookupResultCache.ts";
 import * as Arr from "effect/Array";
 import * as Cache from "effect/Cache";
 import * as Context from "effect/Context";
@@ -66,6 +65,7 @@ import {
 import * as ProjectSetupScriptRunner from "../project/ProjectSetupScriptRunner.ts";
 import * as ProviderRegistry from "../provider/Services/ProviderRegistry.ts";
 import { extractBranchNameFromRemoteRef } from "./remoteRefs.ts";
+import { detachStackFrame } from "./detachStackFrame.ts";
 import * as ServerSettings from "../serverSettings.ts";
 import type { GitManagerServiceError } from "@t3tools/contracts";
 import * as GitVcsDriver from "../vcs/GitVcsDriver.ts";
@@ -1093,7 +1093,7 @@ export const make = Effect.gen(function* () {
     prLookupFailureStreakByKey.set(key, streak);
     return prLookupFailureTtl(streak);
   };
-  const prLookupCache = yield* LookupResultCache.make(
+  const prLookupCache = yield* Cache.makeWith(
     (key: string) => {
       const [
         cwd = "",
@@ -1141,6 +1141,7 @@ export const make = Effect.gen(function* () {
       },
     },
   );
+  const getPrLookup = (key: string) => detachStackFrame(Cache.get(prLookupCache, key));
   // A transient lookup failure (rate limit, network blip) must not clear an
   // already-known PR badge, so the last successful answer per branch sticks
   // around as the fallback. Keep the resolved head context with it so a
@@ -1214,14 +1215,14 @@ export const make = Effect.gen(function* () {
     const branchKey = `${cwd}\u0000${details.branch}`;
     const cacheKey = prLookupCacheKey(cwd, details);
     if (refreshMissingPullRequest) {
-      const cached = yield* prLookupCache
-        .getOption(cacheKey)
-        .pipe(Effect.orElseSucceed(() => Option.none()));
+      const cached = yield* Cache.getOption(prLookupCache, cacheKey).pipe(
+        Effect.orElseSucceed(() => Option.none()),
+      );
       if (Option.isSome(cached) && cached.value.latest === null) {
-        yield* prLookupCache.invalidate(cacheKey);
+        yield* Cache.invalidate(prLookupCache, cacheKey);
       }
     }
-    return yield* prLookupCache.get(cacheKey).pipe(
+    return yield* getPrLookup(cacheKey).pipe(
       Effect.map(({ latest, headContext }) => {
         if (!latest) return { pr: null, headContext };
         // On the default branch, only surface open PRs.
@@ -2226,12 +2227,12 @@ export const make = Effect.gen(function* () {
     if (options?.refresh) {
       // A completed turn can create a PR or reuse a merged PR's branch.
       // Refresh successful answers, but keep failed lookups' retry backoff.
-      const cached = yield* prLookupCache
-        .getOption(cacheKey)
-        .pipe(Effect.orElseSucceed(() => Option.none()));
-      if (Option.isSome(cached)) yield* prLookupCache.invalidate(cacheKey);
+      const cached = yield* Cache.getOption(prLookupCache, cacheKey).pipe(
+        Effect.orElseSucceed(() => Option.none()),
+      );
+      if (Option.isSome(cached)) yield* Cache.invalidate(prLookupCache, cacheKey);
     }
-    let cached = yield* prLookupCache.get(cacheKey);
+    let cached = yield* getPrLookup(cacheKey);
     // The cached head context may have resolved on a different remote than
     // the saved upstream: a branch tracking origin/main but pushed to a fork
     // is looked up on the fork. Verify against the remote the lookup used.
@@ -2258,8 +2259,8 @@ export const make = Effect.gen(function* () {
       });
     }
     if (!hasSameIdentity(cached.headContext, currentIdentity)) {
-      yield* prLookupCache.invalidate(cacheKey);
-      cached = yield* prLookupCache.get(cacheKey);
+      yield* Cache.invalidate(prLookupCache, cacheKey);
+      cached = yield* getPrLookup(cacheKey);
       const refreshedIdentity = yield* resolvePrLookupRepositoryIdentity(
         cacheCwd,
         branch,

apps/server/src/git/LookupResultCache.memory.test.ts → apps/server/src/git/detachStackFrame.memory.test.ts

@@ -5,10 +5,10 @@ import * as NodeUtil from "node:util";
 import { expect, it } from "vite-plus/test";
 const execFile = NodeUtil.promisify(NodeChildProcess.execFile);
 it.each([false, true])(
-  "releases the traced caller snapshot while caching a result (failure=%s)",
+  "a detached cache lookup releases the traced caller snapshot (failure=%s)",
   async (failure) => {
     const fixture = NodeURL.fileURLToPath(
-      new URL("./testing/LookupRetention.fixture.mjs", import.meta.url),
+      new URL("./testing/StackRetention.fixture.mjs", import.meta.url),
     );
     const { stdout } = await execFile(process.execPath, [
       "--expose-gc",

apps/server/src/git/detachStackFrame.ts

@@ -0,0 +1,20 @@
+import * as Effect from "effect/Effect";
+import * as References from "effect/References";
+
+const snapshotStack = (
+  frame: References.StackFrame | undefined,
+): References.StackFrame | undefined => {
+  if (frame === undefined) return undefined;
+  const stack = frame.stack();
+  return { name: frame.name, stack: () => stack, parent: snapshotStack(frame.parent) };
+};
+
+/**
+ * Wrap a `Cache.get` so its lookup fiber inherits a materialized stack. The lazy
+ * caller frame would otherwise retain the caller's request snapshot for the TTL.
+ */
+export const detachStackFrame = <A, E, R>(effect: Effect.Effect<A, E, R>) =>
+  Effect.gen(function* () {
+    const frame = snapshotStack(yield* References.CurrentStackFrame);
+    return yield* Effect.provideService(effect, References.CurrentStackFrame, frame);
+  });

apps/server/src/git/testing/StackRetention.fixture.mjs

@@ -0,0 +1,31 @@
+import { Cache, Effect } from "effect";
+import { detachStackFrame } from "../detachStackFrame.ts";
+// `original` runs the bare Effect Cache to show the leak this helper prevents.
+const original = process.argv.includes("original");
+const failure = process.argv.includes("failure");
+const lookup = () => (failure ? Effect.fail("unavailable") : Effect.succeed(1));
+const cache = await Effect.runPromise(
+  Cache.makeWith(lookup, { capacity: 8, timeToLive: () => "1 hour" }),
+);
+const get = () => (original ? Cache.get(cache, "key") : detachStackFrame(Cache.get(cache, "key")));
+let reference;
+await Effect.runPromise(
+  Effect.gen(function* () {
+    const snapshot = { values: Array.from({ length: 250000 }, (_, i) => i) };
+    reference = new WeakRef(snapshot);
+    const request = Effect.fn("StackRetention.request")(function* () {
+      yield* Effect.exit(get());
+      return snapshot.values.length;
+    });
+    yield* request();
+  }),
+);
+for (let i = 0; i < 12; i++) {
+  await new Promise((resolve) => setImmediate(resolve));
+  global.gc();
+}
+const retained = reference.deref() !== undefined;
+const cachedResult = await Effect.runPromise(
+  get().pipe(Effect.catch(() => Effect.succeed("unavailable"))),
+);
+process.stdout.write(JSON.stringify({ retained, cachedResult }));