@forgeax/engine-assets-runtime 0.1.4 → 0.1.6

package/src/__tests__/payload-validate.unit.test.ts

@@ -0,0 +1,285 @@
+// @forgeax/engine-assets-runtime -- register-time payload validation coverage
+// (fix issue #709). Covers validateMeshPayload branch tree, validateTilesetPayload
+// R-6 first-error ordering, and inferAtlasExtent.
+
+import type { Asset, MeshAsset, TilesetAsset } from '@forgeax/engine-types';
+import { describe, expect, it } from 'vitest';
+import { inferAtlasExtent, validateMeshPayload, validateTilesetPayload } from '../payload-validate';
+
+function mesh(over: Partial<MeshAsset>): Asset {
+  return {
+    kind: 'mesh',
+    vertices: new Float32Array(0),
+    attributes: {},
+    submeshes: [
+      { indexOffset: 0, indexCount: 0, vertexCount: 0, topology: 'triangle-list', materialSlot: 0 },
+    ],
+    materialSlots: [{ slotName: 'Default' }],
+    ...over,
+  } as MeshAsset;
+}
+
+describe('validateMeshPayload', () => {
+  it('returns null for a non-mesh asset', () => {
+    expect(validateMeshPayload({ kind: 'material' } as unknown as Asset)).toBeNull();
+  });
+
+  it('returns null for a legal empty mesh (triangle-list, no vertices/indices)', () => {
+    expect(validateMeshPayload(mesh({}))).toBeNull();
+  });
+
+  it('errors when submeshes is empty', () => {
+    const e = validateMeshPayload(mesh({ submeshes: [] }));
+    expect(e?.code).toBe('mesh-asset-submeshes-empty');
+  });
+
+  it('errors on strip topology without an index buffer', () => {
+    const e = validateMeshPayload(
+      mesh({
+        vertices: new Float32Array(12),
+        submeshes: [
+          {
+            indexOffset: 0,
+            indexCount: 0,
+            vertexCount: 1,
+            topology: 'triangle-strip',
+            materialSlot: 0,
+          },
+        ],
+      }),
+    );
+    expect(e?.code).toBe('asset-invalid-value');
+    expect((e?.detail as { reason: string }).reason).toBe('strip-topology-without-indices');
+  });
+
+  it('errors when an empty-geometry submesh uses a non-triangle-list topology', () => {
+    const e = validateMeshPayload(
+      mesh({
+        vertices: new Float32Array(0),
+        submeshes: [
+          { indexOffset: 0, indexCount: 0, vertexCount: 0, topology: 'line-list', materialSlot: 0 },
+        ],
+      }),
+    );
+    expect(e?.code).toBe('asset-invalid-value');
+    expect((e?.detail as { reason: string }).reason).toBe('empty-geometry-non-default-topology');
+  });
+
+  it('errors when a submesh index range exceeds the index buffer length', () => {
+    const e = validateMeshPayload(
+      mesh({
+        vertices: new Float32Array(36), // 3 verts * 12
+        indices: Uint16Array.of(0, 1, 2),
+        submeshes: [
+          {
+            indexOffset: 0,
+            indexCount: 6,
+            vertexCount: 3,
+            topology: 'triangle-list',
+            materialSlot: 0,
+          },
+        ],
+      }),
+    );
+    expect(e?.code).toBe('mesh-submesh-index-range-out-of-bounds');
+  });
+
+  it('errors when vertices.length is not divisible by 12 (stride mismatch)', () => {
+    const e = validateMeshPayload(
+      mesh({
+        vertices: new Float32Array(13),
+        submeshes: [
+          {
+            indexOffset: 0,
+            indexCount: 0,
+            vertexCount: 1,
+            topology: 'triangle-list',
+            materialSlot: 0,
+          },
+        ],
+      }),
+    );
+    expect(e?.code).toBe('mesh-vertex-stride-mismatch');
+  });
+
+  it('errors when maxIndex + 1 !== vertexCount', () => {
+    const e = validateMeshPayload(
+      mesh({
+        vertices: new Float32Array(24), // 2 vertices
+        indices: Uint16Array.of(0, 1, 5), // maxIndex 5 -> expects 6 verts
+        submeshes: [
+          {
+            indexOffset: 0,
+            indexCount: 3,
+            vertexCount: 2,
+            topology: 'triangle-list',
+            materialSlot: 0,
+          },
+        ],
+      }),
+    );
+    expect(e?.code).toBe('mesh-vertex-stride-mismatch');
+    expect((e?.detail as { vertexCount: number }).vertexCount).toBe(6);
+  });
+
+  it('accepts a well-formed indexed mesh', () => {
+    expect(
+      validateMeshPayload(
+        mesh({
+          vertices: new Float32Array(36), // 3 vertices
+          indices: Uint16Array.of(0, 1, 2),
+          submeshes: [
+            {
+              indexOffset: 0,
+              indexCount: 3,
+              vertexCount: 3,
+              topology: 'triangle-list',
+              materialSlot: 0,
+            },
+          ],
+        }),
+      ),
+    ).toBeNull();
+  });
+
+  it('accepts a vertex-only mesh (no indices, skips the maxIndex invariant)', () => {
+    expect(
+      validateMeshPayload(
+        mesh({
+          vertices: new Float32Array(24),
+          submeshes: [
+            {
+              indexOffset: 0,
+              indexCount: 0,
+              vertexCount: 2,
+              topology: 'triangle-list',
+              materialSlot: 0,
+            },
+          ],
+        }),
+      ),
+    ).toBeNull();
+  });
+});
+
+function tileset(over: Partial<TilesetAsset>): TilesetAsset {
+  return {
+    kind: 'tileset',
+    atlases: ['atlas-guid'],
+    tileWidth: 16,
+    tileHeight: 16,
+    columns: 4,
+    rows: 4,
+    regions: [{ x: 0, y: 0, width: 16, height: 16 }],
+    tiles: [{ regionIndex: 0 }],
+    ...over,
+  } as TilesetAsset;
+}
+
+describe('validateTilesetPayload', () => {
+  it('accepts a well-formed tileset', () => {
+    expect(validateTilesetPayload(tileset({}))).toBeNull();
+  });
+
+  it('errors when atlases is empty', () => {
+    const e = validateTilesetPayload(tileset({ atlases: [] }));
+    expect(e?.code).toBe('tileset-tile-entry-malformed');
+    expect((e?.detail as { field: string }).field).toBe('atlases');
+  });
+
+  it('errors on a negative/zero region rectangle', () => {
+    const e = validateTilesetPayload(
+      tileset({ regions: [{ x: -1, y: 0, width: 16, height: 16 }] }),
+    );
+    expect(e?.code).toBe('tileset-region-index-out-of-range');
+  });
+
+  it('errors when a region escapes the supplied atlas extent', () => {
+    const e = validateTilesetPayload(
+      tileset({ regions: [{ x: 0, y: 0, width: 100, height: 16 }] }),
+      { atlasWidth: 64, atlasHeight: 64 },
+    );
+    expect(e?.code).toBe('tileset-region-index-out-of-range');
+  });
+
+  it('errors on an out-of-range region.atlasIndex', () => {
+    const e = validateTilesetPayload(
+      tileset({ regions: [{ x: 0, y: 0, width: 16, height: 16, atlasIndex: 5 }] }),
+    );
+    expect((e?.detail as { field: string }).field).toBe('atlasIndex');
+  });
+
+  it('errors on an out-of-range tile.regionIndex', () => {
+    const e = validateTilesetPayload(tileset({ tiles: [{ regionIndex: 9 }] }));
+    expect(e?.code).toBe('tileset-region-index-out-of-range');
+  });
+
+  it('errors on widthCells / heightCells / pivotX / pivotY out of bounds', () => {
+    expect(
+      validateTilesetPayload(tileset({ tiles: [{ regionIndex: 0, widthCells: 0 }] }))?.detail,
+    ).toMatchObject({ field: 'widthCells' });
+    expect(
+      validateTilesetPayload(tileset({ tiles: [{ regionIndex: 0, heightCells: 65 }] }))?.detail,
+    ).toMatchObject({ field: 'heightCells' });
+    expect(
+      validateTilesetPayload(tileset({ tiles: [{ regionIndex: 0, pivotX: 2 }] }))?.detail,
+    ).toMatchObject({ field: 'pivotX' });
+    expect(
+      validateTilesetPayload(tileset({ tiles: [{ regionIndex: 0, pivotY: -1 }] }))?.detail,
+    ).toMatchObject({ field: 'pivotY' });
+  });
+
+  it('accepts a valid rect collider and rejects a malformed one', () => {
+    expect(
+      validateTilesetPayload(
+        tileset({
+          tiles: [{ regionIndex: 0, collider: { type: 'rect', rect: [0, 0, 0.5, 0.5] } }],
+        }),
+      ),
+    ).toBeNull();
+    const e = validateTilesetPayload(
+      tileset({ tiles: [{ regionIndex: 0, collider: { type: 'rect', rect: [0, 0, 2, 2] } }] }),
+    );
+    expect((e?.detail as { field: string }).field).toBe('collider');
+  });
+
+  it('accepts a valid polygon collider and rejects fewer-than-3 points', () => {
+    expect(
+      validateTilesetPayload(
+        tileset({
+          tiles: [
+            {
+              regionIndex: 0,
+              collider: {
+                type: 'polygon',
+                points: [
+                  [0, 0],
+                  [1, 0],
+                  [0, 1],
+                ],
+              },
+            },
+          ],
+        }),
+      ),
+    ).toBeNull();
+    const e = validateTilesetPayload(
+      tileset({ tiles: [{ regionIndex: 0, collider: { type: 'polygon', points: [[0, 0]] } }] }),
+    );
+    expect((e?.detail as { field: string }).field).toBe('collider');
+  });
+
+  it("accepts a 'none' collider", () => {
+    expect(
+      validateTilesetPayload(tileset({ tiles: [{ regionIndex: 0, collider: { type: 'none' } }] })),
+    ).toBeNull();
+  });
+});
+
+describe('inferAtlasExtent', () => {
+  it('multiplies columns*tileWidth and rows*tileHeight', () => {
+    expect(
+      inferAtlasExtent(tileset({ columns: 8, tileWidth: 16, rows: 4, tileHeight: 32 })),
+    ).toEqual({ atlasWidth: 128, atlasHeight: 128 });
+  });
+});

