@forgeax/engine-fbx 0.1.2

package/scripts/fetch-wasm.mjs

@@ -0,0 +1,91 @@
+#!/usr/bin/env node
+// fetch-wasm.mjs — Download the pre-built fbx-wasm pkg/ bundle from GitHub
+// Releases so no-Emscripten consumers (Studio setup, editor standalone, CI
+// typecheck, fresh clones) can resolve @forgeax/engine-fbx without an emcc
+// toolchain.
+//
+// Like @forgeax/engine-wgpu-wasm and @forgeax/engine-codec, the fbx pkg/ carries
+// TWO files emcc emits together — fbx-wasm.wasm + its self-loading fbx-wasm.mjs
+// glue (MODULARIZE + EXPORT_ES6). src/index.ts imports the .mjs glue at runtime,
+// so fetching only the .wasm would leave consumers without a loader. The release
+// asset is therefore the WHOLE pkg/ packed as a content-keyed .tar.gz; this
+// script downloads and extracts it into packages/fbx/pkg/.
+//
+// The content key (see content-key.mjs) is the SSOT shared with the CI publish
+// job, so producer and consumer always agree on the asset name.
+//
+// Usage:
+//   pnpm -F @forgeax/engine-fbx fetch-wasm
+//   node scripts/fetch-wasm.mjs
+//
+// Environment:
+//   GITHUB_TOKEN — optional Bearer token for private-repo auth. Falls back to
+//   `gh auth token`. Anonymous requests work for public repos.
+//
+// Exit codes: 0 on success; 1 on any FetchError. Callers that want a build
+// fallback treat a non-zero exit as "release unavailable, compile via
+// build:wasm" (graceful degradation: architecture-principles #9).
+
+import { rm, readdir } from 'node:fs/promises';
+import { join } from 'node:path';
+
+import { FetchError, getGitOrigin, getReleaseAsset, downloadAsset, extractTarball } from '../../../scripts/lib/fetch-wasm-lib.mjs';
+import { PKG_ROOT, RELEASE_TAG, resolveAsset } from './content-key.mjs';
+
+const PKG_DIR = join(PKG_ROOT, 'pkg');
+const TMP_TARBALL = join(PKG_ROOT, '.pkg-fetch.tar.gz');
+
+const PKG_LABEL = 'fbx-wasm';
+const BUILD_HINT =
+  'compile locally with `pnpm -F @forgeax/engine-fbx build:wasm` (needs the Emscripten emcc toolchain)';
+
+// ---------------------------------------------------------------------------
+// Main
+// ---------------------------------------------------------------------------
+
+async function main() {
+  console.log('Resolving git origin...');
+  const { owner, repo } = getGitOrigin();
+  console.log(`  origin: ${owner}/${repo}`);
+
+  console.log('Computing content key (bridge.c + fetch-ufbx.mjs + build-wasm.mjs)...');
+  const { sha256, assetName } = await resolveAsset();
+  console.log(`  content SHA256: ${sha256}`);
+  console.log(`  asset name:     ${assetName}`);
+
+  console.log(`Fetching release tag "${RELEASE_TAG}" from ${owner}/${repo}...`);
+  const asset = await getReleaseAsset(owner, repo, RELEASE_TAG, assetName, {
+    pkgLabel: PKG_LABEL,
+    buildHint: BUILD_HINT,
+    missingAssetHint:
+      'bridge.c or the fbx build scripts have uncommitted changes, or the release for this content is not yet published.',
+  });
+
+  console.log(`Downloading ${assetName} (${(asset.size / 1024).toFixed(0)} KB)...`);
+  await downloadAsset(asset, TMP_TARBALL, {
+    owner,
+    repo,
+    tag: RELEASE_TAG,
+    pkgLabel: PKG_LABEL,
+    buildHint: BUILD_HINT,
+  });
+
+  console.log(`Extracting into ${PKG_DIR} ...`);
+  await extractTarball(TMP_TARBALL, PKG_DIR);
+  await rm(TMP_TARBALL, { force: true });
+
+  const members = await readdir(PKG_DIR);
+  console.log(`  pkg/ now holds: ${members.join(', ')}`);
+  console.log('Done.');
+}
+
+main().catch(async (e) => {
+  await rm(TMP_TARBALL, { force: true }).catch(() => {});
+  if (e instanceof FetchError) {
+    console.error(`\n[${e.code}] ${e.message}`);
+    console.error(`Hint: ${e.hint}`);
+  } else {
+    console.error('\nUnexpected error:', e.message || e);
+  }
+  process.exit(1);
+});

