@forgeax/engine-runtime 0.0.0-dev.8d955ade1c79

package/src/__tests__/resolve-asset-handle.unit.test.ts

@@ -0,0 +1,64 @@
+// M7 w55 / M8 w59: resolveAssetHandle two-tier dispatch unit test.
+//
+// D-15 two-tier asset resolution: resolveAssetHandle(world, handle) dispatches
+// by slot range — builtin slots (< BUILTIN_BASE) resolve through
+// BuiltinAssetRegistry.resolve (process-static, no World needed); user-tier
+// slots (>= BUILTIN_BASE) resolve through world.sharedRefs (minted via
+// world.allocSharedRef). The AssetRegistry holds no handle->payload map.
+
+import { BUILTIN_CUBE, HANDLE_CUBE, resolveAssetHandle } from '@forgeax/engine-assets-runtime';
+import { World } from '@forgeax/engine-ecs';
+import type { MeshAsset } from '@forgeax/engine-types';
+import { BUILTIN_BASE } from '@forgeax/engine-types';
+import { describe, expect, it } from 'vitest';
+
+function mesh(): MeshAsset {
+  return {
+    kind: 'mesh',
+    vertices: new Float32Array([0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 1]),
+    indices: new Uint16Array([0]),
+    attributes: {},
+    submeshes: [
+      {
+        indexOffset: 0,
+        indexCount: 1,
+        vertexCount: 12,
+        topology: 'triangle-list' as const,
+      },
+    ],
+  } as unknown as MeshAsset;
+}
+
+describe('resolveAssetHandle two-tier slot-range dispatch (AC-31)', () => {
+  it('builtin slot (< BUILTIN_BASE): resolves through BuiltinAssetRegistry', () => {
+    // HANDLE_CUBE has slot=1 < BUILTIN_BASE=1024.
+    // Builtins are process-static — the World is unused for this path.
+    const world = new World();
+    const res = resolveAssetHandle(world, HANDLE_CUBE);
+    expect(res.ok).toBe(true);
+    if (res.ok) expect(res.value).toBe(BUILTIN_CUBE);
+  });
+
+  it('user-tier slot (>= BUILTIN_BASE): resolves through world.sharedRefs', () => {
+    // User-tier payloads live in the per-World SharedRefStore, minted via
+    // world.allocSharedRef. resolveAssetHandle routes user-tier slots there.
+    const world = new World();
+    const payload = mesh();
+    const handle = world.allocSharedRef('MeshAsset', payload);
+    expect(handle).toBeGreaterThanOrEqual(BUILTIN_BASE);
+    const res = resolveAssetHandle<MeshAsset>(world, handle);
+    expect(res.ok).toBe(true);
+    if (res.ok) expect(res.value).toBe(payload);
+  });
+
+  it('user-tier handle not in this World returns asset-not-found', () => {
+    // A handle minted in a DIFFERENT world is absent from this world's
+    // SharedRefStore — resolveAssetHandle must return err(asset-not-found).
+    const world = new World();
+    const foreign = new World();
+    const foreignHandle = foreign.allocSharedRef('MeshAsset', mesh());
+    const res = resolveAssetHandle(world, foreignHandle);
+    expect(res.ok).toBe(false);
+    if (!res.ok) expect(res.error.code).toBe('asset-not-found');
+  });
+});

package/src/__tests__/resolve-depth-only-view.test.ts

