@flighthq/scene3d-resources 0.2.1-next.840.857425c

package/src/awd2Load.test.ts

@@ -0,0 +1,63 @@
+import type * as NetModule from '@flighthq/net';
+import type * as Scene3DFormatsModule from '@flighthq/scene3d-formats';
+import type { NetResponse, Scene3DDocument } from '@flighthq/types';
+import type { Mock } from 'vitest';
+import { afterAll, afterEach, beforeAll, describe, expect, it, vi } from 'vitest';
+
+import type * as LoadAwd2Module from './awd2Load';
+
+let loadScene3DDocumentFromAwd2Url: typeof LoadAwd2Module.loadScene3DDocumentFromAwd2Url;
+let parseAwd2: Mock<typeof Scene3DFormatsModule.parseAwd2>;
+let sendNetRequest: Mock<typeof NetModule.sendNetRequest>;
+
+function emptyDocument(): Scene3DDocument {
+  return {
+    animations: [],
+    cameras: [],
+    lights: [],
+    materials: [],
+    meshes: [],
+    metadata: null,
+    nodes: [],
+    resources: [],
+    scenes: [],
+    skins: [],
+  };
+}
+
+function okResponse(body: ArrayBuffer): NetResponse {
+  return { body, headers: {}, ok: true, status: 200, statusText: 'OK', url: 'u' };
+}
+
+beforeAll(async () => {
+  vi.resetModules();
+  parseAwd2 = vi.fn<typeof Scene3DFormatsModule.parseAwd2>();
+  sendNetRequest = vi.fn<typeof NetModule.sendNetRequest>();
+  vi.doMock('@flighthq/net', () => ({ sendNetRequest }));
+  vi.doMock('@flighthq/scene3d-formats', () => ({ parseAwd2 }));
+  ({ loadScene3DDocumentFromAwd2Url } = await import('./awd2Load'));
+});
+
+afterAll(() => {
+  vi.doUnmock('@flighthq/net');
+  vi.doUnmock('@flighthq/scene3d-formats');
+  vi.resetModules();
+});
+
+afterEach(() => {
+  parseAwd2.mockReset();
+  sendNetRequest.mockReset();
+});
+
+describe('loadScene3DDocumentFromAwd2Url', () => {
+  it('fetches bytes and returns the parsed CPU document without resolving resources', async () => {
+    const document = emptyDocument();
+    parseAwd2.mockReturnValue(document);
+    sendNetRequest.mockResolvedValue(okResponse(new Uint8Array([5, 6]).buffer));
+
+    const loaded = await loadScene3DDocumentFromAwd2Url('model.awd');
+
+    expect(Array.from(parseAwd2.mock.calls[0][0])).toEqual([5, 6]);
+    expect(loaded).toBe(document);
+  });
+});

package/src/enableScene3DResourceFailureGuards.test.ts

