@forgeax/engine-runtime 0.1.4 → 0.1.7

package/dist/renderer-host.mjs

@@ -0,0 +1,62 @@
+import { constructRendererHost } from '@forgeax/engine-render/internal/construct-renderer';
+import { ok, err, RhiError } from '@forgeax/engine-rhi';
+import * as rhiWebgpu from '@forgeax/engine-rhi-webgpu';
+
+// src/renderer-host.ts
+function loadRhiPack(mod, instrumentation) {
+  const rhi = mod.rhi;
+  const createShaderModule = mod.createShaderModule;
+  const translateErrorEventToRhiError = mod.translateErrorEventToRhiError;
+  const rawDeviceAccessor = mod._internal_getRawDevice;
+  const backendInstrumentation = mod.instrumentation;
+  const pack = {
+    rhi,
+    ...createShaderModule === void 0 ? {} : { createShaderModule },
+    ...translateErrorEventToRhiError === void 0 ? {} : { translateErrorEventToRhiError },
+    ...rawDeviceAccessor === void 0 ? {} : { _internal_getRawDevice: rawDeviceAccessor }
+  };
+  const resolvedInstrumentation = instrumentation ?? backendInstrumentation;
+  return resolvedInstrumentation === void 0 ? pack : { ...pack, instrumentation: resolvedInstrumentation };
+}
+async function loadBackendPack(options, preferWgpu = false) {
+  const explicit = options?.rhi;
+  if (explicit !== void 0 && explicit !== null) {
+    return ok(loadRhiPack({ rhi: explicit, ...explicit }, options?.rhiInstrumentation));
+  }
+  const nav = typeof globalThis === "undefined" ? void 0 : globalThis.navigator;
+  if (!preferWgpu && nav?.gpu !== void 0 && nav.gpu !== null) {
+    return ok(
+      loadRhiPack(rhiWebgpu, options?.rhiInstrumentation)
+    );
+  }
+  try {
+    const mod = await import('@forgeax/engine-rhi-wgpu');
+    await mod.ensureReady();
+    return ok(loadRhiPack(mod, options?.rhiInstrumentation));
+  } catch (cause) {
+    return err(
+      new RhiError({
+        code: "rhi-not-available",
+        expected: "a usable RHI backend is available",
+        hint: `failed to load wgpu backend: ${String(cause)}`
+      })
+    );
+  }
+}
+
+// src/renderer-host.ts
+async function constructRuntimeRendererHost(canvas, options, bundler) {
+  const first = await loadBackendPack(options);
+  if (!first.ok) throw first.error;
+  const constructed = await constructRendererHost(canvas, options, bundler, first.value);
+  if (constructed.ok || options?.rhi !== void 0 || typeof globalThis === "undefined") {
+    return constructed;
+  }
+  const fallback = await loadBackendPack(options, true);
+  if (!fallback.ok) return constructed;
+  return constructRendererHost(canvas, options, bundler, fallback.value);
+}
+
+export { constructRuntimeRendererHost, loadRhiPack };
+//# sourceMappingURL=renderer-host.mjs.map
+//# sourceMappingURL=renderer-host.mjs.map

