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

package/src/{resolveScene3DResourcesAndWait.test.ts → loadScene3DResources.test.ts}

@@ -3,18 +3,20 @@ import { createBoxMeshGeometry } from '@flighthq/mesh/contract';
 import { addNodeChild } from '@flighthq/node/contract';
 import { createMesh, createScene3D } from '@flighthq/scene3d/contract';
 import { connectSignal, createSignal } from '@flighthq/signals/contract';
-import { createTexture } from '@flighthq/texture/contract';
-import type { ImageResource, ImageResourceReference, Scene3DResourceLoadProgress } from '@flighthq/types/contract';
+import { createTexture, getTextureSource } from '@flighthq/texture/contract';
+import type { Image, ImageResourceReference, Scene3DResourceLoadProgress, Texture } from '@flighthq/types/contract';
 import { ResourceResolutionState, ImageResourceReferenceKind } from '@flighthq/types/contract';
 import { describe, expect, it, vi } from 'vitest';
 
-import { loadScene3DResources, waitForScene3DResourceResolver } from './resolveScene3DResourcesAndWait';
+import { loadScene3DResources, waitForScene3DResourceResolver } from './loadScene3DResources';
 import { createBuiltInScene3DResourceResolver, disposeScene3DResourceResolver } from './sceneResourceResolver';
 