package/src/__tests__/plugin.test.ts

@@ -0,0 +1,55 @@
+import { Context } from '@forgeax/engine-plugin';
+import type { Loader } from '@forgeax/engine-types';
+import { describe, expect, it } from 'vitest';
+import type { AssetRegistry } from '../asset-registry';
+import { LoaderRegistry } from '../loader-registry';
+import { assetLoaderPlugin, assetsPlugin, packLoaderPlugin } from '../plugin';
+
+describe('asset capability plugins', () => {
+  it('removes loader contributions with their Fibers', async () => {
+    const loaders = new LoaderRegistry();
+    const assets = { loaders } as AssetRegistry;
+    const loader = {
+      kind: 'test-dialogue',
+      load: () => ({ lines: [] }),
+    } satisfies Loader<unknown>;
+    const packLoader = {
+      kind: 'test-cutscene',
+      load: () => ({ shots: [] }),
+    };
+    const context = new Context();
+    await context.plugin(assetsPlugin(assets));
+    const loaderFiber = await context.plugin(assetLoaderPlugin(loader));
+    const packFiber = await context.plugin(packLoaderPlugin(packLoader));
+
+    expect(loaders.get(loader.kind)).toBe(loader);
+    expect(
+      await loaders.loadPack(
+        {
+          guid: '00000000-0000-7000-8000-000000000001',
+          kind: packLoader.kind,
+          payload: {},
+          refs: [],
+          artifacts: {},
+        },
+        {} as never,
+      ),
+    ).toMatchObject({ ok: true });
+
+    await packFiber.dispose();
+    await loaderFiber.dispose();
+    expect(loaders.get(loader.kind)).toBeUndefined();
+    expect(
+      await loaders.loadPack(
+        {
+          guid: '00000000-0000-7000-8000-000000000001',
+          kind: packLoader.kind,
+          payload: {},
+          refs: [],
+          artifacts: {},
+        },
+        {} as never,
+      ),
+    ).toMatchObject({ ok: false });
+  });
+});