package/dist/renderer-host.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/backend-selection.ts","../src/renderer-host.ts"],"names":[],"mappings":"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","file":"renderer-host.mjs","sourcesContent":["import type { RendererOptions } from '@forgeax/engine-render';\nimport type { RhiBackendPack } from '@forgeax/engine-render/internal/construct-renderer';\nimport { err, ok, RhiError } from '@forgeax/engine-rhi';\nimport * as rhiWebgpu from '@forgeax/engine-rhi-webgpu';\n\nexport function loadRhiPack(\n  mod: Record<string, unknown>,\n  instrumentation?: RhiBackendPack['instrumentation'],\n): RhiBackendPack {\n  const rhi = mod.rhi as unknown as RhiBackendPack['rhi'];\n  const createShaderModule = mod.createShaderModule as\n    | RhiBackendPack['createShaderModule']\n    | undefined;\n  const translateErrorEventToRhiError = mod.translateErrorEventToRhiError as\n    | RhiBackendPack['translateErrorEventToRhiError']\n    | undefined;\n  const rawDeviceAccessor = mod._internal_getRawDevice as unknown as\n    | RhiBackendPack['_internal_getRawDevice']\n    | undefined;\n  const backendInstrumentation = mod.instrumentation as\n    | RhiBackendPack['instrumentation']\n    | undefined;\n  const pack: RhiBackendPack = {\n    rhi,\n    ...(createShaderModule === undefined ? {} : { createShaderModule }),\n    ...(translateErrorEventToRhiError === undefined ? {} : { translateErrorEventToRhiError }),\n    ...(rawDeviceAccessor === undefined ? {} : { _internal_getRawDevice: rawDeviceAccessor }),\n  };\n  const resolvedInstrumentation = instrumentation ?? backendInstrumentation;\n  return resolvedInstrumentation === undefined\n    ? pack\n    : { ...pack, instrumentation: resolvedInstrumentation };\n}\n\n/** Selects one backend pack; render receives only this typed owner contract. */\nexport async function loadBackendPack(\n  options: RendererOptions | undefined,\n  preferWgpu = false,\n): Promise<\n  | { readonly ok: true; readonly value: RhiBackendPack }\n  | { readonly ok: false; readonly error: RhiError }\n> {\n  const explicit = options?.rhi;\n  if (explicit !== undefined && explicit !== null) {\n    return ok(loadRhiPack({ rhi: explicit, ...(explicit as object) }, options?.rhiInstrumentation));\n  }\n  const nav =\n    typeof globalThis === 'undefined'\n      ? undefined\n      : (globalThis as { navigator?: { gpu?: unknown } }).navigator;\n  if (!preferWgpu && nav?.gpu !== undefined && nav.gpu !== null) {\n    return ok(\n      loadRhiPack(rhiWebgpu as unknown as Record<string, unknown>, options?.rhiInstrumentation),\n    );\n  }\n  try {\n    const mod = (await import('@forgeax/engine-rhi-wgpu')) as Record<string, unknown>;\n    await (mod.ensureReady as () => Promise<unknown>)();\n    return ok(loadRhiPack(mod, options?.rhiInstrumentation));\n  } catch (cause) {\n    return err(\n      new RhiError({\n        code: 'rhi-not-available',\n        expected: 'a usable RHI backend is available',\n        hint: `failed to load wgpu backend: ${String(cause)}`,\n      }),\n    );\n  }\n}\n","import type { AssetRegistry } from '@forgeax/engine-assets-runtime';\nimport type { RenderError, RendererOptions, RenderResult } from '@forgeax/engine-render';\nimport type {\n  BundlerOptions,\n  RendererHostAssembly,\n} from '@forgeax/engine-render/internal/construct-renderer';\nimport { constructRendererHost } from '@forgeax/engine-render/internal/construct-renderer';\nimport { loadBackendPack } from './backend-selection';\n\nexport type {\n  BundlerOptions,\n  RendererHostAssembly,\n} from '@forgeax/engine-render/internal/construct-renderer';\n\n/** Assemble renderer plus asset services in the Runtime-owned backend host. */\nexport async function constructRuntimeRendererHost(\n  canvas: unknown,\n  options?: RendererOptions,\n  bundler?: BundlerOptions,\n): Promise<RenderResult<RendererHostAssembly, RenderError>> {\n  const first = await loadBackendPack(options);\n  if (!first.ok) throw first.error;\n  const constructed = await constructRendererHost(canvas, options, bundler, first.value);\n  if (constructed.ok || options?.rhi !== undefined || typeof globalThis === 'undefined') {\n    return constructed;\n  }\n  const fallback = await loadBackendPack(options, true);\n  if (!fallback.ok) return constructed;\n  return constructRendererHost(canvas, options, bundler, fallback.value);\n}\n\nexport { loadRhiPack } from './backend-selection';\nexport type { AssetRegistry };\n"]}

package/dist/scene-instances/index.d.ts

@@ -0,0 +1,2 @@
+export { postSpawnResolveJoints, type SkinJointResolver, } from '../../../render/src/scene-instances/post-spawn-resolve-joints';
+//# sourceMappingURL=index.d.ts.map

package/dist/scene-instances/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/scene-instances/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,sBAAsB,EACtB,KAAK,iBAAiB,GACvB,MAAM,+DAA+D,CAAC"}

package/dist/scene-utils/mount-override-fold.d.ts

