@forgeax/engine-runtime 0.1.4 → 0.1.6

package/dist/index.mjs

@@ -1,57 +1,29 @@
-import { constructRenderer } from '@forgeax/engine-render/internal/construct-renderer';
-import { EngineEnvironmentError, collectSubtree, SceneInstance } from '@forgeax/engine-render/internal';
-export { EngineEnvironmentError } from '@forgeax/engine-render/internal';
+import * as rhiWebgpu from '@forgeax/engine-rhi-webgpu';
 export { acquireCanvasContext } from '@forgeax/engine-rhi-webgpu';
 import { animationClipContribution, animationGraphContribution } from '@forgeax/engine-animation';
-import { err, ok, handleSlot } from '@forgeax/engine-types';
+import { err, ok } from '@forgeax/engine-types';
 export { AssetError, MATERIAL_PARAM_TYPES } from '@forgeax/engine-types';
 import { defineComponent, Time, componentDefinition } from '@forgeax/engine-ecs';
-import { sceneAssetContribution, externalizeSceneAsset, worldGetSceneInstanceState, worldGetSceneAssetForInstance, SCENE_COLLECT_PROFILE } from '@forgeax/engine-scene';
+import { sceneAssetContribution, externalizeSceneAsset, collectSubtree, worldGetSceneInstanceState, worldGetSceneAssetForInstance, SCENE_COLLECT_PROFILE } from '@forgeax/engine-scene';
 import { fontContribution } from '@forgeax/engine-font';
 import { meshAssetContribution } from '@forgeax/engine-geometry';
 import { tilesetContribution, videoContribution } from '@forgeax/engine-graphics-extras';
 import { textureContribution, equirectContribution } from '@forgeax/engine-image';
-import { materialContribution, samplerContribution, renderPipelineContribution } from '@forgeax/engine-render';
+import { materialContribution, samplerContribution, renderPipelineContribution, SceneInstance } from '@forgeax/engine-render';
 import { skeletonContribution, skinContribution } from '@forgeax/engine-skinning';
 import { particleEffectContribution } from '@forgeax/engine-vfx';
-import { SpriteAnimationInvalidError, fillComponentDefaults } from '@forgeax/engine-ecs/projection';
-export { SpriteAnimationInvalidError } from '@forgeax/engine-ecs/projection';
-import { err as err$1, ok as ok$1 } from '@forgeax/engine-rhi';
+import { EngineEnvironmentError, constructRendererHost } from '@forgeax/engine-render/internal/construct-renderer';
+export { EngineEnvironmentError } from '@forgeax/engine-render/internal/construct-renderer';
+import { err as err$1, ok as ok$1, RhiError } from '@forgeax/engine-rhi';
 export { RhiError } from '@forgeax/engine-rhi';
+import { SpriteAnimationInvalidError, fillComponentDefaults } from '@forgeax/engine-ecs/projection';
 import { SpriteAnimation, spritePlaybackModeFromU32, SpriteRegionOverride } from '@forgeax/engine-render/authoring';
 export { quat } from '@forgeax/engine-math';
+import { SceneCollectAssetGuidUnresolvedError, resolveAssetHandle, SceneCollectEntityRefOutOfClosureError } from '@forgeax/engine-assets-runtime';
 import { classifyEntityField } from '@forgeax/engine-ecs/externalization';
 import { componentSchema } from '@forgeax/engine-ecs/internal';
 
