@forgeax/engine-assets-runtime 0.1.4 → 0.1.7

package/src/__tests__/asset-graph-red.integration.test.ts

@@ -1,113 +0,0 @@
-import type { AssetLoadError } from '@forgeax/engine-types';
-import { err, ok } from '@forgeax/engine-types';
-import { describe, expect, it, vi } from 'vitest';
-import { AssetGraph } from '../internal/asset-graph.js';
-
-type Value = { readonly refs: readonly string[]; readonly value: string };
-
-const failure = (guid: string): AssetLoadError => ({
-  code: 'asset-dependency-failed',
-  expected: 'a readable dependency',
-  hint: 'repair the dependency publication and retry',
-  detail: { guid, dependencyGuid: guid },
-});
-
-describe('AssetGraph', () => {
-  it('deduplicates shared reads, bounds concurrency, and promotes a closure atomically', async () => {
-    let active = 0;
-    let peak = 0;
-    const reads = vi.fn(async (guid: string) => {
-      active += 1;
-      peak = Math.max(peak, active);
-      await new Promise((resolve) => setTimeout(resolve, 1));
-      active -= 1;
-      if (guid === 'root') return ok({ value: guid, refs: ['shared', 'left'] });
-      if (guid === 'left') return ok({ value: guid, refs: ['shared'] });
-      return ok({ value: guid, refs: [] });
-    });
-    const graph = new AssetGraph<Value>({ read: reads, maxConcurrentReads: 2 });
-
-    const [first, second] = await Promise.all([graph.load('root'), graph.load('root')]);
-    expect(first).toEqual(second);
-    expect(reads.mock.calls.filter(([guid]) => guid === 'shared')).toHaveLength(1);
-    expect(peak).toBeLessThanOrEqual(2);
-    expect(graph.snapshot().ready).toEqual(['left', 'root', 'shared']);
-    expect(graph.snapshot().pending).toBe(0);
-  });
-
-  it('terminates cycles as one SCC and does not deadlock', async () => {
-    const reads = vi.fn(async (guid: string) =>
-      ok<Value>({ value: guid, refs: [guid === 'a' ? 'b' : 'a'] }),
-    );
-    const graph = new AssetGraph<Value>({ read: reads, maxConcurrentReads: 1 });
-
-    expect((await graph.load('a')).ok).toBe(true);
-    expect(reads).toHaveBeenCalledTimes(2);
-    expect(graph.snapshot().sccs).toContainEqual(['a', 'b']);
-  });
-
-  it('clears failed pending work so a repaired publication can retry', async () => {
-    let repaired = false;
-    const reads = vi.fn(async (guid: string) => {
-      if (guid === 'child' && !repaired) return err(failure(guid));
-      return ok<Value>({ value: guid, refs: [] });
-    });
-    const graph = new AssetGraph<Value>({ read: reads });
-
-    expect((await graph.load('child')).ok).toBe(false);
-    expect(graph.snapshot().pending).toBe(0);
-    repaired = true;
-    expect((await graph.load('child')).ok).toBe(true);
-    expect(reads).toHaveBeenCalledTimes(2);
-  });
-
-  it('fences an in-flight read after publication invalidation', async () => {
-    let release: (() => void) | undefined;
-    let reads = 0;
-    const graph = new AssetGraph<Value>({
-      read: async (guid) => {
-        reads += 1;
-        await new Promise<void>((resolve) => {
-          release = resolve;
-        });
-        return ok<Value>({ value: guid, refs: [] });
-      },
-    });
-
-    const first = graph.load('asset');
-    graph.invalidate('asset');
-    release?.();
-    expect(await first).toEqual({
-      ok: false,
-      error: expect.objectContaining({ code: 'asset-superseded' }),
-    });
-    expect(reads).toBe(1);
-  });
-
-  it('resolves a queued permit with the terminal dispose result', async () => {
-    let release: (() => void) | undefined;
-    const graph = new AssetGraph<Value>({
-      maxConcurrentReads: 1,
-      read: async (guid) => {
-        await new Promise<void>((resolve) => {
-          release = resolve;
-        });
-        return ok<Value>({ value: guid, refs: [] });
-      },
-    });
-
-    const first = graph.load('first');
-    await Promise.resolve();
-    const second = graph.load('second');
-    graph.dispose();
-    expect(await second).toEqual({
-      ok: false,
-      error: expect.objectContaining({ code: 'asset-runtime-disposed' }),
-    });
-    release?.();
-    expect(await first).toEqual({
-      ok: false,
-      error: expect.objectContaining({ code: 'asset-runtime-disposed' }),
-    });
-  });
-});