@@ -0,0 +1,173 @@
+// resolve-depth-only-view.test.ts —
+// feat-20260702-postprocess-camera-depth-read M2 / w6.
+//
+// Spy/mock unit tests for resolveDepthOnlyView and its SSAO delegate:
+// (a) resolveDepthOnlyView calls graph.getColorTargetTexture(key) and
+//     device.createTextureView({aspect:'depth-only'}) with the caller's label.
+// (b) resolveHdrDepthDepthOnlyView delegates with label 'ssao-hdr-depth-only-view'
+//     (plan-strategy D-5: thin delegate, byte-identical behaviour).
+// (c) Null return paths: graph null, texture undefined, createTextureView error.
+//
+// Pure mock — no real GPU required.
+
+import type { RenderGraph } from '@forgeax/engine-render-graph';
+import { describe, expect, it, vi } from 'vitest';
+
+// resolveDepthOnlyView is exported from render-graph-primitives.ts.
+// resolveHdrDepthDepthOnlyView is package-private — we test it indirectly
+// through resolveDepthOnlyView with the SSAO label (behaviour equivalence).
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+let resolveDepthOnlyView: (
+  internals: Record<string, unknown>,
+  key: string,
+  label: string,
+  preferredKey?: string | null,
+) => unknown;
+
+// Dynamic import so Vitest hoists vi.mock before the module loads.
+await vi.hoisted(async () => {
+  // No hoisting needed — we import after mock setup.
+});
+
+// Import the render-graph-primitives module to extract the functions under test.
+// We can reach them through the resolved module namespace.
+const mod = await import('../../../render/src/render-graph-primitives');
+// resolveDepthOnlyView is exported; resolveHdrDepthDepthOnlyView is not.
+// We can test the delegate equivalence by calling resolveDepthOnlyView with
+// the SSAO label, which is the exact body of the delegate.
+resolveDepthOnlyView = (mod as unknown as Record<string, unknown>)
+  .resolveDepthOnlyView as typeof resolveDepthOnlyView;
+expect(resolveDepthOnlyView).toBeDefined();
+expect(typeof resolveDepthOnlyView).toBe('function');
+
+function makeSpyInternals(overrides: {
+  graph?: unknown;
+  device?: { createTextureView: ReturnType<typeof vi.fn> };
+}) {
+  return {
+    frameState: {
+      perFrameGraph: overrides.graph ?? null,
+    },
+    runtime: {
+      device: overrides.device ?? {
+        createTextureView: vi.fn(),
+      },
+      errorRegistry: {
+        fire: vi.fn(),
+      },
+    },
+  };
+}
+
+describe('resolveDepthOnlyView', () => {
+  it('returns null when perFrameGraph is null', () => {
+    const internals = makeSpyInternals({ graph: null });
+    const result = resolveDepthOnlyView(internals, 'depth', 'test-label');
+    expect(result).toBeNull();
+  });
+
+  it('returns null when getColorTargetTexture returns undefined', () => {
+    const graph = {
+      getColorTargetTexture: vi.fn().mockReturnValue(undefined),
+    } as unknown as RenderGraph;
+    const internals = makeSpyInternals({ graph });
+    const result = resolveDepthOnlyView(internals, 'missing-key', 'test-label');
+    expect(result).toBeNull();
+    expect(graph.getColorTargetTexture).toHaveBeenCalledWith('missing-key');
+  });
+
+  it('resolves depth-only texture view with correct parameters', () => {
+    const fakeTexture = { __fakeTex: true };
+    const fakeView = { __fakeView: true };
+    const createTextureViewFn = vi.fn().mockReturnValue({ ok: true, value: fakeView });
+    const graph = {
+      getColorTargetTexture: vi.fn().mockReturnValue(fakeTexture),
+    } as unknown as RenderGraph;
+    const internals = makeSpyInternals({
+      graph,
+      device: { createTextureView: createTextureViewFn },
+    });
+
+    const result = resolveDepthOnlyView(internals, 'hdrDepth', 'my-depth-view');
+
+    expect(result).toBe(fakeView);
+    expect(graph.getColorTargetTexture).toHaveBeenCalledWith('hdrDepth');
+    expect(createTextureViewFn).toHaveBeenCalledWith(fakeTexture, {
+      label: 'my-depth-view',
+      dimension: '2d',
+      aspect: 'depth-only',
+      baseMipLevel: 0,
+      mipLevelCount: 1,
+      baseArrayLayer: 0,
+      arrayLayerCount: 1,
+    });
+  });
+
+  it('prefers the active geometry depth target when supplied', () => {
+    const logicalTexture = { __logicalDepth: true };
+    const activeTexture = { __activeDepth: true };
+    const createTextureViewFn = vi.fn().mockReturnValue({ ok: true, value: { __view: true } });
+    const graph = {
+      getColorTargetTexture: vi.fn((key: string) =>
+        key === 'hdrDepthMsaa' ? activeTexture : logicalTexture,
+      ),
+    } as unknown as RenderGraph;
+    const internals = makeSpyInternals({
+      graph,
+      device: { createTextureView: createTextureViewFn },
+    });
+
+    resolveDepthOnlyView(internals, 'depth', 'active-depth-view', 'hdrDepthMsaa');
+
+    expect(createTextureViewFn).toHaveBeenCalledWith(activeTexture, expect.anything());
+  });
+
+  it('fires error on createTextureView failure and returns null', () => {
+    const fakeTexture = { __fakeTex: true };
+    const fakeError = { message: 'failed' };
+    const createTextureViewFn = vi.fn().mockReturnValue({ ok: false, error: fakeError });
+    const errorRegistry = { fire: vi.fn() };
+    const graph = {
+      getColorTargetTexture: vi.fn().mockReturnValue(fakeTexture),
+    } as unknown as RenderGraph;
+    const internals = {
+      frameState: { perFrameGraph: graph },
+      runtime: {
+        device: { createTextureView: createTextureViewFn },
+        errorRegistry,
+      },
+    };
+
+    const result = resolveDepthOnlyView(internals, 'depth', 'err-view');
+
+    expect(result).toBeNull();
+    expect(errorRegistry.fire).toHaveBeenCalledWith(fakeError);
+  });
+});
+
+describe('SSAO delegate: resolveHdrDepthDepthOnlyView behaviour preservation', () => {
+  it('delegates with label ssao-hdr-depth-only-view (D-5 thin delegate)', () => {
+    // The delegate body is resolveDepthOnlyView(internals, hdrDepthKey, 'ssao-hdr-depth-only-view').
+    // We verify this by calling resolveDepthOnlyView with the SSAO label and confirming the
+    // createTextureView receives that exact label.
+    const fakeTexture = { __fakeTex: true };
+    const fakeView = { __fakeView: true };
+    const createTextureViewFn = vi.fn().mockReturnValue({ ok: true, value: fakeView });
+    const graph = {
+      getColorTargetTexture: vi.fn().mockReturnValue(fakeTexture),
+    } as unknown as RenderGraph;
+    const internals = makeSpyInternals({
+      graph,
+      device: { createTextureView: createTextureViewFn },
+    });
+
+    const result = resolveDepthOnlyView(internals, 'hdrDepth', 'ssao-hdr-depth-only-view');
+
+    expect(result).toBe(fakeView);
+    expect(graph.getColorTargetTexture).toHaveBeenCalledWith('hdrDepth');
+    expect(createTextureViewFn).toHaveBeenCalledWith(
+      fakeTexture,
+      expect.objectContaining({ label: 'ssao-hdr-depth-only-view' }),
+    );
+  });
+});

