@flighthq/scene3d-resources 0.3.0-next.906.07cea63 → 0.3.0

package/dist/wrappedDiffusePbrScene3DMaterialTextures.js

@@ -0,0 +1,12 @@
+import { WrappedDiffusePbrExtensionKind } from '@flighthq/types/contract';
+import { registerScene3DPbrExtensionTextures } from './sceneMaterialTextureRegistry';
+export function registerWrappedDiffusePbrScene3DMaterialTextures(registry) {
+    registerScene3DPbrExtensionTextures(registry, WrappedDiffusePbrExtensionKind, (extension, out) => {
+        const wrappedDiffuse = extension;
+        if (wrappedDiffuse.wrappedDiffuseMap !== null)
+            out.push(wrappedDiffuse.wrappedDiffuseMap);
+        if (wrappedDiffuse.thicknessMap !== null)
+            out.push(wrappedDiffuse.thicknessMap);
+    });
+}
+//# sourceMappingURL=wrappedDiffusePbrScene3DMaterialTextures.js.map

package/dist/wrappedDiffusePbrScene3DMaterialTextures.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"wrappedDiffusePbrScene3DMaterialTextures.js","sourceRoot":"","sources":["../src/wrappedDiffusePbrScene3DMaterialTextures.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,8BAA8B,EAAE,MAAM,0BAA0B,CAAC;AAE1E,OAAO,EAAE,mCAAmC,EAAE,MAAM,gCAAgC,CAAC;AAErF,MAAM,UAAU,gDAAgD,CAAC,QAAwC;IACvG,mCAAmC,CAAC,QAAQ,EAAE,8BAA8B,EAAE,CAAC,SAAS,EAAE,GAAG,EAAQ,EAAE;QACrG,MAAM,cAAc,GAAG,SAAiD,CAAC;QACzE,IAAI,cAAc,CAAC,iBAAiB,KAAK,IAAI;YAAE,GAAG,CAAC,IAAI,CAAC,cAAc,CAAC,iBAAiB,CAAC,CAAC;QAC1F,IAAI,cAAc,CAAC,YAAY,KAAK,IAAI;YAAE,GAAG,CAAC,IAAI,CAAC,cAAc,CAAC,YAAY,CAAC,CAAC;IAClF,CAAC,CAAC,CAAC;AACL,CAAC"}

package/package.json