@@ -0,0 +1,116 @@
+import { addLogSink, createMemoryLogSink, getMemoryLogSinkEntries, removeLogSink } from '@flighthq/log';
+import { emitSignal } from '@flighthq/signals';
+import { createTexture } from '@flighthq/texture';
+import type { ImageResourceReference } from '@flighthq/types';
+import {
+  ImageResourceFailureKind,
+  ImageResourceReferenceKind,
+  LogLevel,
+  ResourceResolutionState,
+} from '@flighthq/types';
+import { afterEach, describe, expect, it } from 'vitest';
+
+import {
+  areScene3DResourceFailureGuardsEnabled,
+  disableScene3DResourceFailureGuards,
+  enableScene3DResourceFailureGuards,
+} from './enableScene3DResourceFailureGuards';
+import { createScene3DResourceResolver, disposeScene3DResourceResolver } from './sceneResourceResolver';
+import { enableScene3DResourceSignals } from './sceneResourceSignals';
+
+const sinks: ReturnType<typeof createMemoryLogSink>[] = [];
+
+afterEach(() => {
+  for (const sink of sinks) removeLogSink(sink.sink);
+  sinks.length = 0;
+});
+
+function failedRef(): ImageResourceReference {
+  return {
+    basePath: null,
+    failure: { kind: ImageResourceFailureKind.Error, message: 'bad image', name: 'CodecError' },
+    kind: ImageResourceReferenceKind.External,
+    mimeType: null,
+    state: ResourceResolutionState.Failed,
+    uri: 'bad.png',
+  };
+}
+
+describe('areScene3DResourceFailureGuardsEnabled', () => {
+  it('tracks resolver-scoped enable and disable state', () => {
+    const resolver = createScene3DResourceResolver();
+    expect(areScene3DResourceFailureGuardsEnabled(resolver)).toBe(false);
+    enableScene3DResourceFailureGuards(resolver);
+    expect(areScene3DResourceFailureGuardsEnabled(resolver)).toBe(true);
+    disableScene3DResourceFailureGuards(resolver);
+    expect(areScene3DResourceFailureGuardsEnabled(resolver)).toBe(false);
+    disposeScene3DResourceResolver(resolver);
+  });
+});
+
+describe('disableScene3DResourceFailureGuards', () => {
+  it('is harmless when the guard is absent', () => {
+    const resolver = createScene3DResourceResolver();
+    expect(() => disableScene3DResourceFailureGuards(resolver)).not.toThrow();
+    disposeScene3DResourceResolver(resolver);
+  });
+});
+
+describe('enableScene3DResourceFailureGuards', () => {
+  it('warns once per failed attempt, names recovery, and does not change resolver settlement', () => {
+    const sink = createMemoryLogSink(4);
+    sinks.push(sink);
+    addLogSink(sink.sink);
+    const resolver = createScene3DResourceResolver();
+    const signals = enableScene3DResourceSignals(resolver);
+    const texture = createTexture({ resource: failedRef() });
+    const dispose = enableScene3DResourceFailureGuards(resolver);
+    const event = { ref: texture.resource!, texture };
+
+    expect(() => emitSignal(signals.onResourceFailed, event)).not.toThrow();
+    emitSignal(signals.onResourceFailed, event);
+    const entries = getMemoryLogSinkEntries(sink);
+    expect(entries).toHaveLength(1);
+    expect(entries[0]).toMatchObject({ channel: 'scene-resources', level: LogLevel.Warn });
+    expect(entries[0]?.data).toMatchObject({
+      failureKind: ImageResourceFailureKind.Error,
+      failureMessage: 'bad image',
+      failureName: 'CodecError',
+      message:
+        'resolveScene3DResources: image resource resolution failed — call retryFailedScene3DResources to request it again',
+    });
+    expect(texture.resource?.state).toBe(ResourceResolutionState.Failed);
+
+    emitSignal(signals.onResourceResolved, event);
+    texture.resource!.failure = {
+      kind: ImageResourceFailureKind.Unavailable,
+      message: 'still unavailable',
+      name: null,
+    };
+    emitSignal(signals.onResourceFailed, event);
+    expect(getMemoryLogSinkEntries(sink)).toHaveLength(2);
+    dispose();
+    emitSignal(signals.onResourceResolved, event);
+    emitSignal(signals.onResourceFailed, event);
+    expect(getMemoryLogSinkEntries(sink)).toHaveLength(2);
+    disposeScene3DResourceResolver(resolver);
+  });
+
+  it('is idempotent for one resolver', () => {
+    const sink = createMemoryLogSink(4);
+    sinks.push(sink);
+    addLogSink(sink.sink);
+    const resolver = createScene3DResourceResolver();
+    const signals = enableScene3DResourceSignals(resolver);
+    const texture = createTexture({ resource: failedRef() });
+    const firstDispose = enableScene3DResourceFailureGuards(resolver);
+    const secondDispose = enableScene3DResourceFailureGuards(resolver);
+
+    emitSignal(signals.onResourceFailed, { ref: texture.resource!, texture });
+    expect(getMemoryLogSinkEntries(sink)).toHaveLength(1);
+    secondDispose();
+    expect(areScene3DResourceFailureGuardsEnabled(resolver)).toBe(false);
+    firstDispose();
+    disposeScene3DResourceResolver(resolver);
+  });
+});

package/src/getScene3DResourceTextures.test.ts