package/src/__tests__/registry-concurrency.bench.test.ts

@@ -0,0 +1,40 @@
+import { describe, expect, it, vi } from 'vitest';
+import { AssetRegistry } from '../asset-registry';
+
+const GUID = 'cccccccc-cccc-4ccc-8ccc-cccccccccccc';
+
+describe('registry concurrency counters', () => {
+  it('deduplicates concurrent same-GUID fetch and parse work', async () => {
+    const registry = new AssetRegistry({} as never);
+    registry.loaders.register({
+      kind: 'counter-node',
+      load: vi.fn((payload) => ({ kind: 'counter-node', ...payload })),
+    });
+    registry.configurePackIndex('/pack-index.json');
+    const fetcher = vi.fn(async (url: string) => {
+      if (url.endsWith('pack-index.json')) {
+        return new Response(
+          JSON.stringify([
+            { guid: GUID, packageUrl: '/counter.pack.json', kind: 'counter-node', sourcePath: 'a' },
+          ]),
+        );
+      }
+      return new Response(
+        JSON.stringify({
+          schemaVersion: '2.0.0',
+          kind: 'internal-text-package',
+          assets: [
+            { guid: GUID, kind: 'counter-node', payload: { value: 1 }, refs: [], artifacts: {} },
+          ],
+        }),
+      );
+    });
+    vi.stubGlobal('fetch', fetcher);
+
+    const results = await Promise.all(
+      Array.from({ length: 8 }, () => registry.loadByGuid(registry.parseGuid(GUID))),
+    );
+    expect(results.every((result) => result.ok)).toBe(true);
+    expect(fetcher.mock.calls.filter(([url]) => url.endsWith('counter.pack.json'))).toHaveLength(1);
+  });
+});