package/scripts/parity-diff.mjs

@@ -0,0 +1,127 @@
+#!/usr/bin/env node
+// freeze-snapshot.mjs (historically parity-diff.mjs) — re-freeze the parity
+// regression snapshots from live ufbx output.
+//
+// History: during M1 this script double-ran ufbx (WASM) vs the in-repo FBX SDK
+// binding to prove field-for-field parity before the SDK was deleted (M2). Once
+// the SDK left the repo that diff half became unrunnable, so it was removed; the
+// human-signed parity baseline it produced now lives frozen under
+// __tests__/__snapshots__/ and parity-snapshot.test.ts asserts live ufbx output
+// against it (see that file's header). What remains here is the re-freeze tool:
+// it recomputes the compact structural digest from live ufbx and overwrites the
+// snapshots. Re-freezing changes the human-signed baseline, so run it only with
+// a deliberate parity re-sign (charter: Human as Final Authority).
+//
+// Usage:
+//   pnpm -F @forgeax/engine-fbx build          # dist/ must be current
+//   node scripts/parity-diff.mjs               # print each sample's digest
+//   node scripts/parity-diff.mjs --freeze      # overwrite __tests__/__snapshots__/*.json
+//
+// The digest() below MUST stay identical to parity-snapshot.test.ts's copy so
+// the freeze and the assertion agree (the .mjs script and the .ts test cannot
+// cleanly import each other).
+
+import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { initFbxWasm, parseFbxToObject } from '../dist/index.mjs';
+
+const HERE = dirname(fileURLToPath(import.meta.url));
+const PKG = join(HERE, '..');
+const VENDOR = join(PKG, '../../forgeax-engine-assets/vendor/fbx-test');
+const SNAP_DIR = join(PKG, '__tests__/__snapshots__');
+
+const SAMPLES = ['cube', 'humanoid'];
+
+const ufbxRaw = (name) =>
+  parseFbxToObject(new Uint8Array(readFileSync(join(VENDOR, `${name}.fbx`))));
+
+// A compact, git-friendly structural digest of the raw ufbx output. The full
+// raw dump is ~13 MB (dense 9s animation keyframes) — too large to commit — so
+// the frozen snapshot captures the parity-critical structure plus representative
+// value spot-checks. It stays falsifiable: any bridge regression on counts,
+// material, geometry bounds, node roster, or sampled key values trips it.
+function bboxOf(vertices) {
+  const min = [Infinity, Infinity, Infinity];
+  const max = [-Infinity, -Infinity, -Infinity];
+  for (let i = 0; i < vertices.length; i += 3) {
+    for (let k = 0; k < 3; k++) {
+      const v = vertices[i + k];
+      if (v < min[k]) min[k] = v;
+      if (v > max[k]) max[k] = v;
+    }
+  }
+  return { min: min.map((x) => +x.toFixed(4)), max: max.map((x) => +x.toFixed(4)) };
+}
+function digest(raw) {
+  const meshes = (raw.meshes ?? []).map((m) => ({
+    name: m.name,
+    vertexFloats: m.vertices.length,
+    indexCount: (m.indices ?? []).length,
+    bbox: bboxOf(m.vertices),
+    attributes: Object.keys(m.attributes ?? {}).sort(),
+  }));
+  const nodes = (raw.nodes ?? []).map((n) => n.name);
+  const materials = (raw.materials ?? []).map((m) => ({
+    name: m.name,
+    kind: m.kind,
+    ...(m.diffuse && { diffuse: m.diffuse.map((x) => +x.toFixed(6)) }),
+    ...(m.shininess !== undefined && { shininess: +m.shininess.toFixed(4) }),
+    ...(m.stingrayProps && { stingrayProps: m.stingrayProps }),
+  }));
+  const clips = (raw.clips ?? []).map((c) => ({
+    name: c.name,
+    duration: +c.duration.toFixed(6),
+    channelCount: c.channels.length,
+    channelsByProperty: {
+      translation: c.channels.filter((ch) => ch.property === 'translation').length,
+      rotation: c.channels.filter((ch) => ch.property === 'rotation').length,
+      scale: c.channels.filter((ch) => ch.property === 'scale').length,
+    },
+    // Spot-check the first channel's first/last key so value regressions trip.
+    firstChannel: c.channels[0] && {
+      targetNode: c.channels[0].targetNode,
+      property: c.channels[0].property,
+      keyCount: c.channels[0].keyTimes.length,
+      firstKeyValues: c.channels[0].keyValues.slice(0, 4).map((x) => +x.toFixed(4)),
+    },
+  }));
+  const skeletons = (raw.skeletons ?? []).map((s) => ({
+    jointCount: s.jointCount,
+    jointPaths: s.jointPaths,
+  }));
+  const skins = (raw.skins ?? []).map((s) => ({
+    meshSourceIndex: s.meshSourceIndex,
+    vertexCount: s.vertexCount,
+    jointPathCount: s.jointPaths.length,
+  }));
+  return { meshes, nodes, materials, clips, skeletons, skins };
+}
+
+async function main() {
+  const freeze = process.argv.includes('--freeze');
+  await initFbxWasm();
+
+  const frozen = {};
+  for (const name of SAMPLES) {
+    const raw = ufbxRaw(name);
+    frozen[name] = digest(raw);
+    console.log(`[${name}] ${JSON.stringify(frozen[name]).length} bytes digest`);
+  }
+
+  if (freeze) {
+    mkdirSync(SNAP_DIR, { recursive: true });
+    for (const name of SAMPLES) {
+      const dst = join(SNAP_DIR, `${name}-snapshot.json`);
+      writeFileSync(dst, `${JSON.stringify(frozen[name], null, 2)}\n`);
+      console.log(`froze ${dst}`);
+    }
+  }
+
+  process.exit(0);
+}
+
+main().catch((e) => {
+  console.error(e);
+  process.exit(1);
+});