package/src/__tests__/asset-registry-core.integration.test.ts

@@ -1,161 +0,0 @@
-import type { AssetDecoder, CatalogDelta, CatalogEntry } from '@forgeax/engine-types';
-import { ok } from '@forgeax/engine-types';
-import { describe, expect, it } from 'vitest';
-import { defineAssetKind } from '../asset-kind.js';
-import { createCatalogSource } from '../catalog-source.js';
-import { createAssetRegistry } from '../internal/load-asset.js';
-
-const ROOT = '00000000-0000-7000-8000-000000000021';
-const CHILD = '00000000-0000-7000-8000-000000000022';
-const PACKAGE_URL = 'https://assets.test/runtime.pack.json';
-const kind = defineAssetKind<unknown, 'host-blob'>('host-blob');
-
-function row(guid: string, refs: readonly string[] = [], revision = 1): CatalogEntry {
-  return {
-    guid,
-    packageUrl: PACKAGE_URL,
-    kind: kind.kind,
-    sourcePath: `fixtures/${guid}`,
-    revision: { rootId: 'root', digest: `sha256:catalog-${revision}`, observedAt: revision },
-    publication: {
-      schemaVersion: 'asset-publication/1',
-      sourcePath: `fixtures/${guid}`,
-      sourceRevision: 'source-1',
-      generation: 1,
-      digest: 'sha256:pack',
-      outputSetDigest: 'sha256:outputs',
-      outputs: [{ guid, sourceKey: guid, kind: kind.kind, digest: `sha256:${guid}`, refs }],
-      receipt: {
-        schemaVersion: 'asset-publication-receipt/1',
-        sourcePath: `fixtures/${guid}`,
-        sourceRevision: 'source-1',
-        inputFingerprint: 'input-1',
-        outputDigest: 'sha256:outputs',
-        outputSetDigest: 'sha256:outputs',
-        externalEvidence: [],
-      },
-      externalEvidence: [],
-    },
-  };
-}
-
-describe('AssetRegistry integration', () => {
-  it('loads a real Pack closure through the owner decoder and reuses one Pack read', async () => {
-    let packReads = 0;
-    let artifactReads = 0;
-    let publishCatalog: ((delta: CatalogDelta) => void) | undefined;
-    const fetcher: typeof globalThis.fetch = async (input) => {
-      const url = String(input);
-      if (url === PACKAGE_URL) {
-        packReads += 1;
-        return new Response(
-          JSON.stringify({
-            schemaVersion: '2.0.0',
-            kind: 'internal-text-package',
-            scopeId: 'scope',
-            generation: 1,
-            digest: 'sha256:pack',
-            outputSetDigest: 'sha256:outputs',
-            assets: [
-              {
-                guid: ROOT,
-                kind: kind.kind,
-                payload: { label: 'root' },
-                refs: [CHILD],
-                artifacts: {
-                  preview: {
-                    path: 'preview.bin',
-                    mediaType: 'application/octet-stream',
-                    contentEncoding: 'identity',
-                    byteLength: 3,
-                    integrity: {
-                      algorithm: 'sha256',
-                      digest:
-                        'sha256:039058c6f2c0cb492c533b0a4d14ef77cc0f78abccced5287d84a1a2011cfb81',
-                    },
-                  },
-                },
-              },
-              {
-                guid: CHILD,
-                kind: kind.kind,
-                payload: { label: 'child' },
-                refs: [],
-                artifacts: {},
-              },
-            ],
-          }),
-        );
-      }
-      if (url === 'https://assets.test/preview.bin') {
-        artifactReads += 1;
-        return new Response(new Uint8Array([1, 2, 3]));
-      }
-      return new Response('not found', { status: 404 });
-    };
-    const decoder: AssetDecoder<unknown> = {
-      decode: async ({ envelope, artifacts }) => {
-        if (envelope.guid === ROOT) {
-          const preview = await artifacts.read(
-            envelope.artifacts.preview as NonNullable<typeof envelope.artifacts.preview>,
-          );
-          if (!preview.ok) return preview;
-          return ok({
-            child: envelope.refs[0],
-            inline: (envelope.payload as { label: string }).label,
-            preview: [...preview.value],
-          });
-        }
-        return ok({ inline: (envelope.payload as { label: string }).label });
-      },
-    };
-    const core = createAssetRegistry({
-      catalog: createCatalogSource({
-        entries: [row(ROOT, [CHILD]), row(CHILD)],
-        expectedScope: { scopeId: 'scope', generation: 1 },
-        subscribe(listener) {
-          publishCatalog = listener;
-          return () => {};
-        },
-      }),
-      fetcher,
-      maxConcurrentReads: 2,
-    });
-    core.installDecoder(kind, decoder);
-
-    const result = await core.load(ROOT, kind);
-
-    expect(result).toEqual({
-      ok: true,
-      value: { child: CHILD, inline: 'root', preview: [1, 2, 3] },
-    });
-    expect(result.ok && Object.isFrozen(result.value)).toBe(true);
-    expect(packReads).toBe(1);
-    expect(artifactReads).toBe(1);
-    expect(core.snapshot().ready).toHaveLength(2);
-    expect(core.snapshot().resources).toBe(2);
-    publishCatalog?.({
-      added: [],
-      changed: [row(ROOT, [CHILD], 2)],
-      removed: [],
-    });
-    expect(core.snapshot().resources).toBe(1);
-    expect(core.snapshot().ready).toEqual([CHILD]);
-
-    publishCatalog?.({
-      added: [],
-      changed: [row(ROOT, [CHILD], 3)],
-      removed: [],
-      revisions: {
-        baseline: [{ rootId: 'root', revision: 1 }],
-        current: [{ rootId: 'root', revision: 3 }],
-      },
-    });
-    expect(core.snapshot().resources).toBe(0);
-    const recovered = await core.load(ROOT, kind);
-    expect(recovered.ok).toBe(true);
-    expect(core.snapshot().resources).toBe(2);
-    expect(packReads).toBe(1);
-    core.dispose();
-  });
-});