@@ -0,0 +1,101 @@
+import { createStandardPbrMaterial, createUnlitMaterial } from '@flighthq/materials';
+import { createBoxMeshGeometry } from '@flighthq/mesh';
+import { addNodeChild } from '@flighthq/node';
+import { createMesh, createScene3D } from '@flighthq/scene3d';
+import { createTexture } from '@flighthq/texture';
+import type { ImageResourceReference, Texture } from '@flighthq/types';
+import { ResourceResolutionState, ImageResourceReferenceKind } from '@flighthq/types';
+import { describe, expect, it } from 'vitest';
+
+import { getScene3DResourceTextures } from './getScene3DResourceTextures';
+import {
+  createScene3DMaterialTextureRegistry,
+  registerBuiltInScene3DMaterialTextures,
+} from './sceneMaterialTextureRegistry';
+
+function embeddedRef(state: ResourceResolutionState = ResourceResolutionState.Unresolved): ImageResourceReference {
+  return {
+    bytes: new Uint8Array([1, 2, 3]),
+    failure: null,
+    kind: ImageResourceReferenceKind.Embedded,
+    mimeType: 'image/png',
+    state,
+  };
+}
+
+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 root = createMesh(createBoxMeshGeometry(), [createUnlitMaterial({ baseColorMap: rootMap })]);
+    const child = createMesh(createBoxMeshGeometry(), [createUnlitMaterial({ baseColorMap: childMap })]);
+    addNodeChild(root, child);
+
+    const out: Texture[] = [];
+    getScene3DResourceTextures(root, registry(), out);
+    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]);
+  });
+
+  it('dedupes a texture shared across meshes and materials', () => {
+    const shared = createTexture({ resource: embeddedRef() });
+    const scene = createScene3D();
+    const a = createMesh(createBoxMeshGeometry(), [
+      createUnlitMaterial({ baseColorMap: shared }),
+      createStandardPbrMaterial({ baseColorMap: shared }),
+    ]);
+    const b = createMesh(createBoxMeshGeometry(), [createUnlitMaterial({ baseColorMap: shared })]);
+    addNodeChild(scene.root, a);
+    addNodeChild(scene.root, b);
+
+    const out: Texture[] = [];
+    getScene3DResourceTextures(scene.root, registry(), out);
+    expect(out).toEqual([shared]);
+  });
+
+  it('ignores a texture that carries no resource ref', () => {
+    const bound = createTexture();
+    const pending = createTexture({ resource: embeddedRef() });
+    const mesh = createMesh(createBoxMeshGeometry(), [
+      createStandardPbrMaterial({ baseColorMap: bound, normalMap: pending }),
+    ]);
+
+    const out: Texture[] = [];
+    getScene3DResourceTextures(mesh, registry(), out);
+    expect(out).toEqual([pending]);
+  });
+
+  it('skips null material slots', () => {
+    const map = createTexture({ resource: embeddedRef() });
+    const mesh = createMesh(createBoxMeshGeometry(), [null, createUnlitMaterial({ baseColorMap: map })]);
+    const out: Texture[] = [];
+    getScene3DResourceTextures(mesh, registry(), out);
+    expect(out).toEqual([map]);
+  });
+
+  it('clears out before filling it', () => {
+    const map = createTexture({ resource: embeddedRef() });
+    const mesh = createMesh(createBoxMeshGeometry(), [createUnlitMaterial({ baseColorMap: map })]);
+    const out: Texture[] = [createTexture(), createTexture()];
+    getScene3DResourceTextures(mesh, registry(), out);
+    expect(out).toEqual([map]);
+  });
+});

package/src/gltfLoad.test.ts