package/scripts/test-wasm.mjs

@@ -0,0 +1,91 @@
+#!/usr/bin/env node
+// test-wasm.mjs — quick smoke test for the compiled fbx-wasm module.
+// Runs in Node.js (not the browser) using the compiled .mjs + .wasm.
+//
+// Usage: node scripts/test-wasm.mjs <path-to-fbx>
+//   e.g.: node scripts/test-wasm.mjs ../../forgeax-engine-assets/vendor/fbx-test/cube.fbx
+
+import { readFileSync } from 'node:fs';
+import { resolve, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const pkgDir = resolve(__dirname, '..');
+
+// Emscripten builds with ENVIRONMENT=web, but we can make it work in Node
+// by providing a locateFile that resolves the .wasm correctly.
+const wasmPath = resolve(pkgDir, 'pkg', 'fbx-wasm.wasm');
+const wasmBinary = readFileSync(wasmPath);
+
+// Dynamic import of the Emscripten module (Windows needs file:// URLs)
+import { pathToFileURL } from 'node:url';
+const modulePath = pathToFileURL(resolve(pkgDir, 'pkg', 'fbx-wasm.mjs')).href;
+const createModule = (await import(modulePath)).default;
+
+const mod = await createModule({
+  wasmBinary,
+});
+
+// Read the FBX file
+const fbxPath = process.argv[2];
+if (!fbxPath) {
+  console.error('Usage: node scripts/test-wasm.mjs <path-to-fbx>');
+  process.exit(1);
+}
+
+const fbxBytes = readFileSync(resolve(fbxPath));
+console.log(`Parsing: ${fbxPath} (${fbxBytes.length} bytes)`);
+
+const ptr = mod._malloc(fbxBytes.length);
+mod.HEAPU8.set(fbxBytes, ptr);
+mod._parseFbxWasm(ptr, fbxBytes.length);
+mod._free(ptr);
+
+const resultPtr = mod._getResultPtr();
+const resultLen = mod._getResultLen();
+
+if (!resultPtr || !resultLen) {
+  console.error('WASM returned empty result');
+  mod._freeResult();
+  process.exit(1);
+}
+
+const json = mod.UTF8ToString(resultPtr, resultLen);
+mod._freeResult();
+
+const parsed = JSON.parse(json);
+
+if (parsed.error) {
+  console.error('Parse error:', parsed.error);
+  process.exit(1);
+}
+
+console.log('\n=== FBX Parse Result ===');
+console.log(`Meshes:     ${parsed.meshes?.length ?? 0}`);
+console.log(`Nodes:      ${parsed.nodes?.length ?? 0}`);
+console.log(`Materials:  ${parsed.materials?.length ?? 0}`);
+console.log(`Skeletons:  ${parsed.skeletons?.length ?? 0}`);
+console.log(`Skins:      ${parsed.skins?.length ?? 0}`);
+console.log(`Clips:      ${parsed.clips?.length ?? 0}`);
+
+if (parsed.meshes?.length > 0) {
+  const m = parsed.meshes[0];
+  console.log(`\nFirst mesh: "${m.name ?? '(unnamed)'}"`);
+  console.log(`  vertices: ${m.vertices.length / 3} positions`);
+  console.log(`  indices:  ${m.indices?.length ?? 0}`);
+  console.log(`  polygons: ${m.polygonCount}`);
+  console.log(`  attrs:    ${Object.keys(m.attributes).join(', ')}`);
+}
+
+if (parsed.skeletons?.length > 0) {
+  const s = parsed.skeletons[0];
+  console.log(`\nSkeleton: ${s.jointCount} joints`);
+  console.log(`  jointPaths: ${s.jointPaths.slice(0, 5).join(', ')}${s.jointCount > 5 ? '...' : ''}`);
+}
+
+if (parsed.clips?.length > 0) {
+  const c = parsed.clips[0];
+  console.log(`\nFirst clip: "${c.name ?? '(unnamed)'}" (${c.duration.toFixed(3)}s, ${c.channels.length} channels)`);
+}
+
+console.log('\n✅ WASM FBX parsing test passed!');

package/src/__tests__/asset-runtime-fixture.ts

@@ -0,0 +1,251 @@
+import { createHash } from 'node:crypto';
+import {
+  type AssetRegistry,
+  createAssetRegistry,
+  createCatalogSource,
+} from '@forgeax/engine-assets-runtime';
+import { meshAssetDecoder, meshAssetKind } from '@forgeax/engine-geometry';
+import { type DdcPack, normaliseForPack } from '@forgeax/engine-import';
+import type {
+  AssetDecoder,
+  AssetLoadError,
+  MeshAsset,
+  MorphTarget,
+  Result,
+  VertexAttributeMap,
+} from '@forgeax/engine-types';
+import { err } from '@forgeax/engine-types';
+
+const SCOPE_ID = 'fbx-test-scope';
+const GENERATION = 1;
+const PACK_DIGEST = `sha256:${'4'.repeat(64)}`;
+const OUTPUT_SET_DIGEST = `sha256:${'5'.repeat(64)}`;
+const OUTPUT_DIGEST = `sha256:${'6'.repeat(64)}`;
+const ATTRIBUTE_KEYS = [
+  'position',
+  'normal',
+  'uv',
+  'tangent',
+  'skinIndex',
+  'skinWeight',
+  'uv1',
+  'uv2',
+  'uv3',
+  'uv4',
+  'uv5',
+  'uv6',
+  'uv7',
+] as const;
+
+type FixtureAsset = DdcPack['assets'][number];
+
+function sha256(bytes: Uint8Array): string {
+  return `sha256:${createHash('sha256').update(bytes).digest('hex')}`;
+}
+
+function floatArray(value: unknown): Float32Array | undefined {
+  if (value instanceof Float32Array) return value;
+  if (value instanceof ArrayBuffer) return new Float32Array(value);
+  if (ArrayBuffer.isView(value))
+    return new Float32Array(Array.from(value as unknown as ArrayLike<number>));
+  if (Array.isArray(value)) return new Float32Array(value as number[]);
+  return undefined;
+}
+
+function indexArray(value: unknown): Uint16Array | Uint32Array | undefined {
+  if (value instanceof Uint16Array || value instanceof Uint32Array) return value;
+  if (ArrayBuffer.isView(value) || Array.isArray(value)) {
+    const values = Array.from(value as unknown as ArrayLike<number>);
+    return values.some((entry) => entry > 0xffff)
+      ? new Uint32Array(values)
+      : new Uint16Array(values);
+  }
+  return undefined;
+}
+
+function integerAttribute(value: unknown): Uint16Array | undefined {
+  if (value instanceof Uint16Array) return value;
+  if (Array.isArray(value) || ArrayBuffer.isView(value)) {
+    return new Uint16Array(Array.from(value as unknown as ArrayLike<number>));
+  }
+  return undefined;
+}
+
+function morphTarget(value: unknown): MorphTarget | undefined {
+  if (value === null || typeof value !== 'object') return undefined;
+  const source = value as Record<string, unknown>;
+  const position = floatArray(source.position);
+  const normal = floatArray(source.normal);
+  const tangent = floatArray(source.tangent);
+  return {
+    ...(position === undefined ? {} : { position }),
+    ...(normal === undefined ? {} : { normal }),
+    ...(tangent === undefined ? {} : { tangent }),
+  };
+}
+
+function meshPayload(value: unknown): MeshAsset | undefined {
+  if (value === null || typeof value !== 'object') return undefined;
+  const source = value as Record<string, unknown>;
+  const rawAttributes = source.attributes;
+  if (
+    source.kind !== 'mesh' ||
+    floatArray(source.vertices) === undefined ||
+    rawAttributes === null ||
+    typeof rawAttributes !== 'object' ||
+    !Array.isArray(source.submeshes) ||
+    !Array.isArray(source.materialSlots)
+  ) {
+    return undefined;
+  }
+  const attributes: VertexAttributeMap = {};
+  const sourceAttributes = rawAttributes as Record<string, unknown>;
+  for (const key of ATTRIBUTE_KEYS) {
+    const raw = sourceAttributes[key];
+    if (raw === undefined) continue;
+    const converted = key === 'skinIndex' ? integerAttribute(raw) : floatArray(raw);
+    if (converted !== undefined) attributes[key] = converted;
+  }
+  const morphWeights = floatArray(source.morphWeights);
+  const morphTargets = Array.isArray(source.morphTargets)
+    ? source.morphTargets.flatMap((target) => {
+        const converted = morphTarget(target);
+        return converted === undefined ? [] : [converted];
+      })
+    : undefined;
+  const vertices = floatArray(source.vertices) as Float32Array;
+  const indices = indexArray(source.indices);
+  const aabb = floatArray(source.aabb);
+  return {
+    kind: 'mesh',
+    vertices,
+    ...(indices === undefined ? {} : { indices }),
+    attributes,
+    ...(aabb === undefined ? {} : { aabb }),
+    submeshes: source.submeshes as MeshAsset['submeshes'],
+    materialSlots: source.materialSlots as MeshAsset['materialSlots'],
+    ...(morphTargets === undefined ? {} : { morphTargets }),
+    ...(morphWeights === undefined ? {} : { morphWeights }),
+  };
+}
+
+export const normalizedMeshAssetDecoder: AssetDecoder<MeshAsset> = {
+  async decode(input): Promise<Result<MeshAsset, AssetLoadError>> {
+    const body = input.envelope.artifacts.body;
+    if (body !== undefined) {
+      const bytes = await input.artifacts.read(body);
+      if (!bytes.ok) return bytes;
+    }
+    const payload = meshPayload(input.envelope.payload);
+    if (payload === undefined) {
+      return err({
+        code: 'asset-package-invalid',
+        expected: 'a JSON-safe mesh payload that can be owned by Geometry',
+        hint: 'recook the mesh payload with typed vertex and attribute fields',
+        detail: { guid: input.envelope.guid, reason: 'mesh payload normalization failed' },
+      });
+    }
+    return meshAssetDecoder.decode({
+      ...input,
+      envelope: { ...input.envelope, payload },
+    });
+  },
+};
+
+export function installMeshDecoder(assets: AssetRegistry) {
+  return assets.installDecoder(meshAssetKind, normalizedMeshAssetDecoder);
+}
+
+function row(asset: FixtureAsset, packageUrl: string) {
+  const sourcePath = `fixtures/${asset.guid}`;
+  return {
+    guid: asset.guid,
+    packageUrl,
+    kind: asset.kind,
+    sourcePath,
+    revision: { rootId: 'fbx-fixture', digest: 'sha256:catalog', observedAt: 1 },
+    publication: {
+      schemaVersion: 'asset-publication/1' as const,
+      sourcePath,
+      sourceRevision: 'fbx-fixture-source',
+      generation: GENERATION,
+      digest: PACK_DIGEST,
+      outputSetDigest: OUTPUT_SET_DIGEST,
+      outputs: [
+        {
+          guid: asset.guid,
+          sourceKey: asset.sourceKey ?? asset.guid,
+          kind: asset.kind,
+          digest: OUTPUT_DIGEST,
+          refs: asset.refs,
+        },
+      ],
+      receipt: {
+        schemaVersion: 'asset-publication-receipt/1' as const,
+        sourcePath,
+        sourceRevision: 'fbx-fixture-source',
+        inputFingerprint: 'fbx-fixture-input',
+        outputDigest: OUTPUT_DIGEST,
+        outputSetDigest: OUTPUT_SET_DIGEST,
+        externalEvidence: [],
+      },
+      externalEvidence: [],
+    },
+  };
+}
+
+export function createAssetRuntimeFixture(sourceAssets: readonly FixtureAsset[]): AssetRegistry {
+  const packageUrl = 'https://assets.test/fbx-fixture.pack.json';
+  const artifactBytes = new Map<string, Uint8Array>();
+  const runtimeAssets = sourceAssets.map((asset) => {
+    const artifacts = Object.fromEntries(
+      Object.entries(asset.artifacts).map(([key, body]) => {
+        const path = `${asset.guid}/${key}.bin`;
+        const url = new URL(path, packageUrl).toString();
+        artifactBytes.set(url, body.bytes);
+        return [
+          key,
+          {
+            path,
+            mediaType: body.mediaType,
+            contentEncoding: 'identity' as const,
+            byteLength: body.bytes.byteLength,
+            integrity: { algorithm: 'sha256' as const, digest: sha256(body.bytes) },
+            ...(body.assetCodec === undefined ? {} : { assetCodec: body.assetCodec }),
+          },
+        ];
+      }),
+    );
+    return {
+      guid: asset.guid,
+      kind: asset.kind,
+      ...(asset.name === undefined ? {} : { name: asset.name }),
+      payload: normaliseForPack(asset.payload) as Record<string, unknown>,
+      refs: asset.refs,
+      artifacts,
+    };
+  });
+  const pack = {
+    schemaVersion: '2.0.0' as const,
+    kind: 'internal-text-package' as const,
+    scopeId: SCOPE_ID,
+    generation: GENERATION,
+    digest: PACK_DIGEST,
+    outputSetDigest: OUTPUT_SET_DIGEST,
+    assets: runtimeAssets,
+  };
+  const fetcher: typeof globalThis.fetch = async (input) => {
+    const url = String(input);
+    if (url === packageUrl) return new Response(JSON.stringify(pack));
+    const bytes = artifactBytes.get(url);
+    return bytes === undefined
+      ? new Response('not found', { status: 404 })
+      : new Response(bytes as unknown as BodyInit);
+  };
+  return createAssetRegistry({
+    catalog: createCatalogSource({ entries: sourceAssets.map((asset) => row(asset, packageUrl)) }),
+    fetcher,
+    scopeId: SCOPE_ID,
+    generation: GENERATION,
+  });
+}

package/src/__tests__/blendshape-import.integration.test.ts

@@ -0,0 +1,96 @@
+import { World } from '@forgeax/engine-ecs';
+import { meshAssetKind } from '@forgeax/engine-geometry';
+import { ImporterRegistry, type RunImportMeta, runImport } from '@forgeax/engine-import';
+import { describe, expect, it } from 'vitest';
+import { fbxImporter } from '../fbx-importer.js';
+import { initFbxWasm, parseFbx } from '../index.js';
+import { createAssetRuntimeFixture, installMeshDecoder } from './asset-runtime-fixture';
+
+const MESH_GUID = 'aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa';
+const sourceUrl = new URL(
+  '../../../../apps/hello/format-tier1/fixtures/multi-target-morph.fbx',
+  import.meta.url,
+);
+
+async function readFixture(url: URL): Promise<Uint8Array> {
+  const nodeFs = (await import('node:' + 'fs/promises')) as unknown as {
+    readonly readFile: (path: URL) => Promise<Uint8Array>;
+  };
+  return new Uint8Array(await nodeFs.readFile(url));
+}
+
+function meta(): RunImportMeta {
+  return {
+    importer: 'fbx',
+    source: 'apps/hello/format-tier1/fixtures/multi-target-morph.fbx',
+    subAssets: [
+      { guid: MESH_GUID, sourceIndex: 0, sourceKey: 'fbx:mesh:MorphTriangle', kind: 'mesh' },
+    ],
+  };
+}
+
+describe('real FBX BlendShape import through ufbx WASM', () => {
+  it('keeps source target order, authored weights, and target lengths', async () => {
+    const bytes = await readFixture(sourceUrl);
+    await initFbxWasm();
+    const raw = JSON.parse(parseFbx(bytes)) as {
+      readonly meshes: readonly {
+        readonly morphTargets?: readonly { readonly position?: readonly number[] }[];
+        readonly morphWeights?: readonly number[];
+      }[];
+    };
+    expect(raw.meshes).toHaveLength(1);
+    expect(raw.meshes[0]?.morphTargets).toHaveLength(2);
+    expect(raw.meshes[0]?.morphTargets?.[0]?.position).toEqual([0, 0, 0, 0.25, 0, 0, 0, 0.5, 0]);
+    expect(raw.meshes[0]?.morphTargets?.[1]?.position).toEqual([0, 0, -0.25, 0, 0, 0, 0, 0, 0]);
+    expect(raw.meshes[0]?.morphWeights).toEqual([0.25, 0.5]);
+
+    const registry = new ImporterRegistry();
+    registry.register(fbxImporter);
+    const fs = { readSource: async () => ({ ok: true as const, value: bytes }) };
+    const result = await runImport(meta(), registry, fs);
+    expect(result.ok).toBe(true);
+    if (!result.ok || 'skipped' in result.value) throw new Error('expected FBX DDC pack');
+    const entry = result.value.pack.assets.find((asset) => asset.guid === MESH_GUID);
+    expect(entry?.kind).toBe('mesh');
+    if (entry === undefined) return;
+    const payload = entry?.payload as {
+      readonly vertices: readonly number[];
+      readonly morphTargets?: readonly { readonly position?: readonly number[] }[];
+      readonly morphWeights?: readonly number[];
+    };
+    expect(payload.morphTargets).toHaveLength(2);
+    expect(payload.morphTargets?.map((target) => target.position?.length)).toEqual([9, 9]);
+    expect(payload.morphWeights).toEqual([0.25, 0.5]);
+    expect(payload.vertices.length).toBe(3 * 12);
+
+    const assets = createAssetRuntimeFixture([entry]);
+    installMeshDecoder(assets);
+    try {
+      const loaded = await assets.load(MESH_GUID, meshAssetKind);
+      expect(loaded.ok).toBe(true);
+      if (!loaded.ok) return;
+      const world = new World();
+      world.internSharedRef('MeshAsset', loaded.value);
+      expect(loaded.value.kind).toBe('mesh');
+      expect(Array.from(loaded.value.morphWeights ?? [])).toEqual([0.25, 0.5]);
+      expect(loaded.value.morphTargets).toHaveLength(2);
+    } finally {
+      assets.dispose();
+    }
+  });
+
+  it('records that this real fixture has no imported animation clip', async () => {
+    const bytes = await readFixture(sourceUrl);
+    await initFbxWasm();
+    const registry = new ImporterRegistry();
+    registry.register(fbxImporter);
+    const fs = { readSource: async () => ({ ok: true as const, value: bytes }) };
+    const result = await runImport(meta(), registry, fs);
+    expect(result.ok).toBe(true);
+    if (!result.ok || 'skipped' in result.value) return;
+    expect(
+      result.value.pack.assets.filter((asset) => asset.kind === 'animation-clip'),
+    ).toHaveLength(0);
+  });
+});