package/src/__tests__/asset-registry-public-api.test-d.ts

@@ -1,31 +0,0 @@
-import { describe, expectTypeOf, it } from 'vitest';
-import type { CatalogSource } from '../catalog-source.js';
-import {
-  type AssetRegistry,
-  type AssetRegistryOptions,
-  type AssetRegistrySnapshot,
-  createAssetRegistry,
-} from '../index.js';
-
-describe('AssetRegistry public API', () => {
-  it('binds the factory and options to the root registry interface', () => {
-    const options = { catalog: null as unknown as CatalogSource } satisfies AssetRegistryOptions;
-    expectTypeOf(createAssetRegistry(options)).toEqualTypeOf<AssetRegistry>();
-  });
-
-  it('exposes the graph observation through registry snapshot types', () => {
-    const registry = null as unknown as AssetRegistry;
-    expectTypeOf(registry.snapshot()).toEqualTypeOf<AssetRegistrySnapshot>();
-    expectTypeOf(registry.snapshot().ready).toEqualTypeOf<readonly string[]>();
-    expectTypeOf(registry.snapshot().counters.loads).toEqualTypeOf<number>();
-  });
-
-  it('keeps renderer payload projection out of the five-action root surface', () => {
-    const registry = null as unknown as AssetRegistry;
-    expectTypeOf(registry.installDecoder).toBeFunction();
-    expectTypeOf(registry.load).toBeFunction();
-    expectTypeOf(registry.snapshot).toBeFunction();
-    expectTypeOf(registry.subscribe).toBeFunction();
-    expectTypeOf(registry.dispose).toBeFunction();
-  });
-});

package/src/__tests__/asset-runtime-core-lifecycle.integration.test.ts

