@forgeax/engine-fbx 0.0.0-dev.8d955ade1c79

package/dist/resolve-texture-path.d.ts

@@ -0,0 +1,25 @@
+export type FbxTextureResolutionStrategy = 'exact' | 'case-folded' | 'suffix' | 'basename';
+export interface FbxTexturePathRequest {
+    readonly declaredRelativePath?: string;
+    readonly declaredFilename?: string;
+    readonly declaredAbsolutePath?: string;
+}
+export interface FbxTextureCandidate {
+    /** Candidate path relative to the FBX source file's directory. */
+    readonly relativePath: string;
+}
+export type FbxTextureResolution = {
+    readonly ok: true;
+    readonly relativePath: string;
+    /** URI passed to ImportContext.readSibling from the FBX source. */
+    readonly readUri: string;
+    readonly strategy: FbxTextureResolutionStrategy;
+} | {
+    readonly ok: false;
+    readonly code: 'fbx-external-texture-missing' | 'fbx-external-texture-ambiguous';
+    readonly requestedPath: string;
+    readonly candidates: readonly string[];
+};
+/** Resolve an FBX-declared texture against a caller-authorized candidate tree. */
+export declare function resolveFbxTexturePath(sourcePath: string, request: FbxTexturePathRequest, candidates: readonly FbxTextureCandidate[]): FbxTextureResolution;
+//# sourceMappingURL=resolve-texture-path.d.ts.map

package/dist/resolve-texture-path.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve-texture-path.d.ts","sourceRoot":"","sources":["../src/resolve-texture-path.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,4BAA4B,GAAG,OAAO,GAAG,aAAa,GAAG,QAAQ,GAAG,UAAU,CAAC;AAE3F,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,oBAAoB,CAAC,EAAE,MAAM,CAAC;IACvC,QAAQ,CAAC,gBAAgB,CAAC,EAAE,MAAM,CAAC;IACnC,QAAQ,CAAC,oBAAoB,CAAC,EAAE,MAAM,CAAC;CACxC;AAED,MAAM,WAAW,mBAAmB;IAClC,kEAAkE;IAClE,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;CAC/B;AAED,MAAM,MAAM,oBAAoB,GAC5B;IACE,QAAQ,CAAC,EAAE,EAAE,IAAI,CAAC;IAClB,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,mEAAmE;IACnE,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,QAAQ,EAAE,4BAA4B,CAAC;CACjD,GACD;IACE,QAAQ,CAAC,EAAE,EAAE,KAAK,CAAC;IACnB,QAAQ,CAAC,IAAI,EAAE,8BAA8B,GAAG,gCAAgC,CAAC;IACjF,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,UAAU,EAAE,SAAS,MAAM,EAAE,CAAC;CACxC,CAAC;AA4CN,kFAAkF;AAClF,wBAAgB,qBAAqB,CACnC,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,qBAAqB,EAC9B,UAAU,EAAE,SAAS,mBAAmB,EAAE,GACzC,oBAAoB,CA4EtB"}

package/dist/to-asset-pack.d.ts

@@ -0,0 +1,31 @@
+import type { AnimationClipPod, ImportedAsset, MaterialPod, MeshMaterialSlotTopologyEntry, MeshPod, ScenePod, SkeletonPod, SkinPod, SourceOverrideMap, TexturePod } from '@forgeax/engine-types';
+type SubAsset = {
+    readonly guid: string;
+    readonly sourceIndex: number;
+    readonly kind: string;
+    readonly sourceKey?: string;
+};
+export declare function buildMeshAsset(pod: MeshPod, guid: string, influences?: readonly {
+    jointIndices: Uint16Array;
+    jointWeights: Float32Array;
+}[], materialContext?: {
+    readonly guidByIndex?: ReadonlyMap<number, string>;
+    readonly nameByIndex?: ReadonlyMap<number, string>;
+    readonly sourceKeyByIndex?: ReadonlyMap<number, string>;
+    readonly previousMaterialSlots?: readonly MeshMaterialSlotTopologyEntry[];
+    readonly materialSlotDefaultOverrides?: Readonly<Record<string, string | null>>;
+    readonly meshSourceKey?: string;
+}): ImportedAsset;
+export declare function toAssetPack(params: {
+    readonly meshes: readonly MeshPod[];
+    readonly scene: ScenePod;
+    readonly materials: readonly MaterialPod[];
+    readonly textures: readonly TexturePod[];
+    readonly skeleton: SkeletonPod;
+    readonly skin: SkinPod;
+    readonly animationClips: readonly AnimationClipPod[];
+    readonly subAssets: readonly SubAsset[];
+    readonly sourceOverrides?: SourceOverrideMap;
+}): readonly ImportedAsset[];
+export {};
+//# sourceMappingURL=to-asset-pack.d.ts.map