-const fakeImage = { height: 1, width: 1 } as unknown as ImageResource;
+const fakeImage = { height: 1, width: 1 } as unknown as Image;
+const testResources: ImageResourceReference[] = [];
+let sceneResources: ImageResourceReference[] = [];
 
 function externalRef(): ImageResourceReference {
-  return {
+  const ref: ImageResourceReference = {
     basePath: null,
     failure: null,
     kind: ImageResourceReferenceKind.External,
@@ -22,6 +24,21 @@ function externalRef(): ImageResourceReference {
     state: ResourceResolutionState.Unresolved,
     uri: 'leaf.png',
   };
+  testResources.push(ref);
+  return ref;
+}
+
+// Hands the scene only the references its own test created, then drains the accumulator. Copying the
+// whole accumulator used to give every scene the previous tests' references as well — harmless only
+// while discovery narrowed by mesh attachment and quietly dropped whatever no mesh referenced.
+function configureResources(scene: ReturnType<typeof createScene3D>): void {
+  sceneResources = testResources.slice();
+  testResources.length = 0;
+  scene.resources = sceneResources;
+}
+
+function resourceOf(texture: Texture): ImageResourceReference | undefined {
+  return sceneResources.find((ref) => ref.textures?.includes(texture) === true);
 }
 
 describe('loadScene3DResources', () => {
@@ -30,22 +47,24 @@ describe('loadScene3DResources', () => {
     const a = createTexture({ resource: externalRef() });
     const b = createTexture({ resource: externalRef() });
     const scene = createScene3D();
+    configureResources(scene);
     addNodeChild(scene.root, createMesh(createBoxMeshGeometry(), [createUnlitMaterial({ baseColorMap: a })]));
     addNodeChild(scene.root, createMesh(createBoxMeshGeometry(), [createUnlitMaterial({ baseColorMap: b })]));
     const resolver = createBuiltInScene3DResourceResolver({ fetch });
 
-    await loadScene3DResources(scene.root, resolver);
+    await loadScene3DResources(scene, resolver);
 
-    expect(a.storage.image).toBe(fakeImage);
-    expect(b.storage.image).toBe(fakeImage);
-    expect(a.resource?.state).toBe(ResourceResolutionState.Resolved);
+    expect(getTextureSource(a)).toBe(fakeImage);
+    expect(getTextureSource(b)).toBe(fakeImage);
+    expect(resourceOf(a)?.state).toBe(ResourceResolutionState.Resolved);
     disposeScene3DResourceResolver(resolver);
   });
 
   it('resolves immediately when there is nothing pending', async () => {
     const scene = createScene3D();
+    configureResources(scene);
     const resolver = createBuiltInScene3DResourceResolver({ fetch: async () => fakeImage });
-    await expect(loadScene3DResources(scene.root, resolver)).resolves.toBeUndefined();
+    await expect(loadScene3DResources(scene, resolver)).resolves.toBeUndefined();
     disposeScene3DResourceResolver(resolver);
   });
 
@@ -53,6 +72,7 @@ describe('loadScene3DResources', () => {
     const a = createTexture({ resource: externalRef() });
     const b = createTexture({ resource: externalRef() });
     const scene = createScene3D();
+    configureResources(scene);
     addNodeChild(scene.root, createMesh(createBoxMeshGeometry(), [createUnlitMaterial({ baseColorMap: a })]));
     addNodeChild(scene.root, createMesh(createBoxMeshGeometry(), [createUnlitMaterial({ baseColorMap: b })]));
     const resolver = createBuiltInScene3DResourceResolver({ fetch: async () => fakeImage });
@@ -60,7 +80,7 @@ describe('loadScene3DResources', () => {
     const progress = createSignal<(event: Readonly<Scene3DResourceLoadProgress>) => void>();
     connectSignal(progress, (event) => events.push({ ...event }));
 
-    await loadScene3DResources(scene.root, resolver, { progress });
+    await loadScene3DResources(scene, resolver, { progress });
 
     expect(events[0]).toEqual({ loaded: 0, total: 2 });
     expect(events.at(-1)).toEqual({ loaded: 2, total: 2 });
@@ -70,16 +90,17 @@ describe('loadScene3DResources', () => {
   it('counts failed references as terminal without hiding their failure state', async () => {
     const texture = createTexture({ resource: externalRef() });
     const scene = createScene3D();
+    configureResources(scene);
     addNodeChild(scene.root, createMesh(createBoxMeshGeometry(), [createUnlitMaterial({ baseColorMap: texture })]));
     const resolver = createBuiltInScene3DResourceResolver({ fetch: async () => null });
     const events: Scene3DResourceLoadProgress[] = [];
     const progress = createSignal<(event: Readonly<Scene3DResourceLoadProgress>) => void>();
     connectSignal(progress, (event) => events.push({ ...event }));
 
-    await loadScene3DResources(scene.root, resolver, { progress });
+    await loadScene3DResources(scene, resolver, { progress });
 
-    expect(texture.storage.image).toBeNull();
-    expect(texture.resource?.state).toBe(ResourceResolutionState.Failed);
+    expect(getTextureSource(texture)).toBeNull();
+    expect(resourceOf(texture)?.state).toBe(ResourceResolutionState.Failed);
     expect(events).toEqual([
       { loaded: 0, total: 1 },
       { loaded: 1, total: 1 },
@@ -91,6 +112,7 @@ describe('loadScene3DResources', () => {
     const selected = createTexture({ resource: externalRef() });
     const deferred = createTexture({ resource: externalRef() });
     const scene = createScene3D();
+    configureResources(scene);
     addNodeChild(scene.root, createMesh(createBoxMeshGeometry(), [createUnlitMaterial({ baseColorMap: selected })]));
     addNodeChild(scene.root, createMesh(createBoxMeshGeometry(), [createUnlitMaterial({ baseColorMap: deferred })]));
     const fetch = vi.fn(async () => fakeImage);
@@ -99,11 +121,11 @@ describe('loadScene3DResources', () => {
     const progress = createSignal<(event: Readonly<Scene3DResourceLoadProgress>) => void>();
     connectSignal(progress, (event) => events.push({ ...event }));
 
-    await loadScene3DResources(scene.root, resolver, { progress, select: (texture) => texture === selected });
+    await loadScene3DResources(scene, resolver, { progress, select: (texture) => texture === selected });
 
-    expect(selected.storage.image).toBe(fakeImage);
-    expect(deferred.storage.image).toBeNull();
-    expect(deferred.resource?.state).toBe(ResourceResolutionState.Unresolved);
+    expect(getTextureSource(selected)).toBe(fakeImage);
+    expect(getTextureSource(deferred)).toBeNull();
+    expect(resourceOf(deferred)?.state).toBe(ResourceResolutionState.Unresolved);
     expect(fetch).toHaveBeenCalledOnce();
     expect(events.at(-1)).toEqual({ loaded: 1, total: 1 });
     disposeScene3DResourceResolver(resolver);

package/src/md2Load.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/md5Load.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/objLoad.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/resolveScene3DResources.test.ts

@@ -4,22 +4,23 @@ import { createBoxMeshGeometry } from '@flighthq/mesh/contract';
 import { addNodeChild } from '@flighthq/node/contract';
 import { createMesh, createScene3D } from '@flighthq/scene3d/contract';
 import { connectSignal } from '@flighthq/signals/contract';
-import { createTexture } from '@flighthq/texture/contract';
-import type { ImageResource, ImageResourceReference, Scene3DResourceResolver, Texture } from '@flighthq/types/contract';
+import { createTexture, getTextureSource } from '@flighthq/texture/contract';
+import type { Image, ImageResourceReference, Scene3DResourceResolver, Texture } from '@flighthq/types/contract';
 import {
   ImageResourceFailureKind,
+  ImageTextureSourceKind,
   ResourceResolutionState,
   ImageResourceReferenceKind,
 } from '@flighthq/types/contract';
 import type { Mock } from 'vitest';
 import { afterAll, afterEach, beforeAll, describe, expect, it, vi } from 'vitest';
 
+import type * as LoadScene3DResourcesModule from './loadScene3DResources';
 import type * as ResolveScene3DResourcesModule from './resolveScene3DResources';
-import type * as ResolveScene3DResourcesAndWaitModule from './resolveScene3DResourcesAndWait';
 import type * as Scene3DResourceResolverModule from './sceneResourceResolver';
 import type * as Scene3DResourceSignalsModule from './sceneResourceSignals';
 
-const fakeImage = { height: 2, width: 2 } as unknown as ImageResource;
+const fakeImage = { height: 2, kind: ImageTextureSourceKind, width: 2 } as unknown as Image;
 type LoadImageResourceFromBytes = typeof ImageModule.loadImageResourceFromBytes;
 
 let createBuiltInScene3DResourceResolver: typeof Scene3DResourceResolverModule.createBuiltInScene3DResourceResolver;
@@ -28,20 +29,25 @@ let enableScene3DResourceSignals: typeof Scene3DResourceSignalsModule.enableScen
 let loadFromBytes: Mock<LoadImageResourceFromBytes>;
 let resolveOneScene3DResourceTexture: typeof ResolveScene3DResourcesModule.resolveOneScene3DResourceTexture;
 let resolveScene3DResources: typeof ResolveScene3DResourcesModule.resolveScene3DResources;
-let waitForScene3DResourceResolver: typeof ResolveScene3DResourcesAndWaitModule.waitForScene3DResourceResolver;
+let updateScene3DResourceStreaming: typeof ResolveScene3DResourcesModule.updateScene3DResourceStreaming;
+let waitForScene3DResourceResolver: typeof LoadScene3DResourcesModule.waitForScene3DResourceResolver;
+const testResources: ImageResourceReference[] = [];
+let sceneResources: ImageResourceReference[] = [];
 
 function embeddedRef(mimeType: string | null = 'image/png'): ImageResourceReference {
-  return {
+  const ref: ImageResourceReference = {
     bytes: new Uint8Array([9, 9]),
     failure: null,
     kind: ImageResourceReferenceKind.Embedded,
     mimeType,
     state: ResourceResolutionState.Unresolved,
   };
+  testResources.push(ref);
+  return ref;
 }
 
 function externalRef(uri = 'leaf.png'): ImageResourceReference {
-  return {
+  const ref: ImageResourceReference = {
     basePath: null,
     failure: null,
     kind: ImageResourceReferenceKind.External,
@@ -49,6 +55,12 @@ function externalRef(uri = 'leaf.png'): ImageResourceReference {
     state: ResourceResolutionState.Unresolved,
     uri,
   };
+  testResources.push(ref);
+  return ref;
+}
+
+function resourceOf(texture: Texture): ImageResourceReference | undefined {
+  return sceneResources.find((ref) => ref.textures?.includes(texture) === true);
 }
 
 function pendingTexture(): Texture {
@@ -57,6 +69,11 @@ function pendingTexture(): Texture {
 
 function meshScene3D(...textures: Texture[]) {
   const scene = createScene3D();
+  // Only this test's references. Copying the whole accumulator used to hand each scene the previous
+  // tests' references too, which discovery quietly dropped while it narrowed by mesh attachment.
+  sceneResources = testResources.slice();
+  testResources.length = 0;
+  scene.resources = sceneResources;
   for (const texture of textures) {
     addNodeChild(scene.root, createMesh(createBoxMeshGeometry(), [createUnlitMaterial({ baseColorMap: texture })]));
   }
@@ -70,18 +87,22 @@ async function settle(resolver: Scene3DResourceResolver): Promise<void> {
 beforeAll(async () => {
   vi.resetModules();
   loadFromBytes = vi.fn<LoadImageResourceFromBytes>();
-  vi.doMock('@flighthq/image/contract', () => ({
+  // Override only the two loaders; the rest of the module stays real, so growing @flighthq/image cannot
+  // silently blank out a code path under test.
+  vi.doMock('@flighthq/image/contract', async (importOriginal) => ({
+    ...(await importOriginal<typeof ImageModule>()),
     loadImageResourceFromBytes: loadFromBytes,
     loadImageResourceFromUrl: vi.fn(),
   }));
-  ({ resolveOneScene3DResourceTexture, resolveScene3DResources } = await import('./resolveScene3DResources'));
-  ({ waitForScene3DResourceResolver } = await import('./resolveScene3DResourcesAndWait'));
+  ({ resolveOneScene3DResourceTexture, resolveScene3DResources, updateScene3DResourceStreaming } =
+    await import('./resolveScene3DResources'));
+  ({ waitForScene3DResourceResolver } = await import('./loadScene3DResources'));
   ({ createBuiltInScene3DResourceResolver, disposeScene3DResourceResolver } = await import('./sceneResourceResolver'));
   ({ enableScene3DResourceSignals } = await import('./sceneResourceSignals'));
 });
 
 afterAll(() => {
-  vi.doUnmock('@flighthq/image');
+  vi.doUnmock('@flighthq/image/contract');
   vi.resetModules();
 });
 
@@ -122,6 +143,68 @@ describe('resolveOneScene3DResourceTexture', () => {
 });
 
 describe('resolveScene3DResources', () => {
+  it('does not cancel acquisition owned by a streaming update', async () => {
+    let loadSignal: AbortSignal | undefined;
+    loadFromBytes.mockImplementation(
+      (_bytes, _mime, signal) =>
+        new Promise<Image>((_resolve, reject) => {
+          loadSignal = signal;
+          signal?.addEventListener('abort', () => reject(signal.reason));
+        }),
+    );
+    const ref = embeddedRef();
+    const scene = meshScene3D(createTexture({ resource: ref }));
+    const resolver = createBuiltInScene3DResourceResolver();
+    updateScene3DResourceStreaming(scene, resolver);
+    await vi.waitFor(() => expect(loadSignal).toBeDefined());
+
+    const resources = resolveScene3DResources(scene, resolver, { select: () => false });
+
+    expect(resources.resolved).toEqual([]);
+    expect(resources.unresolved).toEqual([]);
+    expect(loadSignal?.aborted).toBe(false);
+    expect(ref.state).toBe(ResourceResolutionState.Loading);
+    disposeScene3DResourceResolver(resolver);
+  });
+
+  it('returns the selected unresolved working set without starting acquisition', () => {
+    loadFromBytes.mockResolvedValue(fakeImage);
+    const ref = embeddedRef();
+    const a = createTexture({ resource: ref });
+    const b = createTexture({ resource: ref });
+    const scene = meshScene3D(a, b);
+    const resolver = createBuiltInScene3DResourceResolver();
+
+    const resources = resolveScene3DResources(scene, resolver);
+
+    expect(resources.scene).toBe(scene);
+    expect(resources.resolved).toEqual([]);
+    expect(resources.unresolved).toEqual([{ ref, textures: [a, b] }]);
+    expect(ref.state).toBe(ResourceResolutionState.Unresolved);
+    expect(loadFromBytes).not.toHaveBeenCalled();
+    disposeScene3DResourceResolver(resolver);
+  });
+
+  it('binds ready content across subscribers and returns its resolved group', () => {
+    const ref = embeddedRef();
+    const a = createTexture({ resource: ref });
+    const b = createTexture({ resource: ref });
+    if (a.dimension !== '2d') throw new Error('test texture must be 2d');
+    a.source = fakeImage;
+    const scene = meshScene3D(a, b);
+    const resolver = createBuiltInScene3DResourceResolver();
+
+    const resources = resolveScene3DResources(scene, resolver);
+
+    expect(resources.unresolved).toEqual([]);
+    expect(resources.resolved).toEqual([{ image: fakeImage, ref, textures: [a, b] }]);
+    expect(getTextureSource(b)).toBe(fakeImage);
+    expect(ref.state).toBe(ResourceResolutionState.Resolved);
+    disposeScene3DResourceResolver(resolver);
+  });
+});
+
+describe('updateScene3DResourceStreaming', () => {
   it('resolves every pending texture, binding the image and advancing state', async () => {
     loadFromBytes.mockResolvedValue(fakeImage);
     const a = pendingTexture();
@@ -129,14 +212,14 @@ describe('resolveScene3DResources', () => {
     const scene = meshScene3D(a, b);
     const resolver = createBuiltInScene3DResourceResolver();
 
-    resolveScene3DResources(scene.root, resolver);
+    updateScene3DResourceStreaming(scene, resolver);
     await settle(resolver);
 
-    expect(a.storage.image).toBe(fakeImage);
-    expect(b.storage.image).toBe(fakeImage);
-    expect(a.resource?.state).toBe(ResourceResolutionState.Resolved);
-    expect(a.resource?.failure).toBeNull();
-    expect(b.resource?.state).toBe(ResourceResolutionState.Resolved);
+    expect(getTextureSource(a)).toBe(fakeImage);
+    expect(getTextureSource(b)).toBe(fakeImage);
+    expect(resourceOf(a)?.state).toBe(ResourceResolutionState.Resolved);
+    expect(resourceOf(a)?.failure).toBeNull();
+    expect(resourceOf(b)?.state).toBe(ResourceResolutionState.Resolved);
     disposeScene3DResourceResolver(resolver);
   });
 
@@ -148,12 +231,12 @@ describe('resolveScene3DResources', () => {
     const scene = meshScene3D(a, b);
     const resolver = createBuiltInScene3DResourceResolver();
 
-    resolveScene3DResources(scene.root, resolver);
+    updateScene3DResourceStreaming(scene, resolver);
     await settle(resolver);
 
     expect(loadFromBytes).toHaveBeenCalledTimes(1);
-    expect(a.storage.image).toBe(fakeImage);
-    expect(b.storage.image).toBe(fakeImage);
+    expect(getTextureSource(a)).toBe(fakeImage);
+    expect(getTextureSource(b)).toBe(fakeImage);
     expect(ref.state).toBe(ResourceResolutionState.Resolved);
     disposeScene3DResourceResolver(resolver);
   });
@@ -162,7 +245,7 @@ describe('resolveScene3DResources', () => {
     let loadSignal: AbortSignal | undefined;
     loadFromBytes.mockImplementation(
       (_bytes, _mime, signal) =>
-        new Promise<ImageResource>((_resolve, reject) => {
+        new Promise<Image>((_resolve, reject) => {
           loadSignal = signal;
           signal?.addEventListener('abort', () => reject(signal.reason));
         }),
@@ -173,13 +256,13 @@ describe('resolveScene3DResources', () => {
     const scene = meshScene3D(a, b);
     const resolver = createBuiltInScene3DResourceResolver();
 
-    resolveScene3DResources(scene.root, resolver);
+    updateScene3DResourceStreaming(scene, resolver);
     await vi.waitFor(() => expect(loadSignal).toBeDefined());
-    resolveScene3DResources(scene.root, resolver, { select: (texture) => texture === b });
+    updateScene3DResourceStreaming(scene, resolver, { select: (texture) => texture === b });
     expect(loadSignal?.aborted).toBe(false);
     expect(ref.state).toBe(ResourceResolutionState.Loading);
 
-    resolveScene3DResources(scene.root, resolver, { select: () => false });
+    updateScene3DResourceStreaming(scene, resolver, { select: () => false });
     expect(loadSignal?.aborted).toBe(true);
     expect(ref.state).toBe(ResourceResolutionState.Unresolved);
     disposeScene3DResourceResolver(resolver);
@@ -193,13 +276,13 @@ describe('resolveScene3DResources', () => {
     const scene = meshScene3D(a, b);
     const resolver = createBuiltInScene3DResourceResolver();
 
-    resolveScene3DResources(scene.root, resolver, { select: (texture) => texture === a });
+    updateScene3DResourceStreaming(scene, resolver, { select: (texture) => texture === a });
     await settle(resolver);
-    expect(a.storage.image).toBe(fakeImage);
-    expect(b.storage.image).toBeNull();
+    expect(getTextureSource(a)).toBe(fakeImage);
+    expect(getTextureSource(b)).toBeNull();
 
-    resolveScene3DResources(scene.root, resolver, { select: (texture) => texture === b });
-    expect(b.storage.image).toBe(fakeImage);
+    updateScene3DResourceStreaming(scene, resolver, { select: (texture) => texture === b });
+    expect(getTextureSource(b)).toBe(fakeImage);
     expect(loadFromBytes).toHaveBeenCalledTimes(1);
     disposeScene3DResourceResolver(resolver);
   });
@@ -211,12 +294,12 @@ describe('resolveScene3DResources', () => {
     const scene = meshScene3D(wanted, skipped);
     const resolver = createBuiltInScene3DResourceResolver();
 
-    resolveScene3DResources(scene.root, resolver, { select: (texture) => texture === wanted });
+    updateScene3DResourceStreaming(scene, resolver, { select: (texture) => texture === wanted });
     await settle(resolver);
 
-    expect(wanted.resource?.state).toBe(ResourceResolutionState.Resolved);
-    expect(skipped.resource?.state).toBe(ResourceResolutionState.Unresolved);
-    expect(skipped.storage.image).toBeNull();
+    expect(resourceOf(wanted)?.state).toBe(ResourceResolutionState.Resolved);
+    expect(resourceOf(skipped)?.state).toBe(ResourceResolutionState.Unresolved);
+    expect(getTextureSource(skipped)).toBeNull();
     disposeScene3DResourceResolver(resolver);
   });
 
@@ -225,12 +308,12 @@ describe('resolveScene3DResources', () => {
     const scene = meshScene3D(texture);
     const resolver = createBuiltInScene3DResourceResolver({ fetch: async () => null });
 
-    resolveScene3DResources(scene.root, resolver);
+    updateScene3DResourceStreaming(scene, resolver);
     await settle(resolver);
 
-    expect(texture.storage.image).toBeNull();
-    expect(texture.resource?.state).toBe(ResourceResolutionState.Failed);
-    expect(texture.resource?.failure).toEqual({
+    expect(getTextureSource(texture)).toBeNull();
+    expect(resourceOf(texture)?.state).toBe(ResourceResolutionState.Failed);
+    expect(resourceOf(texture)?.failure).toEqual({
       kind: ImageResourceFailureKind.Unavailable,
       message: 'Image resource resolution returned no image',
       name: null,
@@ -244,11 +327,11 @@ describe('resolveScene3DResources', () => {
     const scene = meshScene3D(texture);
     const resolver = createBuiltInScene3DResourceResolver();
 
-    resolveScene3DResources(scene.root, resolver);
+    updateScene3DResourceStreaming(scene, resolver);
     await settle(resolver);
 
-    expect(texture.resource?.state).toBe(ResourceResolutionState.Failed);
-    expect(texture.resource?.failure).toEqual({
+    expect(resourceOf(texture)?.state).toBe(ResourceResolutionState.Failed);
+    expect(resourceOf(texture)?.failure).toEqual({
       kind: ImageResourceFailureKind.Error,
       message: 'bad image',
       name: 'Error',
@@ -261,7 +344,7 @@ describe('resolveScene3DResources', () => {
     // A load that hangs until its signal aborts, so we can drop it mid-flight.
     loadFromBytes.mockImplementation(
       (_bytes, _mime, signal) =>
-        new Promise<ImageResource>((_resolve, reject) => {
+        new Promise<Image>((_resolve, reject) => {
           if (signal !== undefined) loadSignals.push(signal);
           signal?.addEventListener('abort', () => reject(signal.reason));
         }),
@@ -270,33 +353,33 @@ describe('resolveScene3DResources', () => {
     const scene = meshScene3D(texture);
     const resolver = createBuiltInScene3DResourceResolver();
 
-    resolveScene3DResources(scene.root, resolver, { select: () => true });
-    expect(texture.resource?.state).toBe(ResourceResolutionState.Loading);
+    updateScene3DResourceStreaming(scene, resolver, { select: () => true });
+    expect(resourceOf(texture)?.state).toBe(ResourceResolutionState.Loading);
     await vi.waitFor(() => expect(loadSignals).toHaveLength(1));
 
     // Drop it: not in the working set this pass → abort + revert.
-    resolveScene3DResources(scene.root, resolver, { select: () => false });
-    expect(texture.resource?.state).toBe(ResourceResolutionState.Unresolved);
-    expect(texture.storage.image).toBeNull();
+    updateScene3DResourceStreaming(scene, resolver, { select: () => false });
+    expect(resourceOf(texture)?.state).toBe(ResourceResolutionState.Unresolved);
+    expect(getTextureSource(texture)).toBeNull();
     expect(loadSignals[0].aborted).toBe(true);
 
     // Re-entry re-requests from scratch.
-    resolveScene3DResources(scene.root, resolver, { select: () => true });
-    expect(texture.resource?.state).toBe(ResourceResolutionState.Loading);
+    updateScene3DResourceStreaming(scene, resolver, { select: () => true });
+    expect(resourceOf(texture)?.state).toBe(ResourceResolutionState.Loading);
     await vi.waitFor(() => expect(loadSignals).toHaveLength(2));
 
     disposeScene3DResourceResolver(resolver);
   });
 
   it('does not re-request a texture already in flight', async () => {
-    loadFromBytes.mockImplementation(() => new Promise<ImageResource>(() => {}));
+    loadFromBytes.mockImplementation(() => new Promise<Image>(() => {}));
     const texture = pendingTexture();
     const scene = meshScene3D(texture);
     const resolver = createBuiltInScene3DResourceResolver();
 
-    resolveScene3DResources(scene.root, resolver);
+    updateScene3DResourceStreaming(scene, resolver);
     await vi.waitFor(() => expect(loadFromBytes).toHaveBeenCalledTimes(1));
-    resolveScene3DResources(scene.root, resolver);
+    updateScene3DResourceStreaming(scene, resolver);
     expect(loadFromBytes).toHaveBeenCalledTimes(1);
 
     disposeScene3DResourceResolver(resolver);
@@ -313,7 +396,7 @@ describe('resolveScene3DResources', () => {
     connectSignal(signals.onResourceResolved, (event) => resolved.push(event.texture));
     connectSignal(signals.onResourceFailed, (event) => failed.push(event.texture));
 
-    resolveScene3DResources(scene.root, resolver);
+    updateScene3DResourceStreaming(scene, resolver);
     await settle(resolver);
 
     expect(resolved).toEqual([texture]);
@@ -330,7 +413,7 @@ describe('resolveScene3DResources', () => {
     const failed: Texture[] = [];
     connectSignal(signals.onResourceFailed, (event) => failed.push(event.texture));
 
-    resolveScene3DResources(scene.root, resolver);
+    updateScene3DResourceStreaming(scene, resolver);
     await settle(resolver);
 
     expect(failed).toEqual([texture]);