package/src/__tests__/resolveName-fallback.test.ts

@@ -0,0 +1,64 @@
+// AC-15 deterministic name fallback — runtime integration (feat-20260618 w19).
+//
+// deriveAssetName's branch logic is unit-tested in @forgeax/engine-pack (w8);
+// this test exercises the runtime wiring (resolveName passing the right args).
+//
+// Coverage:
+//   AC-15.1 — multi-asset package entry with no stored name -> basename(path),
+//             no throw (old add-only packs are a reachable state).
+//   AC-15.2 — null package with no stored name -> '' (the detectable
+//             "genuinely no name" signal), no throw.
+//   D-5     — builtin meshes resolve to '' (null package, no name).
+
+import { AssetRegistry } from '@forgeax/engine-assets-runtime';
+import { AssetGuid } from '@forgeax/engine-pack/guid';
+import type { SamplerAsset } from '@forgeax/engine-types';
+import { describe, expect, it } from 'vitest';
+import { makeMockShaderRegistry } from './helpers/mock-shader-registry';
+
+const MULTI_A = 'e0000000-0000-4000-e000-000000000001';
+const MULTI_B = 'e0000000-0000-4000-e000-000000000002';
+const NO_PKG = 'e0000000-0000-4000-e000-000000000003';
+// Builtin cube GUID -- the constructor registers it with a null package (D-5).
+const BUILTIN_CUBE_GUID = 'cbe42beb-8975-5096-b3a1-3dda4cb4c077';
+
+function parseGuid(s: string): AssetGuid {
+  const r = AssetGuid.parse(s);
+  if (!r.ok) throw new Error(`invalid test GUID: ${s}`);
+  return r.value;
+}
+
+function makeRegistry(): AssetRegistry {
+  return new AssetRegistry(makeMockShaderRegistry());
+}
+
+const sampler: SamplerAsset = { kind: 'sampler' };
+
+describe('resolveName deterministic fallback (AC-15)', () => {
+  it('AC-15.1 multi-asset entry with no stored name falls back to basename', () => {
+    const reg = makeRegistry();
+    reg.catalog(parseGuid(MULTI_A), sampler);
+    reg.catalog(parseGuid(MULTI_B), sampler);
+    // Only MULTI_A carries a name; MULTI_B has none (old add-only pack).
+    reg._registerPackage('assets/world.glb', [MULTI_A, MULTI_B], new Map([[MULTI_A, 'Ground']]));
+
+    expect(() => reg.resolveName(MULTI_B)).not.toThrow();
+    expect(reg.resolveName(MULTI_B)).toBe('world.glb');
+    expect(reg.resolveName(MULTI_A)).toBe('Ground');
+  });
+
+  it('AC-15.2 null package with no name resolves to empty string', () => {
+    const reg = makeRegistry();
+    reg.catalog(parseGuid(NO_PKG), sampler);
+    reg._registerPackage(null, [NO_PKG]);
+
+    expect(() => reg.resolveName(NO_PKG)).not.toThrow();
+    expect(reg.resolveName(NO_PKG)).toBe('');
+  });
+
+  it('D-5 builtin mesh resolves to empty string (null package, no name)', () => {
+    const reg = makeRegistry();
+    expect(reg.packageOf(BUILTIN_CUBE_GUID)).toBe(null);
+    expect(reg.resolveName(BUILTIN_CUBE_GUID)).toBe('');
+  });
+});