package/dist/to-asset-pack.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"to-asset-pack.d.ts","sourceRoot":"","sources":["../src/to-asset-pack.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EACV,gBAAgB,EAEhB,aAAa,EAEb,WAAW,EAGX,6BAA6B,EAC7B,OAAO,EAEP,QAAQ,EACR,WAAW,EACX,OAAO,EACP,iBAAiB,EACjB,UAAU,EACX,MAAM,uBAAuB,CAAC;AAS/B,KAAK,QAAQ,GAAG;IACd,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;CAC7B,CAAC;AAWF,wBAAgB,cAAc,CAC5B,GAAG,EAAE,OAAO,EACZ,IAAI,EAAE,MAAM,EACZ,UAAU,CAAC,EAAE,SAAS;IAAE,YAAY,EAAE,WAAW,CAAC;IAAC,YAAY,EAAE,YAAY,CAAA;CAAE,EAAE,EACjF,eAAe,GAAE;IACf,QAAQ,CAAC,WAAW,CAAC,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACnD,QAAQ,CAAC,WAAW,CAAC,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACnD,QAAQ,CAAC,gBAAgB,CAAC,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACxD,QAAQ,CAAC,qBAAqB,CAAC,EAAE,SAAS,6BAA6B,EAAE,CAAC;IAC1E,QAAQ,CAAC,4BAA4B,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC,CAAC,CAAC;IAChF,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC;CAC5B,GACL,aAAa,CAqRf;AAyJD,wBAAgB,WAAW,CAAC,MAAM,EAAE;IAClC,QAAQ,CAAC,MAAM,EAAE,SAAS,OAAO,EAAE,CAAC;IACpC,QAAQ,CAAC,KAAK,EAAE,QAAQ,CAAC;IACzB,QAAQ,CAAC,SAAS,EAAE,SAAS,WAAW,EAAE,CAAC;IAC3C,QAAQ,CAAC,QAAQ,EAAE,SAAS,UAAU,EAAE,CAAC;IACzC,QAAQ,CAAC,QAAQ,EAAE,WAAW,CAAC;IAC/B,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IACvB,QAAQ,CAAC,cAAc,EAAE,SAAS,gBAAgB,EAAE,CAAC;IACrD,QAAQ,CAAC,SAAS,EAAE,SAAS,QAAQ,EAAE,CAAC;IACxC,QAAQ,CAAC,eAAe,CAAC,EAAE,iBAAiB,CAAC;CAC9C,GAAG,SAAS,aAAa,EAAE,CA4O3B"}

package/package.json

@@ -0,0 +1,74 @@
+{
+  "name": "@forgeax/engine-fbx",
+  "version": "0.0.0-dev.8d955ade1c79",
+  "private": false,
+  "type": "module",
+  "license": "MIT",
+  "sideEffects": false,
+  "description": "FBX importer for the forgeax engine via ufbx compiled to WebAssembly. Single parser for both browser and Node; no Autodesk FBX SDK or native addon. Emits the engine FBX POD schema (meshes, nodes, materials, skeletons, skins, clips).",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "main": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist",
+    "pkg",
+    "src",
+    "scripts",
+    "README.md"
+  ],
+  "dependencies": {
+    "@forgeax/engine-animation": "0.0.0-dev.8d955ade1c79",
+    "@forgeax/engine-math": "0.0.0-dev.8d955ade1c79",
+    "@forgeax/engine-pack": "0.0.0-dev.8d955ade1c79",
+    "@forgeax/engine-render": "0.0.0-dev.8d955ade1c79",
+    "@forgeax/engine-scene": "0.0.0-dev.8d955ade1c79",
+    "@forgeax/engine-types": "0.0.0-dev.8d955ade1c79"
+  },
+  "devDependencies": {
+    "@forgeax/engine-assets-runtime": "0.0.0-dev.8d955ade1c79",
+    "@forgeax/engine-import": "0.0.0-dev.8d955ade1c79",
+    "@forgeax/engine-picking": "0.0.0-dev.8d955ade1c79",
+    "@forgeax/engine-runtime": "0.0.0-dev.8d955ade1c79",
+    "@types/node": "^20.14.0"
+  },
+  "forgeax": {
+    "metrics": {
+      "bundle-size": {
+        "enabled": true,
+        "path": "pkg/fbx-wasm.wasm",
+        "compression": "gzip",
+        "expected": 147043
+      },
+      "fps": {
+        "enabled": false,
+        "reason": "parser package: no render loop; FPS is reported by the apps that consume imported FBX assets"
+      },
+      "bench": {
+        "enabled": false,
+        "reason": "no hot-path bench at the FBX parse boundary yet; import cost is one-shot cook, not a per-frame path"
+      },
+      "gate": {
+        "enabled": true,
+        "command": "pnpm --filter @forgeax/engine-fbx test"
+      },
+      "spike-report": {
+        "enabled": false,
+        "reason": "not a spike package; productionised browser FBX parser sized by the bundle-size MetricKind above"
+      }
+    }
+  },
+  "scripts": {
+    "build:wasm": "node scripts/fetch-ufbx.mjs && node scripts/build-wasm.mjs",
+    "fetch-ufbx": "node scripts/fetch-ufbx.mjs",
+    "fetch-wasm": "node scripts/fetch-wasm.mjs",
+    "postinstall": "node scripts/ensure-wasm.mjs",
+    "build": "tsup",
+    "test": "vitest run"
+  }
+}