@@ -1,79 +0,0 @@
-import type { CatalogEntry } from '@forgeax/engine-types';
-import { ok } from '@forgeax/engine-types';
-import { describe, expect, it } from 'vitest';
-import { defineAssetKind } from '../asset-kind.js';
-import { createCatalogSource } from '../catalog-source.js';
-import { createAssetRegistry } from '../internal/load-asset.js';
-
-const GUID = '00000000-0000-7000-8000-000000000011';
-const kind = defineAssetKind<string, 'host-blob'>('host-blob');
-
-function row(): CatalogEntry {
-  return {
-    guid: GUID,
-    packageUrl: '/asset.pack.json',
-    kind: kind.kind,
-    sourcePath: 'test',
-    publication: {
-      schemaVersion: 'asset-publication/1',
-      sourcePath: 'test',
-      sourceRevision: 'source-1',
-      generation: 1,
-      digest: 'sha256:pack',
-      outputSetDigest: 'sha256:outputs',
-      outputs: [
-        { guid: GUID, sourceKey: 'test', kind: kind.kind, digest: 'sha256:asset', refs: [] },
-      ],
-      receipt: {
-        schemaVersion: 'asset-publication-receipt/1',
-        sourcePath: 'test',
-        sourceRevision: 'source-1',
-        inputFingerprint: 'input-1',
-        outputDigest: 'sha256:outputs',
-        outputSetDigest: 'sha256:outputs',
-        externalEvidence: [],
-      },
-      externalEvidence: [],
-    },
-  };
-}
-
-describe('AssetRegistry lifecycle', () => {
-  it('does not promote a late Pack result after dispose', async () => {
-    let resolveFetch: ((response: Response) => void) | undefined;
-    const fetcher = () =>
-      new Promise<Response>((resolve) => {
-        resolveFetch = resolve;
-      });
-    const core = createAssetRegistry({
-      catalog: createCatalogSource({ entries: [row()] }),
-      fetcher,
-      scopeId: 'scope',
-      generation: 1,
-    });
-    core.installDecoder(kind, {
-      decode: async ({ envelope }) => ok(envelope.payload as string),
-    });
-    const request = core.load(GUID, kind);
-    core.dispose();
-    resolveFetch?.(
-      new Response(
-        JSON.stringify({
-          schemaVersion: '2.0.0',
-          kind: 'internal-text-package',
-          scopeId: 'scope',
-          generation: 1,
-          digest: 'sha256:pack',
-          outputSetDigest: 'sha256:outputs',
-          assets: [{ guid: GUID, kind: kind.kind, payload: 'value', refs: [], artifacts: {} }],
-        }),
-      ),
-    );
-    expect(await request).toEqual({
-      ok: false,
-      error: expect.objectContaining({ code: 'asset-runtime-disposed' }),
-    });
-    expect(core.snapshot().pending).toBe(0);
-    expect(core.snapshot().resources).toBe(0);
-  });
-});

package/src/__tests__/asset-runtime-snapshot.unit.test.ts

@@ -1,23 +0,0 @@
-import { ok } from '@forgeax/engine-types';
-import { describe, expect, it } from 'vitest';
-import { AssetGraph } from '../internal/asset-graph.js';
-
-describe('asset runtime snapshot counters', () => {
-  it('reports no-change loads without new reads and keeps bounded counters', async () => {
-    let reads = 0;
-    const graph = new AssetGraph<{ readonly refs: readonly string[]; readonly value: string }>({
-      read: async (guid) => {
-        reads += 1;
-        return ok({ value: guid, refs: [] });
-      },
-    });
-    await graph.load('same');
-    const before = graph.snapshot();
-    await graph.load('same');
-    const after = graph.snapshot();
-    expect(reads).toBe(1);
-    expect(after.counters.noChange).toBe(before.counters.noChange + 1);
-    expect(after.resources).toBe(1);
-    expect(after.pending).toBe(0);
-  });
-});

package/src/__tests__/catalog-session-red.unit.test.ts