@@ -0,0 +1,118 @@
+import type * as NetModule from '@flighthq/net';
+import type * as Scene3DFormatsModule from '@flighthq/scene3d-formats';
+import type { NetResponse, Scene3DDocument } from '@flighthq/types';
+import type { Mock } from 'vitest';
+import { afterAll, afterEach, beforeAll, describe, expect, it, vi } from 'vitest';
+
+import type * as LoadGltfModule from './gltfLoad';
+
+let loadScene3DDocumentFromGlbUrl: typeof LoadGltfModule.loadScene3DDocumentFromGlbUrl;
+let loadScene3DDocumentFromGltfUrl: typeof LoadGltfModule.loadScene3DDocumentFromGltfUrl;
+let parseGlb: Mock<typeof Scene3DFormatsModule.parseGlb>;
+let parseGltf: Mock<typeof Scene3DFormatsModule.parseGltf>;
+let sendNetRequest: Mock<typeof NetModule.sendNetRequest>;
+
+function emptyDocument(): Scene3DDocument {
+  return {
+    animations: [],
+    cameras: [],
+    lights: [],
+    materials: [],
+    meshes: [],
+    metadata: null,
+    nodes: [],
+    resources: [],
+    scenes: [],
+    skins: [],
+  };
+}
+
+function response(body: string | ArrayBuffer, url = 'u'): NetResponse {
+  return { body, headers: {}, ok: true, status: 200, statusText: 'OK', url };
+}
+
+beforeAll(async () => {
+  vi.resetModules();
+  parseGlb = vi.fn<typeof Scene3DFormatsModule.parseGlb>();
+  parseGltf = vi.fn<typeof Scene3DFormatsModule.parseGltf>();
+  sendNetRequest = vi.fn<typeof NetModule.sendNetRequest>();
+  vi.doMock('@flighthq/net', () => ({ sendNetRequest }));
+  vi.doMock('@flighthq/scene3d-formats', () => ({ parseGlb, parseGltf }));
+  ({ loadScene3DDocumentFromGlbUrl, loadScene3DDocumentFromGltfUrl } = await import('./gltfLoad'));
+});
+
+afterAll(() => {
+  vi.doUnmock('@flighthq/net');
+  vi.doUnmock('@flighthq/scene3d-formats');
+  vi.resetModules();
+});
+
+afterEach(() => {
+  parseGlb.mockReset();
+  parseGltf.mockReset();
+  sendNetRequest.mockReset();
+});
+
+describe('loadScene3DDocumentFromGlbUrl', () => {
+  it('fetches bytes, carries the source base path, and returns a CPU document', async () => {
+    const document = emptyDocument();
+    parseGlb.mockReturnValue(document);
+    sendNetRequest.mockResolvedValue(response(new Uint8Array([1, 2, 3]).buffer));
+
+    const loaded = await loadScene3DDocumentFromGlbUrl('models/ship.glb');
+
+    expect(Array.from(parseGlb.mock.calls[0][0])).toEqual([1, 2, 3]);
+    expect(parseGlb.mock.calls[0][2]).toEqual({ basePath: 'models' });
+    expect(loaded).toBe(document);
+  });
+
+  it('returns null rather than an empty document on transport failure', async () => {
+    sendNetRequest.mockResolvedValue({
+      body: null,
+      headers: {},
+      ok: false,
+      status: 404,
+      statusText: 'x',
+      url: 'u',
+    });
+
+    await expect(loadScene3DDocumentFromGlbUrl('missing.glb')).resolves.toBeNull();
+    expect(parseGlb).not.toHaveBeenCalled();
+  });
+});
+
+describe('loadScene3DDocumentFromGltfUrl', () => {
+  it('fetches external geometry buffers and supplies the image base path to parsing', async () => {
+    const document = emptyDocument();
+    parseGltf.mockReturnValue(document);
+    const requested: string[] = [];
+    sendNetRequest.mockImplementation(async (request) => {
+      requested.push(request.url);
+      return request.url.endsWith('.gltf')
+        ? response('{"asset":{"version":"2.0"},"buffers":[{"byteLength":2,"uri":"mesh.bin"}]}')
+        : response(new Uint8Array([8, 9]).buffer);
+    });
+
+    const loaded = await loadScene3DDocumentFromGltfUrl('models/ship.gltf');
+
+    expect(requested).toEqual(['models/ship.gltf', 'models/mesh.bin']);
+    expect(parseGltf.mock.calls[0][2]).toEqual({
+      basePath: 'models',
+      externalBuffers: { 'mesh.bin': new Uint8Array([8, 9]) },
+    });
+    expect(loaded).toBe(document);
+  });
+
+  it('returns null when JSON or a required external buffer cannot load', async () => {
+    sendNetRequest.mockResolvedValue(response('{'));
+    await expect(loadScene3DDocumentFromGltfUrl('broken.gltf')).resolves.toBeNull();
+
+    sendNetRequest.mockImplementation(async (request) =>
+      request.url.endsWith('.gltf')
+        ? response('{"asset":{"version":"2.0"},"buffers":[{"byteLength":2,"uri":"missing.bin"}]}')
+        : { body: null, headers: {}, ok: false, status: 404, statusText: 'x', url: request.url },
+    );
+    await expect(loadScene3DDocumentFromGltfUrl('models/ship.gltf')).resolves.toBeNull();
+    expect(parseGltf).not.toHaveBeenCalled();
+  });
+});