package/pkg/fbx-wasm.mjs

@@ -0,0 +1,2 @@
+async function Module(moduleArg={}){var Module=moduleArg;var ENVIRONMENT_IS_WEB=!!globalThis.window;var ENVIRONMENT_IS_WORKER=!!globalThis.WorkerGlobalScope;var ENVIRONMENT_IS_NODE=globalThis.process?.versions?.node&&globalThis.process?.type!="renderer";if(ENVIRONMENT_IS_NODE){const{createRequire}=await import("node:module");var require=createRequire(import.meta.url)}var programArgs=[];var thisProgram="./this.program";var quit_=(status,toThrow)=>{throw toThrow};var _scriptName=import.meta.url;var scriptDirectory="";function locateFile(path){if(Module["locateFile"]){return Module["locateFile"](path,scriptDirectory)}return scriptDirectory+path}var readAsync,readBinary;if(ENVIRONMENT_IS_NODE){var fs=require("node:fs");if(_scriptName.startsWith("file:")){scriptDirectory=require("node:path").dirname(require("node:url").fileURLToPath(_scriptName))+"/"}readBinary=filename=>{filename=isFileURI(filename)?new URL(filename):filename;var ret=fs.readFileSync(filename);return ret};readAsync=async(filename,binary=true)=>{filename=isFileURI(filename)?new URL(filename):filename;var ret=fs.readFileSync(filename,binary?undefined:"utf8");return ret};if(process.argv.length>1){thisProgram=process.argv[1].replace(/\\/g,"/")}programArgs=process.argv.slice(2);quit_=(status,toThrow)=>{process.exitCode=status;throw toThrow}}else if(ENVIRONMENT_IS_WEB||ENVIRONMENT_IS_WORKER){try{scriptDirectory=new URL(".",_scriptName).href}catch{}{readAsync=async url=>{var response=await fetch(url,{credentials:"same-origin"});if(response.ok){return response.arrayBuffer()}throw new Error(response.status+" : "+response.url)}}}else{}var out=console.log.bind(console);var err=console.error.bind(console);var wasmBinary;var ABORT=false;var isFileURI=filename=>filename.startsWith("file://");class EmscriptenEH{}class EmscriptenSjLj extends EmscriptenEH{}var runtimeInitialized=false;function getMemoryBuffer(){try{var b=wasmMemory.toResizableBuffer();return b}catch{}return wasmMemory.buffer}function updateMemoryViews(){if(HEAP8?.buffer?.resizable)return;var b=getMemoryBuffer();HEAP8=new Int8Array(b);HEAP16=new Int16Array(b);Module["HEAPU8"]=HEAPU8=new Uint8Array(b);HEAPU16=new Uint16Array(b);HEAP32=new Int32Array(b);HEAPU32=new Uint32Array(b);HEAPF32=new Float32Array(b);HEAPF64=new Float64Array(b);HEAP64=new BigInt64Array(b);HEAPU64=new BigUint64Array(b)}function preRun(){var preRun=Module["preRun"];if(preRun){if(typeof preRun=="function")preRun=[preRun];onPreRuns.push(...preRun)}callRuntimeCallbacks(onPreRuns)}function initRuntime(){runtimeInitialized=true;wasmExports["k"]()}function postRun(){var postRun=Module["postRun"];if(postRun){if(typeof postRun=="function")postRun=[postRun];onPostRuns.push(...postRun)}callRuntimeCallbacks(onPostRuns)}function abort(what){Module["onAbort"]?.(what);what=`Aborted(${what})`;err(what);ABORT=true;what+=". Build with -sASSERTIONS for more info.";var e=new WebAssembly.RuntimeError(what);throw e}var wasmBinaryFile;function findWasmBinary(){if(Module["locateFile"]){return locateFile("fbx-wasm.wasm")}return new URL("fbx-wasm.wasm",import.meta.url).href}function getBinarySync(file){if(readBinary){return readBinary(file)}throw"both async and sync fetching of the wasm failed"}async function getWasmBinary(binaryFile){if(!wasmBinary){try{var response=await readAsync(binaryFile);return new Uint8Array(response)}catch{}}return getBinarySync(binaryFile)}async function instantiateArrayBuffer(binaryFile,imports){try{var binary=await getWasmBinary(binaryFile);var instance=await WebAssembly.instantiate(binary,imports);return instance}catch(reason){err(`failed to asynchronously prepare wasm: ${reason}`);abort(reason)}}async function instantiateAsync(binary,binaryFile,imports){if(!binary&&!ENVIRONMENT_IS_NODE){try{var response=fetch(binaryFile,{credentials:"same-origin"});var instantiationResult=await WebAssembly.instantiateStreaming(response,imports);return instantiationResult}catch(reason){err(`wasm streaming compile failed: ${reason}`);err("falling back to ArrayBuffer instantiation")}}return instantiateArrayBuffer(binaryFile,imports)}function getWasmImports(){var imports={a:wasmImports};return imports}async function createWasm(){function receiveInstance(instance){wasmExports=instance.exports;assignWasmExports(wasmExports);updateMemoryViews();return wasmExports}function receiveInstantiationResult(result){return receiveInstance(result["instance"])}var info=getWasmImports();var instantiateWasm=Module["instantiateWasm"];if(instantiateWasm){return new Promise(resolve=>{instantiateWasm(info,inst=>resolve(receiveInstance(inst)))})}wasmBinaryFile??=findWasmBinary();var result=await instantiateAsync(wasmBinary,wasmBinaryFile,info);var exports=receiveInstantiationResult(result);return exports}class ExitStatus{name="ExitStatus";constructor(status){this.message=`Program terminated with exit(${status})`;this.status=status}}var HEAP16;var HEAP32;var HEAP64;var HEAP8;var HEAPF32;var HEAPF64;var HEAPU16;var HEAPU32;var HEAPU64;var HEAPU8;var callRuntimeCallbacks=callbacks=>{while(callbacks.length>0){callbacks.shift()(Module)}};var onPostRuns=[];var onPreRuns=[];var noExitRuntime=true;var stackRestore=val=>__emscripten_stack_restore(val);var stackSave=()=>_emscripten_stack_get_current();var UTF8Decoder=globalThis.TextDecoder&&new TextDecoder;var findStringEnd=(heapOrArray,idx,maxBytesToRead,ignoreNul)=>{var maxIdx=idx+maxBytesToRead;if(ignoreNul)return maxIdx;while(heapOrArray[idx]&&!(idx>=maxIdx))++idx;return idx};var UTF8ArrayToString=(heapOrArray,idx=0,maxBytesToRead,ignoreNul)=>{var endPtr=findStringEnd(heapOrArray,idx,maxBytesToRead,ignoreNul);if(endPtr-idx>16&&heapOrArray.buffer&&UTF8Decoder){return UTF8Decoder.decode(heapOrArray.subarray(idx,endPtr))}var str="";while(idx<endPtr){var u0=heapOrArray[idx++];if(!(u0&128)){str+=String.fromCharCode(u0);continue}var u1=heapOrArray[idx++]&63;if((u0&224)==192){str+=String.fromCharCode((u0&31)<<6|u1);continue}var u2=heapOrArray[idx++]&63;if((u0&240)==224){u0=(u0&15)<<12|u1<<6|u2}else{u0=(u0&7)<<18|u1<<12|u2<<6|heapOrArray[idx++]&63}if(u0<65536){str+=String.fromCharCode(u0)}else{var ch=u0-65536;str+=String.fromCharCode(55296|ch>>10,56320|ch&1023)}}return str};var UTF8ToString=(ptr,maxBytesToRead,ignoreNul)=>ptr?UTF8ArrayToString(HEAPU8,ptr,maxBytesToRead,ignoreNul):"";var ___assert_fail=(condition,filename,line,func)=>abort(`Assertion failed: ${UTF8ToString(condition)}, at: `+[filename?UTF8ToString(filename):"unknown filename",line,func?UTF8ToString(func):"unknown function"]);var SYSCALLS={varargs:undefined,getStr(ptr){var ret=UTF8ToString(ptr);return ret}};function ___syscall_fcntl64(fd,cmd,varargs){SYSCALLS.varargs=varargs;return 0}function ___syscall_ioctl(fd,op,varargs){SYSCALLS.varargs=varargs;return 0}function ___syscall_openat(dirfd,path,flags,varargs){SYSCALLS.varargs=varargs}var getHeapMax=()=>2147483648;var alignMemory=(size,alignment)=>Math.ceil(size/alignment)*alignment;var growMemory=size=>{var oldHeapSize=wasmMemory.buffer.byteLength;var pages=(size-oldHeapSize+65535)/65536|0;try{wasmMemory.grow(pages);updateMemoryViews();return 1}catch(e){}};var _emscripten_resize_heap=requestedSize=>{var oldSize=HEAPU8.length;requestedSize>>>=0;var maxHeapSize=getHeapMax();if(requestedSize>maxHeapSize){return false}for(var cutDown=1;cutDown<=4;cutDown*=2){var overGrownHeapSize=oldSize*(1+.2/cutDown);overGrownHeapSize=Math.min(overGrownHeapSize,requestedSize+100663296);var newSize=Math.min(maxHeapSize,alignMemory(Math.max(requestedSize,overGrownHeapSize),65536));var replacement=growMemory(newSize);if(replacement){return true}}return false};var _fd_close=fd=>52;var _fd_read=(fd,iov,iovcnt,pnum)=>52;var INT53_MAX=9007199254740992;var INT53_MIN=-9007199254740992;var bigintToI53Checked=num=>num<INT53_MIN||num>INT53_MAX?NaN:Number(num);function _fd_seek(fd,offset,whence,newOffset){offset=bigintToI53Checked(offset);return 70}var printCharBuffers=[null,[],[]];var printChar=(stream,curr)=>{var buffer=printCharBuffers[stream];if(curr===0||curr===10){(stream===1?out:err)(UTF8ArrayToString(buffer));buffer.length=0}else{buffer.push(curr)}};var _fd_write=(fd,iov,iovcnt,pnum)=>{var num=0;for(var i=0;i<iovcnt;i++){var ptr=HEAPU32[iov>>2];var len=HEAPU32[iov+4>>2];iov+=8;for(var j=0;j<len;j++){printChar(fd,HEAPU8[ptr+j])}num+=len}HEAPU32[pnum>>2]=num;return 0};var getCFunc=ident=>{var func=Module["_"+ident];return func};var writeArrayToMemory=(array,buffer)=>{HEAP8.set(array,buffer)};var lengthBytesUTF8=str=>{var len=0;for(var i=0;i<str.length;++i){var c=str.charCodeAt(i);if(c<=127){len++}else if(c<=2047){len+=2}else if(c>=55296&&c<=57343){len+=4;++i}else{len+=3}}return len};var stringToUTF8Array=(str,heap,outIdx,maxBytesToWrite)=>{if(!(maxBytesToWrite>0))return 0;var startIdx=outIdx;var endIdx=outIdx+maxBytesToWrite-1;for(var i=0;i<str.length;++i){var u=str.codePointAt(i);if(u<=127){if(outIdx>=endIdx)break;heap[outIdx++]=u}else if(u<=2047){if(outIdx+1>=endIdx)break;heap[outIdx++]=192|u>>6;heap[outIdx++]=128|u&63}else if(u<=65535){if(outIdx+2>=endIdx)break;heap[outIdx++]=224|u>>12;heap[outIdx++]=128|u>>6&63;heap[outIdx++]=128|u&63}else{if(outIdx+3>=endIdx)break;heap[outIdx++]=240|u>>18;heap[outIdx++]=128|u>>12&63;heap[outIdx++]=128|u>>6&63;heap[outIdx++]=128|u&63;i++}}heap[outIdx]=0;return outIdx-startIdx};var stringToUTF8=(str,outPtr,maxBytesToWrite)=>stringToUTF8Array(str,HEAPU8,outPtr,maxBytesToWrite);var stackAlloc=sz=>__emscripten_stack_alloc(sz);var stringToUTF8OnStack=str=>{var size=lengthBytesUTF8(str)+1;var ret=stackAlloc(size);stringToUTF8(str,ret,size);return ret};var ccall=(ident,returnType,argTypes,args,opts)=>{var toC={string:str=>{var ret=0;if(str!==null&&str!==undefined&&str!==0){ret=stringToUTF8OnStack(str)}return ret},array:arr=>{var ret=stackAlloc(arr.length);writeArrayToMemory(arr,ret);return ret}};function convertReturnValue(ret){if(returnType==="string"){return UTF8ToString(ret)}if(returnType==="boolean")return Boolean(ret);return ret}var func=getCFunc(ident);var cArgs=[];var stack=0;if(args){for(var i=0;i<args.length;i++){var converter=toC[argTypes[i]];if(converter){if(stack===0)stack=stackSave();cArgs[i]=converter(args[i])}else{cArgs[i]=args[i]}}}var ret=func(...cArgs);function onDone(ret){if(stack!==0)stackRestore(stack);return convertReturnValue(ret)}ret=onDone(ret);return ret};var cwrap=(ident,returnType,argTypes,opts)=>{var numericArgs=!argTypes||argTypes.every(type=>type==="number"||type==="boolean");var numericRet=returnType!=="string";if(numericRet&&numericArgs&&!opts){return getCFunc(ident)}return(...args)=>ccall(ident,returnType,argTypes,args,opts)};{if(Module["noExitRuntime"])noExitRuntime=Module["noExitRuntime"];if(Module["print"])out=Module["print"];if(Module["printErr"])err=Module["printErr"];if(Module["arguments"])programArgs=Module["arguments"];if(Module["thisProgram"])thisProgram=Module["thisProgram"];var preInit=Module["preInit"];if(preInit){if(typeof preInit=="function")Module["preInit"]=preInit=[preInit];while(preInit.length>0){preInit.shift()()}}}Module["ccall"]=ccall;Module["cwrap"]=cwrap;Module["UTF8ToString"]=UTF8ToString;var _malloc,_free,_parseFbxWasm,_getResultPtr,_getResultLen,_freeResult,__emscripten_stack_restore,__emscripten_stack_alloc,_emscripten_stack_get_current,memory,__indirect_function_table,wasmMemory;function assignWasmExports(wasmExports){_malloc=Module["_malloc"]=wasmExports["l"];_free=Module["_free"]=wasmExports["m"];_parseFbxWasm=Module["_parseFbxWasm"]=wasmExports["n"];_getResultPtr=Module["_getResultPtr"]=wasmExports["o"];_getResultLen=Module["_getResultLen"]=wasmExports["p"];_freeResult=Module["_freeResult"]=wasmExports["q"];__emscripten_stack_restore=wasmExports["r"];__emscripten_stack_alloc=wasmExports["s"];_emscripten_stack_get_current=wasmExports["t"];memory=wasmMemory=wasmExports["j"];__indirect_function_table=wasmExports["__indirect_function_table"]}var wasmImports={a:___assert_fail,d:___syscall_fcntl64,h:___syscall_ioctl,i:___syscall_openat,e:_emscripten_resize_heap,b:_fd_close,g:_fd_read,f:_fd_seek,c:_fd_write};async function run(){preRun();var setStatus=Module["setStatus"];if(setStatus){setStatus("Running...");await new Promise(resolve=>setTimeout(resolve,1));setTimeout(setStatus,1,"")}if(ABORT)return;initRuntime();Module["onRuntimeInitialized"]?.();postRun()}var wasmExports;wasmExports=await createWasm();await run();
+;return Module}export default Module;