@@ -1,276 +0,0 @@
-import type { CatalogDelta, CatalogEntry } from '@forgeax/engine-types';
-import { ok } from '@forgeax/engine-types';
-import { describe, expect, it } from 'vitest';
-import { createCatalogSource } from '../catalog-source.js';
-import { ArtifactCache } from '../internal/artifact-cache.js';
-import { CatalogSession } from '../internal/catalog-session.js';
-import { PackReader } from '../internal/pack-reader.js';
-
-const GUID = '00000000-0000-7000-8000-000000000001';
-
-function entry(guid = GUID, revision = 1): CatalogEntry {
-  return {
-    guid,
-    packageUrl: '/runtime.pack.json',
-    kind: 'host-blob',
-    sourcePath: 'test',
-    revision: { rootId: 'root', digest: `sha256:revision-${revision}`, observedAt: revision },
-    publication: {
-      schemaVersion: 'asset-publication/1',
-      sourcePath: 'test',
-      sourceRevision: `source-${revision}`,
-      generation: 1,
-      digest: 'sha256:pack',
-      outputSetDigest: 'sha256:outputs',
-      outputs: [{ guid, sourceKey: guid, kind: 'host-blob', digest: 'sha256:asset', refs: [] }],
-      receipt: {
-        schemaVersion: 'asset-publication-receipt/1',
-        sourcePath: 'test',
-        sourceRevision: `source-${revision}`,
-        inputFingerprint: 'input',
-        outputDigest: 'sha256:outputs',
-        outputSetDigest: 'sha256:outputs',
-        externalEvidence: [],
-      },
-      externalEvidence: [],
-    },
-  };
-}
-
-describe('CatalogSession', () => {
-  it('rejects a Catalog row without a complete publication at the runtime boundary', async () => {
-    const invalidRow = { ...entry() };
-    delete (invalidRow as { publication?: CatalogEntry['publication'] }).publication;
-    const session = new CatalogSession(createCatalogSource({ entries: [invalidRow] }));
-
-    expect(await session.start()).toEqual({
-      ok: false,
-      error: expect.objectContaining({ code: 'asset-package-invalid' }),
-    });
-  });
-
-  it('turns a thrown Catalog enumeration into a structured runtime failure', async () => {
-    const session = new CatalogSession({
-      enumerate: async () => {
-        throw new Error('catalog transport unavailable');
-      },
-      subscribe: () => () => {},
-    });
-
-    await expect(session.start()).resolves.toMatchObject({
-      ok: false,
-      error: { code: 'asset-package-invalid' },
-    });
-    expect(session.snapshot().stale).toBe(true);
-  });
-
-  it('binds one scope and rejects a delta from another scope', async () => {
-    let publish: ((delta: CatalogDelta) => void) | undefined;
-    const source = createCatalogSource({
-      entries: [entry()],
-      expectedScope: { scopeId: 'scope-a', generation: 4 },
-      subscribe(listener) {
-        publish = listener;
-        return () => {};
-      },
-    });
-    const session = new CatalogSession(source);
-
-    expect((await session.start()).ok).toBe(true);
-    expect(session.snapshot().scopeId).toBe('scope-a');
-    expect(session.snapshot().generation).toBe(4);
-    publish?.({
-      scopeId: 'scope-b',
-      generation: 4,
-      added: [entry('00000000-0000-7000-8000-000000000002', 2)],
-      changed: [],
-      removed: [],
-    });
-
-    expect(session.snapshot().entries).toHaveLength(1);
-    expect(session.snapshot().diagnostics.map((item) => item.code)).toContain(
-      'catalog-scope-mismatch',
-    );
-  });
-
-  it('serializes reconcile and preserves continuity across ordered deltas', async () => {
-    const deltas: CatalogDelta[] = [];
-    const source = createCatalogSource({
-      entries: [entry()],
-      subscribe(listener) {
-        deltas.push({
-          added: [],
-          changed: [entry(GUID, 2)],
-          removed: [],
-          revisions: {
-            baseline: [{ rootId: 'root', revision: 1 }],
-            current: [{ rootId: 'root', revision: 2 }],
-          },
-        });
-        listener(deltas[0] as CatalogDelta);
-        return () => {};
-      },
-    });
-    const session = new CatalogSession(source, { scopeId: 'scope', generation: 1 });
-
-    await session.start();
-    expect(session.current(GUID)?.revision?.observedAt).toBe(2);
-    expect((await session.reconcile()).ok).toBe(true);
-    expect(session.snapshot().epoch).toBeGreaterThan(0);
-  });
-
-  it('marks a discontinuous delta and clears the terminal observation on reconcile', async () => {
-    let publish: ((delta: CatalogDelta) => void) | undefined;
-    const source = createCatalogSource({
-      entries: [entry()],
-      subscribe(listener) {
-        publish = listener;
-        return () => {};
-      },
-    });
-    const session = new CatalogSession(source, { scopeId: 'scope', generation: 1 });
-
-    await session.start();
-    publish?.({
-      added: [],
-      changed: [entry(GUID, 3)],
-      removed: [],
-      revisions: {
-        baseline: [{ rootId: 'root', revision: 1 }],
-        current: [{ rootId: 'root', revision: 3 }],
-      },
-    });
-
-    expect(session.snapshot().stale).toBe(true);
-    expect(session.snapshot().epoch).toBeGreaterThan(0);
-    expect(session.discontinuity()).toMatchObject({ code: 'catalog-discontinuous' });
-
-    expect((await session.reconcile()).ok).toBe(true);
-    expect(session.snapshot().stale).toBe(false);
-    expect(session.snapshot().diagnostics).toEqual([]);
-    expect(session.discontinuity()).toBeUndefined();
-  });
-
-  it('does not expose mutable session state', async () => {
-    const session = new CatalogSession(createCatalogSource({ entries: [entry()] }), {
-      scopeId: 'scope',
-      generation: 1,
-    });
-    await session.start();
-    const snapshot = session.snapshot();
-    expect(Object.isFrozen(snapshot)).toBe(true);
-    expect(Object.isFrozen(snapshot.entries)).toBe(true);
-    expect(ok(snapshot.entries[0])).toEqual(ok(snapshot.entries[0]));
-  });
-
-  it('records observer failures without starving later observers', async () => {
-    const session = new CatalogSession(createCatalogSource({ entries: [entry()] }));
-    const seen: number[] = [];
-    session.subscribe(() => {
-      throw new Error('observer failure');
-    });
-    session.subscribe((snapshot) => seen.push(snapshot.entries.length));
-
-    await session.start();
-
-    expect(seen).toContain(1);
-    expect(session.snapshot().listenerFailures).toBe(1);
-  });
-
-  it('accepts only the current Pack v2 tuple and complete artifact descriptors', async () => {
-    const tuple = {
-      scopeId: 'scope',
-      generation: 1,
-      digest: 'sha256:pack',
-      outputSetDigest: 'sha256:outputs',
-    };
-    const reader = new PackReader();
-    const result = reader.verify(
-      {
-        schemaVersion: '2.0.0',
-        kind: 'internal-text-package',
-        ...tuple,
-        assets: [
-          {
-            guid: GUID,
-            kind: 'host-blob',
-            payload: { value: 'ok' },
-            refs: [],
-            artifacts: {
-              body: {
-                path: 'body.bin',
-                mediaType: 'application/octet-stream',
-                contentEncoding: 'identity',
-                byteLength: 2,
-                integrity: {
-                  algorithm: 'sha256',
-                  digest: 'sha256:230d8358dc8e8890b4c58deeb62912ee2f20357ae92a5cc861b98e68fe31acb5',
-                },
-              },
-            },
-          },
-        ],
-      },
-      tuple,
-    );
-    expect(result.ok).toBe(true);
-    if (result.ok) expect(Object.isFrozen(result.value.assets[0])).toBe(true);
-    expect(reader.verify({ schemaVersion: '1.0.0' }, tuple).ok).toBe(false);
-  });
-
-  it('resolves a late-installed host fetch when no transport was injected', async () => {
-    const tuple = {
-      scopeId: 'scope',
-      generation: 1,
-      digest: 'sha256:pack',
-      outputSetDigest: 'sha256:outputs',
-    };
-    const pack = {
-      schemaVersion: '2.0.0',
-      kind: 'internal-text-package',
-      ...tuple,
-      assets: [
-        {
-          guid: GUID,
-          kind: 'host-blob',
-          payload: { value: 'late-fetch' },
-          refs: [],
-          artifacts: {},
-        },
-      ],
-    };
-    const originalFetch = globalThis.fetch;
-    try {
-      const reader = new PackReader();
-      globalThis.fetch = (async () => new Response(JSON.stringify(pack))) as typeof fetch;
-      const result = await reader.read('/late.pack.json', tuple, new AbortController().signal);
-      expect(result.ok).toBe(true);
-    } finally {
-      globalThis.fetch = originalFetch;
-    }
-  });
-
-  it('deduplicates content-addressed artifact reads and removes rejected entries', async () => {
-    const cache = new ArtifactCache();
-    let reads = 0;
-    const read = () => {
-      reads += 1;
-      return Promise.resolve(ok(new Uint8Array([1, 2, 3])));
-    };
-    await Promise.all([cache.read('sha256:body', read), cache.read('sha256:body', read)]);
-    expect(reads).toBe(1);
-    expect(cache.snapshot().hits).toBe(1);
-    await cache.read('sha256:failed', () =>
-      Promise.resolve({
-        ok: false as const,
-        error: {
-          code: 'asset-fetch-failed' as const,
-          expected: 'bytes',
-          hint: 'retry',
-          detail: { guid: GUID, packageUrl: '/body.bin' },
-        },
-      } as never),
-    );
-    expect(cache.snapshot().pending).toBe(0);
-  });
-});