package/src/imageResourceFetch.test.ts

@@ -0,0 +1,95 @@
+import type * as ImageModule from '@flighthq/image';
+import type { ExternalImageResourceReference, ImageResource } from '@flighthq/types';
+import { ResourceResolutionState, ImageResourceReferenceKind } from '@flighthq/types';
+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;
+type LoadImageResourceFromUrl = typeof ImageModule.loadImageResourceFromUrl;
+
+let fetchWebImageResource: typeof ImageResourceFetchModule.fetchWebImageResource;
+let loadFromUrl: Mock<LoadImageResourceFromUrl>;
+let resolveImageResourceUri: typeof ImageResourceFetchModule.resolveImageResourceUri;
+
+function externalRef(uri: string, basePath: string | null): ExternalImageResourceReference {
+  return {
+    basePath,
+    failure: null,
+    kind: ImageResourceReferenceKind.External,
+    mimeType: null,
+    state: ResourceResolutionState.Unresolved,
+    uri,
+  };
+}
+
+beforeAll(async () => {
+  vi.resetModules();
+  loadFromUrl = vi.fn<LoadImageResourceFromUrl>();
+  vi.doMock('@flighthq/image', () => ({
+    loadImageResourceFromBytes: vi.fn(),
+    loadImageResourceFromUrl: loadFromUrl,
+  }));
+  ({ fetchWebImageResource, resolveImageResourceUri } = await import('./imageResourceFetch'));
+});
+
+afterAll(() => {
+  vi.doUnmock('@flighthq/image');
+  vi.resetModules();
+});
+
+afterEach(() => {
+  loadFromUrl.mockReset();
+});
+
+describe('fetchWebImageResource', () => {
+  it('fetches the resolved URL and returns the decoded image', async () => {
+    loadFromUrl.mockResolvedValue(fakeImage);
+    const result = await fetchWebImageResource(
+      externalRef('leaf.png', 'assets/textures'),
+      new AbortController().signal,
+    );
+    expect(loadFromUrl).toHaveBeenCalledWith('assets/textures/leaf.png', undefined, expect.anything());
+    expect(result).toBe(fakeImage);
+  });
+
+  it('returns null on a non-abort failure', async () => {
+    loadFromUrl.mockRejectedValue(new Error('404'));
+    const result = await fetchWebImageResource(externalRef('missing.png', null), new AbortController().signal);
+    expect(result).toBeNull();
+  });
+
+  it('rethrows when the signal aborted (a cancellation, not a failure)', async () => {
+    const controller = new AbortController();
+    controller.abort();
+    loadFromUrl.mockRejectedValue(new Error('aborted'));
+    await expect(fetchWebImageResource(externalRef('x.png', null), controller.signal)).rejects.toThrow();
+  });
+});
+
+describe('resolveImageResourceUri', () => {
+  it('joins a relative uri to a base path', () => {
+    expect(resolveImageResourceUri('leaf.png', 'assets/tex')).toBe('assets/tex/leaf.png');
+  });
+
+  it('does not double the separator when the base ends with a slash', () => {
+    expect(resolveImageResourceUri('leaf.png', 'assets/tex/')).toBe('assets/tex/leaf.png');
+  });
+
+  it('keeps a scheme-absolute uri verbatim', () => {
+    expect(resolveImageResourceUri('https://cdn.test/leaf.png', 'assets/tex')).toBe('https://cdn.test/leaf.png');
+  });
+
+  it('keeps a data uri verbatim', () => {
+    expect(resolveImageResourceUri('data:image/png;base64,AAAA', 'assets/tex')).toBe('data:image/png;base64,AAAA');
+  });
+
+  it('keeps a root-absolute uri verbatim', () => {
+    expect(resolveImageResourceUri('/textures/leaf.png', 'assets/tex')).toBe('/textures/leaf.png');
+  });
+
+  it('returns a relative uri unchanged when the base path is null', () => {
+    expect(resolveImageResourceUri('leaf.png', null)).toBe('leaf.png');
+  });
+});