package/src/__tests__/resolveName-null-package.test.ts

@@ -0,0 +1,38 @@
+// resolveName null package — AC-03 (feat-20260618 w17).
+//
+// Red-first: written before w10 implements resolveName.
+//
+// Coverage:
+//   AC-03 — no-package asset: packageOf(guid) === null, resolveName returns the
+//           stored self name, and no synthetic guid path is minted (OOS-3).
+
+import { AssetRegistry } from '@forgeax/engine-assets-runtime';
+import { AssetGuid } from '@forgeax/engine-pack/guid';
+import type { SamplerAsset } from '@forgeax/engine-types';
+import { describe, expect, it } from 'vitest';
+import { makeMockShaderRegistry } from './helpers/mock-shader-registry';
+
+const NO_PKG_GUID = 'b0000000-0000-4000-b000-000000000001';
+
+function parseGuid(s: string): AssetGuid {
+  const r = AssetGuid.parse(s);
+  if (!r.ok) throw new Error(`invalid test GUID: ${s}`);
+  return r.value;
+}
+
+function makeRegistry(): AssetRegistry {
+  return new AssetRegistry(makeMockShaderRegistry());
+}
+
+const sampler: SamplerAsset = { kind: 'sampler' };
+
+describe('resolveName null package (AC-03)', () => {
+  it('packageOf is null, resolveName returns the stored name, no synthetic path', () => {
+    const reg = makeRegistry();
+    reg.catalog(parseGuid(NO_PKG_GUID), sampler);
+    reg._registerPackage(null, [NO_PKG_GUID], new Map([[NO_PKG_GUID, 'myProcMesh']]));
+
+    expect(reg.packageOf(NO_PKG_GUID)).toBe(null);
+    expect(reg.resolveName(NO_PKG_GUID)).toBe('myProcMesh');
+  });
+});

package/src/__tests__/resolveName-unified-entry.test.ts