@@ -1,6 +1,8 @@
 {
   "name": "@flighthq/scene3d-resources",
-  "version": "0.3.0-next.906.07cea63",
+  "version": "0.3.0",
+  "author": "Joshua Granick and other contributors",
+  "license": "MIT",
   "repository": {
     "type": "git",
     "url": "https://github.com/flighthq/flight.git",
@@ -36,22 +38,23 @@
     "clean:dist": "tsx ../../scripts/clean-package-dist.ts"
   },
   "dependencies": {
-    "@flighthq/entity": "0.3.0-next.906.07cea63",
-    "@flighthq/image": "0.3.0-next.906.07cea63",
-    "@flighthq/loader": "0.3.0-next.906.07cea63",
-    "@flighthq/log": "0.3.0-next.906.07cea63",
-    "@flighthq/net": "0.3.0-next.906.07cea63",
-    "@flighthq/node": "0.3.0-next.906.07cea63",
-    "@flighthq/scene3d": "0.3.0-next.906.07cea63",
-    "@flighthq/scene3d-formats": "0.3.0-next.906.07cea63",
-    "@flighthq/signals": "0.3.0-next.906.07cea63",
-    "@flighthq/tween": "0.3.0-next.906.07cea63",
-    "@flighthq/types": "0.3.0-next.906.07cea63"
+    "@flighthq/entity": "0.3.0",
+    "@flighthq/image": "0.3.0",
+    "@flighthq/loader": "0.3.0",
+    "@flighthq/log": "0.3.0",
+    "@flighthq/net": "0.3.0",
+    "@flighthq/node": "0.3.0",
+    "@flighthq/scene3d": "0.3.0",
+    "@flighthq/scene3d-formats": "0.3.0",
+    "@flighthq/signals": "0.3.0",
+    "@flighthq/texture": "0.3.0",
+    "@flighthq/tween": "0.3.0",
+    "@flighthq/types": "0.3.0"
   },
   "devDependencies": {
     "@flighthq/materials": "*",
     "@flighthq/mesh": "*",
-    "@flighthq/texture": "*",
+    "@flighthq/shading": "*",
     "typescript": "^5.3.0"
   },
   "description": "Renderer-neutral scene-document URL acquisition and caller-driven resolution of scene texture references into live ImageResources",

package/src/anisotropyPbrScene3DMaterialTextures.test.ts

@@ -0,0 +1,26 @@
+import { createAnisotropyPbrExtension, createExtendedPbrMaterial } from '@flighthq/materials/contract';
+import { createTexture } from '@flighthq/texture/contract';
+import type { Texture } from '@flighthq/types/contract';
+
+import { registerAnisotropyPbrScene3DMaterialTextures } from './anisotropyPbrScene3DMaterialTextures';
+import {
+  createScene3DMaterialTextureRegistry,
+  getScene3DMaterialTextures,
+  registerExtendedPbrScene3DMaterialTextures,
+} from './sceneMaterialTextureRegistry';
+
+describe('registerAnisotropyPbrScene3DMaterialTextures', () => {
+  it('lists the anisotropy map through the generic Extended PBR material lister', () => {
+    const registry = createScene3DMaterialTextureRegistry();
+    registerExtendedPbrScene3DMaterialTextures(registry);
+    registerAnisotropyPbrScene3DMaterialTextures(registry);
+    const map = createTexture();
+    const out: Texture[] = [];
+    getScene3DMaterialTextures(
+      registry,
+      createExtendedPbrMaterial({ extensions: [createAnisotropyPbrExtension({ anisotropyMap: map })] }),
+      out,
+    );
+    expect(out).toEqual([map]);
+  });
+});

package/src/awd2Load.test.ts

@@ -39,8 +39,8 @@ beforeAll(async () => {
 });
 
 afterAll(() => {
-  vi.doUnmock('@flighthq/net');
-  vi.doUnmock('@flighthq/scene3d-formats');
+  vi.doUnmock('@flighthq/net/contract');
+  vi.doUnmock('@flighthq/scene3d-formats/contract');
   vi.resetModules();
 });
 

package/src/clearcoatPbrScene3DMaterialTextures.test.ts

@@ -0,0 +1,36 @@
+import { createClearcoatPbrExtension, createExtendedPbrMaterial } from '@flighthq/materials/contract';
+import { createTexture } from '@flighthq/texture/contract';
+import type { Texture } from '@flighthq/types/contract';
+
+import { registerClearcoatPbrScene3DMaterialTextures } from './clearcoatPbrScene3DMaterialTextures';
+import {
+  createScene3DMaterialTextureRegistry,
+  getScene3DMaterialTextures,
+  registerExtendedPbrScene3DMaterialTextures,
+} from './sceneMaterialTextureRegistry';
+
+describe('registerClearcoatPbrScene3DMaterialTextures', () => {
+  it('lists all clearcoat maps in descriptor order', () => {
+    const registry = createScene3DMaterialTextureRegistry();
+    registerExtendedPbrScene3DMaterialTextures(registry);
+    registerClearcoatPbrScene3DMaterialTextures(registry);
+    const factor = createTexture();
+    const normal = createTexture();
+    const roughness = createTexture();
+    const out: Texture[] = [];
+    getScene3DMaterialTextures(
+      registry,
+      createExtendedPbrMaterial({
+        extensions: [
+          createClearcoatPbrExtension({
+            clearcoatMap: factor,
+            clearcoatNormalMap: normal,
+            clearcoatRoughnessMap: roughness,
+          }),
+        ],
+      }),
+      out,
+    );
+    expect(out).toEqual([factor, normal, roughness]);
+  });
+});

package/src/enableScene3DResourceFailureGuards.test.ts

@@ -63,9 +63,10 @@ describe('enableScene3DResourceFailureGuards', () => {
     addLogSink(sink.sink);
     const resolver = createScene3DResourceResolver();
     const signals = enableScene3DResourceSignals(resolver);
-    const texture = createTexture({ resource: failedRef() });
+    const ref = failedRef();
+    const texture = createTexture({ resource: ref });
     const dispose = enableScene3DResourceFailureGuards(resolver);
-    const event = { ref: texture.resource!, texture };
+    const event = { ref, texture };
 
     expect(() => emitSignal(signals.onResourceFailed, event)).not.toThrow();
     emitSignal(signals.onResourceFailed, event);
@@ -76,13 +77,12 @@ describe('enableScene3DResourceFailureGuards', () => {
       failureKind: ImageResourceFailureKind.Error,
       failureMessage: 'bad image',
       failureName: 'CodecError',
-      message:
-        'resolveScene3DResources: image resource resolution failed — call retryFailedScene3DResources to request it again',
+      message: 'Scene3D resource acquisition failed — call retryFailedScene3DResources to request it again',
     });
-    expect(texture.resource?.state).toBe(ResourceResolutionState.Failed);
+    expect(ref.state).toBe(ResourceResolutionState.Failed);
 
     emitSignal(signals.onResourceResolved, event);
-    texture.resource!.failure = {
+    ref.failure = {
       kind: ImageResourceFailureKind.Unavailable,
       message: 'still unavailable',
       name: null,
@@ -102,11 +102,12 @@ describe('enableScene3DResourceFailureGuards', () => {
     addLogSink(sink.sink);
     const resolver = createScene3DResourceResolver();
     const signals = enableScene3DResourceSignals(resolver);
-    const texture = createTexture({ resource: failedRef() });
+    const ref = failedRef();
+    const texture = createTexture({ resource: ref });
     const firstDispose = enableScene3DResourceFailureGuards(resolver);
     const secondDispose = enableScene3DResourceFailureGuards(resolver);
 
-    emitSignal(signals.onResourceFailed, { ref: texture.resource!, texture });
+    emitSignal(signals.onResourceFailed, { ref, texture });
     expect(getMemoryLogSinkEntries(sink)).toHaveLength(1);
     secondDispose();
     expect(areScene3DResourceFailureGuardsEnabled(resolver)).toBe(false);

package/src/explainScene3DResourceCoverage.test.ts

@@ -0,0 +1,115 @@
+import { createBlinnPhongMaterial, createUnlitMaterial } from '@flighthq/materials/contract';
+import { createBoxMeshGeometry } from '@flighthq/mesh/contract';
+import { addNodeChild } from '@flighthq/node/contract';
+import { createMesh, createScene3D, createScene3DKindUsage, getScene3DKindUsage } from '@flighthq/scene3d/contract';
+import { createShadedMaterial } from '@flighthq/shading/contract';
+import type { Material, SceneCoverageEntry, Scene3DKindUsage } from '@flighthq/types/contract';
+import { RenderRegistry, SceneCoverage } from '@flighthq/types/contract';
+import { describe, expect, it } from 'vitest';
+
+import { explainScene3DResourceCoverage, hasScene3DResourceCoverage } from './explainScene3DResourceCoverage';
+import { createBuiltInScene3DResourceResolver, createScene3DResourceResolver } from './sceneResourceResolver';
+import { registerShadedScene3DMaterialTextures } from './shadedScene3DMaterialTextures';
+
+function usageOf(...materials: Material[]): Scene3DKindUsage {
+  const scene = createScene3D();
+  for (const material of materials) {
+    addNodeChild(scene.root, createMesh(createBoxMeshGeometry(), [material]));
+  }
+  const usage = createScene3DKindUsage();
+  getScene3DKindUsage(usage, scene);
+  return usage;
+}
+
+function gaps(resolver: Parameters<typeof explainScene3DResourceCoverage>[1], usage: Scene3DKindUsage) {
+  const out: SceneCoverageEntry[] = [];
+  explainScene3DResourceCoverage(out, resolver, usage);
+  return out;
+}
+
+describe('explainScene3DResourceCoverage', () => {
+  it('reports a bare resolver as missing every material kind, since its registry starts empty', () => {
+    const found = gaps(createScene3DResourceResolver(), usageOf(createUnlitMaterial()));
+    expect(found).toEqual([
+      { coverage: SceneCoverage.Missing, kind: 'UnlitMaterial', registry: RenderRegistry.MaterialTextureLister },
+    ]);
+  });
+
+  it('reports a covered kind as Satisfied rather than omitting it', () => {
+    // The manifest lists every requirement, so a caller can render a checklist and tell "covered" from
+    // "never asked about". Omitting covered kinds would make those two indistinguishable.
+    expect(gaps(createBuiltInScene3DResourceResolver(), usageOf(createUnlitMaterial()))).toEqual([
+      { coverage: SceneCoverage.Satisfied, kind: 'UnlitMaterial', registry: RenderRegistry.MaterialTextureLister },
+    ]);
+  });
+
+  it('reports ShadedMaterial against the built-in assembly, which does not wire its lister', () => {
+    // The gap this query exists to surface: shading ships registerShadedScene3DMaterialTextures, but
+    // createBuiltInScene3DResourceResolver covers only the surface-PBR families, so an AWD2 document
+    // loaded through the built-in assembly has no lister for its materials.
+    expect(gaps(createBuiltInScene3DResourceResolver(), usageOf(createShadedMaterial()))).toContainEqual({
+      coverage: SceneCoverage.Missing,
+      kind: 'ShadedMaterial',
+      registry: RenderRegistry.MaterialTextureLister,
+    });
+  });
+
+  it('stops reporting once the named door for that family is called', () => {
+    const resolver = createBuiltInScene3DResourceResolver();
+    registerShadedScene3DMaterialTextures(resolver.registry);
+    expect(gaps(resolver, usageOf(createShadedMaterial()))).toEqual([
+      { coverage: SceneCoverage.Satisfied, kind: 'ShadedMaterial', registry: RenderRegistry.MaterialTextureLister },
+    ]);
+  });
+
+  it('reports a family that ships no lister at all, so the omission is visible rather than inferred', () => {
+    // BlinnPhongMaterial carries four texture slots and has no lister anywhere in the SDK.
+    expect(gaps(createBuiltInScene3DResourceResolver(), usageOf(createBlinnPhongMaterial()))).toContainEqual({
+      coverage: SceneCoverage.Missing,
+      kind: 'BlinnPhongMaterial',
+      registry: RenderRegistry.MaterialTextureLister,
+    });
+  });
+
+  it('clears out, so a repeated call does not accumulate', () => {
+    const resolver = createScene3DResourceResolver();
+    const usage = usageOf(createUnlitMaterial());
+    const out: SceneCoverageEntry[] = [];
+    explainScene3DResourceCoverage(out, resolver, usage);
+    const first = out.length;
+    explainScene3DResourceCoverage(out, resolver, usage);
+    expect(out).toHaveLength(first);
+  });
+});
+
+describe('hasScene3DResourceCoverage', () => {
+  it('is false while any material kind is undescribed', () => {
+    expect(hasScene3DResourceCoverage(createScene3DResourceResolver(), usageOf(createUnlitMaterial()))).toBe(false);
+  });
+
+  it('agrees with the explain tier on the same resolver, so the two can never disagree', () => {
+    const resolver = createBuiltInScene3DResourceResolver();
+    const usage = usageOf(createUnlitMaterial(), createShadedMaterial());
+    const out: SceneCoverageEntry[] = [];
+    explainScene3DResourceCoverage(out, resolver, usage);
+    expect(hasScene3DResourceCoverage(resolver, usage)).toBe(out.length === 0);
+  });
+
+  it('stays true when the manifest is all Satisfied entries, which are not shortfalls', () => {
+    // The invariant the manifest widening could have broken: explain now appends entries for covered
+    // kinds too, and the predicate must keep counting only real gaps.
+    const resolver = createBuiltInScene3DResourceResolver();
+    const usage = usageOf(createUnlitMaterial());
+    const out: SceneCoverageEntry[] = [];
+    explainScene3DResourceCoverage(out, resolver, usage);
+    expect(out.length).toBeGreaterThan(0);
+    expect(out.every((e) => e.coverage === SceneCoverage.Satisfied)).toBe(true);
+    expect(hasScene3DResourceCoverage(resolver, usage)).toBe(true);
+  });
+
+  it('is true for an empty scene, which names no material kinds', () => {
+    const usage = createScene3DKindUsage();
+    getScene3DKindUsage(usage, createScene3D());
+    expect(hasScene3DResourceCoverage(createScene3DResourceResolver(), usage)).toBe(true);
+  });
+});

package/src/getScene3DResourceTextures.test.ts

@@ -1,17 +1,13 @@
-import { createStandardPbrMaterial, createUnlitMaterial } from '@flighthq/materials/contract';
+import { createBlinnPhongMaterial, createStandardPbrMaterial, createUnlitMaterial } from '@flighthq/materials/contract';
 import { createBoxMeshGeometry } from '@flighthq/mesh/contract';
 import { addNodeChild } from '@flighthq/node/contract';
 import { createMesh, createScene3D } from '@flighthq/scene3d/contract';
 import { createTexture } from '@flighthq/texture/contract';
 import type { ImageResourceReference, Texture } from '@flighthq/types/contract';
-import { ResourceResolutionState, ImageResourceReferenceKind } from '@flighthq/types/contract';
+import { ImageResourceReferenceKind, ResourceResolutionState } from '@flighthq/types/contract';
 import { describe, expect, it } from 'vitest';
 
-import { getScene3DResourceTextures } from './getScene3DResourceTextures';
-import {
-  createScene3DMaterialTextureRegistry,
-  registerBuiltInScene3DMaterialTextures,
-} from './sceneMaterialTextureRegistry';
+import { getScene3DResourceTextures, getScene3DTextureResourceReference } from './getScene3DResourceTextures';
 
 function embeddedRef(state: ResourceResolutionState = ResourceResolutionState.Unresolved): ImageResourceReference {
   return {
@@ -23,41 +19,32 @@ function embeddedRef(state: ResourceResolutionState = ResourceResolutionState.Un
   };
 }
 
-function registry() {
-  const r = createScene3DMaterialTextureRegistry();
-  registerBuiltInScene3DMaterialTextures(r);
-  return r;
-}
-
 describe('getScene3DResourceTextures', () => {
   it('finds pending textures on the root mesh and descendants', () => {
-    const rootMap = createTexture({ resource: embeddedRef() });
-    const childMap = createTexture({ resource: embeddedRef() });
+    const rootRef = embeddedRef();
+    const childRef = embeddedRef();
+    const rootMap = createTexture({ resource: rootRef });
+    const childMap = createTexture({ resource: childRef });
     const root = createMesh(createBoxMeshGeometry(), [createUnlitMaterial({ baseColorMap: rootMap })]);
     const child = createMesh(createBoxMeshGeometry(), [createUnlitMaterial({ baseColorMap: childMap })]);
     addNodeChild(root, child);
+    const scene = createScene3D();
+    scene.resources.push(rootRef, childRef);
+    addNodeChild(scene.root, root);
 
     const out: Texture[] = [];
-    getScene3DResourceTextures(root, registry(), out);
+    getScene3DResourceTextures(out, scene);
     expect(out).toContain(rootMap);
     expect(out).toContain(childMap);
     expect(out).toHaveLength(2);
-  });
-
-  it('walks a group scene root that is not itself a mesh', () => {
-    const map = createTexture({ resource: embeddedRef() });
-    const scene = createScene3D();
-    const mesh = createMesh(createBoxMeshGeometry(), [createUnlitMaterial({ baseColorMap: map })]);
-    addNodeChild(scene.root, mesh);
-
-    const out: Texture[] = [];
-    getScene3DResourceTextures(scene.root, registry(), out);
-    expect(out).toEqual([map]);
+    expect(getScene3DTextureResourceReference(scene, rootMap)).toBe(rootRef);
   });
 
   it('dedupes a texture shared across meshes and materials', () => {
-    const shared = createTexture({ resource: embeddedRef() });
+    const ref = embeddedRef();
+    const shared = createTexture({ resource: ref });
     const scene = createScene3D();
+    scene.resources.push(ref);
     const a = createMesh(createBoxMeshGeometry(), [
       createUnlitMaterial({ baseColorMap: shared }),
       createStandardPbrMaterial({ baseColorMap: shared }),
@@ -67,35 +54,75 @@ describe('getScene3DResourceTextures', () => {
     addNodeChild(scene.root, b);
 
     const out: Texture[] = [];
-    getScene3DResourceTextures(scene.root, registry(), out);
+    getScene3DResourceTextures(out, scene);
     expect(out).toEqual([shared]);
   });
 
-  it('ignores a texture that carries no resource ref', () => {
+  it('ignores a texture that carries no resource ref, since nothing needs fetching for it', () => {
     const bound = createTexture();
-    const pending = createTexture({ resource: embeddedRef() });
+    const ref = embeddedRef();
+    const pending = createTexture({ resource: ref });
     const mesh = createMesh(createBoxMeshGeometry(), [
       createStandardPbrMaterial({ baseColorMap: bound, normalMap: pending }),
     ]);
 
+    const scene = createScene3D();
+    scene.resources.push(ref);
+    addNodeChild(scene.root, mesh);
     const out: Texture[] = [];
-    getScene3DResourceTextures(mesh, registry(), out);
+    getScene3DResourceTextures(out, scene);
     expect(out).toEqual([pending]);
   });
 
-  it('skips null material slots', () => {
-    const map = createTexture({ resource: embeddedRef() });
-    const mesh = createMesh(createBoxMeshGeometry(), [null, createUnlitMaterial({ baseColorMap: map })]);
+  it('finds a texture on any material kind, with nothing registered', () => {
+    // The defect this closes: discovery used to run through a per-kind lister registry, so a kind with
+    // no lister — BlinnPhongMaterial here, and every custom kind — was undiscoverable. The map was
+    // never requested and the model rendered untextured in silence. Now the resource's own back-edge
+    // answers, so no registration exists to forget.
+    const ref = embeddedRef();
+    const map = createTexture({ resource: ref });
+    const scene = createScene3D();
+    scene.resources.push(ref);
+    addNodeChild(scene.root, createMesh(createBoxMeshGeometry(), [createBlinnPhongMaterial({ specularMap: map })]));
+
     const out: Texture[] = [];
-    getScene3DResourceTextures(mesh, registry(), out);
+    getScene3DResourceTextures(out, scene);
     expect(out).toEqual([map]);
   });
 
+  it('returns a texture whose material hangs off no mesh, which is the cost of dropping the registry', () => {
+    // Honest about the trade: the lister walk used to narrow the set by mesh attachment, so an orphan
+    // material's map was not fetched. That narrowing only ever held while every kind in the scene was
+    // describable, and it cost a registry the caller had to know to populate. The residue is one
+    // over-fetch for a document carrying materials it never attaches.
+    const attachedRef = embeddedRef();
+    const orphanRef = embeddedRef();
+    const attached = createTexture({ resource: attachedRef });
+    const orphan = createTexture({ resource: orphanRef });
+    const scene = createScene3D();
+    scene.resources.push(attachedRef, orphanRef);
+    addNodeChild(scene.root, createMesh(createBoxMeshGeometry(), [createUnlitMaterial({ baseColorMap: attached })]));
+
+    const out: Texture[] = [];
+    getScene3DResourceTextures(out, scene);
+    expect(out).toEqual([attached, orphan]);
+  });
+
   it('clears out before filling it', () => {
-    const map = createTexture({ resource: embeddedRef() });
+    const ref = embeddedRef();
+    const map = createTexture({ resource: ref });
     const mesh = createMesh(createBoxMeshGeometry(), [createUnlitMaterial({ baseColorMap: map })]);
+    const scene = createScene3D();
+    scene.resources.push(ref);
+    addNodeChild(scene.root, mesh);
     const out: Texture[] = [createTexture(), createTexture()];
-    getScene3DResourceTextures(mesh, registry(), out);
+    getScene3DResourceTextures(out, scene);
     expect(out).toEqual([map]);
   });
 });
+
+describe('getScene3DTextureResourceReference', () => {
+  it('returns null for a texture outside the scene resource sidecar', () => {
+    expect(getScene3DTextureResourceReference(createScene3D(), createTexture())).toBeNull();
+  });
+});

package/src/gltfLoad.test.ts

@@ -42,8 +42,8 @@ beforeAll(async () => {
 });
 
 afterAll(() => {
-  vi.doUnmock('@flighthq/net');
-  vi.doUnmock('@flighthq/scene3d-formats');
+  vi.doUnmock('@flighthq/net/contract');
+  vi.doUnmock('@flighthq/scene3d-formats/contract');
   vi.resetModules();
 });
 

package/src/imageResourceFetch.test.ts

@@ -1,12 +1,12 @@
 import type * as ImageModule from '@flighthq/image/contract';
-import type { ExternalImageResourceReference, ImageResource } from '@flighthq/types/contract';
+import type { ExternalImageResourceReference, Image } from '@flighthq/types/contract';
 import { ResourceResolutionState, ImageResourceReferenceKind } from '@flighthq/types/contract';
 import type { Mock } from 'vitest';
 import { afterAll, afterEach, beforeAll, describe, expect, it, vi } from 'vitest';
 
 import type * as ImageResourceFetchModule from './imageResourceFetch';
 
-const fakeImage = { height: 1, width: 1 } as unknown as ImageResource;
+const fakeImage = { height: 1, width: 1 } as unknown as Image;
 type LoadImageResourceFromUrl = typeof ImageModule.loadImageResourceFromUrl;
 
 let fetchWebImageResource: typeof ImageResourceFetchModule.fetchWebImageResource;
@@ -35,7 +35,7 @@ beforeAll(async () => {
 });
 
 afterAll(() => {
-  vi.doUnmock('@flighthq/image');
+  vi.doUnmock('@flighthq/image/contract');
   vi.resetModules();
 });
 

package/src/iridescencePbrScene3DMaterialTextures.test.ts

@@ -0,0 +1,34 @@
+import { createExtendedPbrMaterial, createIridescencePbrExtension } from '@flighthq/materials/contract';
+import { createTexture } from '@flighthq/texture/contract';
+import type { Texture } from '@flighthq/types/contract';
+
+import { registerIridescencePbrScene3DMaterialTextures } from './iridescencePbrScene3DMaterialTextures';
+import {
+  createScene3DMaterialTextureRegistry,
+  getScene3DMaterialTextures,
+  registerExtendedPbrScene3DMaterialTextures,
+} from './sceneMaterialTextureRegistry';
+
+describe('registerIridescencePbrScene3DMaterialTextures', () => {
+  it('lists the iridescence factor and thickness maps', () => {
+    const registry = createScene3DMaterialTextureRegistry();
+    registerExtendedPbrScene3DMaterialTextures(registry);
+    registerIridescencePbrScene3DMaterialTextures(registry);
+    const factor = createTexture();
+    const thickness = createTexture();
+    const out: Texture[] = [];
+    getScene3DMaterialTextures(
+      registry,
+      createExtendedPbrMaterial({
+        extensions: [
+          createIridescencePbrExtension({
+            iridescenceMap: factor,
+            iridescenceThicknessMap: thickness,
+          }),
+        ],
+      }),
+      out,
+    );
+    expect(out).toEqual([factor, thickness]);
+  });
+});