package/src/__tests__/registry-failure-retry.integration.test.ts

@@ -0,0 +1,69 @@
+import { describe, expect, it, vi } from 'vitest';
+import { AssetRegistry } from '../asset-registry';
+
+const ROOT = '11111111-1111-4111-8111-111111111111';
+const REF = '22222222-2222-4222-8222-222222222222';
+
+describe('registry failure cleanup and retry', () => {
+  it('purges a failed ref closure before retrying the repaired package', async () => {
+    const registry = new AssetRegistry({} as never);
+    registry.loaders.register({
+      kind: 'retry-node',
+      load: (payload) => ({ kind: 'retry-node', ...payload }),
+    });
+    registry.configurePackIndex('/pack-index.json');
+    let repaired = false;
+    vi.stubGlobal(
+      'fetch',
+      vi.fn(async (url: string) => {
+        if (url.endsWith('pack-index.json')) {
+          return new Response(
+            JSON.stringify([
+              {
+                guid: ROOT,
+                packageUrl: '/retry.pack.json',
+                kind: 'retry-node',
+                sourcePath: 'root',
+              },
+              { guid: REF, packageUrl: '/retry.pack.json', kind: 'retry-node', sourcePath: 'ref' },
+            ]),
+          );
+        }
+        return new Response(
+          JSON.stringify({
+            schemaVersion: '2.0.0',
+            kind: 'internal-text-package',
+            assets: [
+              {
+                guid: ROOT,
+                kind: 'retry-node',
+                payload: { name: 'root' },
+                refs: [REF],
+                artifacts: {},
+              },
+              ...(repaired
+                ? [
+                    {
+                      guid: REF,
+                      kind: 'retry-node',
+                      payload: { name: 'ref' },
+                      refs: [],
+                      artifacts: {},
+                    },
+                  ]
+                : []),
+            ],
+          }),
+        );
+      }),
+    );
+
+    const failed = await registry.loadByGuid(registry.parseGuid(ROOT));
+    expect(failed.ok).toBe(false);
+    expect(registry.lookup(ROOT)).toBeUndefined();
+    repaired = true;
+    const retried = await registry.loadByGuid(registry.parseGuid(ROOT));
+    expect(retried.ok).toBe(true);
+    expect(registry.lookup(REF)).toBeDefined();
+  });
+});

package/src/__tests__/registry-load-graph.integration.test.ts