@@ -1,6 +1,5 @@
 import { type EntityHandle, type World } from '@forgeax/engine-ecs';
 import type { Handle, LocalEntityId, MountOverride } from '@forgeax/engine-types';
-import type { SceneAssetPort } from '../scene-asset-port';
 /** Minimal structural view of a SceneInstanceState the fold reads (D-4 boundary:
  * `world.getSceneInstanceState(root).value` is structurally assignable). */
 export interface FoldSceneInstanceState {
@@ -12,5 +11,5 @@ export interface FoldSceneInstanceState {
  * MountOverride[] (child-namespace localIds, live value domain). See file
  * header for the full contract. Returns [] when nothing differs from source.
  */
-export declare function foldMountOverrides(world: World, assets: SceneAssetPort, state: FoldSceneInstanceState): MountOverride[];
+export declare function foldMountOverrides(world: World, state: FoldSceneInstanceState): MountOverride[];
 //# sourceMappingURL=mount-override-fold.d.ts.map

package/dist/scene-utils/mount-override-fold.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mount-override-fold.d.ts","sourceRoot":"","sources":["../../src/scene-utils/mount-override-fold.ts"],"names":[],"mappings":"AA0CA,OAAO,EAGL,KAAK,YAAY,EACjB,KAAK,KAAK,EACX,MAAM,qBAAqB,CAAC;AAG7B,OAAO,KAAK,EACV,MAAM,EACN,aAAa,EACb,aAAa,EAGd,MAAM,uBAAuB,CAAC;AAC/B,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAE1D;4EAC4E;AAC5E,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC,YAAY,EAAE,QAAQ,CAAC,CAAC;IAChD,QAAQ,CAAC,eAAe,EAAE,GAAG,CAAC,YAAY,EAAE,aAAa,CAAC,CAAC;CAC5D;AA4ED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,KAAK,EACZ,MAAM,EAAE,cAAc,EACtB,KAAK,EAAE,sBAAsB,GAC5B,aAAa,EAAE,CAmEjB"}
+{"version":3,"file":"mount-override-fold.d.ts","sourceRoot":"","sources":["../../src/scene-utils/mount-override-fold.ts"],"names":[],"mappings":"AA2CA,OAAO,EAGL,KAAK,YAAY,EACjB,KAAK,KAAK,EACX,MAAM,qBAAqB,CAAC;AAG7B,OAAO,KAAK,EACV,MAAM,EACN,aAAa,EACb,aAAa,EAGd,MAAM,uBAAuB,CAAC;AAE/B;4EAC4E;AAC5E,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC,YAAY,EAAE,QAAQ,CAAC,CAAC;IAChD,QAAQ,CAAC,eAAe,EAAE,GAAG,CAAC,YAAY,EAAE,aAAa,CAAC,CAAC;CAC5D;AA4ED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,sBAAsB,GAAG,aAAa,EAAE,CAmE/F"}

package/dist/systems/sprite-animation-tick.d.ts

@@ -1,6 +1,6 @@
 import { type World } from '@forgeax/engine-ecs';
+import { SpriteAnimationInvalidError } from '@forgeax/engine-ecs/projection';
 import { type Result } from '@forgeax/engine-types';
-import { SpriteAnimationInvalidError } from '../errors/sprite-animation';
 /**
  * Walk every entity carrying `SpriteAnimation`, advance its dt
  * accumulator, and write the current frame's UV slice to the entity's

package/dist/systems/sprite-animation-tick.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sprite-animation-tick.d.ts","sourceRoot":"","sources":["../../src/systems/sprite-animation-tick.ts"],"names":[],"mappings":"AA2DA,OAAO,EAA2B,KAAK,KAAK,EAAE,MAAM,qBAAqB,CAAC;AAM1E,OAAO,EAAW,KAAK,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAC7D,OAAO,EAAE,2BAA2B,EAAE,MAAM,4BAA4B,CAAC;AAEzE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AACH,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,KAAK,GAAG,MAAM,CAAC,IAAI,EAAE,2BAA2B,CAAC,CA0BjG"}
+{"version":3,"file":"sprite-animation-tick.d.ts","sourceRoot":"","sources":["../../src/systems/sprite-animation-tick.ts"],"names":[],"mappings":"AA2DA,OAAO,EAA2B,KAAK,KAAK,EAAE,MAAM,qBAAqB,CAAC;AAC1E,OAAO,EAAE,2BAA2B,EAAE,MAAM,gCAAgC,CAAC;AAM7E,OAAO,EAAW,KAAK,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAE7D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AACH,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,KAAK,GAAG,MAAM,CAAC,IAAI,EAAE,2BAA2B,CAAC,CA0BjG"}

package/dist/systems/transparent-sort.d.ts

@@ -1,6 +1,5 @@
 import type { World } from '@forgeax/engine-ecs';
-import type { TransparentEntry } from '@forgeax/engine-render/internal';
-export type { TransparentEntry } from '@forgeax/engine-render/internal';
+import type { TransparentEntry } from '../../../render/src/systems/transparent-sort-config';
 /**
  * Sort the transparent-bucket entries by `(layer ASC, sortValue ASC,
  * insertion-order)` and return the reordered list.

package/dist/systems/transparent-sort.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"transparent-sort.d.ts","sourceRoot":"","sources":["../../src/systems/transparent-sort.ts"],"names":[],"mappings":"AA2DA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,qBAAqB,CAAC;AACjD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,iCAAiC,CAAC;AASxE,YAAY,EAAE,gBAAgB,EAAE,MAAM,iCAAiC,CAAC;AAexE;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,sBAAsB,CACpC,OAAO,EAAE,SAAS,gBAAgB,EAAE,EACpC,KAAK,EAAE,KAAK,EACZ,SAAS,CAAC,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,GAC5C,SAAS,gBAAgB,EAAE,CAoC7B;AA6HD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,YAAY,EAAE,OAAO,EAAE,UAAU,GAAG,IAAI,CA2I5E"}
+{"version":3,"file":"transparent-sort.d.ts","sourceRoot":"","sources":["../../src/systems/transparent-sort.ts"],"names":[],"mappings":"AA4DA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,qBAAqB,CAAC;AACjD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,qDAAqD,CAAC;AAS5F;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,sBAAsB,CACpC,OAAO,EAAE,SAAS,gBAAgB,EAAE,EACpC,KAAK,EAAE,KAAK,EACZ,SAAS,CAAC,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,GAC5C,SAAS,gBAAgB,EAAE,CAkD7B;AA6HD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,YAAY,EAAE,OAAO,EAAE,UAAU,GAAG,IAAI,CA2I5E"}

package/dist/tilemap-register-validate.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tilemap-register-validate.d.ts","sourceRoot":"","sources":["../src/tilemap-register-validate.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAE,YAAY,EAAE,KAAK,EAAE,MAAM,qBAAqB,CAAC;AAK/D,OAAO,EAAW,KAAK,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAE3D,OAAO,EAAqB,UAAU,EAAE,MAAM,uBAAuB,CAAC;AAWtE;;;;;;;GAOG;AACH,wBAAgB,yBAAyB,CACvC,KAAK,EAAE,KAAK,EACZ,aAAa,EAAE,YAAY,GAC1B,MAAM,CAAC,IAAI,EAAE,UAAU,CAAC,CAkB1B;AAED;;;;;;GAMG;AACH,wBAAgB,2BAA2B,CACzC,KAAK,EAAE,KAAK,EACZ,WAAW,EAAE,YAAY,GACxB,MAAM,CAAC,IAAI,EAAE,UAAU,CAAC,CA4B1B"}
+{"version":3,"file":"tilemap-register-validate.d.ts","sourceRoot":"","sources":["../src/tilemap-register-validate.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAE,YAAY,EAAE,KAAK,EAAE,MAAM,qBAAqB,CAAC;AAC/D,OAAO,EAAW,KAAK,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAE3D,OAAO,EAAqB,UAAU,EAAE,MAAM,uBAAuB,CAAC;AAetE;;;;;;;GAOG;AACH,wBAAgB,yBAAyB,CACvC,KAAK,EAAE,KAAK,EACZ,aAAa,EAAE,YAAY,GAC1B,MAAM,CAAC,IAAI,EAAE,UAAU,CAAC,CAkB1B;AAED;;;;;;GAMG;AACH,wBAAgB,2BAA2B,CACzC,KAAK,EAAE,KAAK,EACZ,WAAW,EAAE,YAAY,GACxB,MAAM,CAAC,IAAI,EAAE,UAAU,CAAC,CA4B1B"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@forgeax/engine-runtime",
-  "version": "0.1.4",
+  "version": "0.1.7",
   "private": false,
   "type": "module",
   "license": "Apache-2.0",
@@ -11,7 +11,10 @@
       "types": "./dist/index.d.ts",
       "import": "./dist/index.mjs"
     },
-    "./internal/*": null,
+    "./internal/renderer-host": {
+      "types": "./dist/renderer-host.d.ts",
+      "import": "./dist/renderer-host.mjs"
+    },
     "./package.json": "./package.json"
   },
   "main": "./dist/index.mjs",
@@ -23,39 +26,37 @@
     "LICENSE"
   ],
   "dependencies": {
-    "@forgeax/engine-animation": "0.1.4",
-    "@forgeax/engine-assets-runtime": "0.1.4",
-    "@forgeax/engine-audio-webaudio": "0.1.4",
-    "@forgeax/engine-codec": "0.1.4",
-    "@forgeax/engine-debug-draw": "0.1.4",
-    "@forgeax/engine-ecs": "0.1.4",
-    "@forgeax/engine-font": "0.1.4",
-    "@forgeax/engine-geometry": "0.1.4",
-    "@forgeax/engine-graphics-extras": "0.1.4",
-    "@forgeax/engine-image": "0.1.4",
-    "@forgeax/engine-input": "0.1.4",
-    "@forgeax/engine-math": "0.1.4",
-    "@forgeax/engine-pack": "0.1.4",
-    "@forgeax/engine-profiler": "0.1.4",
-    "@forgeax/engine-render": "0.1.4",
-    "@forgeax/engine-render-graph": "0.1.4",
-    "@forgeax/engine-rhi": "0.1.4",
-    "@forgeax/engine-rhi-null": "0.1.4",
-    "@forgeax/engine-rhi-webgpu": "0.1.4",
-    "@forgeax/engine-rhi-wgpu": "0.1.4",
-    "@forgeax/engine-scene": "0.1.4",
-    "@forgeax/engine-shader": "0.1.4",
-    "@forgeax/engine-skinning": "0.1.4",
-    "@forgeax/engine-types": "0.1.4",
-    "@forgeax/engine-vfx": "0.1.4"
+    "@forgeax/engine-animation": "0.1.7",
+    "@forgeax/engine-assets-runtime": "0.1.7",
+    "@forgeax/engine-audio-webaudio": "0.1.7",
+    "@forgeax/engine-codec": "0.1.7",
+    "@forgeax/engine-debug-draw": "0.1.7",
+    "@forgeax/engine-ecs": "0.1.7",
+    "@forgeax/engine-font": "0.1.7",
+    "@forgeax/engine-geometry": "0.1.7",
+    "@forgeax/engine-graphics-extras": "0.1.7",
+    "@forgeax/engine-image": "0.1.7",
+    "@forgeax/engine-input": "0.1.7",
+    "@forgeax/engine-math": "0.1.7",
+    "@forgeax/engine-pack": "0.1.7",
+    "@forgeax/engine-profiler": "0.1.7",
+    "@forgeax/engine-render": "0.1.7",
+    "@forgeax/engine-render-graph": "0.1.7",
+    "@forgeax/engine-rhi": "0.1.7",
+    "@forgeax/engine-rhi-null": "0.1.7",
+    "@forgeax/engine-rhi-webgpu": "0.1.7",
+    "@forgeax/engine-rhi-wgpu": "0.1.7",
+    "@forgeax/engine-scene": "0.1.7",
+    "@forgeax/engine-shader": "0.1.7",
+    "@forgeax/engine-skinning": "0.1.7",
+    "@forgeax/engine-types": "0.1.7",
+    "@forgeax/engine-vfx": "0.1.7"
   },
   "devDependencies": {
-    "@forgeax/engine-import": "0.1.4",
-    "@forgeax/engine-naga": "0.1.4",
-    "@forgeax/engine-state": "0.1.4",
-    "@forgeax/engine-vfx-compiler": "0.1.4",
-    "@forgeax/engine-vfx-render": "0.1.4",
-    "@forgeax/engine-vite-plugin-shader": "0.1.4",
+    "@forgeax/engine-import": "0.1.7",
+    "@forgeax/engine-naga": "0.1.7",
+    "@forgeax/engine-state": "0.1.7",
+    "@forgeax/engine-vite-plugin-shader": "0.1.7",
     "@types/node": "^20.14.0"
   },
   "forgeax": {

package/src/__tests__/active-camera.unit.test.ts

@@ -25,19 +25,19 @@
 //   plan-strategy D-2: engine renderer gains neutral by-entity-ID active
 //     camera capability; resource absent -> first-hit fallback (backward compat)
 
+import { AssetRegistry } from '@forgeax/engine-assets-runtime';
 import { World } from '@forgeax/engine-ecs';
+import { Camera } from '@forgeax/engine-render';
+import { Transform } from '@forgeax/engine-scene';
+import { ShaderRegistry, type ShaderRegistryDevice } from '@forgeax/engine-shader';
+import { describe, expect, it } from 'vitest';
+import { extractFrame, prepareExtractContext } from '../../../render/src/render-system-extract';
 import {
   ACTIVE_CAMERA_KEY,
-  Camera,
-  extractFrame,
   getActiveCamera,
-  prepareExtractContext,
   selectActiveCameraIndex,
   setActiveCamera,
-} from '@forgeax/engine-render/internal';
-import { Transform } from '@forgeax/engine-scene';
-import { describe, expect, it } from 'vitest';
-import { createTestRenderAssetStore } from './helpers/render-asset-port';
+} from '../../../render/src/systems/active-camera';
 
 // ── Fixtures ─────────────────────────────────────────────────────────────────
 
@@ -49,8 +49,18 @@ function identityTransform(): {
   return { pos: [0, 0, 0], quat: [0, 0, 0, 1], scale: [1, 1, 1] };
 }
 
-function makeAssets() {
-  return createTestRenderAssetStore().port;
+function makeAssets(): AssetRegistry {
+  const mockDevice: ShaderRegistryDevice = {
+    createShaderModule() {
+      return {
+        ok: true,
+        value: undefined,
+        unwrap: () => undefined,
+        unwrapOr: (d: unknown) => d,
+      } as unknown as ReturnType<ShaderRegistryDevice['createShaderModule']>;
+    },
+  };
+  return new AssetRegistry(new ShaderRegistry({ device: mockDevice, manifestUrl: undefined }));
 }
 
 /** Spawn a Camera entity with a distinguishing fov so snapshots are identifiable. */

package/src/__tests__/animation-graph-collect-roundtrip.test.ts

@@ -0,0 +1,213 @@
+// feat-20260713-animation-state-machine-plugin M4 / w28 -- graph-holding entity
+// scene collect round-trip (AC-14 part b).
+//
+// AC-14 (part b) metric: an entity carrying a `shared<AnimationGraph>` handle is
+// collected through scene collect; the graph handle resolves to a persistable
+// GUID reference (schema-driven, plan D-4: `classifyFieldSchema` sees the
+// `shared<AnimationGraph>` scalar and routes it through `_guidForAsset` with ZERO
+// special-case in collect-scene-asset.ts, w31 verifies this); a `graph == 0`
+// (no-graph) entity is skipped by the existing 0-sentinel path (lossless); and a
+// graph reloaded from its serialized pack payload evaluates to the SAME derived
+// N-slot weights as the original (round-trip lossless).
+//
+// TDD red anchor: serializeAnimationGraph (w29) + animationGraphLoader (w30) do
+// not resolve until those tasks land; the eval-consistency case then goes green.
+// The collect->GUID cases exercise the already-present schema-driven path (w31 is
+// a verify-only landing that this test is the witness for).
+
+import {
+  AnimationPlayer,
+  defineAnimationGraph,
+  evaluateAnimationGraph,
+  serializeAnimationGraph,
+} from '@forgeax/engine-animation';
+import { AssetRegistry, animationGraphLoader } from '@forgeax/engine-assets-runtime';
+import { World } from '@forgeax/engine-ecs';
+import { AssetGuid } from '@forgeax/engine-pack/guid';
+import type { AnimationClip, AnimationGraph, Handle, LoadContext } from '@forgeax/engine-types';
+import { describe, expect, it } from 'vitest';
+import { rootsToSceneAsset } from '../collect-scene-asset';
+import { makeMockShaderRegistry } from './helpers/mock-shader-registry';
+
+function makeRegistry(): AssetRegistry {
+  return new AssetRegistry(makeMockShaderRegistry());
+}
+
+function makeWorld(): World {
+  const world = new World();
+  world.components.register(AnimationPlayer).unwrap();
+  return world;
+}
+
+const stubCtx = {} as LoadContext;
+
+// Register a clip in the registry catalog + world shared-ref store under the same
+// payload identity, returning both its handle and its GUID string.
+function registerClip(
+  world: World,
+  reg: AssetRegistry,
+  guidStr: string,
+  duration: number,
+): { handle: Handle<'AnimationClip', 'shared'>; guid: string; asset: AnimationClip } {
+  const parsed = AssetGuid.parse(guidStr);
+  if (!parsed.ok) throw new Error(`bad test GUID ${guidStr}`);
+  const clip: AnimationClip = { kind: 'animation-clip', duration, channels: [] };
+  reg.catalog(parsed.value, clip);
+  const handle = world.allocSharedRef('AnimationClip', clip) as Handle<'AnimationClip', 'shared'>;
+  return { handle, guid: AssetGuid.format(parsed.value), asset: clip };
+}
+
+// Register a graph POD in both stores; returns its handle + GUID string.
+function registerGraph(
+  world: World,
+  reg: AssetRegistry,
+  guidStr: string,
+  graph: AnimationGraph,
+): { handle: Handle<'AnimationGraph', 'shared'>; guid: string } {
+  const parsed = AssetGuid.parse(guidStr);
+  if (!parsed.ok) throw new Error(`bad test GUID ${guidStr}`);
+  reg.catalog(parsed.value, graph);
+  const handle = world.allocSharedRef('AnimationGraph', graph) as Handle<
+    'AnimationGraph',
+    'shared'
+  >;
+  return { handle, guid: AssetGuid.format(parsed.value) };
+}
+
+function apOf(scene: { entities: readonly unknown[] }): Record<string, unknown> | undefined {
+  for (const e of scene.entities) {
+    const comps = (e as { components: Record<string, Record<string, unknown>> }).components;
+    if (comps.AnimationPlayer !== undefined) return comps.AnimationPlayer;
+  }
+  return undefined;
+}
+
+const G_WALK = 'b1000000-0000-4000-8000-000000000001';
+const G_RUN = 'b1000000-0000-4000-8000-000000000002';
+const G_SURVEY = 'b1000000-0000-4000-8000-000000000003';
+const G_GRAPH = 'b1000000-0000-4000-8000-0000000000aa';
+const G_GRAPH2 = 'b1000000-0000-4000-8000-0000000000bb';
+
+// Build the standard test graph: Add(base=Blend(walk, run), additive=[survey@0.3]).
+function buildStandardGraph(walk: string, run: string, survey: string): AnimationGraph {
+  const built = defineAnimationGraph((b) => {
+    const w = b.clip(walk);
+    const r = b.clip(run);
+    const loco = b.blend([w, r]);
+    const overlay = b.clip(survey, 0.3);
+    return b.add(loco, [overlay]);
+  });
+  if (!built.ok) throw new Error('graph build failed');
+  return built.value;
+}
+
+describe('AnimationGraph collect round-trip (M4 / w28, AC-14 part b)', () => {
+  it('collects a graph-holding entity with graph resolved to its GUID (schema-driven, zero special-case)', () => {
+    const world = makeWorld();
+    const reg = makeRegistry();
+    const walk = registerClip(world, reg, G_WALK, 10);
+    const run = registerClip(world, reg, G_RUN, 20);
+    const survey = registerClip(world, reg, G_SURVEY, 30);
+    const graph = buildStandardGraph(walk.guid, run.guid, survey.guid);
+    const g = registerGraph(world, reg, G_GRAPH, graph);
+
+    const e = world
+      .spawn({
+        component: AnimationPlayer,
+        data: { graph: g.handle, nodeWeights: [1, 1, 1, 1, 1] },
+      })
+      .unwrap();
+
+    const collected = rootsToSceneAsset(reg, world, [e]);
+    expect(collected.ok).toBe(true);
+    if (!collected.ok) return;
+
+    const ap = apOf(collected.value);
+    expect(ap).not.toBeUndefined();
+    if (ap === undefined) return;
+    // The graph scalar shared field resolves to the catalogued GUID string.
+    expect(ap.graph).toBe(g.guid);
+  });
+
+  it('skips a graph == 0 (no-graph) entity 0-sentinel: lossless, no graph key emitted', () => {
+    const world = makeWorld();
+    const reg = makeRegistry();
+
+    const e = world
+      .spawn({
+        component: AnimationPlayer,
+        data: { clips: [], times: [], weights: [], speeds: [] },
+      })
+      .unwrap();
+
+    const collected = rootsToSceneAsset(reg, world, [e]);
+    expect(collected.ok).toBe(true);
+    if (!collected.ok) return;
+
+    const ap = apOf(collected.value);
+    expect(ap).not.toBeUndefined();
+    if (ap === undefined) return;
+    // graph == 0 (unset) is dropped by the shared-scalar 0-sentinel skip.
+    expect('graph' in ap).toBe(false);
+  });
+
+  it('a graph reloaded from its serialized pack payload evaluates to identical weights', () => {
+    const world = makeWorld();
+    const reg = makeRegistry();
+    const walk = registerClip(world, reg, G_WALK, 10);
+    const run = registerClip(world, reg, G_RUN, 20);
+    const survey = registerClip(world, reg, G_SURVEY, 30);
+    const original = buildStandardGraph(walk.guid, run.guid, survey.guid);
+    const lookup = (guid: string): AnimationClip | undefined =>
+      new Map([
+        [walk.guid, walk.asset],
+        [run.guid, run.asset],
+        [survey.guid, survey.asset],
+      ]).get(guid);
+
+    // Original graph -> register -> spawn -> eval one frame -> read weights.
+    const g0 = registerGraph(world, reg, G_GRAPH, original);
+    const e0 = world.spawn({ component: AnimationPlayer, data: { graph: g0.handle } }).unwrap();
+    evaluateAnimationGraph(world, 1 / 60, lookup);
+    const w0res = world.get(e0, AnimationPlayer);
+    expect(w0res.ok).toBe(true);
+    if (!w0res.ok) return;
+    const weights0 = Array.from((w0res.value as unknown as { weights: Float32Array }).weights);
+
+    // Serialize -> deserialize -> re-resolve clip GUIDs to their handles -> rebuild.
+    const clipGuidResolver = (clip: string): string | undefined => clip;
+    const out = serializeAnimationGraph(original, clipGuidResolver);
+    expect(out).not.toBeUndefined();
+    if (out === undefined) return;
+    const parsed = animationGraphLoader.load(out.payload, out.refs, stubCtx);
+    if (parsed === undefined || typeof parsed !== 'object' || 'ok' in parsed) {
+      throw new Error('animationGraphLoader returned a non-asset result');
+    }
+    const reloaded = parsed as AnimationGraph;
+
+    const rebuilt: AnimationGraph = reloaded;
+
+    const g1 = registerGraph(world, reg, G_GRAPH2, rebuilt);
+    const e1 = world.spawn({ component: AnimationPlayer, data: { graph: g1.handle } }).unwrap();
+    evaluateAnimationGraph(world, 1 / 60, lookup);
+    const w1res = world.get(e1, AnimationPlayer);
+    expect(w1res.ok).toBe(true);
+    if (!w1res.ok) return;
+    const weights1 = Array.from((w1res.value as unknown as { weights: Float32Array }).weights);
+
+    // Round-trip lossless: reloaded graph evaluates to the same derived weights.
+    expect(weights1).toHaveLength(weights0.length);
+    for (let i = 0; i < weights0.length; i++) {
+      expect(weights1[i]).toBeCloseTo(weights0[i] as number, 6);
+    }
+    // Sanity: the standard graph yields Blend(walk,run)=[0.5,0.5] + Add survey@0.3.
+    // weights[] is a Float32Array column, so 0.3 reads back as its f32 nearest
+    // (0.30000001192...) -- compare per-slot with f32-scale tolerance, not
+    // strict f64 equality.
+    const expectedWeights0 = [0.5, 0.5, 0.3];
+    expect(weights0).toHaveLength(expectedWeights0.length);
+    for (let i = 0; i < expectedWeights0.length; i++) {
+      expect(weights0[i]).toBeCloseTo(expectedWeights0[i] as number, 6);
+    }
+  });
+});