fix(cache): repair discovery globs, error discrimination, cache-dir linking, manifest refcounts, and LRU adapter defects

src/utils/bundle-manifest.test.ts

@@ -2,6 +2,7 @@ import "#veryfront/schemas/_test-setup.ts";
 import { assertEquals, assertExists } from "#veryfront/testing/assert.ts";
 import { describe, it } from "#veryfront/testing/bdd.ts";
 import { delay } from "#std/async.ts";
+import { FakeTime } from "#std/testing/time";
 import { scaleMs } from "#veryfront/testing/timing.ts";
 import {
   type BundleCode,
@@ -95,6 +96,245 @@ describe("InMemoryBundleManifestStore", () => {
     assertEquals(await store.getBundleMetadata("key-2"), undefined);
   });
 
+  it("removes a replaced key from its previous source index", async () => {
+    const store = new InMemoryBundleManifestStore();
+    const original: BundleMetadata = {
+      hash: "hash-original",
+      codeHash: "code-original",
+      size: 10,
+      compiledAt: Date.now(),
+      source: "original.mdx",
+      mode: "development",
+    };
+    const replacement: BundleMetadata = {
+      ...original,
+      hash: "hash-replacement",
+      codeHash: "code-replacement",
+      source: "replacement.mdx",
+    };
+
+    await store.setBundleMetadata("shared-key", original);
+    await store.setBundleMetadata("shared-key", replacement);
+
+    assertEquals(await store.invalidateSource("original.mdx"), 0);
+    assertEquals(await store.getBundleMetadata("shared-key"), replacement);
+  });
+
+  it("does not delete code that is still referenced by another bundle", async () => {
+    const store = new InMemoryBundleManifestStore();
+    const sharedCode: BundleCode = { code: "export default 1" };
+    const first: BundleMetadata = {
+      hash: "hash-first",
+      codeHash: "shared-code",
+      size: 10,
+      compiledAt: Date.now(),
+      source: "first.mdx",
+      mode: "development",
+    };
+    const second: BundleMetadata = {
+      ...first,
+      hash: "hash-second",
+      source: "second.mdx",
+    };
+
+    await store.setBundleMetadata("first", first);
+    await store.setBundleMetadata("second", second);
+    await store.setBundleCode("shared-code", sharedCode);
+    await store.deleteBundle("first");
+
+    assertEquals(await store.getBundleMetadata("second"), second);
+    assertEquals(await store.getBundleCode("shared-code"), sharedCode);
+
+    await store.deleteBundle("second");
+    assertEquals(await store.getBundleCode("shared-code"), undefined);
+  });
+
+  it("retains shared code across partial source invalidation", async () => {
+    const store = new InMemoryBundleManifestStore();
+    const sharedCode: BundleCode = { code: "export default 1" };
+    const metadata: BundleMetadata = {
+      hash: "hash",
+      codeHash: "shared-code",
+      size: 10,
+      compiledAt: Date.now(),
+      source: "first.mdx",
+      mode: "development",
+    };
+
+    await store.setBundleCode(metadata.codeHash, sharedCode);
+    await store.setBundleMetadata("first-a", metadata);
+    await store.setBundleMetadata("first-b", { ...metadata, hash: "hash-b" });
+    await store.setBundleMetadata("second", { ...metadata, source: "second.mdx" });
+
+    assertEquals(await store.invalidateSource("first.mdx"), 2);
+    assertEquals(await store.getBundleCode(metadata.codeHash), sharedCode);
+
+    assertEquals(await store.invalidateSource("second.mdx"), 1);
+    assertEquals(await store.getBundleCode(metadata.codeHash), undefined);
+  });
+
+  it("transfers code references when metadata is replaced", async () => {
+    const store = new InMemoryBundleManifestStore();
+    const originalCode: BundleCode = { code: "export default 'original'" };
+    const replacementCode: BundleCode = { code: "export default 'replacement'" };
+    const original: BundleMetadata = {
+      hash: "hash-original",
+      codeHash: "code-original",
+      size: 10,
+      compiledAt: Date.now(),
+      source: "original.mdx",
+      mode: "development",
+    };
+    const replacement: BundleMetadata = {
+      ...original,
+      hash: "hash-replacement",
+      codeHash: "code-replacement",
+      source: "replacement.mdx",
+    };
+
+    await store.setBundleCode(original.codeHash, originalCode);
+    await store.setBundleCode(replacement.codeHash, replacementCode);
+    await store.setBundleMetadata("replaced", original);
+    await store.setBundleMetadata("remaining-original", {
+      ...original,
+      source: "remaining.mdx",
+    });
+    await store.setBundleMetadata("replaced", replacement);
+
+    assertEquals(await store.getBundleCode(original.codeHash), originalCode);
+    assertEquals(await store.getBundleCode(replacement.codeHash), replacementCode);
+
+    await store.deleteBundle("remaining-original");
+    assertEquals(await store.getBundleCode(original.codeHash), undefined);
+    assertEquals(await store.getBundleCode(replacement.codeHash), replacementCode);
+
+    await store.deleteBundle("replaced");
+    assertEquals(await store.getBundleCode(replacement.codeHash), undefined);
+  });
+
+  it("does not double-count an unchanged key and code hash", async () => {
+    const store = new InMemoryBundleManifestStore();
+    const code: BundleCode = { code: "export default true" };
+    const metadata: BundleMetadata = {
+      hash: "hash",
+      codeHash: "code",
+      size: 10,
+      compiledAt: Date.now(),
+      source: "source.mdx",
+      mode: "development",
+    };
+
+    await store.setBundleCode(metadata.codeHash, code);
+    await store.setBundleMetadata("key", metadata);
+    await store.setBundleMetadata("key", { ...metadata, hash: "updated-hash" });
+    await store.deleteBundle("key");
+
+    assertEquals(await store.getBundleCode(metadata.codeHash), undefined);
+  });
+
+  it("snapshots metadata supplied by callers", async () => {
+    const store = new InMemoryBundleManifestStore();
+    const code: BundleCode = { code: "export default true" };
+    const metadata: BundleMetadata = {
+      hash: "original-hash",
+      codeHash: "original-code",
+      size: 10,
+      compiledAt: Date.now(),
+      source: "original.mdx",
+      mode: "development",
+      meta: {
+        type: "mdx",
+        headings: [{ id: "original", text: "Original", level: 1 }],
+      },
+    };
+
+    await store.setBundleCode(metadata.codeHash, code);
+    await store.setBundleMetadata("key", metadata);
+
+    metadata.codeHash = "mutated-code";
+    metadata.source = "mutated.mdx";
+    const suppliedHeading = metadata.meta?.headings?.[0];
+    assertExists(suppliedHeading);
+    suppliedHeading.text = "Mutated";
+
+    const stored = await store.getBundleMetadata("key");
+    assertEquals(stored?.codeHash, "original-code");
+    assertEquals(stored?.source, "original.mdx");
+    assertEquals(stored?.meta?.headings?.[0]?.text, "Original");
+
+    await store.deleteBundle("key");
+    assertEquals(await store.getBundleCode("original-code"), undefined);
+    assertEquals(await store.invalidateSource("original.mdx"), 0);
+  });
+
+  it("does not expose indexed metadata records to callers", async () => {
+    const store = new InMemoryBundleManifestStore();
+    const first: BundleMetadata = {
+      hash: "first-hash",
+      codeHash: "first-code",
+      size: 10,
+      compiledAt: Date.now(),
+      source: "first.mdx",
+      mode: "development",
+      meta: {
+        type: "mdx",
+        headings: [{ id: "first", text: "First", level: 1 }],
+      },
+    };
+    const second: BundleMetadata = {
+      ...first,
+      hash: "second-hash",
+      codeHash: "second-code",
+      source: "second.mdx",
+    };
+
+    await store.setBundleCode(first.codeHash, { code: "export default 1" });
+    await store.setBundleCode(second.codeHash, { code: "export default 2" });
+    await store.setBundleMetadata("first", first);
+    await store.setBundleMetadata("second", second);
+
+    const exposed = await store.getBundleMetadata("first");
+    assertExists(exposed);
+    exposed.codeHash = second.codeHash;
+    exposed.source = second.source;
+    const exposedHeading = exposed.meta?.headings?.[0];
+    assertExists(exposedHeading);
+    exposedHeading.text = "Mutated";
+
+    const stored = await store.getBundleMetadata("first");
+    assertEquals(stored?.codeHash, first.codeHash);
+    assertEquals(stored?.source, first.source);
+    assertEquals(stored?.meta?.headings?.[0]?.text, "First");
+
+    await store.deleteBundle("first");
+    assertEquals(await store.getBundleCode(first.codeHash), undefined);
+    assertEquals(await store.getBundleCode(second.codeHash), { code: "export default 2" });
+    assertEquals(await store.invalidateSource(first.source), 0);
+    assertEquals(await store.getBundleMetadata("second"), second);
+  });
+
+  it("releases code and source references when metadata expires", async () => {
+    using time = new FakeTime();
+    const store = new InMemoryBundleManifestStore();
+    const code: BundleCode = { code: "export default true" };
+    const metadata: BundleMetadata = {
+      hash: "hash",
+      codeHash: "code",
+      size: 10,
+      compiledAt: Date.now(),
+      source: "source.mdx",
+      mode: "development",
+    };
+
+    await store.setBundleCode(metadata.codeHash, code);
+    await store.setBundleMetadata("key", metadata, 10);
+    await time.tickAsync(11);
+
+    assertEquals(await store.getBundleMetadata("key"), undefined);
+    assertEquals(await store.getBundleCode(metadata.codeHash), undefined);
+    assertEquals(await store.invalidateSource(metadata.source), 0);
+  });
+
   it("delete bundle", async () => {
     const store = new InMemoryBundleManifestStore();
 
@@ -141,6 +381,29 @@ describe("InMemoryBundleManifestStore", () => {
     assertEquals(await store.getBundleCode(metadata.codeHash), undefined);
   });
 
+  it("clear resets code reference counts", async () => {
+    const store = new InMemoryBundleManifestStore();
+    const code: BundleCode = { code: "export default true" };
+    const metadata: BundleMetadata = {
+      hash: "hash",
+      codeHash: "shared-code",
+      size: 10,
+      compiledAt: Date.now(),
+      source: "source.mdx",
+      mode: "development",
+    };
+
+    await store.setBundleMetadata("first", metadata);
+    await store.setBundleMetadata("second", { ...metadata, source: "second.mdx" });
+    await store.clear();
+
+    await store.setBundleCode(metadata.codeHash, code);
+    await store.setBundleMetadata("after-clear", metadata);
+    await store.deleteBundle("after-clear");
+
+    assertEquals(await store.getBundleCode(metadata.codeHash), undefined);
+  });
+
   it("statistics", async () => {
     const store = new InMemoryBundleManifestStore();
     const now = Date.now();