package/src/md2Load.test.ts

@@ -0,0 +1,63 @@
+import type * as NetModule from '@flighthq/net';
+import type * as Scene3DFormatsModule from '@flighthq/scene3d-formats';
+import type { NetResponse, Scene3DDocument } from '@flighthq/types';
+import type { Mock } from 'vitest';
+import { afterAll, afterEach, beforeAll, describe, expect, it, vi } from 'vitest';
+
+import type * as LoadMd2Module from './md2Load';
+
+let loadScene3DDocumentFromMd2Url: typeof LoadMd2Module.loadScene3DDocumentFromMd2Url;
+let parseMd2: Mock<typeof Scene3DFormatsModule.parseMd2>;
+let sendNetRequest: Mock<typeof NetModule.sendNetRequest>;
+
+function emptyDocument(): Scene3DDocument {
+  return {
+    animations: [],
+    cameras: [],
+    lights: [],
+    materials: [],
+    meshes: [],
+    metadata: null,
+    nodes: [],
+    resources: [],
+    scenes: [],
+    skins: [],
+  };
+}
+
+function okResponse(body: ArrayBuffer): NetResponse {
+  return { body, headers: {}, ok: true, status: 200, statusText: 'OK', url: 'u' };
+}
+
+beforeAll(async () => {
+  vi.resetModules();
+  parseMd2 = vi.fn<typeof Scene3DFormatsModule.parseMd2>();
+  sendNetRequest = vi.fn<typeof NetModule.sendNetRequest>();
+  vi.doMock('@flighthq/net', () => ({ sendNetRequest }));
+  vi.doMock('@flighthq/scene3d-formats', () => ({ parseMd2 }));
+  ({ loadScene3DDocumentFromMd2Url } = await import('./md2Load'));
+});
+
+afterAll(() => {
+  vi.doUnmock('@flighthq/net');
+  vi.doUnmock('@flighthq/scene3d-formats');
+  vi.resetModules();
+});
+
+afterEach(() => {
+  parseMd2.mockReset();
+  sendNetRequest.mockReset();
+});
+
+describe('loadScene3DDocumentFromMd2Url', () => {
+  it('fetches bytes and returns the parsed CPU document without resolving resources', async () => {
+    const document = emptyDocument();
+    parseMd2.mockReturnValue(document);
+    sendNetRequest.mockResolvedValue(okResponse(new Uint8Array([7]).buffer));
+
+    const loaded = await loadScene3DDocumentFromMd2Url('model.md2');
+
+    expect(Array.from(parseMd2.mock.calls[0][0])).toEqual([7]);
+    expect(loaded).toBe(document);
+  });
+});

package/src/md5Load.test.ts