@@ -0,0 +1,65 @@
+// AC-04 unified name resolution — single source of truth, no bypass (feat-20260618 w18).
+//
+// resolveName is the one runtime name-truth function and it delegates to the
+// stateless deriveAssetName pure function (D-6). Every other name consumer reads
+// resolveName or that same deriveAssetName -- none re-implements the XOR rule.
+//
+// This is a grep/fixture test, not a pure runtime assertion: it reads the source
+// trees and asserts structural unification.
+//
+// M4 (w24/w22) wiring completed: inspect() now calls resolveName; the catalog
+// builder now calls deriveAssetName. The grep assertions below confirm both
+// paths route through the SSOT, no bypass.
+
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { describe, expect, it } from 'vitest';
+
+const here = fileURLToPath(new URL('.', import.meta.url));
+const registrySrc = readFileSync(`${here}../../../assets-runtime/src/asset-registry.ts`, 'utf8');
+const deriveSrc = readFileSync(
+  fileURLToPath(new URL('../../../pack/src/deriveAssetName.ts', import.meta.url)),
+  'utf8',
+);
+const buildCatalogSrc = readFileSync(
+  fileURLToPath(new URL('../../../pack/src/catalog-builder.ts', import.meta.url)),
+  'utf8',
+);
+
+describe('unified name resolution (AC-04)', () => {
+  it('deriveAssetName is the single XOR rule definition', () => {
+    expect(deriveSrc).toContain('export function deriveAssetName');
+  });
+
+  it('resolveName delegates to deriveAssetName (no inline XOR re-implementation)', () => {
+    expect(registrySrc).toContain("import { deriveAssetName } from '@forgeax/engine-pack/name'");
+    // resolveName returns the result of deriveAssetName, not a hand-rolled rule.
+    const body = registrySrc.slice(
+      registrySrc.indexOf('resolveName(guid: AssetGuid | string): string'),
+    );
+    const fnBody = body.slice(0, body.indexOf('\n  }'));
+    expect(fnBody).toContain('return deriveAssetName(');
+  });
+
+  it('resolveName is the only public name accessor on the registry (no sibling getName)', () => {
+    expect(registrySrc).not.toMatch(/\n {2}getName\(/);
+    expect(registrySrc).not.toMatch(/\n {2}displayName\(/);
+  });
+
+  // M4 expansion (w24 landed): inspect() routes through resolveName
+  it('inspect() calls resolveName per entry (M4 w24 wiring)', () => {
+    // inspect() pushes { name: this.resolveName(guid) } -- no inline basename
+    expect(registrySrc).toContain('name: this.resolveName(guid)');
+    // No hardcoded '' placeholder left from M1/w3
+    expect(registrySrc).not.toContain("name: ''");
+  });
+
+  // M4 expansion (w22 landed): catalog-builder routes through deriveAssetName
+  it('catalog-builder imports and calls deriveAssetName (no inline XOR)', () => {
+    expect(buildCatalogSrc).toContain("import { deriveAssetName } from './deriveAssetName.js'");
+    expect(buildCatalogSrc).toContain('deriveAssetName(');
+    // No inline re-implementation of the XOR rule (no hand-rolled basename)
+    // The single deriveAssetName pure function handles all branches.
+    expect(buildCatalogSrc.match(/deriveAssetName\(/g)?.length ?? 0).toBeGreaterThanOrEqual(2);
+  });
+});

package/src/__tests__/resolveName.test.ts

@@ -0,0 +1,64 @@
+// resolveName single / multi asset package — AC-01 + AC-02 (feat-20260618 w16).
+//
+// Red-first: written before w10 implements resolveName. Constructs the package
+// state directly through registerPackage (Risk-2: no pack-index fetch needed).
+//
+// Coverage:
+//   AC-01 — single-asset package: resolveName === basename(path); the stored
+//           Asset POD carries no `name` property (name is never on the payload).
+//   AC-02 — multi-asset package: resolveName returns each entry's stored name.
+
+import { AssetRegistry } from '@forgeax/engine-assets-runtime';
+import { AssetGuid } from '@forgeax/engine-pack/guid';
+import type { SamplerAsset } from '@forgeax/engine-types';
+import { describe, expect, it } from 'vitest';
+import { makeMockShaderRegistry } from './helpers/mock-shader-registry';
+
+const SINGLE_GUID = 'a0000000-0000-4000-a000-000000000001';
+const MULTI_A_GUID = 'a0000000-0000-4000-a000-000000000002';
+const MULTI_B_GUID = 'a0000000-0000-4000-a000-000000000003';
+
+function parseGuid(s: string): AssetGuid {
+  const r = AssetGuid.parse(s);
+  if (!r.ok) throw new Error(`invalid test GUID: ${s}`);
+  return r.value;
+}
+
+function makeRegistry(): AssetRegistry {
+  return new AssetRegistry(makeMockShaderRegistry());
+}
+
+const sampler: SamplerAsset = { kind: 'sampler' };
+
+describe('resolveName single-asset package (AC-01)', () => {
+  it('returns basename(path) and the POD has no name property', () => {
+    const reg = makeRegistry();
+    reg.catalog(parseGuid(SINGLE_GUID), sampler);
+    reg._registerPackage('assets/hero.glb', [SINGLE_GUID]);
+
+    expect(reg.resolveName(SINGLE_GUID)).toBe('hero.glb');
+
+    const stored = reg.lookup(SINGLE_GUID);
+    expect(stored).toBeDefined();
+    expect(Object.hasOwn(stored as object, 'name')).toBe(false);
+  });
+});
+
+describe('resolveName multi-asset package (AC-02)', () => {
+  it('returns each entry stored name', () => {
+    const reg = makeRegistry();
+    reg.catalog(parseGuid(MULTI_A_GUID), sampler);
+    reg.catalog(parseGuid(MULTI_B_GUID), sampler);
+    reg._registerPackage(
+      'assets/char.glb',
+      [MULTI_A_GUID, MULTI_B_GUID],
+      new Map([
+        [MULTI_A_GUID, 'Body'],
+        [MULTI_B_GUID, 'Head'],
+      ]),
+    );
+
+    expect(reg.resolveName(MULTI_A_GUID)).toBe('Body');
+    expect(reg.resolveName(MULTI_B_GUID)).toBe('Head');
+  });
+});

package/src/__tests__/rhi-null-command-flow.unit.test.ts

@@ -0,0 +1,69 @@
+import { World } from '@forgeax/engine-ecs';
+import type { Renderer } from '@forgeax/engine-render';
+import { rhi } from '@forgeax/engine-rhi-null';
+import { describe, expect, it } from 'vitest';
+import { requireRenderer } from './renderer-test-utils';
+
+function canvas(): HTMLCanvasElement {
+  return { width: 800, height: 600, getContext: () => null } as unknown as HTMLCanvasElement;
+}
+
+const manifest = `data:application/json,${encodeURIComponent(JSON.stringify({ schemaVersion: '1.0.0', entries: [] }))}`;
+
+function frameRequest(lease: Parameters<Renderer['draw']>[0]['leases'][number]) {
+  return { leases: [lease], camera: { lease }, environment: { lease } };
+}
+
+describe('RhiNull command flow', () => {
+  it('returns the synchronous receipt after the host submits a frame', async () => {
+    const renderer = await requireRenderer(canvas(), { rhi }, { shaderManifestUrl: manifest });
+    const events: Array<{
+      readonly kind: string;
+      readonly frameId?: number;
+      readonly deviceGeneration?: number;
+    }> = [];
+    const unsubscribe = renderer.subscribe((event) => events.push(event));
+    const world = new World();
+    const attached = renderer.attach(world);
+    expect(attached.ok).toBe(true);
+    if (!attached.ok) return;
+    expect(world.update().ok).toBe(true);
+
+    const frame = renderer.draw(frameRequest(attached.value));
+    expect(frame.ok).toBe(true);
+    if (!frame.ok) return;
+    expect(events.filter((event) => event.kind === 'frame-submitted')).toEqual([
+      {
+        kind: 'frame-submitted',
+        frameId: frame.value.frameId,
+        deviceGeneration: frame.value.deviceGeneration,
+      },
+    ]);
+    const completed = await frame.value.completed;
+    expect(completed.ok).toBe(true);
+    expect(renderer.inspect().frame.frameId).toBe(frame.value.frameId);
+    unsubscribe();
+    renderer.dispose();
+  });
+
+  it('observes the same receipt without exposing RHI command objects', async () => {
+    const renderer = await requireRenderer(canvas(), { rhi }, { shaderManifestUrl: manifest });
+    const world = new World();
+    const attached = renderer.attach(world);
+    expect(attached.ok).toBe(true);
+    if (!attached.ok) return;
+    expect(world.update().ok).toBe(true);
+    const frame = renderer.draw(frameRequest(attached.value));
+    expect(frame.ok).toBe(true);
+    if (!frame.ok) return;
+    const observation = await renderer.observe(frame.value, {
+      include: ['timings', 'draws', 'bindings'],
+    });
+    expect(observation.ok).toBe(true);
+    if (observation.ok) expect(observation.value.frameId).toBe(frame.value.frameId);
+    expect(renderer).not.toHaveProperty('device');
+    expect(renderer).not.toHaveProperty('encoder');
+    expect(renderer).not.toHaveProperty('queue');
+    renderer.dispose();
+  });
+});