@@ -0,0 +1,246 @@
+import { describe, expect, it, vi } from 'vitest';
+import { AssetRegistry } from '../asset-registry';
+
+const A = 'aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa';
+const B = 'bbbbbbbb-bbbb-4bbb-8bbb-bbbbbbbbbbbb';
+const C = 'cccccccc-cccc-4ccc-8ccc-cccccccccccc';
+const D = 'dddddddd-dddd-4ddd-8ddd-dddddddddddd';
+
+describe('registry load graph', () => {
+  it('restores descriptor payloads through the production Pack path', async () => {
+    const registry = new AssetRegistry({} as never);
+    registry.configurePackIndex('/pack-index.json');
+    const pack = {
+      schemaVersion: '2.0.0',
+      kind: 'internal-text-package',
+      assets: [
+        {
+          guid: C,
+          kind: 'render-pipeline',
+          payload: { kind: 'render-pipeline', pipelineId: 'forgeax::urp' },
+          refs: [],
+          artifacts: {},
+        },
+      ],
+    };
+    vi.stubGlobal(
+      'fetch',
+      vi.fn(async (url: string) => {
+        if (url.endsWith('pack-index.json')) {
+          return new Response(
+            JSON.stringify([
+              {
+                guid: C,
+                packageUrl: '/descriptor.pack.json',
+                kind: 'render-pipeline',
+                sourcePath: 'pipeline',
+              },
+            ]),
+          );
+        }
+        return new Response(JSON.stringify(pack));
+      }),
+    );
+
+    const result = await registry.loadByGuid(registry.parseGuid(C));
+    expect(result).toMatchObject({ ok: true, value: { kind: 'render-pipeline' } });
+  });
+
+  it('keeps a parent asset out of lookup when a recursive dependency is not ready', async () => {
+    const registry = new AssetRegistry({} as never);
+    registry.loaders.register({
+      kind: 'parent-node',
+      load: (payload) => ({ kind: 'parent-node', ...payload }),
+    });
+    registry.configurePackIndex('/pack-index.json');
+    vi.stubGlobal(
+      'fetch',
+      vi.fn(async (url: string) => {
+        if (url.endsWith('pack-index.json')) {
+          return new Response(
+            JSON.stringify([
+              { guid: A, packageUrl: '/parent.pack.json', kind: 'parent-node', sourcePath: 'a' },
+            ]),
+          );
+        }
+        return new Response(
+          JSON.stringify({
+            schemaVersion: '2.0.0',
+            kind: 'internal-text-package',
+            assets: [
+              {
+                guid: A,
+                kind: 'parent-node',
+                payload: { name: 'parent' },
+                refs: [B],
+                artifacts: {},
+              },
+            ],
+          }),
+        );
+      }),
+    );
+
+    const result = await registry.loadByGuid(registry.parseGuid(A));
+    expect(result).toMatchObject({
+      ok: false,
+      error: { code: expect.any(String), hint: expect.any(String) },
+    });
+    expect(registry.lookup(A)).toBeUndefined();
+  });
+
+  it('terminates a cycle without exposing either provisional asset early', async () => {
+    const registry = new AssetRegistry({} as never);
+    registry.loaders.register({
+      kind: 'cycle-node',
+      load: (payload) => ({ kind: 'cycle-node', ...payload }),
+    });
+    registry.configurePackIndex('/pack-index.json');
+    const pack = {
+      schemaVersion: '2.0.0',
+      kind: 'internal-text-package',
+      assets: [
+        { guid: A, kind: 'cycle-node', payload: { name: 'a' }, refs: [B], artifacts: {} },
+        { guid: B, kind: 'cycle-node', payload: { name: 'b' }, refs: [A], artifacts: {} },
+      ],
+    };
+    vi.stubGlobal(
+      'fetch',
+      vi.fn(async (url: string) => {
+        if (url.endsWith('pack-index.json')) {
+          return new Response(
+            JSON.stringify([
+              { guid: A, packageUrl: '/cycle.pack.json', kind: 'cycle-node', sourcePath: 'a' },
+              { guid: B, packageUrl: '/cycle.pack.json', kind: 'cycle-node', sourcePath: 'b' },
+            ]),
+          );
+        }
+        return new Response(JSON.stringify(pack));
+      }),
+    );
+
+    const result = await registry.loadByGuid(registry.parseGuid(A));
+    expect(result.ok).toBe(true);
+    expect(registry.lookup(A)).toBeDefined();
+    expect(registry.lookup(B)).toBeDefined();
+  });
+
+  it('keeps a public concurrent load pending until a cyclic ref is ready', async () => {
+    const registry = new AssetRegistry({} as never);
+    registry.loaders.register({
+      kind: 'race-node',
+      load: (payload) => ({ kind: 'race-node', ...payload }),
+    });
+    registry.configurePackIndex('/pack-index.json');
+    let releaseRef!: () => void;
+    const refStarted = new Promise<void>((resolve) => {
+      releaseRef = resolve;
+    });
+    let refRequested!: () => void;
+    const refRequest = new Promise<void>((resolve) => {
+      refRequested = resolve;
+    });
+    vi.stubGlobal(
+      'fetch',
+      vi.fn(async (url: string) => {
+        if (url.endsWith('pack-index.json')) {
+          return new Response(
+            JSON.stringify([
+              { guid: A, packageUrl: '/race.pack.json', kind: 'race-node', sourcePath: 'a' },
+              { guid: B, packageUrl: '/race.pack.json', kind: 'race-node', sourcePath: 'b' },
+            ]),
+          );
+        }
+        if (url.endsWith('a.json')) {
+          return new Response(JSON.stringify({ format: 'race', emitters: [{ id: 'a' }] }));
+        }
+        if (url.endsWith('b.json')) {
+          refRequested();
+          await refStarted;
+          return new Response(JSON.stringify({ format: 'race', emitters: [{ id: 'b' }] }));
+        }
+        return new Response(
+          JSON.stringify({
+            schemaVersion: '2.0.0',
+            kind: 'internal-text-package',
+            assets: [
+              {
+                guid: A,
+                kind: 'race-node',
+                payload: { name: 'a' },
+                refs: [B],
+                artifacts: { program: { path: 'a.json', mediaType: 'application/json' } },
+              },
+              {
+                guid: B,
+                kind: 'race-node',
+                payload: { name: 'b' },
+                refs: [],
+                artifacts: { program: { path: 'b.json', mediaType: 'application/json' } },
+              },
+            ],
+          }),
+        );
+      }),
+    );
+
+    const first = registry.loadByGuid(registry.parseGuid(A));
+    await refRequest;
+    let publicSettled = false;
+    const concurrent = registry.loadByGuid(registry.parseGuid(A)).then((result) => {
+      publicSettled = true;
+      return result;
+    });
+    await new Promise<void>((resolve) => setTimeout(resolve, 0));
+    expect(publicSettled).toBe(false);
+
+    releaseRef();
+    const [firstResult, concurrentResult] = await Promise.all([first, concurrent]);
+    expect(firstResult.ok).toBe(true);
+    expect(concurrentResult).toEqual(firstResult);
+  });
+
+  it('waits for a shared sibling dependency while preserving SCC back-edges', async () => {
+    const registry = new AssetRegistry({} as never);
+    registry.loaders.register({
+      kind: 'shared-node',
+      load: (payload) => ({ kind: 'shared-node', ...payload }),
+    });
+    registry.configurePackIndex('/pack-index.json');
+    vi.stubGlobal(
+      'fetch',
+      vi.fn(async (url: string) => {
+        if (url.endsWith('pack-index.json')) {
+          return new Response(
+            JSON.stringify([
+              { guid: A, packageUrl: '/shared.pack.json', kind: 'shared-node', sourcePath: 'a' },
+              { guid: B, packageUrl: '/shared.pack.json', kind: 'shared-node', sourcePath: 'b' },
+              { guid: C, packageUrl: '/shared.pack.json', kind: 'shared-node', sourcePath: 'c' },
+              { guid: D, packageUrl: '/shared.pack.json', kind: 'shared-node', sourcePath: 'd' },
+            ]),
+          );
+        }
+        return new Response(
+          JSON.stringify({
+            schemaVersion: '2.0.0',
+            kind: 'internal-text-package',
+            assets: [
+              { guid: A, kind: 'shared-node', payload: { name: 'a' }, refs: [B, C], artifacts: {} },
+              { guid: B, kind: 'shared-node', payload: { name: 'b' }, refs: [D], artifacts: {} },
+              { guid: C, kind: 'shared-node', payload: { name: 'c' }, refs: [D], artifacts: {} },
+              { guid: D, kind: 'shared-node', payload: { name: 'd' }, refs: [], artifacts: {} },
+            ],
+          }),
+        );
+      }),
+    );
+
+    const result = await registry.loadByGuid(registry.parseGuid(A));
+
+    expect(result.ok).toBe(true);
+    expect(registry.lookup(A)).toBeDefined();
+    expect(registry.lookup(B)).toBeDefined();
+    expect(registry.lookup(C)).toBeDefined();
+    expect(registry.lookup(D)).toBeDefined();
+  });
+});