-// src/createRenderer.ts
-
-// src/createRenderer.ts
-async function createRenderer(canvas, options, bundler) {
-  if (options !== void 0 && "rhi" in options && options.rhi === void 0) {
-    throw new EngineEnvironmentError("no usable rendering backend");
-  }
-  const rendererOptions = options === void 0 ? void 0 : {
-    ...options.rhi === void 0 ? {} : { rhi: options.rhi },
-    ...options.rawDeviceForContextConfigure === void 0 ? {} : { rawDeviceForContextConfigure: options.rawDeviceForContextConfigure },
-    ...options.features === void 0 ? {} : { features: options.features },
-    ...options.profiler === void 0 ? {} : { profiler: options.profiler },
-    ...options.membershipTiming === void 0 ? {} : { membershipTiming: options.membershipTiming },
-    ...options.rhiInstrumentation === void 0 ? {} : { rhiInstrumentation: options.rhiInstrumentation }
-  };
-  try {
-    return await constructRenderer(canvas, rendererOptions, bundler);
-  } catch (cause) {
-    if (isStructuredRenderError(cause)) throw cause;
-    if (cause instanceof EngineEnvironmentError) throw cause;
-    const detail = cause instanceof Error ? cause : new Error(String(cause));
-    throw new EngineEnvironmentError("renderer construction failed", { webgpuError: detail });
-  }
-}
-function isStructuredRenderError(value) {
-  if (!(value instanceof Error)) return false;
-  const candidate = value;
-  return typeof candidate.code === "string" && typeof candidate.expected === "string" && typeof candidate.hint === "string" && candidate.detail !== void 0;
-}
+// src/index.ts
 var audioContribution = {
   kind: { kind: "audio" },
   consumer: "AudioBackend",
@@ -115,11 +87,81 @@ var typedDefaultAssetDecoderContributions = [
 var defaultAssetDecoderContributions = Object.freeze(
   typedDefaultAssetDecoderContributions
 );
+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$1(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$1(
+      loadRhiPack(rhiWebgpu, options?.rhiInstrumentation)
+    );
+  }
+  try {
+    const mod = await import('@forgeax/engine-rhi-wgpu');
+    await mod.ensureReady();
+    return ok$1(loadRhiPack(mod, options?.rhiInstrumentation));
+  } catch (cause) {
+    return err$1(
+      new RhiError({
+        code: "rhi-not-available",
+        expected: "a usable RHI backend is available",
+        hint: `failed to load wgpu backend: ${String(cause)}`
+      })
+    );
+  }
+}
 
-// src/asset-kind.ts
-function builtinAssetKind(kind) {
-  const token = { kind };
-  return Object.freeze(token);
+// 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);
+}
+
+// src/createRenderer.ts
+async function createRenderer(canvas, options, bundler) {
+  if (options !== void 0 && "rhi" in options && options.rhi === void 0) {
+    return err(new EngineEnvironmentError("no usable rendering backend"));
+  }
+  const rendererOptions = options === void 0 ? void 0 : {
+    ...options.rhi === void 0 ? {} : { rhi: options.rhi },
+    ...options.features === void 0 ? {} : { features: options.features },
+    ...options.profiler === void 0 ? {} : { profiler: options.profiler },
+    ...options.rhiInstrumentation === void 0 ? {} : { rhiInstrumentation: options.rhiInstrumentation },
+    ...options.standardProfile === void 0 ? {} : { standardProfile: options.standardProfile }
+  };
+  try {
+    const constructed = await constructRuntimeRendererHost(canvas, rendererOptions, bundler);
+    if (!constructed.ok) return err(constructed.error);
+    return ok(constructed.value.renderer);
+  } catch (cause) {
+    if (cause instanceof EngineEnvironmentError) return err(cause);
+    const detail = cause instanceof Error ? cause : new Error(String(cause));
+    return err(new EngineEnvironmentError("renderer construction failed", { webgpuError: detail }));
+  }
 }
 
 // src/dev-import-transport.ts
@@ -251,34 +293,6 @@ function writeOverride(world, entity, region) {
     world.set(entity, SpriteRegionOverride, { region });
   }
 }
-
-// src/scene-collect-errors.ts
-var SceneCollectEntityRefOutOfClosureError = class extends Error {
-  code = "scene-collect-entity-ref-out-of-closure";
-  expected;
-  hint = "Expand roots to include the target entity, or remove the reference.";
-  detail;
-  constructor(entity, field, target) {
-    super(
-      `entity ${entity} field ${field} references entity ${target} outside the collected roots`
-    );
-    this.name = "SceneCollectEntityRefOutOfClosureError";
-    this.expected = `entity ${entity} field ${field} to reference an entity inside the collected roots`;
-    this.detail = { entity, field, target };
-  }
-};
-var SceneCollectAssetGuidUnresolvedError = class extends Error {
-  code = "scene-collect-asset-guid-unresolved";
-  expected;
-  hint = "Provide a GUID through the active scene asset port before collecting shared asset fields.";
-  detail;
-  constructor(field, handle) {
-    super(`shared asset field ${field} has no GUID for handle ${handle}`);
-    this.name = "SceneCollectAssetGuidUnresolvedError";
-    this.expected = `shared asset field ${field} to resolve through the active scene asset port`;
-    this.detail = { field, handle };
-  }
-};
 function excludedComponentNames() {
   return /* @__PURE__ */ new Set(["Entity", "ChildOf", "Children"]);
 }
@@ -316,8 +330,8 @@ function liveFields(world, entity, comp) {
   }
   return out;
 }