package/scripts/build-wasm.mjs

@@ -0,0 +1,85 @@
+#!/usr/bin/env node
+// build-wasm.mjs — Compile ufbx + bridge to WebAssembly via Emscripten.
+//
+// Prerequisites:
+//   1. Install Emscripten SDK: https://emscripten.org/docs/getting_started/downloads.html
+//   2. Run `emsdk activate latest` so `emcc` is on PATH
+//   3. Run `pnpm fetch-ufbx` to download ufbx.h + ufbx.c
+//
+// Output: pkg/fbx-wasm.mjs + pkg/fbx-wasm.wasm
+//
+// The WASM module exports a single function `parseFbx(ptr, size) → ptr`
+// that takes FBX file bytes and returns a JSON string pointer (same schema
+// as @forgeax/engine-fbx binding.cc output).
+
+import { execSync } from 'node:child_process';
+import { existsSync, mkdirSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const ROOT = join(__dirname, '..');
+const NATIVE = join(ROOT, 'src', 'native');
+const PKG = join(ROOT, 'pkg');
+const REPRODUCIBLE_PATH = `-ffile-prefix-map=${ROOT}=/forgeax/fbx`;
+
+if (!existsSync(join(NATIVE, 'ufbx.c'))) {
+  console.error('ufbx.c not found. Run `pnpm fetch-ufbx` first.');
+  process.exit(1);
+}
+
+if (!existsSync(join(NATIVE, 'bridge.c'))) {
+  console.error('bridge.c not found in src/native/.');
+  process.exit(1);
+}
+
+// pkg/ is gitignored (zero-binary invariant) so a bare checkout has no such
+// dir; emcc will not create the -o parent itself. Ensure it exists.
+mkdirSync(PKG, { recursive: true });
+
+// Emscripten compilation flags:
+//   -O3                  : optimize for size+speed
+//   -s WASM=1            : emit .wasm (not asm.js)
+//   -s EXPORTED_FUNCTIONS: export malloc/free + our bridge function
+//   -s EXPORTED_RUNTIME_METHODS: expose ccall/cwrap/UTF8ToString/stringToUTF8
+//   -s ALLOW_MEMORY_GROWTH=1: FBX files can be large
+//   -s MODULARIZE=1      : wrap in a factory function (ESM-friendly)
+//   -s EXPORT_ES6=1      : emit ES6 module
+//   -s ENVIRONMENT=web,node : browser + Node; the Node glue self-loads the
+//                          .wasm via fs (no manual wasmBinary hand-off needed)
+//   -s FILESYSTEM=0      : we use ufbx_load_memory, no FS needed
+//   -s SINGLE_FILE=0     : keep .wasm separate for streaming compilation
+//   -lm                  : link math library
+const cmd = [
+  'emcc',
+  '-O3',
+  REPRODUCIBLE_PATH,
+  '-s WASM=1',
+  '-s "EXPORTED_FUNCTIONS=[\'_parseFbxWasm\',\'_getResultPtr\',\'_getResultLen\',\'_freeResult\',\'_malloc\',\'_free\']"',
+  '-s "EXPORTED_RUNTIME_METHODS=[\'ccall\',\'cwrap\',\'HEAPU8\',\'UTF8ToString\']"',
+  '-s ALLOW_MEMORY_GROWTH=1',
+  '-s MODULARIZE=1',
+  '-s EXPORT_ES6=1',
+  '-s ENVIRONMENT=web,node',
+  '-s FILESYSTEM=0',
+  '-s STACK_SIZE=1048576',
+  '-lm',
+  '-I', NATIVE,
+  join(NATIVE, 'ufbx.c'),
+  join(NATIVE, 'bridge.c'),
+  '-o', join(PKG, 'fbx-wasm.mjs'),
+].join(' ');
+
+console.log('Building WASM...');
+console.log(`  ${cmd}\n`);
+
+try {
+  execSync(cmd, { stdio: 'inherit', cwd: ROOT });
+  console.log('\nBuild complete:');
+  console.log(`  ${join(PKG, 'fbx-wasm.mjs')}`);
+  console.log(`  ${join(PKG, 'fbx-wasm.wasm')}`);
+} catch (e) {
+  console.error('\nEmscripten build failed. Is emcc on PATH?');
+  console.error('Install: https://emscripten.org/docs/getting_started/downloads.html');
+  process.exit(1);
+}

package/scripts/content-key.mjs

@@ -0,0 +1,88 @@
+// content-key.mjs — Single source of truth for the fbx-wasm release asset key.
+//
+// The pkg/ bundle (fbx-wasm.wasm + fbx-wasm.mjs emcc glue) is an emcc build
+// artifact — NOT committed to git (zero-binary invariant, see
+// packages/fbx/.gitignore). It is published to the `wasm-artifacts` GitHub
+// Release, content-keyed so a bundle is uploaded once per unique source state
+// and fetched deterministically.
+//
+// Like @forgeax/engine-wgpu-wasm and @forgeax/engine-codec (and unlike the old
+// lone-.wasm scheme), the fbx pkg/ carries TWO files that emcc emits together —
+// the .wasm binary plus its self-loading .mjs glue (MODULARIZE + EXPORT_ES6).
+// src/index.ts imports the .mjs glue at runtime, so a fetch that grabs only the
+// .wasm leaves consumers without a loader. The release asset is therefore the
+// WHOLE pkg/ packed as a .tar.gz.
+//
+// What determines pkg/ output, and therefore the content key:
+//   - src/native/bridge.c — the hand-written C bridge over ufbx.
+//   - scripts/fetch-ufbx.mjs — pins the exact ufbx version (UFBX_VERSION); the
+//     upstream ufbx.h/.c is gitignored (downloaded on demand) but this pin
+//     uniquely fixes it, so hashing the pin script is equivalent to hashing the
+//     source.
+//   - scripts/build-wasm.mjs — the emcc flag set that emits the .wasm/.mjs pair
+//     bit-for-bit.
+//
+// Both scripts/fetch-wasm.mjs (consumer) and the CI publish job import this
+// module so producer and consumer never disagree on the asset name (Pipeline
+// Isolation + SSOT: architecture-principles #1, #4).
+
+import { createHash } from 'node:crypto';
+import { readFile } from 'node:fs/promises';
+import { join, dirname, relative } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+export const PKG_ROOT = join(__dirname, '..');
+
+export const RELEASE_TAG = 'wasm-artifacts';
+export const UFBX_VERSION = 'v0.23.0';
+
+/**
+ * Compute the full SHA-256 (hex) over every input that determines the pkg/
+ * output. Path is included in the hash so a rename alone shifts the key.
+ *
+ * Inputs: the C bridge source + the two build scripts that fully determine the
+ * emitted pair (fetch-ufbx.mjs pins the ufbx version, build-wasm.mjs the emcc
+ * flags).
+ */
+export async function computeContentSha256() {
+  const inputs = [
+    join(PKG_ROOT, 'src', 'native', 'bridge.c'),
+    join(PKG_ROOT, 'scripts', 'fetch-ufbx.mjs'),
+    join(PKG_ROOT, 'scripts', 'build-wasm.mjs'),
+  ];
+  const hash = createHash('sha256');
+  for (const path of inputs) {
+    const rel = relative(PKG_ROOT, path).split('\\').join('/');
+    const content = await readFile(path);
+    hash.update(rel);
+    hash.update('\0');
+    hash.update(content);
+    hash.update('\0');
+  }
+  return hash.digest('hex');
+}
+
+export function buildAssetName(sha8) {
+  return `fbx-wasm-${UFBX_VERSION}-${sha8}.tar.gz`;
+}
+
+/** Convenience: returns { sha256, sha8, assetName }. */
+export async function resolveAsset() {
+  const sha256 = await computeContentSha256();
+  const sha8 = sha256.slice(0, 8);
+  return { sha256, sha8, assetName: buildAssetName(sha8) };
+}
+
+// CLI: `node scripts/content-key.mjs` prints the asset name (used by CI shell).
+if (process.argv[1] && fileURLToPath(import.meta.url) === process.argv[1]) {
+  resolveAsset()
+    .then(({ sha256, assetName }) => {
+      // Two lines: full sha then asset name, so shell can pick either.
+      process.stdout.write(`${sha256}\n${assetName}\n`);
+    })
+    .catch((e) => {
+      console.error('content-key: failed to compute:', e.message || e);
+      process.exit(1);
+    });
+}

package/scripts/ensure-wasm.mjs

@@ -0,0 +1,28 @@
+#!/usr/bin/env node
+// ensure-wasm.mjs — postinstall best-effort hydration of the fbx pkg/ WASM.
+// Thin config over scripts/lib/ensure-wasm-lib.mjs (shared with -codec, -wgpu-wasm).
+
+import { existsSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const SCRIPT_DIR = dirname(fileURLToPath(import.meta.url));
+const PKG = join(SCRIPT_DIR, '..', 'pkg');
+const presenceMarkers = [join(PKG, 'fbx-wasm.mjs'), join(PKG, 'fbx-wasm.wasm')];
+if (presenceMarkers.every(existsSync)) {
+  process.stdout.write('[fbx] pkg/ WASM already present -- skipping fetch.\n');
+  process.exit(0);
+}
+const { ensureWasm } = await import('../../../scripts/lib/ensure-wasm-lib.mjs');
+
+process.exit(
+  ensureWasm({
+    pkgLabel: 'fbx',
+    presenceMarkers,
+    fetchScript: join(SCRIPT_DIR, 'fetch-wasm.mjs'),
+    skipEnv: 'FORGEAX_SKIP_FBX_WASM_FETCH',
+    buildHint:
+      'pnpm -F @forgeax/engine-fbx fetch-wasm  (needs network + published release)\n' +
+      '        or pnpm -F @forgeax/engine-fbx build:wasm  (needs Emscripten emcc)',
+  }),
+);

package/scripts/fetch-ufbx.mjs

@@ -0,0 +1,42 @@
+#!/usr/bin/env node
+// fetch-ufbx.mjs — Download ufbx.h + ufbx.c from the official GitHub repo.
+// Usage: node scripts/fetch-ufbx.mjs [version]
+// Default version: v0.23.0 (latest stable as of 2026-07)
+
+import { writeFileSync, mkdirSync, existsSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const NATIVE_DIR = join(__dirname, '..', 'src', 'native');
+
+const VERSION = process.argv[2] || 'v0.23.0';
+const BASE_URL = `https://raw.githubusercontent.com/ufbx/ufbx/${VERSION}`;
+
+const FILES = ['ufbx.h', 'ufbx.c'];
+
+async function fetchFile(name) {
+  const url = `${BASE_URL}/${name}`;
+  console.log(`Fetching ${url} ...`);
+  const resp = await fetch(url);
+  if (!resp.ok) throw new Error(`Failed to fetch ${url}: ${resp.status}`);
+  return resp.text();
+}
+
+async function main() {
+  if (!existsSync(NATIVE_DIR)) mkdirSync(NATIVE_DIR, { recursive: true });
+
+  for (const file of FILES) {
+    const dest = join(NATIVE_DIR, file);
+    if (existsSync(dest)) {
+      console.log(`  ${file} already exists, skipping (delete to re-fetch)`);
+      continue;
+    }
+    const content = await fetchFile(file);
+    writeFileSync(dest, content);
+    console.log(`  → ${dest} (${(content.length / 1024).toFixed(0)} KB)`);
+  }
+  console.log('Done.');
+}
+
+main().catch((e) => { console.error(e); process.exit(1); });

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);
+});