@forgeax/engine-assets-runtime 0.1.4 → 0.1.7

package/src/__tests__/registry-lifecycle-red.integration.test.ts

@@ -1,80 +0,0 @@
-import { ok } from '@forgeax/engine-types';
-import { describe, expect, it } from 'vitest';
-import { defineAssetKind } from '../asset-kind.js';
-import { AssetGraph } from '../internal/asset-graph.js';
-import { DecoderRegistry } from '../internal/decoder-registry.js';
-
-const kind = defineAssetKind<string, 'host-blob'>('host-blob');
-
-describe('asset runtime terminal lifecycle', () => {
-  it('shares leases for one decoder identity and rejects a different owner', () => {
-    const decoders = new DecoderRegistry({ scopeId: 'scope' });
-    const decoder = { decode: async () => ok('value') };
-    const first = decoders.install(kind, decoder);
-    const second = decoders.install(kind, decoder);
-
-    expect(decoders.has(kind)).toBe(true);
-    expect(() => decoders.install(kind, { decode: async () => ok('other') })).toThrow(
-      'duplicate decoder kind "host-blob"',
-    );
-    first.dispose();
-    expect(decoders.has(kind)).toBe(true);
-    second.dispose();
-    expect(decoders.has(kind)).toBe(false);
-  });
-
-  it('normalizes decoder throws and preserves the terminal error shape', async () => {
-    const decoders = new DecoderRegistry({ scopeId: 'scope' });
-    const lease = decoders.install(kind, {
-      async decode() {
-        throw new Error('boom');
-      },
-    });
-    const result = await decoders.decode(kind, {
-      envelope: { guid: 'guid', kind: kind.kind, payload: 'raw', refs: [], artifacts: {} },
-      artifacts: { read: async () => ok(new Uint8Array()) },
-      signal: new AbortController().signal,
-    });
-    lease.dispose();
-    expect(result.ok).toBe(false);
-    if (!result.ok) expect(result.error.code).toBe('asset-decode-failed');
-  });
-
-  it('drops a late non-cancellable result after dispose and zeroes resources', async () => {
-    let resolve: ((value: { ok: true; value: string }) => void) | undefined;
-    const pending = new Promise<{ ok: true; value: string }>((done) => {
-      resolve = done;
-    });
-    const graph = new AssetGraph<{ readonly refs: readonly string[]; readonly value: string }>({
-      read: async (guid) => {
-        await pending;
-        return ok({ value: guid, refs: [] });
-      },
-    });
-    const request = graph.load('late');
-    graph.dispose();
-    resolve?.({ ok: true, value: 'late' });
-    expect(await request).toEqual({
-      ok: false,
-      error: expect.objectContaining({ code: 'asset-runtime-disposed' }),
-    });
-    expect(graph.snapshot().resources).toBe(0);
-    expect(graph.snapshot().pending).toBe(0);
-  });
-
-  it('returns detached frozen observations and isolates listener failure', async () => {
-    const graph = new AssetGraph<{ readonly refs: readonly string[]; readonly value: string }>({
-      read: async (guid) => ok({ value: guid, refs: [] }),
-    });
-    const seen: string[] = [];
-    graph.subscribe(() => {
-      throw new Error('observer failure');
-    });
-    graph.subscribe((snapshot) => seen.push(snapshot.ready.join(',')));
-    await graph.load('asset');
-    const snapshot = graph.snapshot();
-    expect(Object.isFrozen(snapshot)).toBe(true);
-    expect(seen).toContain('asset');
-    expect(snapshot.counters.listenerFailures).toBeGreaterThan(0);
-  });
-});