-function foldMountOverrides(world, assets, state) {
-  const sourceRes = assets.resolve(
+function foldMountOverrides(world, state) {
+  const sourceRes = resolveAssetHandle(
     world,
     state.source
   );
@@ -383,18 +397,18 @@ function classifyFieldSchema(fieldType) {
   if (fieldType.startsWith("array<shared<")) return { kind: "shared", scalar: false };
   return void 0;
 }
-function _handleToGuid(world, assets, handle, field) {
+function _handleToGuid(world, registry, handle, field) {
   if (handle === 0) return ok$1(void 0);
-  const assetRes = assets.resolve(world, handle);
+  const assetRes = resolveAssetHandle(world, handle);
   if (!assetRes.ok) return err$1(new SceneCollectAssetGuidUnresolvedError(field, handle));
-  const guid = assets.guidOf(assetRes.value);
+  const guid = registry._guidForAsset(assetRes.value);
   if (guid === void 0) return err$1(new SceneCollectAssetGuidUnresolvedError(field, handle));
   return ok$1(guid);
 }
-function _serializeSharedFieldValue(world, assets, classification, value, field) {
+function _serializeSharedFieldValue(world, registry, classification, value, field) {
   if (classification.scalar) {
     if (typeof value !== "number") return ok$1(value);
-    return _handleToGuid(world, assets, value, field);
+    return _handleToGuid(world, registry, value, field);
   }
   if (!Array.isArray(value)) return ok$1(value);
   const mapped = [];
@@ -403,19 +417,19 @@ function _serializeSharedFieldValue(world, assets, classification, value, field)
       mapped.push(elem);
       continue;
     }
-    const g = _handleToGuid(world, assets, elem, field);
+    const g = _handleToGuid(world, registry, elem, field);
     if (!g.ok) return g;
     mapped.push(g.value ?? 0);
   }
   return ok$1(mapped);
 }
-function _serializeOverrideValueHandles(world, assets, ov) {
+function _serializeOverrideValueHandles(world, registry, ov) {
   const comp = world.components.resolve(ov.comp);
   const schema = comp === void 0 ? void 0 : componentSchema(comp);
   if (ov.field !== void 0) {
     const classification = schema ? classifyFieldSchema(schema[ov.field]) : void 0;
     if (!classification || classification.kind !== "shared") return ok$1(ov.value);
-    const conv = _serializeSharedFieldValue(world, assets, classification, ov.value, ov.field);
+    const conv = _serializeSharedFieldValue(world, registry, classification, ov.value, ov.field);
     if (!conv.ok) return conv;
     return ok$1(conv.value ?? 0);
   }
@@ -432,7 +446,7 @@ function _serializeOverrideValueHandles(world, assets, ov) {
     }
     const conv = _serializeSharedFieldValue(
       world,
-      assets,
+      registry,
       classification,
       src[fieldName],
       fieldName
@@ -471,7 +485,7 @@ function serializeSceneAssetToPack(sceneAsset, components, guid) {
     ]
   });
 }
-function rootsToSceneAsset(assets, world, roots) {
+function rootsToSceneAsset(registry, world, roots) {
   const collectProfile = SCENE_COLLECT_PROFILE;
   const visited = /* @__PURE__ */ new Set();
   for (const root of roots) collectSubtree(world, root, visited);
@@ -570,7 +584,10 @@ function rootsToSceneAsset(assets, world, roots) {
           sh.error
         )
       );
-    const pr = assets.resolve(world, sh.value);
+    const pr = resolveAssetHandle(
+      world,
+      sh.value
+    );
     if (!pr.ok)
       return err$1(
         new SceneCollectAssetGuidUnresolvedError(
@@ -578,7 +595,7 @@ function rootsToSceneAsset(assets, world, roots) {
           sh.value
         )
       );
-    const g = assets.guidOf(pr.value);
+    const g = registry._guidForAsset(pr.value);
     if (g === void 0)
       return err$1(
         new SceneCollectAssetGuidUnresolvedError(
@@ -635,11 +652,11 @@ function rootsToSceneAsset(assets, world, roots) {
     let mountOverrides;
     const foldStateRes = worldGetSceneInstanceState(world, a.entityRaw);
     if (foldStateRes.ok) {
-      const rawOverrides = foldMountOverrides(world, assets, foldStateRes.value);
+      const rawOverrides = foldMountOverrides(world, foldStateRes.value);
       if (rawOverrides.length > 0) {
         mountOverrides = [];
         for (const ov of rawOverrides) {
-          const convRes = _serializeOverrideValueHandles(world, assets, ov);
+          const convRes = _serializeOverrideValueHandles(world, registry, ov);
           if (!convRes.ok) return convRes;
           mountOverrides.push({
             ...ov,
@@ -768,7 +785,7 @@ function rootsToSceneAsset(assets, world, roots) {
           }
           const conv = _serializeSharedFieldValue(
             world,
-            assets,
+            registry,
             sharedClass,
             normalized,
             fieldName
@@ -788,27 +805,7 @@ function rootsToSceneAsset(assets, world, roots) {
     ...outMounts.length > 0 ? { mounts: outMounts } : {}
   });
 }
-function createSceneAssetPort(guidOf) {
-  return {
-    resolve(world, handle) {
-      const shared = world.sharedRefs.resolve(handle);
-      if (shared.ok) return ok(shared.value);
-      return err({
-        code: "scene-asset-unresolved",
-        expected: "the handle to identify a World.sharedRefs-owned scene asset",
-        hint: "allocate the asset through the active World shared-ref owner before collecting the scene",
-        detail: { handle: handleSlot(handle) }
-      });
-    },
-    guidOf
-  };
-}
-
-// src/index.ts
-var Engine = {
-  create: createRenderer
-};
 
-export { Engine, SceneCollectAssetGuidUnresolvedError, SceneCollectEntityRefOutOfClosureError, builtinAssetKind, createDevImportTransport, createRenderer, createSceneAssetPort, defaultAssetDecoderContributions, rootsToSceneAsset, serializeSceneAssetToPack, spriteAnimationTickSystem };
+export { createDevImportTransport, createRenderer, defaultAssetDecoderContributions, rootsToSceneAsset, serializeSceneAssetToPack, spriteAnimationTickSystem };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map