@@ -0,0 +1,63 @@
+import type * as NetModule from '@flighthq/net';
+import type * as Scene3DFormatsModule from '@flighthq/scene3d-formats';
+import type { NetResponse, Scene3DDocument } from '@flighthq/types';
+import type { Mock } from 'vitest';
+import { afterAll, afterEach, beforeAll, describe, expect, it, vi } from 'vitest';
+
+import type * as LoadMd5Module from './md5Load';
+
+let loadScene3DDocumentFromMd5MeshUrl: typeof LoadMd5Module.loadScene3DDocumentFromMd5MeshUrl;
+let parseMd5Mesh: Mock<typeof Scene3DFormatsModule.parseMd5Mesh>;
+let sendNetRequest: Mock<typeof NetModule.sendNetRequest>;
+
+function emptyDocument(): Scene3DDocument {
+  return {
+    animations: [],
+    cameras: [],
+    lights: [],
+    materials: [],
+    meshes: [],
+    metadata: null,
+    nodes: [],
+    resources: [],
+    scenes: [],
+    skins: [],
+  };
+}
+
+function okResponse(body: string): NetResponse {
+  return { body, headers: {}, ok: true, status: 200, statusText: 'OK', url: 'u' };
+}
+
+beforeAll(async () => {
+  vi.resetModules();
+  parseMd5Mesh = vi.fn<typeof Scene3DFormatsModule.parseMd5Mesh>();
+  sendNetRequest = vi.fn<typeof NetModule.sendNetRequest>();
+  vi.doMock('@flighthq/net', () => ({ sendNetRequest }));
+  vi.doMock('@flighthq/scene3d-formats', () => ({ parseMd5Mesh }));
+  ({ loadScene3DDocumentFromMd5MeshUrl } = await import('./md5Load'));
+});
+
+afterAll(() => {
+  vi.doUnmock('@flighthq/net');
+  vi.doUnmock('@flighthq/scene3d-formats');
+  vi.resetModules();
+});
+
+afterEach(() => {
+  parseMd5Mesh.mockReset();
+  sendNetRequest.mockReset();
+});
+
+describe('loadScene3DDocumentFromMd5MeshUrl', () => {
+  it('fetches text and returns the parsed CPU document without resolving resources', async () => {
+    const document = emptyDocument();
+    parseMd5Mesh.mockReturnValue(document);
+    sendNetRequest.mockResolvedValue(okResponse('MD5Version 10'));
+
+    const loaded = await loadScene3DDocumentFromMd5MeshUrl('model.md5mesh');
+
+    expect(parseMd5Mesh).toHaveBeenCalledWith('MD5Version 10');
+    expect(loaded).toBe(document);
+  });
+});

package/src/objLoad.test.ts

@@ -0,0 +1,63 @@
+import type * as NetModule from '@flighthq/net';
+import type * as Scene3DFormatsModule from '@flighthq/scene3d-formats';
+import type { NetResponse, Scene3DDocument } from '@flighthq/types';
+import type { Mock } from 'vitest';
+import { afterAll, afterEach, beforeAll, describe, expect, it, vi } from 'vitest';
+
+import type * as LoadObjModule from './objLoad';
+
+let loadScene3DDocumentFromObjUrl: typeof LoadObjModule.loadScene3DDocumentFromObjUrl;
+let parseObj: Mock<typeof Scene3DFormatsModule.parseObj>;
+let sendNetRequest: Mock<typeof NetModule.sendNetRequest>;
+
+function emptyDocument(): Scene3DDocument {
+  return {
+    animations: [],
+    cameras: [],
+    lights: [],
+    materials: [],
+    meshes: [],
+    metadata: null,
+    nodes: [],
+    resources: [],
+    scenes: [],
+    skins: [],
+  };
+}
+
+function okResponse(body: string): NetResponse {
+  return { body, headers: {}, ok: true, status: 200, statusText: 'OK', url: 'u' };
+}
+
+beforeAll(async () => {
+  vi.resetModules();
+  parseObj = vi.fn<typeof Scene3DFormatsModule.parseObj>();
+  sendNetRequest = vi.fn<typeof NetModule.sendNetRequest>();
+  vi.doMock('@flighthq/net', () => ({ sendNetRequest }));
+  vi.doMock('@flighthq/scene3d-formats', () => ({ parseObj }));
+  ({ loadScene3DDocumentFromObjUrl } = await import('./objLoad'));
+});
+
+afterAll(() => {
+  vi.doUnmock('@flighthq/net');
+  vi.doUnmock('@flighthq/scene3d-formats');
+  vi.resetModules();
+});
+
+afterEach(() => {
+  parseObj.mockReset();
+  sendNetRequest.mockReset();
+});
+
+describe('loadScene3DDocumentFromObjUrl', () => {
+  it('fetches text and returns the parsed CPU document without resolving resources', async () => {
+    const document = emptyDocument();
+    parseObj.mockReturnValue(document);
+    sendNetRequest.mockResolvedValue(okResponse('v 0 0 0'));
+
+    const loaded = await loadScene3DDocumentFromObjUrl('model.obj');
+
+    expect(parseObj).toHaveBeenCalledWith('v 0 0 0', undefined);
+    expect(loaded).toBe(document);
+  });
+});