@babylonjs/lite 1.2.0 → 1.3.0

package/{index-BgY3QEzL.js → index-C2sM8ERH.js}

@@ -238,7 +238,7 @@ async function createEngine(canvas, options) {
     throw new Error("Babylon Lite: useFloatingOrigin requires useHighPrecisionMatrix on the engine.");
   }
   if (useHpm) {
-    const { allocateF64Mat4 } = await import("./_mat4-storage-f64-WeexU-hd.js");
+    const { allocateF64Mat4 } = await import("./_mat4-storage-f64-BqqOLkos.js");
     _setHpmAllocator(allocateF64Mat4);
   }
   let _wrapRenderableForFO;
@@ -443,7 +443,7 @@ async function setRenderTaskGpuTimingEnabled(engine, enabled) {
   engine._gpuTaskTimerEpoch = epoch;
   engine._gpuTaskTimerWanted = true;
   engine._gpuTaskTimingResult = makeTimingSnapshot("pending", true, true, 0, [], 0);
-  const { createGpuTaskTimer, installGpuTaskTimer } = await import("./gpu-task-timer-DVBNZfq5.js");
+  const { createGpuTaskTimer, installGpuTaskTimer } = await import("./gpu-task-timer-C-3sLTxO.js");
   if (!engine._gpuTaskTimerWanted || engine._gpuTaskTimerEpoch !== epoch) {
     return getRenderTaskGpuTimings(engine);
   }
@@ -471,7 +471,7 @@ function captureScreenshot(surface) {
     (surface._captureQueue ?? (surface._captureQueue = [])).push({ resolve, reject });
   });
   if (!surface._captureService) {
-    void import("./screenshot-readback-DnxR4rhp.js").then(({ createCaptureService, createCapturePreFrame }) => {
+    void import("./screenshot-readback-NxsFpnE4.js").then(({ createCaptureService, createCapturePreFrame }) => {
       surface._captureService ?? (surface._captureService = createCaptureService());
       surface._capturePreFrame ?? (surface._capturePreFrame = createCapturePreFrame());
     });
@@ -702,13 +702,13 @@ function getEffectiveAspectRatio(camera, targetWidth, targetHeight) {
   return targetWidth / targetHeight * (v2 ? v2.width / v2.height : 1);
 }
 let _cachedSceneBGL = null;
-let _cachedDevice$3 = null;
+let _cachedDevice$5 = null;
 function getSceneBindGroupLayout(engine) {
   const device = engine._device;
-  if (_cachedSceneBGL && _cachedDevice$3 === device) {
+  if (_cachedSceneBGL && _cachedDevice$5 === device) {
     return _cachedSceneBGL;
   }
-  _cachedDevice$3 = device;
+  _cachedDevice$5 = device;
   _cachedSceneBGL = device.createBindGroupLayout({
     label: "scene",
     entries: [
@@ -720,7 +720,7 @@ function getSceneBindGroupLayout(engine) {
 }
 function clearSceneBGLCache() {
   _cachedSceneBGL = null;
-  _cachedDevice$3 = null;
+  _cachedDevice$5 = null;
 }
 function createDefaultPipelineDescriptor(opts) {
   const target = opts._blend ? { format: opts._format, blend: opts._blend } : { format: opts._format };
@@ -3047,7 +3047,7 @@ function createGeometryRendererTask(config, engine, scene) {
       if (hasStandard) {
         loads.push(
           (async () => {
-            const [viewMod, matMod] = await Promise.all([import("./geometry-view-DRrscyWU.js"), Promise.resolve().then(() => standardMaterial)]);
+            const [viewMod, matMod] = await Promise.all([import("./geometry-view-L27hzPQF.js"), Promise.resolve().then(() => standardMaterial)]);
             task._createStandardGeometryView = viewMod.createStandardGeometryMaterialView;
             task._computeStandardFeatures = matMod._computeStandardMaterialFeatures;
           })()
@@ -3056,7 +3056,7 @@ function createGeometryRendererTask(config, engine, scene) {
       if (hasPbr) {
         loads.push(
           (async () => {
-            const [viewMod, matMod] = await Promise.all([import("./pbr-geometry-view-Dthf9Aut.js"), Promise.resolve().then(() => pbrMaterial)]);
+            const [viewMod, matMod] = await Promise.all([import("./pbr-geometry-view-BI52zgUI.js"), Promise.resolve().then(() => pbrMaterial)]);
             task._createPbrGeometryView = viewMod.createPbrGeometryMaterialView;
             task._computePbrFeatures = matMod._computePbrMaterialFeatures;
           })()
@@ -3065,7 +3065,7 @@ function createGeometryRendererTask(config, engine, scene) {
       if (hasNode) {
         loads.push(
           (async () => {
-            const viewMod = await import("./node-geometry-view-DfKXWNfV.js");
+            const viewMod = await import("./node-geometry-view-BJDB-lrf.js");
             task._createNodeGeometryView = viewMod.createNodeGeometryMaterialView;
           })()
         );
@@ -11565,6 +11565,23 @@ const GL_RGBA8 = 32856;
 const GL_R8 = 33321;
 const GL_RG8 = 33323;
 const RGBA_CAPS = { astc: false, bptc: false, s3tc: false, pvrtc: false, etc2: false, etc1: false };
+function deviceKtx2Caps(engine) {
+  const f = engine._device.features;
+  const bc = f.has("texture-compression-bc");
+  const etc2 = f.has("texture-compression-etc2");
+  return {
+    astc: f.has("texture-compression-astc"),
+    bptc: bc,
+    // BC6H/BC7
+    s3tc: bc,
+    // BC1/BC2/BC3
+    pvrtc: false,
+    // unsupported on WebGPU
+    etc2,
+    etc1: etc2
+    // ETC1 content transcodes on ETC2-capable GPUs
+  };
+}
 function loadKtx2Decoder() {
   if (_ktx2DecoderPromise) {
     return _ktx2DecoderPromise;
@@ -11747,7 +11764,7 @@ function uploadUncompressed(engine, mips, info, sRGB) {
 }
 async function uploadKtx2Texture2D(engine, buffer, sRGB) {
   const decoder = await loadKtx2Decoder();
-  const decoded = await decoder.decode(new U8(buffer), RGBA_CAPS, { forceRGBA: true });
+  const decoded = await decoder.decode(new U8(buffer), deviceKtx2Caps(engine));
   const mips = validateDecoded(decoded);
   const compressed = getCompressedFormat(decoded.transcodedFormat);
   if (compressed) {
@@ -11759,6 +11776,13 @@ async function uploadKtx2Texture2D(engine, buffer, sRGB) {
   }
   throw new Error(`KTX2: unsupported transcoded format 0x${decoded.transcodedFormat.toString(16)}`);
 }
+async function loadKtx2Texture2D(engine, url, sRGB = false) {
+  const resp = await fetch(url);
+  if (!resp.ok) {
+    throw new Error(`KTX2 fetch failed: ${resp.status} for ${url}`);
+  }
+  return uploadKtx2Texture2D(engine, await resp.arrayBuffer(), sRGB);
+}
 async function decodeKtx2ImageBitmapFromBuffer(buffer) {
   const decoder = await loadKtx2Decoder();
   const decoded = await decoder.decode(new U8(buffer), RGBA_CAPS, { forceRGBA: true });
@@ -11812,14 +11836,14 @@ function _getStdExtsSorted() {
 const NEEDS_UV = HAS_DIFFUSE_TEXTURE | HAS_EMISSIVE_TEXTURE | HAS_BUMP_TEXTURE | HAS_SPECULAR_TEXTURE | HAS_AMBIENT_TEXTURE | HAS_LIGHTMAP_TEXTURE | HAS_OPACITY_TEXTURE;
 const NEEDS_UV2 = LIGHTMAP_USES_UV2 | AMBIENT_USES_UV2 | DIFFUSE_USES_UV2 | SPECULAR_USES_UV2;
 const _STD_MAT_EXTS = [
-  ["bumpTexture", () => import("./normal-map-fragment-BHImLyM-.js"), "bumpStdExt"],
-  ["emissiveTexture", () => import("./std-emissive-fragment-P8yJGclx.js"), "stdEmissiveExt"],
-  ["specularTexture", () => import("./std-specular-fragment-CaBXyAWY.js"), "stdSpecularExt"],
-  ["ambientTexture", () => import("./std-ambient-fragment-P8dHZ4An.js"), "stdAmbientExt"],
-  ["lightmapTexture", () => import("./std-lightmap-fragment-CymEG79z.js"), "stdLightmapExt"],
-  ["opacityTexture", () => import("./std-opacity-fragment-DLa1zV06.js"), "stdOpacityExt"],
-  ["reflectionTexture", () => import("./std-reflection-fragment-BLySsYos.js"), "stdReflectionExt"],
-  ["reflectionCubeTexture", () => import("./std-cube-reflection-fragment-CF03MuQt.js"), "stdCubeReflectionExt"]
+  ["bumpTexture", () => import("./normal-map-fragment-Cjm-v9uq.js"), "bumpStdExt"],
+  ["emissiveTexture", () => import("./std-emissive-fragment-CK7TwRAt.js"), "stdEmissiveExt"],
+  ["specularTexture", () => import("./std-specular-fragment-OBO-zxGh.js"), "stdSpecularExt"],
+  ["ambientTexture", () => import("./std-ambient-fragment-BXl-88sn.js"), "stdAmbientExt"],
+  ["lightmapTexture", () => import("./std-lightmap-fragment-BSeS8K-4.js"), "stdLightmapExt"],
+  ["opacityTexture", () => import("./std-opacity-fragment-DnLaWH9w.js"), "stdOpacityExt"],
+  ["reflectionTexture", () => import("./std-reflection-fragment-BToYPemd.js"), "stdReflectionExt"],
+  ["reflectionCubeTexture", () => import("./std-cube-reflection-fragment-Dn34WuMa.js"), "stdCubeReflectionExt"]
 ];
 const standardGroupBuilder = async (scene, meshes) => {
   const hasTI = meshes.some((m2) => !!m2.thinInstances);
@@ -11835,7 +11859,7 @@ const standardGroupBuilder = async (scene, meshes) => {
   const imports = [];
   if (hasTI) {
     imports.push(
-      import("./thin-instance-gpu-C1DGstap.js").then((m2) => {
+      import("./thin-instance-gpu-QETC_NyQ.js").then((m2) => {
         tiSync = m2.syncThinInstanceBuffers;
       }),
       import("./thin-instance-fragment-hsv-RyDs.js").then((m2) => {
@@ -11844,7 +11868,7 @@ const standardGroupBuilder = async (scene, meshes) => {
     );
     if (hasCulling) {
       imports.push(
-        import("./thin-instance-cull-binding-BNC5JiGw.js").then((m2) => {
+        import("./thin-instance-cull-binding-D-p2Yxfg.js").then((m2) => {
           cull = m2;
         })
       );
@@ -11852,7 +11876,7 @@ const standardGroupBuilder = async (scene, meshes) => {
   }
   if (hasShadow) {
     imports.push(
-      import("./std-shadow-fragment-C_q27Mdi.js").then((m2) => {
+      import("./std-shadow-fragment-9b0rFY7F.js").then((m2) => {
         shadowFragment = m2.createStdShadowFragment;
       })
     );
@@ -11865,7 +11889,7 @@ const standardGroupBuilder = async (scene, meshes) => {
   if (imports.length > 0) {
     await Promise.all(imports);
   }
-  const renderableMod = await import("./standard-renderable-BAc-i-ig.js");
+  const renderableMod = await import("./standard-renderable-AYZ-Pdcm.js");
   const result = renderableMod.buildStandardMeshRenderables(scene, meshes, { tiSync, tiFragment, shadowFragment, cull });
   standardGroupBuilder._rebuildSingle = result.rebuildSingle;
   return result;
@@ -11916,9 +11940,218 @@ const noColorView$3 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defin
   __proto__: null,
   createStandardNoColorMaterialView: createStandardNoColorMaterialView$1
 }, Symbol.toStringTag, { value: "Module" }));
+const MSH_HAS_TANGENTS = 1 << 0;
+const MSH_HAS_SKELETON = 1 << 1;
+const MSH_HAS_SKELETON_8 = 1 << 2;
+const MSH_HAS_MORPH_TARGETS = 1 << 3;
+const MSH_HAS_THIN_INSTANCES = 1 << 4;
+const MSH_HAS_INSTANCE_COLOR = 1 << 5;
+const MSH_HAS_VERTEX_COLOR = 1 << 6;
+const MSH_HAS_UV2 = 1 << 7;
+const MSH_RECEIVE_SHADOWS = 1 << 8;
+const MSH_VAT = 1 << 9;
+function _computeMeshFeatures(mesh, receiveShadows = false) {
+  const gpu = mesh._gpu;
+  let features = 0;
+  if (gpu.tangentBuffer) {
+    features |= MSH_HAS_TANGENTS;
+  }
+  if (mesh.vat) {
+    features |= MSH_VAT;
+    if (mesh.vat.joints1Buffer) {
+      features |= MSH_HAS_SKELETON_8;
+    }
+  } else if (mesh.skeleton) {
+    features |= MSH_HAS_SKELETON;
+    if (mesh.skeleton.joints1Buffer) {
+      features |= MSH_HAS_SKELETON_8;
+    }
+  }
+  if (mesh.morphTargets) {
+    features |= MSH_HAS_MORPH_TARGETS;
+  }
+  if (mesh.thinInstances) {
+    features |= MSH_HAS_THIN_INSTANCES;
+    if (mesh.thinInstances.colors) {
+      features |= MSH_HAS_INSTANCE_COLOR;
+    }
+  }
+  if (gpu.colorBuffer) {
+    features |= MSH_HAS_VERTEX_COLOR;
+  }
+  if (gpu.uv2Buffer) {
+    features |= MSH_HAS_UV2;
+  }
+  if (receiveShadows) {
+    features |= MSH_RECEIVE_SHADOWS;
+  }
+  return features;
+}
+let _stencilResolver$2 = null;
+function _installPbrStencilResolver(resolve) {
+  _stencilResolver$2 = resolve;
+}
+let _pbrFallbackResolver = null;
+function _installPbrFallbackResolver(resolve) {
+  _pbrFallbackResolver = resolve;
+}
+const _bindingsCache$1 = /* @__PURE__ */ new Map();
+let _cachedDevice$4 = null;
+function ensureDevice$2(engine) {
+  if (_cachedDevice$4 !== engine._device) {
+    _bindingsCache$1.clear();
+    _cachedDevice$4 = engine._device;
+  }
+}
+function clearPbrPipelineCache() {
+  _bindingsCache$1.clear();
+  _cachedDevice$4 = null;
+}
+function getOrCreatePbrBindings(engine, features, features2, meshFeatures, sceneFeatures, composed, shaderKey = "", stencil = null) {
+  ensureDevice$2(engine);
+  const resolvedStencil = stencil && _stencilResolver$2 ? _stencilResolver$2(stencil) : null;
+  const key = `${features}:${features2}:${meshFeatures}:${sceneFeatures}:${shaderKey}${resolvedStencil ? resolvedStencil._key : ""}`;
+  const cached = _bindingsCache$1.get(key);
+  if (cached) {
+    return cached;
+  }
+  const device = engine._device;
+  const meshBGL = device.createBindGroupLayout(composed._meshBGLDescriptor);
+  let shadowBGL = null;
+  if (composed._shadowBGLDescriptor) {
+    shadowBGL = device.createBindGroupLayout(composed._shadowBGLDescriptor);
+  }
+  const bindings = {
+    _features: features,
+    _features2: features2,
+    _meshFeatures: meshFeatures,
+    _meshBGL: meshBGL,
+    _shadowBGL: shadowBGL,
+    _composed: composed,
+    _pipelines: /* @__PURE__ */ new Map()
+  };
+  if (resolvedStencil) {
+    bindings._stencil = resolvedStencil._desc;
+  }
+  _bindingsCache$1.set(key, bindings);
+  return bindings;
+}
+function getOrCreatePbrPipeline(engine, sig, bindings) {
+  ensureDevice$2(engine);
+  const key = targetSignatureKey(sig);
+  const cached = bindings._pipelines.get(key);
+  if (cached) {
+    return cached;
+  }
+  const device = engine._device;
+  const { _features: features, _features2: features2, _composed: composed } = bindings;
+  const esmShadowOutput = (features2 & PBR2_ESM_SHADOW_OUTPUT) !== 0;
+  const hasAlpha = !esmShadowOutput && (features & PBR_HAS_ALPHA_BLEND) !== 0;
+  const hasDoubleSided = (features & PBR_HAS_DOUBLE_SIDED) !== 0;
+  const sceneBGL = getSceneBindGroupLayout(engine);
+  const bgls = bindings._shadowBGL ? [sceneBGL, bindings._meshBGL, bindings._shadowBGL] : [sceneBGL, bindings._meshBGL];
+  const vertModule = device.createShaderModule({ code: composed._vertexWGSL });
+  const noColorOutput = (features2 & PBR2_NO_COLOR_OUTPUT) !== 0;
+  const fragModule = !sig._colorFormat && !noColorOutput ? null : device.createShaderModule({ code: composed._fragmentWGSL });
+  const fragTarget = noColorOutput ? null : { format: sig._colorFormat, writeMask: CW$1.ALL };
+  if (hasAlpha && fragTarget) {
+    fragTarget.blend = {
+      color: { srcFactor: "src-alpha", dstFactor: "one-minus-src-alpha", operation: "add" },
+      alpha: { srcFactor: "one", dstFactor: "one", operation: "add" }
+    };
+  }
+  const pipeline = device.createRenderPipeline({
+    layout: device.createPipelineLayout({ bindGroupLayouts: bgls }),
+    vertex: { module: vertModule, entryPoint: "main", buffers: composed._vertexBufferLayouts },
+    ...fragModule ? { fragment: { module: fragModule, entryPoint: "main", targets: fragTarget ? [fragTarget] : [] } } : {},
+    ...sig._depthStencilFormat ? {
+      depthStencil: {
+        format: sig._depthStencilFormat,
+        depthCompare: sig._depthCompare ?? REVERSE_DEPTH_COMPARE,
+        depthWriteEnabled: noColorOutput || esmShadowOutput || !hasAlpha,
+        // Pre-baked stencil sub-fields, applied only on a stencil-capable target — the same
+        // material in the depth32float shadow/depth pass keeps plain depth state (no stencil → no
+        // format mismatch). Gated on `_stencilResolver` (the opt-in hook) so the entire branch —
+        // including the `bindings._stencil` reads — folds out of stencil-free bundles.
+        ..._stencilResolver$2 && bindings._stencil && sig._depthStencilFormat.includes("stencil") ? bindings._stencil : {}
+      }
+    } : {},
+    multisample: { count: sig._sampleCount },
+    primitive: { topology: "triangle-list", cullMode: hasDoubleSided ? "none" : "back", frontFace: "ccw" }
+  });
+  bindings._pipelines.set(key, pipeline);
+  return pipeline;
+}
+function createPbrMeshBindGroup(engine, bindings, composed, meshUBO, materialUBO, material, env, meshCtx, refractionTexture) {
+  const device = engine._device;
+  const features = bindings._features;
+  const features2 = bindings._features2;
+  const meshFeatures = bindings._meshFeatures;
+  const hasNormal = (features & PBR_HAS_NORMAL_MAP) !== 0 && (meshFeatures & MSH_HAS_TANGENTS) !== 0;
+  const hasCotangentNormal = (features & PBR_HAS_NORMAL_MAP) !== 0 && (meshFeatures & MSH_HAS_TANGENTS) === 0;
+  const hasAnyNormal = hasNormal || hasCotangentNormal;
+  const hasEmissive = (features & PBR_HAS_EMISSIVE) !== 0;
+  const hasSpecGloss = (features & PBR_HAS_SPEC_GLOSS) !== 0;
+  const esmShadowOutput = (features2 & PBR2_ESM_SHADOW_OUTPUT) !== 0;
+  const entries = [];
+  let b = 0;
+  const addTex = (t) => {
+    entries.push({ binding: b++, resource: t.view });
+    entries.push({ binding: b++, resource: t.sampler });
+  };
+  const ctx = {
+    _engine: engine,
+    _features: features,
+    _features2: features2,
+    _meshFeatures: meshFeatures,
+    _material: material,
+    _mesh: meshCtx ?? void 0,
+    _env: env,
+    _refractionTexture: refractionTexture
+  };
+  const sortedExts = _getPbrExtsSorted();
+  const fragIds = composed._fragmentKey ? composed._fragmentKey.split("|").filter((s) => s.length > 0) : [];
+  entries.push({ binding: b++, resource: { buffer: meshUBO } });
+  entries.push({ binding: b++, resource: { buffer: materialUBO } });
+  for (const ext of sortedExts) {
+    if (ext.phase === "vertex" && ext.bind) {
+      b = ext.bind(ctx, entries, b);
+    }
+  }
+  addTex(material.baseColorTexture ?? (_pbrFallbackResolver == null ? void 0 : _pbrFallbackResolver(engine)));
+  if (hasAnyNormal) {
+    addTex(material.normalTexture);
+  }
+  addTex(material.ormTexture ?? (_pbrFallbackResolver == null ? void 0 : _pbrFallbackResolver(engine)));
+  if ((features2 & PBR2_HAS_UV2) !== 0 && (meshFeatures & MSH_HAS_UV2) !== 0 && material.occlusionTexture) {
+    addTex(material.occlusionTexture);
+  }
+  if (hasEmissive) {
+    addTex(material.emissiveTexture);
+  }
+  if (hasSpecGloss) {
+    addTex(material.specGlossTexture);
+  }
+  if (esmShadowOutput) {
+    entries.push({
+      binding: b++,
+      resource: { buffer: material._esmShadowParamsUBO }
+    });
+  }
+  const seenExts = [];
+  for (const fid of fragIds) {
+    const ext = sortedExts.find((e) => e.id === fid || fid.startsWith(e.id + "-"));
+    if (!ext || ext.phase === "vertex" || !ext.bind || seenExts.includes(ext)) {
+      continue;
+    }
+    seenExts.push(ext);
+    b = ext.bind(ctx, entries, b);
+  }
+  return device.createBindGroup({ layout: bindings._meshBGL, entries });
+}
 const pbrGroupBuilder = async (scene, meshes) => {
   const envTex = scene._envTextures;
-  const renderableMod = await import("./pbr-renderable-CuKWalEM.js").then((n3) => n3.p);
+  const renderableMod = await import("./pbr-renderable-B0elfRlX.js");
   const result = await renderableMod.buildPbrRenderables(scene, meshes, envTex);
   pbrGroupBuilder._rebuildSingle = result.rebuildSingle;
   return result;
@@ -11962,6 +12195,7 @@ function _computePbrMaterialFeatures(mat) {
   return { features, features2 };
 }
 function createPbrMaterial(props) {
+  _installPbrFallbackResolver((engine) => engine._pbrFallbackTex ?? (engine._pbrFallbackTex = createSolidTexture2D(engine, 1, 1, 1)));
   const mat = {
     ...props,
     _buildGroup: pbrGroupBuilder,
@@ -12003,7 +12237,7 @@ const pbrMaterial = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineP
   pbrGroupBuilder
 }, Symbol.toStringTag, { value: "Module" }));
 const shaderGroupBuilder = async (scene, meshes) => {
-  const { buildShaderGroup } = await import("./shader-renderable-DVMVD6zP.js");
+  const { buildShaderGroup } = await import("./shader-renderable-CUlJSove.js");
   const result = await buildShaderGroup(scene, meshes);
   shaderGroupBuilder._rebuildSingle = result.rebuildSingle;
   return result;
@@ -12688,11 +12922,11 @@ const SENTINEL_FRONT_FACING = "_NME_FRONT_FACING_";
 const SENTINEL_FRAG_COORD = "_NME_FRAG_COORD_";
 const SENTINEL_SCREEN_SIZE = "_NME_SCREEN_SIZE_";
 let _cache$2 = null;
-let _cachedDevice$2 = null;
+let _cachedDevice$3 = null;
 function getCache(engine) {
-  if (!_cache$2 || _cachedDevice$2 !== engine._device) {
+  if (!_cache$2 || _cachedDevice$3 !== engine._device) {
     _cache$2 = /* @__PURE__ */ new Map();
-    _cachedDevice$2 = engine._device;
+    _cachedDevice$3 = engine._device;
   }
   return _cache$2;
 }
@@ -13050,12 +13284,12 @@ async function parseNodeMaterialFromSnippet(engine, snippetId, options = {}) {
   let envHelpers = null;
   let _envEmitter;
   if (state.usesEnv) {
-    envHelpers = await import("./node-env-D7Aee08u.js");
+    envHelpers = await import("./node-env-B-Ca2DL0.js");
     _envEmitter = envHelpers.emitEnv;
   }
   let _shadowEmitter;
   if (options.shadowGenerators && options.shadowGenerators.length > 0) {
-    _shadowEmitter = (await import("./node-shadow-CeTmT6g4.js")).emitShadow;
+    _shadowEmitter = (await import("./node-shadow-DE--Q2V1.js")).emitShadow;
   }
   const compile = compileNodePipeline(state, vertexWgsl, fragmentWgsl, {
     _engine: engine,
@@ -13144,7 +13378,7 @@ async function parseNodeMaterialFromSnippet(engine, snippetId, options = {}) {
     inputs[tb._name] = handle;
   }
   const _buildGroup = async (scene, meshes) => {
-    const { buildNodeMeshRenderables } = await import("./node-renderable-EwLLnaL1.js");
+    const { buildNodeMeshRenderables } = await import("./node-renderable-BOIc3hM1.js");
     const result = buildNodeMeshRenderables(scene, meshes);
     _buildGroup._rebuildSingle = result.rebuildSingle;
     return result;
@@ -13184,7 +13418,7 @@ async function resolvePbrMrHelpers(state) {
   if (state.pbrMrHelperRequests.some((request) => !isCorePbrMrRequest(request))) {
     throw new Error("NodeMaterial: advanced PBR-MR helper request must be emitted by the full PBR-MR block");
   }
-  const core = await import("./pbr-mr-helper-core-CWROQ7OA.js");
+  const core = await import("./pbr-mr-helper-core-XeyKg-g6.js");
   for (const request of state.pbrMrHelperRequests) {
     state.fragment.helpers.set(request.key, core.buildPbrMrHelperCore(request));
   }
@@ -13302,7 +13536,7 @@ function hasBlockEmitter(key) {
 function baseBlockLoader(key) {
   switch (key) {
     case "InputBlock":
-      return () => import("./input-block-DjdlndCL.js");
+      return () => import("./input-block-DfFVJB-8.js");
     case "VectorMergerBlock":
       return () => import("./vector-merger-CrW-ONB0.js");
     case "FragmentOutputBlock":
@@ -13334,7 +13568,7 @@ function baseBlockLoader(key) {
     case "LerpBlock":
       return () => import("./lerp-block-DjI2SfmI.js");
     case "ClampBlock":
-      return () => import("./clamp-block-BD_t8I89.js");
+      return () => import("./clamp-block-Bupvx5sX.js");
     case "SmoothStepBlock":
       return () => import("./smoothstep-block-Di4t37x-.js");
     case "RemapBlock":
@@ -13358,7 +13592,7 @@ function baseBlockLoader(key) {
     case "ViewDirectionBlock":
       return () => import("./view-direction-CWVucfnT.js");
     case "LightBlock":
-      return () => import("./light-block-qjCrz3de.js");
+      return () => import("./light-block-othUHIHC.js");
     case "LightInformationBlock":
       return () => import("./light-information-VJbW0jbs.js");
     case "FogBlock":
@@ -13378,9 +13612,9 @@ function baseBlockLoader(key) {
     case "ReflectionTextureBlock":
       return () => import("./reflection-texture-block-C3QtzoV8.js");
     case "PBRMetallicRoughnessBlock":
-      return () => import("./pbr-metallic-roughness-block-g7wjzwN_.js");
+      return () => import("./pbr-metallic-roughness-block-C7s1jL4q.js");
     case "PBRMetallicRoughnessBlock__full":
-      return () => import("./pbr-metallic-roughness-block-full-DD6zI_Lx.js");
+      return () => import("./pbr-metallic-roughness-block-full-BuhhVBFO.js");
     case "ReflectionBlock":
       return () => import("./reflection-block-DqcwyYqr.js");
     case "ClearCoatBlock":
@@ -13422,7 +13656,7 @@ function extraRegistryLoader(key) {
     case "CurveBlock":
     case "WaveBlock":
     case "RandomNumberBlock":
-      return () => import("./node-registry-extra-math-BA8_l4lB.js");
+      return () => import("./node-registry-extra-math-Bsj4UAE5.js");
     case "ColorMergerBlock":
     case "ColorConverterBlock":
     case "DesaturateBlock":
@@ -13465,7 +13699,7 @@ function extraRegistryLoader(key) {
     case "LoopBlock":
     case "StorageReadBlock":
     case "StorageWriteBlock":
-      return () => import("./node-registry-extra-compat-CDLeBR1P.js");
+      return () => import("./node-registry-extra-compat-SwS962Ax.js");
     default:
       return null;
   }
@@ -13477,7 +13711,7 @@ const nodeRegistry = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.define
 }, Symbol.toStringTag, { value: "Module" }));
 async function loadNodeBlockEmitterWithGeometry(className) {
   if (className === "GeometryTextureOutputBlock") {
-    return (await import("./geometry-texture-output-DURiaJ_n.js")).emitter;
+    return (await import("./geometry-texture-output-DSeH_3G_.js")).emitter;
   }
   return loadBlockEmitter(className);
 }
@@ -13550,7 +13784,7 @@ function rebuildSceneMesh(ctx, mesh) {
   }
   ctx._renderables.splice(i, 0, renderable);
 }
-const STAGE_FRAGMENT$1 = 2;
+const STAGE_FRAGMENT$3 = 2;
 const STD_PLUGIN_UBO = "pluginUbo";
 const FRAG_POINT_TO_SLOTS = {
   CUSTOM_FRAGMENT_MAIN_BEGIN: ["SV"],
@@ -13637,8 +13871,8 @@ function buildPluginFragment(plugins, index, forStandard) {
     if (samplers) {
       for (const s of samplers) {
         bindings.push(
-          { _name: s.texture, _type: { _kind: "texture", _textureType: s.textureType ?? "texture_2d<f32>" }, _visibility: STAGE_FRAGMENT$1 },
-          { _name: s.sampler, _type: { _kind: "sampler", _samplerType: s.samplerType ?? "sampler" }, _visibility: STAGE_FRAGMENT$1 }
+          { _name: s.texture, _type: { _kind: "texture", _textureType: s.textureType ?? "texture_2d<f32>" }, _visibility: STAGE_FRAGMENT$3 },
+          { _name: s.sampler, _type: { _kind: "sampler", _samplerType: s.samplerType ?? "sampler" }, _visibility: STAGE_FRAGMENT$3 }
         );
       }
     }
@@ -13651,7 +13885,7 @@ function buildPluginFragment(plugins, index, forStandard) {
 ${stdUboSpec._structBody}
 }
 ` + helpers;
-    bindings.unshift({ _name: STD_PLUGIN_UBO, _type: { _kind: "uniform-buffer" }, _group: "mesh", _visibility: STAGE_FRAGMENT$1 });
+    bindings.unshift({ _name: STD_PLUGIN_UBO, _type: { _kind: "uniform-buffer" }, _group: "mesh", _visibility: STAGE_FRAGMENT$3 });
     stdUboFields = void 0;
   }
   return {
@@ -13918,13 +14152,956 @@ function enableMaterialPlugins(scene) {
   registerPbrPlugins(_registerPbrExt);
   registerStdPlugins(scene.meshes, scene.surface.engine, _registerStdExt);
 }
+function _resolveStencil(stencil) {
+  const op = {
+    compare: stencil.compare ?? "always",
+    passOp: stencil.passOp ?? "keep",
+    failOp: stencil.failOp ?? "keep",
+    depthFailOp: stencil.depthFailOp ?? "keep"
+  };
+  const readMask = stencil.readMask ?? 255;
+  const writeMask = stencil.writeMask ?? 255;
+  return {
+    // Front and back share the same ops object — GPUStencilFaceState is read by value at pipeline creation.
+    _desc: { stencilFront: op, stencilBack: op, stencilReadMask: readMask, stencilWriteMask: writeMask },
+    _key: `st:${op.compare}:${op.passOp}:${op.failOp}:${op.depthFailOp}:${readMask}:${writeMask}`
+  };
+}
+const WGSL_PERTURB_NORMAL = `
+fn perturbNormal(vNormalW: vec3<f32>, positionW: vec3<f32>, uv: vec2<f32>, bumpScale: f32) -> vec3<f32> {
+let normalSample = textureSample(bT, bS, uv).rgb * 2.0 - 1.0;
+let N = normalize(vNormalW) * bumpScale;
+let dp1 = dpdx(positionW);
+let dp2 = -dpdy(positionW);
+let duv1 = dpdx(uv);
+let duv2 = -dpdy(uv);
+let dp2perp = cross(dp2, N);
+let dp1perp = cross(N, dp1);
+var tangent = dp2perp * duv1.x + dp1perp * duv2.x;
+var bitangent = dp2perp * duv1.y + dp1perp * duv2.y;
+let det = max(dot(tangent, tangent), dot(bitangent, bitangent));
+let invmax = select(inverseSqrt(det), 0.0, det == 0.0);
+let cotangentFrame = mat3x3<f32>(tangent * invmax, bitangent * invmax, N);
+return normalize(cotangentFrame * normalSample);
+}
+`;
+const WGSL_FOG = `
+const E_FOG: f32 = 2.71828;
+fn calcFogFactor(fogDistance: vec3<f32>) -> f32 {
+var fogCoeff: f32 = 1.0;
+let fogMode = scene.vFogInfos.x;
+let fogStart = scene.vFogInfos.y;
+let fogEnd = scene.vFogInfos.z;
+let fogDensity = scene.vFogInfos.w;
+let dist = length(fogDistance);
+if (fogMode == 3.0) { fogCoeff = (fogEnd - dist) / (fogEnd - fogStart); }
+else if (fogMode == 1.0) { fogCoeff = 1.0 / pow(E_FOG, dist * fogDensity); }
+else if (fogMode == 2.0) { fogCoeff = 1.0 / pow(E_FOG, dist * dist * fogDensity * fogDensity); }
+return clamp(fogCoeff, 0.0, 1.0);
+}
+`;
+const WGSL_DITHER = `
+fn dither(seed: vec2<f32>, varianceAmount: f32) -> f32 {
+let rand = fract(sin(dot(seed, vec2<f32>(12.9898, 78.233))) * 43758.5453);
+let normVariance = varianceAmount / 255.0;
+return mix(-normVariance, normVariance, rand);
+}
+`;
+const WGSL_NO_DITHER = "fn dither(a:vec2<f32>,b:f32)->f32{return 0.0;}";
+const STAGE_VERTEX$2 = 1;
+const STAGE_FRAGMENT$2 = 2;
+const LIGHTING_FN = `
+fn computeLighting(viewDir: vec3<f32>, N: vec3<f32>, L: LightEntry, g: f32, P: vec3<f32>) -> array<vec3<f32>, 2> {
+var lv: vec3<f32>;
+var a: f32 = 1.0;
+let t = u32(L.vLightData.w);
+if (t == 3u) {
+let nl = 0.5 + 0.5 * dot(N, normalize(L.vLightData.xyz));
+let diff = mix(L.vLightDirection.xyz, L.vLightDiffuse.rgb, nl);
+let h = normalize(viewDir + normalize(L.vLightData.xyz));
+var s = pow(max(0.0, dot(N, h)), max(1.0, g));
+return array<vec3<f32>, 2>(diff, s * L.vLightSpecular.rgb);
+}
+if (t == 1u) {
+lv = normalize(-L.vLightData.xyz);
+} else {
+let d = L.vLightData.xyz - P;
+a = max(0.0, 1.0 - length(d) / L.vLightDiffuse.a);
+lv = normalize(d);
+if (t == 2u) {
+let c = max(0.0, dot(L.vLightDirection.xyz, -lv));
+if (c >= L.vLightDirection.w) { a *= max(0.0, pow(c, L.vLightSpecular.a)); } else { a = 0.0; }
+}
+}
+let nl = max(0.0, dot(N, lv));
+let diff = nl * L.vLightDiffuse.rgb * a;
+let h = normalize(viewDir + lv);
+var s = max(0.0, dot(N, h));
+s = pow(s, max(1.0, g));
+return array<vec3<f32>, 2>(diff, s * L.vLightSpecular.rgb * a);
+}
+`;
+function createStandardTemplate(config, esmShadowDepthCode = "") {
+  const { _diffuse, _needsUV, _needsUV2, _diffuseUsesUV2, _disableLighting, _noColorOutput, _esmShadowOutput } = config;
+  const _baseVertexAttributes = [
+    { _name: "position", _type: "vec3<f32>", _gpuFormat: "float32x3", _arrayStride: 12 },
+    { _name: "normal", _type: "vec3<f32>", _gpuFormat: "float32x3", _arrayStride: 12 }
+  ];
+  if (_needsUV) {
+    _baseVertexAttributes.push({ _name: "uv", _type: "vec2<f32>", _gpuFormat: "float32x2", _arrayStride: 8 });
+  }
+  if (_needsUV2) {
+    _baseVertexAttributes.push({ _name: "uv2", _type: "vec2<f32>", _gpuFormat: "float32x2", _arrayStride: 8 });
+  }
+  const _baseVaryings = [
+    { _name: "vp", _type: "vec3<f32>" },
+    { _name: "vn", _type: "vec3<f32>" },
+    { _name: "vf", _type: "vec3<f32>" }
+  ];
+  if (_needsUV) {
+    _baseVaryings.push({ _name: "vu", _type: "vec2<f32>" });
+  }
+  if (_needsUV2) {
+    _baseVaryings.push({ _name: "vv", _type: "vec2<f32>" });
+  }
+  const _baseMeshUboFields = [{ _name: "world", _type: "mat4x4<f32>" }];
+  appendMeshLightUboFields(_baseMeshUboFields);
+  const _baseBindings = [{ _name: "mat", _type: { _kind: "uniform-buffer" }, _visibility: STAGE_FRAGMENT$2 }];
+  if (_diffuse) {
+    _baseBindings.push(
+      { _name: "dT", _type: { _kind: "texture", _textureType: "texture_2d<f32>" }, _visibility: STAGE_FRAGMENT$2 },
+      { _name: "dS", _type: { _kind: "sampler", _samplerType: "sampler" }, _visibility: STAGE_FRAGMENT$2 }
+    );
+  }
+  if (_needsUV) {
+    _baseBindings.push({ _name: "up", _type: { _kind: "uniform-buffer" }, _visibility: STAGE_VERTEX$2 });
+  }
+  if (_esmShadowOutput) {
+    _baseBindings.push({ _name: "shadowParams", _type: { _kind: "uniform-buffer" }, _visibility: STAGE_FRAGMENT$2 });
+  }
+  const uvPassthrough = _needsUV ? `out.vu = uv * up.u.xy + up.u.zw;` : "";
+  const uv2Passthrough = _needsUV2 ? `out.vv = uv2;` : "";
+  const vertexUboStructs = _needsUV ? `struct upUniforms { u: vec4<f32>, }` : "";
+  const _vertexTemplate = `/*SU*/
+/*MU*/
+@group(1) @binding(0) var<uniform> mesh: MeshUniforms;
+${vertexUboStructs}
+/*VH*/
+/*VD*/
+/*VO*/
+@vertex fn main(
+/*VP*/
+) -> VertexOutput {
+var out: VertexOutput;
+/*VR*/
+var finalWorld = mesh.world;
+/*VW*/
+let worldPos4 = finalWorld * vec4<f32>(position, 1.0);
+out.vp = worldPos4.xyz;
+let normalWorld = mat3x3<f32>(finalWorld[0].xyz, finalWorld[1].xyz, finalWorld[2].xyz);
+out.vn = normalize(normalWorld * normal);
+out.clipPos = scene.viewProjection * worldPos4;
+out.vf = (scene.view * worldPos4).xyz;
+${uvPassthrough}
+${uv2Passthrough}
+/*VB*/
+return out;
+}`;
+  const lightsStructs = `
+struct LightEntry { vLightData: vec4<f32>, vLightDiffuse: vec4<f32>, vLightSpecular: vec4<f32>, vLightDirection: vec4<f32> };
+struct lightsUniforms { count: u32, _p0: u32, _p1: u32, _p2: u32, lights: array<LightEntry, ${MAX_LIGHTS}> };
+@group(0) @binding(1) var<uniform> lights: lightsUniforms;
+`;
+  const materialStruct = `
+struct matUniforms {
+dc: vec4<f32>,
+sc: vec4<f32>,
+ec: vec3<f32>,
+bs: f32,
+ac: vec3<f32>,
+tl: f32,
+ambTexLvl: f32,
+lmLvl: f32,
+opLvl: f32,
+aCut: f32,
+rLvl: f32,
+rCm: f32,
+_0: f32,
+_1: f32,
+};
+`;
+  const helpers = _disableLighting ? WGSL_FOG : WGSL_FOG + LIGHTING_FN;
+  const doubleSidedEntry = `@fragment fn main(input: FragmentInput)${_noColorOutput ? "" : " -> @location(0) vec4<f32>"} {`;
+  const viewDirCode = !_disableLighting ? `let viewDirectionW = normalize(scene.vEyePosition.xyz - input.vp);` : "";
+  const normalCode = _disableLighting ? "" : `var normalW = normalize(input.vn);`;
+  const opacityCode = `var alpha = mat.dc.a;`;
+  const baseColorCode = _diffuse ? `let _ds = textureSample(dT, dS, ${_diffuseUsesUV2 ? "input.vv" : "input.vu"});
+if (_ds.a < mat.aCut) { discard; }
+var baseColor = _ds.rgb * mat.tl;` : `var baseColor = vec3<f32>(1.0, 1.0, 1.0);`;
+  const diffuseColorCode = `let diffuseColor = mat.dc.rgb;`;
+  const emissiveCode = `var emissiveContrib = mat.ec;`;
+  const specularColorCode = !_disableLighting ? `var specularColor = mat.sc.rgb;` : "";
+  let lightingBlock;
+  if (!_disableLighting) {
+    lightingBlock = `var glossiness = mat.sc.a;
+var diffuseBase = vec3<f32>(0.0);
+var specularBase = vec3<f32>(0.0);
+var shadowFactors = array<f32, ${MAX_LIGHTS}>(${new Array(MAX_LIGHTS).fill("1.0").join(", ")});
+var baseAmbientColor = vec3<f32>(1.0, 1.0, 1.0);
+var reflectionColor = vec3<f32>(0.0);
+let lc = min(mesh.lc, ${MAX_LIGHTS}u);
+/*AD*/
+for (var li = 0u; li < lc; li++) {
+let lightIndex = mli(li);
+let r = computeLighting(viewDirectionW, normalW, lights.lights[lightIndex], glossiness, input.vp);
+let sf = shadowFactors[lightIndex];
+diffuseBase += r[0] * sf;
+specularBase += r[1] * sf;
+}
+let finalDiffuse = clamp(diffuseBase * diffuseColor + emissiveContrib + mat.ac, vec3<f32>(0.0), vec3<f32>(1.0)) * baseColor;
+let finalSpecular = specularBase * specularColor;
+var color = vec4<f32>(finalDiffuse * baseAmbientColor + finalSpecular + reflectionColor, alpha);`;
+  } else {
+    lightingBlock = `var color = vec4<f32>(clamp(emissiveContrib * diffuseColor, vec3<f32>(0.0), vec3<f32>(1.0)) * baseColor, alpha);`;
+  }
+  const _fragmentTemplate = `/*SU*/
+${lightsStructs}
+${materialStruct}
+${_esmShadowOutput ? "struct shadowParamsUniforms { biasAndScale: vec4<f32>, depthValues: vec4<f32>, }" : ""}
+/*MU*/
+@group(1) @binding(0) var<uniform> mesh: MeshUniforms;
+${!_disableLighting ? meshLightIndexWGSL("mesh") : ""}
+${helpers}
+/*HF*/
+/*FB*/
+/*FI*/
+${doubleSidedEntry}
+/*SV*/
+${viewDirCode}
+${normalCode}
+/*AC*/
+${opacityCode}
+${baseColorCode}
+${diffuseColorCode}
+${emissiveCode}
+${specularColorCode}
+/*AT*/
+${_noColorOutput ? "return;" : _esmShadowOutput ? esmShadowDepthCode : ""}
+${lightingBlock}
+/*BC*/
+color = vec4<f32>(max(color.rgb, vec3<f32>(0.0)), color.a);
+if (scene.vFogInfos.x > 0.0) {
+let fog = calcFogFactor(input.vf);
+color = vec4<f32>(mix(scene.vFogColor.rgb, color.rgb, fog), color.a);
+}
+/*BA*/
+${_noColorOutput ? "" : "return color;"}
+}`;
+  return {
+    _vertexTemplate,
+    _fragmentTemplate,
+    _baseMeshUboFields,
+    _baseVertexAttributes,
+    _baseVaryings,
+    _baseBindings
+  };
+}
+const STAGE_VERTEX$1 = 1;
+const STAGE_FRAGMENT$1 = 2;
+function topoSort(fragments) {
+  const byId = /* @__PURE__ */ new Map();
+  for (const f of fragments) {
+    if (byId.has(f._id)) {
+      throw Error();
+    }
+    byId.set(f._id, f);
+  }
+  const inDeg = /* @__PURE__ */ new Map();
+  const deps = /* @__PURE__ */ new Map();
+  for (const f of fragments) {
+    if (!inDeg.has(f._id)) {
+      inDeg.set(f._id, 0);
+    }
+    for (const d of f._dependencies ?? []) {
+      if (!byId.has(d)) {
+        throw Error();
+      }
+      inDeg.set(f._id, (inDeg.get(f._id) ?? 0) + 1);
+      let arr = deps.get(d);
+      if (!arr) {
+        arr = [];
+        deps.set(d, arr);
+      }
+      arr.push(f._id);
+    }
+  }
+  const q = [];
+  for (const [id, d] of inDeg) {
+    if (d === 0) {
+      q.push(id);
+    }
+  }
+  q.sort();
+  const out = [];
+  let qi = 0;
+  while (qi < q.length) {
+    const id = q[qi++];
+    out.push(byId.get(id));
+    for (const d of deps.get(id) ?? []) {
+      const nd = (inDeg.get(d) ?? 1) - 1;
+      inDeg.set(d, nd);
+      if (nd === 0) {
+        let i = qi;
+        while (i < q.length && q[i] < d) {
+          i++;
+        }
+        q.splice(i, 0, d);
+      }
+    }
+  }
+  if (out.length !== fragments.length) {
+    throw Error();
+  }
+  return out;
+}
+function dedup(base, extra) {
+  const seen = /* @__PURE__ */ new Set();
+  const all = [];
+  for (const v2 of base) {
+    if (!seen.has(v2._name)) {
+      seen.add(v2._name);
+      all.push(v2);
+    }
+  }
+  for (const v2 of extra) {
+    if (!seen.has(v2._name)) {
+      seen.add(v2._name);
+      all.push(v2);
+    }
+  }
+  return all;
+}
+function bglEntry(binding, decl) {
+  const e = { binding, visibility: decl._visibility };
+  switch (decl._type._kind) {
+    case "uniform-buffer":
+      e.buffer = { type: "uniform" };
+      break;
+    case "texture": {
+      const def = decl._type._textureType === "texture_depth_2d" ? "depth" : decl._type._textureType === "texture_2d<u32>" ? "uint" : "float";
+      e.texture = {
+        sampleType: decl._type._sampleType ?? def,
+        viewDimension: decl._type._textureType.includes("array") ? "2d-array" : decl._type._textureType.includes("cube") ? "cube" : "2d"
+      };
+      break;
+    }
+    case "sampler":
+      e.sampler = {
+        type: decl._type._samplerType === "sampler_comparison" ? "comparison" : decl._type._samplerType === "sampler_non_filtering" ? "non-filtering" : "filtering"
+      };
+      break;
+    case "storage-texture":
+      e.storageTexture = { access: decl._type._access, format: decl._type._format };
+      break;
+  }
+  return e;
+}
+function declWGSL(g, b, d) {
+  switch (d._type._kind) {
+    case "uniform-buffer":
+      return `@group(${g})@binding(${b}) var<uniform> ${d._name}:${d._name}Uniforms;`;
+    case "texture":
+      return `@group(${g})@binding(${b}) var ${d._name}:${d._type._textureType};`;
+    case "sampler":
+      return `@group(${g})@binding(${b}) var ${d._name}:${d._type._samplerType === "sampler_non_filtering" ? "sampler" : d._type._samplerType};`;
+    case "storage-texture":
+      return `@group(${g})@binding(${b}) var ${d._name}:texture_storage_2d<${d._type._format},${d._type._access}>;`;
+  }
+}
+const SLOT_RE = /\/\*([A-Z_0-9]+)\*\//g;
+function injectSlots(tpl, sorted, key) {
+  return tpl.replace(SLOT_RE, (_, slot) => {
+    const parts = [];
+    for (const f of sorted) {
+      const s = f[key];
+      if (s == null ? void 0 : s[slot]) {
+        parts.push(s[slot]);
+      }
+    }
+    return parts.join("\n");
+  });
+}
+function composeShader(template, fragments) {
+  var _a;
+  const sorted = topoSort(fragments);
+  const fragAttrs = [];
+  const fragVaryings = [];
+  const helpers = [];
+  const vHelpers = [];
+  const vBuiltins = [];
+  for (const f of sorted) {
+    if (f._vertexAttributes) {
+      fragAttrs.push(...f._vertexAttributes);
+    }
+    if (f._varyings) {
+      fragVaryings.push(...f._varyings);
+    }
+    if (f._helperFunctions) {
+      helpers.push(f._helperFunctions);
+    }
+    if (f._vertexHelperFunctions) {
+      vHelpers.push(f._vertexHelperFunctions);
+    }
+    for (const b of f._vertexBuiltins ?? []) {
+      vBuiltins.push(`@builtin(${b._builtin}) ${b._name}:${b._type},`);
+    }
+  }
+  const allAttrs = dedup(template._baseVertexAttributes, fragAttrs);
+  const inputLines = [];
+  const _vertexBufferLayouts = [];
+  const groups = /* @__PURE__ */ new Map();
+  const firstOfGroup = /* @__PURE__ */ new Map();
+  for (let i = 0; i < allAttrs.length; i++) {
+    const a = allAttrs[i];
+    inputLines.push(`@location(${i}) ${a._name}:${a._type},`);
+    if (a._bufferGroup) {
+      if (!groups.has(a._bufferGroup)) {
+        groups.set(a._bufferGroup, []);
+        firstOfGroup.set(a._bufferGroup, a);
+      }
+      groups.get(a._bufferGroup).push({ loc: i, off: a._offset ?? 0, fmt: a._gpuFormat });
+    } else {
+      _vertexBufferLayouts.push({
+        arrayStride: a._arrayStride,
+        stepMode: a._stepMode ?? "vertex",
+        attributes: [{ shaderLocation: i, offset: a._offset ?? 0, format: a._gpuFormat }]
+      });
+    }
+  }
+  for (const [grp, attrs] of groups) {
+    const f = firstOfGroup.get(grp);
+    _vertexBufferLayouts.push({
+      arrayStride: f._arrayStride,
+      stepMode: f._stepMode ?? "vertex",
+      attributes: attrs.map((a) => ({ shaderLocation: a.loc, offset: a.off, format: a.fmt }))
+    });
+  }
+  let nextLoc = allAttrs.length;
+  for (const f of sorted) {
+    if (f._pipelineVertexBuffers) {
+      const r = f._pipelineVertexBuffers(nextLoc);
+      _vertexBufferLayouts.push(...r._buffers);
+      nextLoc = r._nextLoc;
+    }
+  }
+  const allVary = dedup(template._baseVaryings, fragVaryings);
+  const varyBody = `@builtin(position) clipPos:vec4f,
+` + allVary.map((v2, i) => `@location(${i}) ${v2._name}:${v2._type},`).join("\n");
+  const hasMaterialUbo = !!(template._baseMaterialUboFields && template._baseMaterialUboFields.length > 0);
+  const meshFields = [...template._baseMeshUboFields];
+  const materialFields = hasMaterialUbo ? [...template._baseMaterialUboFields] : [];
+  for (const f of sorted) {
+    if ((_a = f._uboFields) == null ? void 0 : _a.length) {
+      (hasMaterialUbo ? materialFields : meshFields).push(...f._uboFields);
+    }
+  }
+  const _meshUboSpec = computeUboLayout(meshFields);
+  const _materialUboSpec = hasMaterialUbo ? computeUboLayout(materialFields) : void 0;
+  const meshBGL = [{ binding: 0, visibility: STAGE_VERTEX$1 | STAGE_FRAGMENT$1, buffer: { type: "uniform" } }];
+  if (hasMaterialUbo) {
+    meshBGL.push({ binding: 1, visibility: STAGE_FRAGMENT$1, buffer: { type: "uniform" } });
+  }
+  const shadowBGL = [];
+  const vDecls = [];
+  const fDecls = [];
+  let mb = hasMaterialUbo ? 2 : 1, sb = 0;
+  function addBinding(d, _isVertex) {
+    const isShadow = d._group === "shadow";
+    const b = isShadow ? sb++ : mb++;
+    const g = isShadow ? 2 : 1;
+    (isShadow ? shadowBGL : meshBGL).push(bglEntry(b, d));
+    const w = declWGSL(g, b, d);
+    if (d._visibility & STAGE_VERTEX$1) {
+      vDecls.push(w);
+    }
+    if (d._visibility & STAGE_FRAGMENT$1) {
+      fDecls.push(w);
+    }
+  }
+  for (const d of template._baseVertexBindings ?? []) {
+    addBinding(d);
+  }
+  for (const f of sorted) {
+    for (const d of f._vertexBindings ?? []) {
+      addBinding(d);
+    }
+  }
+  for (const d of template._baseBindings ?? []) {
+    addBinding(d);
+  }
+  for (const f of sorted) {
+    for (const d of (f._bindings ?? []).filter((b) => (b._group ?? "mesh") === "mesh")) {
+      addBinding(d);
+    }
+  }
+  for (const f of sorted) {
+    for (const d of (f._bindings ?? []).filter((b) => b._group === "shadow")) {
+      addBinding(d);
+    }
+  }
+  const _fragmentKey = sorted.map((f) => f._id).join("|");
+  const vParams = (vBuiltins.length ? vBuiltins.join("\n") + "\n" : "") + inputLines.join("\n");
+  const meshStruct = `struct MeshUniforms{
+${_meshUboSpec._structBody}
+}`;
+  const materialStruct = _materialUboSpec ? `
+struct MaterialUniforms{
+${_materialUboSpec._structBody}
+}
+@group(1)@binding(1) var<uniform> material:MaterialUniforms;` : "";
+  let _vertexWGSL = template._vertexTemplate;
+  _vertexWGSL = _vertexWGSL.replace("/*SU*/", SCENE_UBO_WGSL);
+  _vertexWGSL = _vertexWGSL.replace("/*MU*/", meshStruct);
+  _vertexWGSL = _vertexWGSL.replace("/*VI*/", `struct VertexInput{
+${inputLines.join("\n")}
+}`);
+  _vertexWGSL = _vertexWGSL.replace("/*VO*/", `struct VertexOutput{
+${varyBody}
+}`);
+  _vertexWGSL = _vertexWGSL.replace("/*VD*/", vDecls.join("\n"));
+  _vertexWGSL = _vertexWGSL.replace("/*VP*/", vParams);
+  _vertexWGSL = _vertexWGSL.replace("/*VH*/", vHelpers.join("\n"));
+  _vertexWGSL = injectSlots(_vertexWGSL, sorted, "_vertexSlots");
+  let _fragmentWGSL = template._fragmentTemplate;
+  _fragmentWGSL = _fragmentWGSL.replace("/*SU*/", SCENE_UBO_WGSL);
+  _fragmentWGSL = _fragmentWGSL.replace("/*MU*/", meshStruct + materialStruct);
+  _fragmentWGSL = _fragmentWGSL.replace("/*FI*/", `struct FragmentInput{
+${varyBody}
+}`);
+  _fragmentWGSL = _fragmentWGSL.replace("/*HF*/", helpers.join("\n"));
+  _fragmentWGSL = _fragmentWGSL.replace("/*FB*/", fDecls.join("\n"));
+  _fragmentWGSL = injectSlots(_fragmentWGSL, sorted, "_fragmentSlots");
+  const _meshBGLDescriptor = { entries: meshBGL };
+  const _shadowBGLDescriptor = shadowBGL.length ? { entries: shadowBGL } : null;
+  return {
+    _vertexWGSL,
+    _fragmentWGSL,
+    _meshBGLDescriptor,
+    _shadowBGLDescriptor,
+    _vertexBufferLayouts,
+    _meshUboSpec,
+    _materialUboSpec,
+    _fragmentKey
+  };
+}
+let _stencilResolver$1 = null;
+function _installStandardStencilResolver(resolve) {
+  _stencilResolver$1 = resolve;
+}
+function composeStandardShader(features, _meshFeatures = 0, fragments = [], esmShadowDepthCode = "") {
+  const has = (bit) => (features & bit) !== 0;
+  const template = createStandardTemplate(
+    {
+      _diffuse: has(HAS_DIFFUSE_TEXTURE),
+      _needsUV: has(NEEDS_UV),
+      _needsUV2: has(NEEDS_UV2),
+      _diffuseUsesUV2: has(DIFFUSE_USES_UV2),
+      _disableLighting: has(DISABLE_LIGHTING),
+      _noColorOutput: has(NO_COLOR_OUTPUT),
+      _esmShadowOutput: has(ESM_SHADOW_OUTPUT)
+    },
+    esmShadowDepthCode
+  );
+  return composeShader(template, fragments);
+}
+const _bindingsCache = /* @__PURE__ */ new Map();
+let _composedCache = null;
+let _cachedDevice$2 = null;
+function getComposedCache() {
+  if (!_composedCache) {
+    _composedCache = /* @__PURE__ */ new Map();
+  }
+  return _composedCache;
+}
+function ensureDevice$1(engine) {
+  if (_cachedDevice$2 !== engine._device) {
+    _bindingsCache.clear();
+    _composedCache == null ? void 0 : _composedCache.clear();
+    clearSceneBGLCache();
+    _cachedDevice$2 = engine._device;
+  }
+}
+function clearStandardPipelineCache() {
+  _bindingsCache.clear();
+  _composedCache == null ? void 0 : _composedCache.clear();
+  clearSceneBGLCache();
+  _cachedDevice$2 = null;
+}
+function getOrCreateStandardBindings(engine, features, meshFeatures, fragments = [], shaderKey = "", esmShadowDepthCode = "", stencil = null) {
+  ensureDevice$1(engine);
+  const resolvedStencil = stencil && _stencilResolver$1 ? _stencilResolver$1(stencil) : null;
+  const key = _standardFeatureKey(features, meshFeatures, shaderKey) + (resolvedStencil ? resolvedStencil._key : "");
+  const cached = _bindingsCache.get(key);
+  if (cached) {
+    return cached;
+  }
+  const cc = getComposedCache();
+  let composed = cc.get(key);
+  if (!composed) {
+    composed = composeStandardShader(features, meshFeatures, fragments, esmShadowDepthCode);
+    cc.set(key, composed);
+  }
+  const device = engine._device;
+  const meshBGL = device.createBindGroupLayout(composed._meshBGLDescriptor);
+  let shadowBGL = null;
+  const hasShadow = (meshFeatures & MSH_RECEIVE_SHADOWS) !== 0;
+  if (hasShadow && composed._shadowBGLDescriptor) {
+    shadowBGL = device.createBindGroupLayout(composed._shadowBGLDescriptor);
+  }
+  const bindings = {
+    _features: features,
+    _meshFeatures: meshFeatures,
+    _meshBGL: meshBGL,
+    _shadowBGL: shadowBGL,
+    _composed: composed,
+    _pipelines: /* @__PURE__ */ new Map()
+  };
+  if (resolvedStencil) {
+    bindings._stencil = resolvedStencil._desc;
+  }
+  _bindingsCache.set(key, bindings);
+  return bindings;
+}
+function getOrCreateStandardPipeline(engine, sig, bindings) {
+  ensureDevice$1(engine);
+  const key = targetSignatureKey(sig);
+  const cached = bindings._pipelines.get(key);
+  if (cached) {
+    return cached;
+  }
+  const device = engine._device;
+  const composed = bindings._composed;
+  const features = bindings._features;
+  const sceneBGL = getSceneBindGroupLayout(engine);
+  const bgls = bindings._shadowBGL ? [sceneBGL, bindings._meshBGL, bindings._shadowBGL] : [sceneBGL, bindings._meshBGL];
+  const vertModule = device.createShaderModule({ code: composed._vertexWGSL });
+  const noColorOutput = (features & NO_COLOR_OUTPUT) !== 0;
+  const esmShadowOutput = (features & ESM_SHADOW_OUTPUT) !== 0;
+  const fragModule = !sig._colorFormat && !noColorOutput ? null : device.createShaderModule({ code: composed._fragmentWGSL });
+  const needsBlend = !esmShadowOutput && ((features & HAS_OPACITY_TEXTURE) !== 0 || (features & MATERIAL_ALPHA_BLEND) !== 0);
+  const colorTarget = noColorOutput ? null : needsBlend ? {
+    format: sig._colorFormat,
+    blend: {
+      color: { srcFactor: "src-alpha", dstFactor: "one-minus-src-alpha" },
+      alpha: { srcFactor: "one", dstFactor: "one-minus-src-alpha" }
+    }
+  } : { format: sig._colorFormat };
+  const pipeline = device.createRenderPipeline({
+    layout: device.createPipelineLayout({ bindGroupLayouts: bgls }),
+    vertex: { module: vertModule, entryPoint: "main", buffers: composed._vertexBufferLayouts },
+    ...fragModule ? { fragment: { module: fragModule, entryPoint: "main", targets: colorTarget ? [colorTarget] : [] } } : {},
+    ...sig._depthStencilFormat ? {
+      depthStencil: {
+        format: sig._depthStencilFormat,
+        depthCompare: sig._depthCompare ?? REVERSE_DEPTH_COMPARE,
+        depthWriteEnabled: noColorOutput || esmShadowOutput || !needsBlend,
+        // Pre-baked stencil sub-fields, applied only on a stencil-capable target — the same
+        // material in the depth32float shadow/depth pass keeps plain depth state (no stencil → no
+        // format mismatch). Gated on `_stencilResolver` (the opt-in hook) so the entire branch —
+        // including the `bindings._stencil` reads — folds out of stencil-free bundles.
+        ..._stencilResolver$1 && bindings._stencil && sig._depthStencilFormat.includes("stencil") ? bindings._stencil : {}
+      }
+    } : {},
+    multisample: { count: sig._sampleCount },
+    primitive: { topology: "triangle-list", cullMode: features & DOUBLE_SIDED ? "none" : "back", frontFace: "ccw" }
+  });
+  bindings._pipelines.set(key, pipeline);
+  return pipeline;
+}
+function createStandardMeshBindGroup(engine, bindings, meshUBO, materialUBO, material) {
+  var _a;
+  const device = engine._device;
+  const features = bindings._features;
+  const needsUV = (features & NEEDS_UV) !== 0;
+  const hasDiffuseTex = (features & HAS_DIFFUSE_TEXTURE) !== 0;
+  const esmShadowOutput = (features & ESM_SHADOW_OUTPUT) !== 0;
+  let nextBinding = 0;
+  const entries = [
+    { binding: nextBinding++, resource: { buffer: meshUBO } },
+    { binding: nextBinding++, resource: { buffer: materialUBO } }
+  ];
+  if (hasDiffuseTex) {
+    const tex = material.diffuseTexture;
+    entries.push({ binding: nextBinding++, resource: tex.texture.createView() }, { binding: nextBinding++, resource: tex.sampler });
+  }
+  if (needsUV) {
+    const uvData = new F32(4);
+    const scaleX = material.uvScale[0];
+    let scaleY = material.uvScale[1];
+    let offsetY = 0;
+    if ((_a = material.diffuseTexture) == null ? void 0 : _a.invertY) {
+      offsetY = scaleY;
+      scaleY = -scaleY;
+    }
+    uvData[0] = scaleX;
+    uvData[1] = scaleY;
+    uvData[2] = 0;
+    uvData[3] = offsetY;
+    entries.push({ binding: nextBinding++, resource: { buffer: createUniformBuffer$1(engine, uvData) } });
+  }
+  if (esmShadowOutput) {
+    entries.push({
+      binding: nextBinding++,
+      resource: { buffer: material._esmShadowParamsUBO }
+    });
+  }
+  const sortedExts = _getStdExtsSorted();
+  for (const ext of sortedExts) {
+    if (features & ext._feature && ext._bind) {
+      nextBinding = ext._bind(material, entries, nextBinding);
+    }
+  }
+  return device.createBindGroup({ layout: bindings._meshBGL, entries });
+}
+function writeStdMaterialData(data, mat, textureLevel) {
+  const { diffuseColor: dc, specularColor: sc, emissiveColor: ec, ambientColor: ac } = mat;
+  data[0] = dc[0];
+  data[1] = dc[1];
+  data[2] = dc[2];
+  data[3] = mat.alpha;
+  data[4] = sc[0];
+  data[5] = sc[1];
+  data[6] = sc[2];
+  data[7] = mat.specularPower;
+  data[8] = ec[0];
+  data[9] = ec[1];
+  data[10] = ec[2];
+  data[11] = 1 / mat.bumpLevel;
+  data[12] = ac[0];
+  data[13] = ac[1];
+  data[14] = ac[2];
+  data[15] = textureLevel;
+  data[16] = mat.ambientTexLevel;
+  data[17] = mat.lightmapLevel;
+  data[18] = mat.opacityLevel;
+  data[19] = mat.alphaCutOff;
+  data[20] = mat.reflectionLevel;
+  data[21] = mat.reflectionCoordMode;
+}
+let _stencilResolver = null;
+function _installShaderStencilResolver(resolve) {
+  _stencilResolver = resolve;
+}
+const SHADER_STAGE_ALL = SS.VERTEX | SS.FRAGMENT;
+function getOrCreateShaderPipelineBindings(engine, material) {
+  const state = material;
+  if (state._shaderBindings && state._shaderDevice === engine._device) {
+    return state._shaderBindings;
+  }
+  state._shaderDevice = engine._device;
+  const systemFields = material.uniformDecls.filter((u) => _isShaderSystemUniform(u.name)).map(toUboField);
+  const customFields = material.uniformDecls.filter((u) => !_isShaderSystemUniform(u.name)).map(toUboField);
+  const systemSpec = computeUboLayout(systemFields.length > 0 ? systemFields : [{ _name: "_pad", _type: "vec4<f32>" }]);
+  const customSpec = customFields.length > 0 ? computeUboLayout(customFields) : null;
+  const group1BGL = engine._device.createBindGroupLayout({
+    label: "shader-material-group1",
+    entries: buildBindGroupLayoutEntries(material.samplerDecls, material.storageBufferDecls, customSpec !== null)
+  });
+  const bindings = {
+    group1BGL,
+    systemSpec,
+    customSpec,
+    vertexBuffers: material.attributes.map(attributeLayout),
+    pipelines: /* @__PURE__ */ new Map()
+  };
+  state._shaderBindings = bindings;
+  state._shaderCustomSpec = customSpec;
+  state._shaderCustomUbo = null;
+  state._shaderCustomData = null;
+  state._shaderCustomVersion = -1;
+  return bindings;
+}
+function getOrCreateShaderPipeline(engine, sig, material, bindings, variantKey = "", vertexBuffers = bindings.vertexBuffers, instanceAttrs = "") {
+  const key = `${targetSignatureKey(sig)}${variantKey}`;
+  const cached = bindings.pipelines.get(key);
+  if (cached) {
+    return cached;
+  }
+  const stencil = material.stencil && _stencilResolver ? _stencilResolver(material.stencil) : null;
+  const device = engine._device;
+  const prelude = buildShaderPrelude(material, bindings.systemSpec, bindings.customSpec, instanceAttrs);
+  const vertModule = device.createShaderModule({ label: `${material.name ?? "shader"}-vertex`, code: `${prelude}
+${material.vertexSource}` });
+  const wantsFragment = !!sig._colorFormat || material.depthOnlyFragment;
+  const fragModule = wantsFragment ? device.createShaderModule({ label: `${material.name ?? "shader"}-fragment`, code: `${prelude}
+${material.fragmentSource}` }) : null;
+  const colorTarget = sig._colorFormat ? {
+    format: sig._colorFormat,
+    ...material.needAlphaBlending ? {
+      blend: material.blendMode === "additive" ? {
+        color: { srcFactor: "src-alpha", dstFactor: "one", operation: "add" },
+        alpha: { srcFactor: "one", dstFactor: "one", operation: "add" }
+      } : {
+        color: { srcFactor: "src-alpha", dstFactor: "one-minus-src-alpha", operation: "add" },
+        alpha: { srcFactor: "one", dstFactor: "one-minus-src-alpha", operation: "add" }
+      }
+    } : {}
+  } : null;
+  const pipeline = device.createRenderPipeline({
+    label: `${material.name ?? "shader"}-pipeline`,
+    layout: device.createPipelineLayout({ bindGroupLayouts: [getSceneBindGroupLayout(engine), bindings.group1BGL] }),
+    vertex: { module: vertModule, entryPoint: "mainVertex", buffers: vertexBuffers },
+    ...fragModule ? { fragment: { module: fragModule, entryPoint: "mainFragment", targets: colorTarget ? [colorTarget] : [] } } : {},
+    ...sig._depthStencilFormat ? {
+      depthStencil: {
+        format: sig._depthStencilFormat,
+        // The target's declared depth convention wins over the material default: a depth-only
+        // caster authored for the forward-Z shadow map ("less-equal") must still depth-test
+        // correctly when drawn into a reverse-Z camera depth prepass that declares
+        // "greater-equal" — otherwise every fragment fails against the 0-cleared buffer.
+        depthCompare: sig._depthCompare ?? material.depthCompare,
+        depthWriteEnabled: material.needAlphaBlending ? false : material.depthWrite,
+        ...material.depthBias ? { depthBias: material.depthBias } : {},
+        ...material.depthBiasSlopeScale ? { depthBiasSlopeScale: material.depthBiasSlopeScale } : {},
+        // Pre-baked stencil sub-fields, resolved through the opt-in `_stencilResolver` hook above;
+        // applied only on a stencil-capable target — a material reused in the depth32float
+        // shadow/depth pass keeps plain depth state (no stencil → no format mismatch). `stencil`
+        // is a local const that folds to null in stencil-free bundles, so this branch disappears.
+        ...stencil && sig._depthStencilFormat.includes("stencil") ? stencil._desc : {}
+      }
+    } : {},
+    multisample: { count: sig._sampleCount },
+    primitive: { topology: "triangle-list", cullMode: material.backFaceCulling ? "back" : "none", frontFace: "ccw" }
+  });
+  bindings.pipelines.set(key, pipeline);
+  return pipeline;
+}
+function toUboField(decl) {
+  return { _name: decl.name, _type: decl.type };
+}
+function buildBindGroupLayoutEntries(samplers, storageBuffers, hasCustomUbo) {
+  const entries = [{ binding: 0, visibility: SHADER_STAGE_ALL, buffer: { type: "uniform" } }];
+  let nextBinding = 1;
+  if (hasCustomUbo) {
+    entries.push({ binding: nextBinding++, visibility: SHADER_STAGE_ALL, buffer: { type: "uniform" } });
+  }
+  for (const sampler of samplers) {
+    const isArray = sampler.viewDimension === "2d-array";
+    const sampleType = sampler.comparison === true ? "depth" : sampler.sampleType ?? "float";
+    entries.push({
+      binding: nextBinding++,
+      visibility: SHADER_STAGE_ALL,
+      texture: {
+        sampleType,
+        viewDimension: isArray ? "2d-array" : "2d"
+      }
+    });
+    entries.push({
+      binding: nextBinding++,
+      visibility: SHADER_STAGE_ALL,
+      sampler: { type: sampler.comparison === true ? "comparison" : sampleType === "float" ? "filtering" : "non-filtering" }
+    });
+  }
+  for (const _storage of storageBuffers) {
+    entries.push({
+      binding: nextBinding++,
+      visibility: SHADER_STAGE_ALL,
+      buffer: { type: "read-only-storage" }
+    });
+  }
+  return entries;
+}
+function attributeLayout(name, shaderLocation) {
+  switch (name) {
+    case "position":
+    case "normal":
+      return { arrayStride: 12, attributes: [{ shaderLocation, offset: 0, format: "float32x3" }] };
+    case "uv":
+    case "uv2":
+      return { arrayStride: 8, attributes: [{ shaderLocation, offset: 0, format: "float32x2" }] };
+    case "tangent":
+    case "color":
+      return { arrayStride: 16, attributes: [{ shaderLocation, offset: 0, format: "float32x4" }] };
+  }
+}
+function buildShaderPrelude(material, systemSpec, customSpec, instanceAttrs = "") {
+  let wgsl = `${SCENE_UBO_WGSL}
+struct ShaderSystemUniforms {
+${systemSpec._structBody}
+}
+@group(1) @binding(0) var<uniform> shaderSystem: ShaderSystemUniforms;
+`;
+  if (customSpec) {
+    wgsl += `struct ShaderUniforms {
+${customSpec._structBody}
+}
+@group(1) @binding(1) var<uniform> shaderUniforms: ShaderUniforms;
+`;
+  }
+  let nextBinding = customSpec ? 2 : 1;
+  for (const sampler of material.samplerDecls) {
+    const isArray = sampler.viewDimension === "2d-array";
+    const isDepth = sampler.comparison === true || sampler.sampleType === "depth";
+    const texType = isDepth ? isArray ? "texture_depth_2d_array" : "texture_depth_2d" : isArray ? "texture_2d_array<f32>" : "texture_2d<f32>";
+    const samplerType = sampler.comparison === true ? "sampler_comparison" : "sampler";
+    wgsl += `@group(1) @binding(${nextBinding++}) var ${sampler.name}: ${texType};
+@group(1) @binding(${nextBinding++}) var ${sampler.name}Sampler: ${samplerType};
+`;
+  }
+  for (const storage of material.storageBufferDecls) {
+    wgsl += `@group(1) @binding(${nextBinding++}) var<storage, read> ${storage.name}: ${storage.type};
+`;
+  }
+  for (const define of material.defines) {
+    wgsl += `const ${define.name}: ${typeof define.value === "boolean" ? "bool" : "f32"} = ${formatDefineValue(define.value)};
+`;
+  }
+  wgsl += `struct VertexInput {
+`;
+  for (let i = 0; i < material.attributes.length; i++) {
+    const attr = material.attributes[i];
+    wgsl += `@location(${i}) ${attr}: ${attributeWgslType(attr)},
+`;
+  }
+  wgsl += instanceAttrs;
+  wgsl += `};
+`;
+  return wgsl;
+}
+function formatDefineValue(value) {
+  if (typeof value === "boolean") {
+    return value ? "true" : "false";
+  }
+  if (Number.isInteger(value)) {
+    return `${value}.0`;
+  }
+  return String(value);
+}
+function attributeWgslType(name) {
+  switch (name) {
+    case "position":
+    case "normal":
+      return "vec3<f32>";
+    case "uv":
+    case "uv2":
+      return "vec2<f32>";
+    case "tangent":
+    case "color":
+      return "vec4<f32>";
+  }
+}
+function enableMaterialStencil() {
+  _installPbrStencilResolver(_resolveStencil);
+  _installStandardStencilResolver(_resolveStencil);
+  _installShaderStencilResolver(_resolveStencil);
+}
 async function enableMaterialTracking(material) {
   const source = getMaterialSource(material);
   if ("specularPower" in source) {
-    const { installStdTracking } = await import("./std-tracking-Bw61Dv98.js");
+    const { installStdTracking } = await import("./std-tracking-4SHTntWt.js");
     installStdTracking(source);
   } else {
-    const { installPbrTracking } = await import("./pbr-tracking-CdeqbBrh.js");
+    const { installPbrTracking } = await import("./pbr-tracking-BWWSjls_.js");
     installPbrTracking(source);
   }
 }
@@ -14005,24 +15182,28 @@ const TYPE_SIZES = {
 };
 function resolveAccessor(json, binChunk, accessorIdx) {
   const accessor = json.accessors[accessorIdx];
-  const bufferView = json.bufferViews[accessor.bufferView];
   const componentCount = TYPE_SIZES[accessor.type] ?? 1;
-  const byteOffset = (bufferView.byteOffset ?? 0) + (accessor.byteOffset ?? 0);
   const count = accessor.count;
-  const baseOffset = binChunk.byteOffset + byteOffset;
-  const ab2 = binChunk.buffer;
+  const len2 = count * componentCount;
+  let Ctor;
   switch (accessor.componentType) {
     case FLOAT:
-      return { _data: new F32(ab2, baseOffset, count * componentCount), _count: count, _componentCount: componentCount };
+      Ctor = F32;
+      break;
     case UNSIGNED_SHORT:
-      return { _data: new U16(ab2, baseOffset, count * componentCount), _count: count, _componentCount: componentCount };
+      Ctor = U16;
+      break;
     case UNSIGNED_INT:
-      return { _data: new U32(ab2, baseOffset, count * componentCount), _count: count, _componentCount: componentCount };
+      Ctor = U32;
+      break;
     case UNSIGNED_BYTE:
-      return { _data: new U8(ab2, baseOffset, count * componentCount), _count: count, _componentCount: componentCount };
+      Ctor = U8;
+      break;
     default:
       throw new Error(`Unsupported component type: ${accessor.componentType}`);
   }
+  const data = accessor.bufferView === void 0 ? new Ctor(len2) : new Ctor(binChunk.buffer, binChunk.byteOffset + (json.bufferViews[accessor.bufferView].byteOffset ?? 0) + (accessor.byteOffset ?? 0), len2);
+  return { _data: data, _count: count, _componentCount: componentCount };
 }
 function getTextureImageIndex(tex) {
   var _a, _b2;
@@ -14288,14 +15469,14 @@ async function runMatExts(mat, exts, ctx) {
 }
 let _interleavePromise;
 function loadInterleave() {
-  return _interleavePromise ?? (_interleavePromise = import("./gltf-interleave-OBqmlu-h.js"));
+  return _interleavePromise ?? (_interleavePromise = import("./gltf-interleave-BdKrRH3j.js"));
 }
-async function loadGltf(engine, url) {
+async function loadGltf(engine, source) {
   var _a;
-  const { json, binChunk, baseUrl } = await fetchGltfAsset(url);
+  const { json, binChunk, baseUrl } = await fetchGltfAsset(source);
   const parentMap = buildParentMap(json);
   const worldMatrixCache = /* @__PURE__ */ new Map();
-  const features = assetUsesGltfFeatures(json) ? await (await import("./gltf-feature-registry-wNbt6UC-.js")).loadGltfFeatures(json) : [];
+  const features = assetUsesGltfFeatures(json) ? await (await import("./gltf-feature-registry-DfOiNmhR.js")).loadGltfFeatures(json) : [];
   let activeBin = binChunk;
   for (const f of features) {
     if (f.preParse) {
@@ -14339,27 +15520,35 @@ async function loadGltf(engine, url) {
   }
   return container;
 }
-async function fetchGltfAsset(url) {
+async function fetchGltfAsset(source) {
   var _a;
-  const baseUrl = url.substring(0, url.lastIndexOf("/") + 1);
-  if (url.toLowerCase().endsWith(".glb")) {
-    const buffer = await fetch(url).then((r) => r.arrayBuffer());
-    const { parseGlbContainer } = await import("./gltf-glb-parser-DSQWsT4r.js");
-    const { json: json2, binChunk: binChunk2 } = parseGlbContainer(buffer);
-    return { json: json2, binChunk: binChunk2, baseUrl };
-  }
-  const json = await fetch(url).then((r) => r.json());
+  const isUrl = typeof source === "string";
+  const baseUrl = isUrl ? source.substring(0, source.lastIndexOf("/") + 1) : "";
+  const buffer = isUrl ? await fetch(source).then((r) => r.arrayBuffer()) : source instanceof Blob ? await source.arrayBuffer() : source;
+  if (buffer.byteLength >= 4 && new DV$1(buffer).getUint32(0, true) === 1179937895) {
+    const { parseGlbContainer } = await import("./gltf-glb-parser-DXMAJA8e.js");
+    return { ...parseGlbContainer(buffer), baseUrl };
+  }
+  const json = JSON.parse(new TextDecoder().decode(buffer));
   const bufferDef = (_a = json.buffers) == null ? void 0 : _a[0];
   let binChunk;
   if (bufferDef == null ? void 0 : bufferDef.uri) {
-    const binUrl = new URL(bufferDef.uri, baseUrl + "x").href;
-    const binBuffer = await fetch(binUrl).then((r) => r.arrayBuffer());
-    binChunk = new DV$1(binBuffer);
+    binChunk = new DV$1(await fetch(resolveBufferUri(bufferDef.uri, baseUrl)).then((r) => r.arrayBuffer()));
   } else {
     binChunk = new DV$1(new ArrayBuffer(0));
   }
   return { json, binChunk, baseUrl };
 }
+function resolveBufferUri(uri, baseUrl) {
+  if (baseUrl) {
+    return new URL(uri, baseUrl + "x").href;
+  }
+  try {
+    return new URL(uri).href;
+  } catch {
+    throw new Error(`loadGltf: relative buffer URI "${uri}" needs a base URL — load from a URL, or use a self-contained GLB/data: URI glTF.`);
+  }
+}
 function assetUsesGltfFeatures(json) {
   var _a, _b2, _c;
   return !!(((_a = json.extensionsUsed) == null ? void 0 : _a.length) || ((_b2 = json.animations) == null ? void 0 : _b2.length) || ((_c = json.skins) == null ? void 0 : _c.length) && anyPrimitive(json, (p3) => {
@@ -14554,7 +15743,7 @@ async function uploadMeshes(meshDatas, features, ctx) {
     }
   }
   let _pbrExtPromise = null;
-  const _ensurePbrExt = () => _pbrExtPromise ?? (_pbrExtPromise = import("./gltf-pbr-builder-ext-3imk8Tev.js"));
+  const _ensurePbrExt = () => _pbrExtPromise ?? (_pbrExtPromise = import("./gltf-pbr-builder-ext-DJ8Jm7jo.js"));
   const builtMaterialCache = /* @__PURE__ */ new Map();
   async function buildPbrFromGltfMat(mat) {
     let cached = builtMaterialCache.get(mat);
@@ -14673,16 +15862,199 @@ function resetVariant(container) {
     entry.mesh.material = entry.material;
   }
 }
+let dracoBaseUrl = "/";
+function setDracoBaseUrl(url) {
+  dracoBaseUrl = url.endsWith("/") ? url : url + "/";
+}
+let modulePromise = null;
+let scriptLoadPromise$1 = null;
+function loadDracoScript() {
+  if (scriptLoadPromise$1) {
+    return scriptLoadPromise$1;
+  }
+  scriptLoadPromise$1 = new Promise((resolve, reject) => {
+    const existing = globalThis.DracoDecoderModule;
+    if (existing) {
+      resolve(existing);
+      return;
+    }
+    const script = document.createElement("script");
+    script.src = dracoBaseUrl + "draco_decoder.js";
+    script.onload = () => {
+      const factory = globalThis.DracoDecoderModule;
+      if (!factory) {
+        reject(new Error("draco_decoder.js loaded but DracoDecoderModule is undefined"));
+      } else {
+        resolve(factory);
+      }
+    };
+    script.onerror = () => reject(new Error("Failed to load draco_decoder.js from " + script.src));
+    document.head.appendChild(script);
+  });
+  return scriptLoadPromise$1;
+}
+async function getDracoModule() {
+  if (modulePromise) {
+    return modulePromise;
+  }
+  modulePromise = (async () => {
+    const factory = await loadDracoScript();
+    return factory({ locateFile: (f) => dracoBaseUrl + f });
+  })();
+  return modulePromise;
+}
+async function decodeDracoPrimitive(compressed, attributeMap, accessorTypes) {
+  const module = await getDracoModule();
+  const decoder = new module.Decoder();
+  const buffer = new module.DecoderBuffer();
+  buffer.Init(compressed, compressed.byteLength);
+  const mesh = new module.Mesh();
+  const status = decoder.DecodeBufferToMesh(buffer, mesh);
+  if (!status.ok()) {
+    const err = status.error_msg();
+    module.destroy(buffer);
+    module.destroy(mesh);
+    module.destroy(decoder);
+    throw new Error("Draco decode failed: " + err);
+  }
+  const numPoints = mesh.num_points();
+  const numFaces = mesh.num_faces();
+  const indexCount = numFaces * 3;
+  const indexByteLength = indexCount * 4;
+  const indexPtr = module._malloc(indexByteLength);
+  decoder.GetTrianglesUInt32Array(mesh, indexByteLength, indexPtr);
+  const indices = new U32(module.HEAPU32.buffer, indexPtr, indexCount).slice();
+  module._free(indexPtr);
+  const attributes = /* @__PURE__ */ new Map();
+  for (const name of Object.keys(attributeMap)) {
+    const uniqueId = attributeMap[name];
+    const attr = decoder.GetAttributeByUniqueId(mesh, uniqueId);
+    const componentCount = accessorTypes[name] ?? 3;
+    const totalComponents = numPoints * componentCount;
+    const isIntAttr = name === "JOINTS_0" || name === "JOINTS_1";
+    const bytesPerElement = 4;
+    const byteLength = totalComponents * bytesPerElement;
+    const ptr = module._malloc(byteLength);
+    const dataType = isIntAttr ? module.DT_INT32 : module.DT_FLOAT32;
+    decoder.GetAttributeDataArrayForAllPoints(mesh, attr, dataType, byteLength, ptr);
+    if (isIntAttr) {
+      attributes.set(name, new I32(module.HEAP32.buffer, ptr, totalComponents).slice());
+    } else {
+      attributes.set(name, new F32(module.HEAPF32.buffer, ptr, totalComponents).slice());
+    }
+    module._free(ptr);
+  }
+  module.destroy(buffer);
+  module.destroy(mesh);
+  module.destroy(decoder);
+  return { _attributes: attributes, _indices: indices, _vertexCount: numPoints, _indexCount: indexCount };
+}
+function getDracoBufferViewBytes(json, binChunk, bufferViewIdx) {
+  const view = json.bufferViews[bufferViewIdx];
+  if (!view) {
+    throw new Error(`Draco bufferView ${bufferViewIdx} not found`);
+  }
+  const offset = binChunk.byteOffset + (view.byteOffset ?? 0);
+  return new U8(binChunk.buffer, offset, view.byteLength);
+}
+let meshoptBaseUrl = "/";
+function setMeshoptBaseUrl(url) {
+  meshoptBaseUrl = url.endsWith("/") ? url : url + "/";
+}
+let scriptLoadPromise = null;
+function loadMeshoptScript() {
+  if (scriptLoadPromise) {
+    return scriptLoadPromise;
+  }
+  scriptLoadPromise = new Promise((resolve, reject) => {
+    const existing = globalThis.MeshoptDecoder;
+    if (existing) {
+      resolve(existing);
+      return;
+    }
+    const script = document.createElement("script");
+    script.src = meshoptBaseUrl + "meshopt_decoder.js";
+    script.onload = () => {
+      const mod = globalThis.MeshoptDecoder;
+      if (!mod) {
+        reject(new Error("meshopt_decoder.js loaded but MeshoptDecoder is undefined"));
+      } else {
+        resolve(mod);
+      }
+    };
+    script.onerror = () => reject(new Error("Failed to load meshopt_decoder.js from " + script.src));
+    document.head.appendChild(script);
+  });
+  return scriptLoadPromise;
+}
+async function getMeshoptDecoder() {
+  const mod = await loadMeshoptScript();
+  await mod.ready;
+  return mod;
+}
 function mat4Multiply(a, b) {
   const out = new F32(16);
   mat4MultiplyInto(out, 0, a, 0, b, 0);
   return out;
 }
+function _quatFromRotationBasis(m11, m12, m13, m21, m22, m23, m31, m32, m33) {
+  const trace = m11 + m22 + m33;
+  let s;
+  if (trace > 0) {
+    s = 0.5 / Math.sqrt(trace + 1);
+    return { x: (m32 - m23) * s, y: (m13 - m31) * s, z: (m21 - m12) * s, w: 0.25 / s };
+  }
+  if (m11 > m22 && m11 > m33) {
+    s = 2 * Math.sqrt(1 + m11 - m22 - m33);
+    return { x: 0.25 * s, y: (m12 + m21) / s, z: (m13 + m31) / s, w: (m32 - m23) / s };
+  }
+  if (m22 > m33) {
+    s = 2 * Math.sqrt(1 + m22 - m11 - m33);
+    return { x: (m12 + m21) / s, y: 0.25 * s, z: (m23 + m32) / s, w: (m13 - m31) / s };
+  }
+  s = 2 * Math.sqrt(1 + m33 - m11 - m22);
+  return { x: (m13 + m31) / s, y: (m23 + m32) / s, z: 0.25 * s, w: (m21 - m12) / s };
+}
+function quatFromRotationMatrix(matrix) {
+  return _quatFromRotationBasis(matrix[0], matrix[4], matrix[8], matrix[1], matrix[5], matrix[9], matrix[2], matrix[6], matrix[10]);
+}
+function mat4Decompose(m2) {
+  const sx = Math.hypot(m2[0], m2[1], m2[2]);
+  const sy = Math.hypot(m2[4], m2[5], m2[6]);
+  const sz = Math.hypot(m2[8], m2[9], m2[10]);
+  const invSx = sx > 1e-8 ? 1 / sx : 0;
+  const invSy = sy > 1e-8 ? 1 / sy : 0;
+  const invSz = sz > 1e-8 ? 1 / sz : 0;
+  const q = _quatFromRotationBasis(m2[0] * invSx, m2[4] * invSy, m2[8] * invSz, m2[1] * invSx, m2[5] * invSy, m2[9] * invSz, m2[2] * invSx, m2[6] * invSy, m2[10] * invSz);
+  const invLen = 1 / Math.hypot(q.x, q.y, q.z, q.w);
+  return {
+    translation: { x: m2[12], y: m2[13], z: m2[14] },
+    rotation: { x: q.x * invLen, y: q.y * invLen, z: q.z * invLen, w: q.w * invLen },
+    scale: { x: sx, y: sy, z: sz }
+  };
+}
+function childrenOf(node) {
+  const kids = node == null ? void 0 : node.children;
+  return Array.isArray(kids) ? kids : null;
+}
 function setParent(child, parent) {
   const childWorld = child.worldMatrix;
-  child.parent = parent;
+  if (child.parent !== parent) {
+    const oldChildren = childrenOf(child.parent);
+    if (oldChildren) {
+      const i = oldChildren.indexOf(child);
+      if (i >= 0) {
+        oldChildren.splice(i, 1);
+      }
+    }
+    child.parent = parent;
+    const newChildren = childrenOf(parent);
+    if (newChildren && newChildren.indexOf(child) < 0) {
+      newChildren.push(child);
+    }
+  }
   if (!parent) {
-    decomposeInto(childWorld, child);
+    applyLocal(childWorld, child);
     return;
   }
   const parentWorld = parent.worldMatrix;
@@ -14691,30 +16063,13 @@ function setParent(child, parent) {
     child.position.set(childWorld[12], childWorld[13], childWorld[14]);
     return;
   }
-  const newLocal = mat4Multiply(invParent, childWorld);
-  decomposeInto(newLocal, child);
+  applyLocal(mat4Multiply(invParent, childWorld), child);
 }
-function decomposeInto(m2, mesh) {
-  mesh.position.set(m2[12], m2[13], m2[14]);
-  const sx = Math.sqrt(m2[0] * m2[0] + m2[1] * m2[1] + m2[2] * m2[2]);
-  const sy = Math.sqrt(m2[4] * m2[4] + m2[5] * m2[5] + m2[6] * m2[6]);
-  const sz = Math.sqrt(m2[8] * m2[8] + m2[9] * m2[9] + m2[10] * m2[10]);
-  if (sx > 1e-6 && sy > 1e-6 && sz > 1e-6) {
-    const r00 = m2[0] / sx, r01 = m2[4] / sy, r02 = m2[8] / sz;
-    const r10 = m2[1] / sx, r11 = m2[5] / sy, r12 = m2[9] / sz;
-    const r22 = m2[10] / sz;
-    const ry = Math.asin(Math.max(-1, Math.min(1, r02)));
-    let rx2, rz;
-    if (Math.abs(r02) < 0.9999) {
-      rx2 = Math.atan2(-r12, r22);
-      rz = Math.atan2(-r01, r00);
-    } else {
-      rx2 = Math.atan2(r10, r11);
-      rz = 0;
-    }
-    mesh.rotation.set(rx2, ry, rz);
-    mesh.scaling.set(sx, sy, sz);
-  }
+function applyLocal(m2, node) {
+  const { translation, rotation, scale } = mat4Decompose(m2);
+  node.position.set(translation.x, translation.y, translation.z);
+  node.rotationQuaternion.set(rotation.x, rotation.y, rotation.z, rotation.w);
+  node.scaling.set(scale.x, scale.y, scale.z);
 }
 const TEX_SLOTS = [
   {
@@ -15017,7 +16372,7 @@ async function loadBabylon(engine, url, opts = {}) {
     }
   }
   const camData = opts.loadCamera !== false && ((_v = data.cameras) == null ? void 0 : _v.length) ? (data.activeCameraID ? data.cameras.find((c2) => c2.id === data.activeCameraID) : null) ?? data.cameras[0] : null;
-  const camera = camData ? (await import("./parse-camera-5IGdctAS.js")).parseBabylonCamera(camData) : void 0;
+  const camera = camData ? (await import("./parse-camera-uQ8oKgeH.js")).parseBabylonCamera(camData) : void 0;
   const rootMeshes = allMeshes.filter((m2) => !childNodeIds.has(m2.id));
   const rootTransformNodes = [];
   for (const [id, node] of nodeMap) {
@@ -15114,7 +16469,7 @@ async function loadEnvironment(scene, url, options) {
   const envBuffer = await envPromise;
   const { faceBlobs, irradianceSH, width, mipCount } = parseEnvFile(envBuffer);
   const faceImages = await Promise.all(faceBlobs.map((blob2) => createImageBitmap(blob2, { premultiplyAlpha: "none", colorSpaceConversion: "none" })));
-  const { uploadCubemapRGBD, decodeBrdfPng } = await import("./rgbd-decode-duTlXMWd.js");
+  const { uploadCubemapRGBD, decodeBrdfPng } = await import("./rgbd-decode-CAQ7XSwl.js");
   const specularCube = uploadCubemapRGBD(engine, faceImages, width, mipCount);
   for (const img of faceImages) {
     img.close();
@@ -15148,19 +16503,19 @@ async function loadEnvironment(scene, url, options) {
     const { groundSize, skyboxSize: autoSkyboxSize, rootPosition } = computeSceneSize(scene, options == null ? void 0 : options.skyboxSize);
     const skyHalfSize = autoSkyboxSize / 2;
     if (!bgOptions.skipSkybox) {
-      const { buildSolidSkyboxRenderable } = await import("./background-solid-skybox-DOOBeDIz.js");
+      const { buildSolidSkyboxRenderable } = await import("./background-solid-skybox-CkmGuOn5.js");
       scene._renderables.push(buildSolidSkyboxRenderable(scene, textures, skyHalfSize, rootPosition, primaryColor));
     }
     if (!bgOptions.skipGround) {
-      const { buildGroundRenderable } = await import("./background-ground-Bm6gjWqx.js");
+      const { buildGroundRenderable } = await import("./background-ground-ClcWiDuF.js");
       scene._renderables.push(await buildGroundRenderable(engine, groundSize, rootPosition, primaryColor, groundUrl, groundTexPromise));
     }
     if (skyboxIsDds) {
-      const { buildDdsSkyboxRenderable } = await import("./background-dds-skybox-BpcDr-9c.js");
+      const { buildDdsSkyboxRenderable } = await import("./background-dds-skybox-Cv92mmdC.js");
       scene._renderables.push(await buildDdsSkyboxRenderable(scene, skyHalfSize, rootPosition, primaryColor, skyboxUrl));
     }
     if (skyboxIsEnv) {
-      const { buildHdrSkyboxRenderable } = await import("./background-hdr-skybox-CSFo8RX6.js");
+      const { buildHdrSkyboxRenderable } = await import("./background-hdr-skybox-MfAwLhVx.js");
       scene._renderables.push(buildHdrSkyboxRenderable(scene, textures, skyHalfSize, rootPosition, primaryColor));
     }
   });
@@ -15413,7 +16768,7 @@ async function loadDdsEnvironment(scene, url, options) {
   }
   const irradianceSH = computeSH(raw, width, mipCount);
   const brdfImage = await brdfPromise;
-  const { decodeBrdfPng } = await import("./rgbd-decode-duTlXMWd.js");
+  const { decodeBrdfPng } = await import("./rgbd-decode-CAQ7XSwl.js");
   const brdfLut = decodeBrdfPng(engine, brdfImage);
   brdfImage.close();
   const textures = assembleEnvironmentTextures(specularCube, brdfLut, irradianceSH, 0.8, engine);
@@ -15739,7 +17094,7 @@ async function loadHdrEnvironment(scene, url, options) {
       const { computeSceneSize: computeSceneSize2 } = await Promise.resolve().then(() => sceneSize);
       const { skyboxSize: autoSkyboxSize, rootPosition } = computeSceneSize2(scene, options == null ? void 0 : options.skyboxSize);
       const primaryColor = scene.environmentPrimaryColor ?? [0.08697355964132344, 0.08697355964132344, 0.2122208331110881];
-      const { buildHdrSkyboxRenderable } = await import("./background-hdr-skybox-CSFo8RX6.js");
+      const { buildHdrSkyboxRenderable } = await import("./background-hdr-skybox-MfAwLhVx.js");
       scene._renderables.push(buildHdrSkyboxRenderable(scene, textures, autoSkyboxSize / 2, rootPosition, primaryColor));
     }
     if (!useHdr || !skipGround) {
@@ -15747,11 +17102,11 @@ async function loadHdrEnvironment(scene, url, options) {
       const { computeSceneSize: computeSceneSize2 } = await Promise.resolve().then(() => sceneSize);
       const { groundSize, skyboxSize: autoSkyboxSize, rootPosition } = computeSceneSize2(scene, options == null ? void 0 : options.skyboxSize);
       if (!useHdr) {
-        const { buildSolidSkyboxRenderable } = await import("./background-solid-skybox-DOOBeDIz.js");
+        const { buildSolidSkyboxRenderable } = await import("./background-solid-skybox-CkmGuOn5.js");
         scene._renderables.push(buildSolidSkyboxRenderable(scene, textures, autoSkyboxSize / 2, rootPosition, primaryColor));
       }
       if (!skipGround) {
-        const { buildGroundRenderable } = await import("./background-ground-Bm6gjWqx.js");
+        const { buildGroundRenderable } = await import("./background-ground-ClcWiDuF.js");
         scene._renderables.push(await buildGroundRenderable(engine, groundSize, rootPosition, primaryColor));
       }
     }
@@ -15832,7 +17187,7 @@ async function loadSkybox(scene, baseUrl, ext, size = 100) {
     idxCount: boxData.indices.length,
     worldMatrix: world
   };
-  const { buildSkyboxRenderable } = await import("./skybox-renderable-DJYkfw32.js");
+  const { buildSkyboxRenderable } = await import("./skybox-renderable-lbMC32aI.js");
   scene._renderables.push(buildSkyboxRenderable(scene, skyboxData));
 }
 const SH_C0$2 = 0.28209479177387814;
@@ -16590,7 +17945,7 @@ async function attachParsedSplat(scene, name, parsed, fragments) {
   const eng = scene.surface.engine;
   const mesh = createGaussianSplattingMesh(eng, name, geom, worker, parsed);
   if (parsed.sh && parsed.shDegree && parsed.shDegree > 0) {
-    const { attachGaussianSplattingMeshSH } = await import("./gaussian-splatting-pipeline-sh-B30Mu56i.js");
+    const { attachGaussianSplattingMeshSH } = await import("./gaussian-splatting-pipeline-sh-lM48JDca.js");
     attachGaussianSplattingMeshSH(scene, mesh, parsed.sh, fragments);
   } else {
     attachGaussianSplattingMesh(scene, mesh, fragments);
@@ -16606,7 +17961,7 @@ async function loadSplat(scene, url, fragments) {
   let parsed;
   if (isPly(data)) {
     if (isPlyCompressedOrSH(data)) {
-      const { convertCompressedPlyToParsedSplat } = await import("./splat-ply-compressed-SxMlsKNK.js");
+      const { convertCompressedPlyToParsedSplat } = await import("./splat-ply-compressed-B_w2N_V7.js");
       parsed = convertCompressedPlyToParsedSplat(data);
     } else {
       parsed = convertPlyToSplat(data);
@@ -17435,21 +18790,21 @@ async function preloadEsmShadowTaskState(casterMeshes) {
   }
   if (needsStandard && !createStandardEsmShadowMaterialView) {
     loads.push(
-      import("./esm-shadow-view-DmIORQGZ.js").then((module) => {
+      import("./esm-shadow-view-KyVyZnKZ.js").then((module) => {
         createStandardEsmShadowMaterialView = module.createStandardEsmShadowMaterialView;
       })
     );
   }
   if (needsPbr && !createPbrEsmShadowMaterialView) {
     loads.push(
-      import("./esm-shadow-view-DRpyRAfa.js").then((module) => {
+      import("./esm-shadow-view-Cf2PwVNs.js").then((module) => {
         createPbrEsmShadowMaterialView = module.createPbrEsmShadowMaterialView;
       })
     );
   }
   if (needsNode && !createNodeEsmShadowMaterialView) {
     loads.push(
-      import("./esm-shadow-view-JCPaOOi7.js").then((module) => {
+      import("./esm-shadow-view-CcX1jdrL.js").then((module) => {
         createNodeEsmShadowMaterialView = module.createNodeEsmShadowMaterialView;
       })
     );
@@ -18347,12 +19702,14 @@ function _computeCsmCascades(engine, camera, light, cfg, casterMeshes) {
     cy /= 8;
     cz /= 8;
     let minX, maxX, minY, maxY, minEz, maxEz;
+    let stableRadius = 0;
     if (cfg._stabilizeCascades) {
       let radius = 0;
       for (const p3 of corners) {
         radius = Math.max(radius, Math.hypot(p3[0] - cx, p3[1] - cy, p3[2] - cz));
       }
       radius = Math.ceil(radius * 16) / 16;
+      stableRadius = radius;
       minX = minY = minEz = -radius;
       maxX = maxY = maxEz = radius;
     } else {
@@ -18390,6 +19747,11 @@ function _computeCsmCascades(engine, camera, light, cfg, casterMeshes) {
         viewMinZ = Math.min(viewMinZ, cMinZ);
         viewMaxZ = Math.min(viewMaxZ, cMaxZ);
       }
+      if (cfg._stabilizeCascades && stableRadius > 0) {
+        const zq2 = Math.max(0.5, stableRadius / 128);
+        viewMinZ = Math.floor(viewMinZ / zq2) * zq2;
+        viewMaxZ = Math.ceil(viewMaxZ / zq2) * zq2;
+      }
     }
     const proj0 = orthoOffCenterLH(minX, maxX, minY, maxY, viewMinZ, viewMaxZ);
     let transform = multiply4x4(proj0, view);
@@ -18418,6 +19780,19 @@ function _computeCsmCascades(engine, camera, light, cfg, casterMeshes) {
 function _castersWorldAabb(casterMeshes) {
   let minX = Infinity, minY = Infinity, minZ = Infinity, maxX = -Infinity, maxY = -Infinity, maxZ = -Infinity;
   for (const mesh of casterMeshes) {
+    const ti = mesh.thinInstances;
+    if (ti && ti.count > 0 && ti.matrices) {
+      const a = _thinInstanceWorldAabb(mesh, ti);
+      if (a) {
+        minX = Math.min(minX, a._min[0]);
+        maxX = Math.max(maxX, a._max[0]);
+        minY = Math.min(minY, a._min[1]);
+        maxY = Math.max(maxY, a._max[1]);
+        minZ = Math.min(minZ, a._min[2]);
+        maxZ = Math.max(maxZ, a._max[2]);
+      }
+      continue;
+    }
     const world = mesh.worldMatrix;
     const bmin = mesh.boundMin ?? [-0.5, -0.5, -0.5];
     const bmax = mesh.boundMax ?? [0.5, 0.5, 0.5];
@@ -18441,6 +19816,66 @@ function _castersWorldAabb(casterMeshes) {
   }
   return { _min: [minX, minY, minZ], _max: [maxX, maxY, maxZ] };
 }
+let _thinCasterAabbCache = null;
+function _getThinCasterAabbCache() {
+  if (!_thinCasterAabbCache) {
+    _thinCasterAabbCache = /* @__PURE__ */ new WeakMap();
+  }
+  return _thinCasterAabbCache;
+}
+function _thinInstanceWorldAabb(mesh, ti) {
+  const cache = _getThinCasterAabbCache();
+  const worldVersion = mesh.worldMatrixVersion;
+  const cached = cache.get(mesh);
+  if (cached && cached._version === ti._version && cached._worldVersion === worldVersion) {
+    return cached._aabb;
+  }
+  const world = mesh.worldMatrix;
+  const bmin = mesh.boundMin ?? [-0.5, -0.5, -0.5];
+  const bmax = mesh.boundMax ?? [0.5, 0.5, 0.5];
+  const mats = ti.matrices;
+  const count = Math.min(ti.count, mats.length / 16 | 0);
+  let minX = Infinity, minY = Infinity, minZ = Infinity, maxX = -Infinity, maxY = -Infinity, maxZ = -Infinity;
+  for (let i = 0; i < count; i++) {
+    const o3 = i * 16;
+    const lin = Math.abs(mats[o3]) + Math.abs(mats[o3 + 1]) + Math.abs(mats[o3 + 2]) + Math.abs(mats[o3 + 4]) + Math.abs(mats[o3 + 5]) + Math.abs(mats[o3 + 6]) + Math.abs(mats[o3 + 8]) + Math.abs(mats[o3 + 9]) + Math.abs(mats[o3 + 10]);
+    if (lin < 1e-9) {
+      continue;
+    }
+    for (let k = 0; k < 8; k++) {
+      const lx = k & 1 ? bmax[0] : bmin[0];
+      const ly = k & 2 ? bmax[1] : bmin[1];
+      const lz = k & 4 ? bmax[2] : bmin[2];
+      const ix2 = mats[o3] * lx + mats[o3 + 4] * ly + mats[o3 + 8] * lz + mats[o3 + 12];
+      const iy = mats[o3 + 1] * lx + mats[o3 + 5] * ly + mats[o3 + 9] * lz + mats[o3 + 13];
+      const iz = mats[o3 + 2] * lx + mats[o3 + 6] * ly + mats[o3 + 10] * lz + mats[o3 + 14];
+      const wx = world[0] * ix2 + world[4] * iy + world[8] * iz + world[12];
+      const wy = world[1] * ix2 + world[5] * iy + world[9] * iz + world[13];
+      const wz = world[2] * ix2 + world[6] * iy + world[10] * iz + world[14];
+      if (wx < minX) {
+        minX = wx;
+      }
+      if (wx > maxX) {
+        maxX = wx;
+      }
+      if (wy < minY) {
+        minY = wy;
+      }
+      if (wy > maxY) {
+        maxY = wy;
+      }
+      if (wz < minZ) {
+        minZ = wz;
+      }
+      if (wz > maxZ) {
+        maxZ = wz;
+      }
+    }
+  }
+  const aabb = Number.isFinite(minX) ? { _min: [minX, minY, minZ], _max: [maxX, maxY, maxZ] } : null;
+  cache.set(mesh, { _version: ti._version, _worldVersion: worldVersion, _aabb: aabb });
+  return aabb;
+}
 function _writeCsmUbo(out, cascades, cfg) {
   out.fill(0);
   const n3 = cascades._transforms.length;
@@ -18771,13 +20206,23 @@ function evaluateSampler(sampler, t, stride, isQuat, dst, dstOffset) {
     }
   }
 }
-const _boneTmp$1 = new F32(16);
-const RH_TO_LH$1 = new F32([-1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]);
-const TRS_STRIDE$1 = 12;
-const T_OFF$1 = 0;
-const R_OFF$1 = 3;
-const S_OFF$1 = 7;
-function computeTopoOrder$1(nodes) {
+let _boneBuilder = null;
+let _boneApplier = null;
+function _installBoneControl(builder, applier) {
+  _boneBuilder = builder;
+  _boneApplier = applier;
+}
+const _boneTmp$2 = new F32(16);
+let _maskResolver = null;
+function _installAnimationMaskResolver(resolver) {
+  _maskResolver = resolver;
+}
+const RH_TO_LH$2 = new F32([-1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]);
+const TRS_STRIDE$2 = 12;
+const T_OFF$2 = 0;
+const R_OFF$2 = 3;
+const S_OFF$2 = 7;
+function computeTopoOrder$2(nodes) {
   const n3 = nodes.length;
   const order = new I32(n3);
   const visited = new U8(n3);
@@ -18798,7 +20243,7 @@ function computeTopoOrder$1(nodes) {
   }
   return order;
 }
-function createAnimationController(clip, nodes, skeletons, morphBindings, nodeTargets, excludedNodeIndices) {
+function createAnimationController(clip, nodes, skeletons, morphBindings, nodeTargets, excludedNodeIndices, boneOverrides, nodeNames) {
   const requiresEngine = skeletons.length > 0 || morphBindings.length > 0;
   const numNodes = nodes.length;
   const nodeTrsBindings = [];
@@ -18817,13 +20262,13 @@ function createAnimationController(clip, nodes, skeletons, morphBindings, nodeTa
       maskByNode.set(ni, (maskByNode.get(ni) ?? 0) | bit);
     }
     for (const [ni, mask] of maskByNode) {
-      nodeTrsBindings.push({ target: nodeTargets[ni], off: ni * TRS_STRIDE$1, mask });
+      nodeTrsBindings.push({ target: nodeTargets[ni], off: ni * TRS_STRIDE$2, mask });
     }
   }
-  const currentTRS = new F32(numNodes * TRS_STRIDE$1);
+  const currentTRS = new F32(numNodes * TRS_STRIDE$2);
   const localMat = new F32(numNodes * 16);
   const worldMat = new F32(numNodes * 16);
-  const topoOrder = computeTopoOrder$1(nodes);
+  const topoOrder = computeTopoOrder$2(nodes);
   const boneScratch = skeletons.map((s) => s.boneMatrices);
   const morphBindingsByNode = [];
   for (let morphIndex = 0; morphIndex < morphBindings.length; morphIndex++) {
@@ -18838,11 +20283,40 @@ function createAnimationController(clip, nodes, skeletons, morphBindings, nodeTa
   const morphUploadF32 = new F32(4);
   const pointerScratch = new F32(16);
   let cachedEngine;
+  let maskedNodes = null;
+  let maskActive = false;
+  let cMask = null;
+  let cNames = null;
+  let cLen = -1;
+  let cMode = -1;
+  let cDisabled = false;
+  const _setMask = (mask) => {
+    if (!mask || mask.disabled || !nodeNames || !_maskResolver) {
+      maskActive = false;
+      return;
+    }
+    const names = mask.names;
+    if (mask === cMask && names === cNames && names.length === cLen && mask.mode === cMode && mask.disabled === cDisabled) {
+      maskActive = true;
+      return;
+    }
+    cMask = mask;
+    cNames = names;
+    cLen = names.length;
+    cMode = mask.mode;
+    cDisabled = mask.disabled;
+    if (!maskedNodes) {
+      maskedNodes = new U8(numNodes);
+    }
+    _maskResolver(mask, nodeNames, maskedNodes, numNodes);
+    maskActive = true;
+  };
   const ctrl = {
     time: 0,
     playing: true,
     speedRatio: 1,
     loop: true,
+    _setMask,
     _debugWorldMat: worldMat,
     tick: clip.duration <= 0 ? noopAnimationTick : (deltaMs, engine) => {
       var _a, _b2;
@@ -18868,31 +20342,37 @@ function createAnimationController(clip, nodes, skeletons, morphBindings, nodeTa
       const t = ctrl.time;
       for (let i = 0; i < numNodes; i++) {
         const n3 = nodes[i];
-        const off = i * TRS_STRIDE$1;
-        currentTRS[off + T_OFF$1] = n3.tx;
-        currentTRS[off + T_OFF$1 + 1] = n3.ty;
-        currentTRS[off + T_OFF$1 + 2] = n3.tz;
-        currentTRS[off + R_OFF$1] = n3.rx;
-        currentTRS[off + R_OFF$1 + 1] = n3.ry;
-        currentTRS[off + R_OFF$1 + 2] = n3.rz;
-        currentTRS[off + R_OFF$1 + 3] = n3.rw;
-        currentTRS[off + S_OFF$1] = n3.sx;
-        currentTRS[off + S_OFF$1 + 1] = n3.sy;
-        currentTRS[off + S_OFF$1 + 2] = n3.sz;
+        const off = i * TRS_STRIDE$2;
+        currentTRS[off + T_OFF$2] = n3.tx;
+        currentTRS[off + T_OFF$2 + 1] = n3.ty;
+        currentTRS[off + T_OFF$2 + 2] = n3.tz;
+        currentTRS[off + R_OFF$2] = n3.rx;
+        currentTRS[off + R_OFF$2 + 1] = n3.ry;
+        currentTRS[off + R_OFF$2 + 2] = n3.rz;
+        currentTRS[off + R_OFF$2 + 3] = n3.rw;
+        currentTRS[off + S_OFF$2] = n3.sx;
+        currentTRS[off + S_OFF$2 + 1] = n3.sy;
+        currentTRS[off + S_OFF$2 + 2] = n3.sz;
+      }
+      if (boneOverrides !== void 0 && boneOverrides.size > 0) {
+        _boneApplier == null ? void 0 : _boneApplier(boneOverrides, currentTRS, numNodes);
       }
       for (let channelIndex = 0; channelIndex < clip.channels.length; channelIndex++) {
         const ch = clip.channels[channelIndex];
+        if (_maskResolver !== null && maskActive && ch.nodeIdx >= 0 && maskedNodes[ch.nodeIdx]) {
+          continue;
+        }
         const sampler = clip.samplers[ch.samplerIdx];
-        const base = ch.nodeIdx * TRS_STRIDE$1;
+        const base = ch.nodeIdx * TRS_STRIDE$2;
         switch (ch.path) {
           case PATH_TRANSLATION:
-            evaluateSampler(sampler, t, 3, false, currentTRS, base + T_OFF$1);
+            evaluateSampler(sampler, t, 3, false, currentTRS, base + T_OFF$2);
             break;
           case PATH_ROTATION:
-            evaluateSampler(sampler, t, 4, true, currentTRS, base + R_OFF$1);
+            evaluateSampler(sampler, t, 4, true, currentTRS, base + R_OFF$2);
             break;
           case PATH_SCALE:
-            evaluateSampler(sampler, t, 3, false, currentTRS, base + S_OFF$1);
+            evaluateSampler(sampler, t, 3, false, currentTRS, base + S_OFF$2);
             break;
           case PATH_WEIGHTS: {
             const bindings = morphBindingsByNode[ch.nodeIdx];
@@ -18921,42 +20401,42 @@ function createAnimationController(clip, nodes, skeletons, morphBindings, nodeTa
         const b = nodeTrsBindings[bi];
         const o3 = b.off;
         if (b.mask & 1) {
-          b.target.position.set(currentTRS[o3 + T_OFF$1], currentTRS[o3 + T_OFF$1 + 1], currentTRS[o3 + T_OFF$1 + 2]);
+          b.target.position.set(currentTRS[o3 + T_OFF$2], currentTRS[o3 + T_OFF$2 + 1], currentTRS[o3 + T_OFF$2 + 2]);
         }
         if (b.mask & 2) {
-          b.target.rotationQuaternion.set(currentTRS[o3 + R_OFF$1], currentTRS[o3 + R_OFF$1 + 1], currentTRS[o3 + R_OFF$1 + 2], currentTRS[o3 + R_OFF$1 + 3]);
+          b.target.rotationQuaternion.set(currentTRS[o3 + R_OFF$2], currentTRS[o3 + R_OFF$2 + 1], currentTRS[o3 + R_OFF$2 + 2], currentTRS[o3 + R_OFF$2 + 3]);
         }
         if (b.mask & 4) {
-          b.target.scaling.set(currentTRS[o3 + S_OFF$1], currentTRS[o3 + S_OFF$1 + 1], currentTRS[o3 + S_OFF$1 + 2]);
+          b.target.scaling.set(currentTRS[o3 + S_OFF$2], currentTRS[o3 + S_OFF$2 + 1], currentTRS[o3 + S_OFF$2 + 2]);
         }
       }
       for (let idx = 0; idx < numNodes; idx++) {
         const nodeIdx = topoOrder[idx];
         const node = nodes[nodeIdx];
-        const off = nodeIdx * TRS_STRIDE$1;
+        const off = nodeIdx * TRS_STRIDE$2;
         if (node._matrix) {
           localMat.set(node._matrix, nodeIdx * 16);
         } else {
           mat4ComposeInto(
             localMat,
             nodeIdx * 16,
-            currentTRS[off + T_OFF$1],
-            currentTRS[off + T_OFF$1 + 1],
-            currentTRS[off + T_OFF$1 + 2],
-            currentTRS[off + R_OFF$1],
-            currentTRS[off + R_OFF$1 + 1],
-            currentTRS[off + R_OFF$1 + 2],
-            currentTRS[off + R_OFF$1 + 3],
-            currentTRS[off + S_OFF$1],
-            currentTRS[off + S_OFF$1 + 1],
-            currentTRS[off + S_OFF$1 + 2]
+            currentTRS[off + T_OFF$2],
+            currentTRS[off + T_OFF$2 + 1],
+            currentTRS[off + T_OFF$2 + 2],
+            currentTRS[off + R_OFF$2],
+            currentTRS[off + R_OFF$2 + 1],
+            currentTRS[off + R_OFF$2 + 2],
+            currentTRS[off + R_OFF$2 + 3],
+            currentTRS[off + S_OFF$2],
+            currentTRS[off + S_OFF$2 + 1],
+            currentTRS[off + S_OFF$2 + 2]
           );
         }
         const parentIdx = node.parentIdx;
         if (parentIdx >= 0) {
           mat4MultiplyInto(worldMat, nodeIdx * 16, worldMat, parentIdx * 16, localMat, nodeIdx * 16);
         } else {
-          mat4MultiplyInto(worldMat, nodeIdx * 16, RH_TO_LH$1, 0, localMat, nodeIdx * 16);
+          mat4MultiplyInto(worldMat, nodeIdx * 16, RH_TO_LH$2, 0, localMat, nodeIdx * 16);
         }
       }
       for (let si = 0; si < skeletons.length; si++) {
@@ -18965,8 +20445,8 @@ function createAnimationController(clip, nodes, skeletons, morphBindings, nodeTa
         for (let bi = 0; bi < skel.boneCount; bi++) {
           const jointIdx = skel.jointNodes[bi];
           const ibmOff = bi * 16;
-          mat4MultiplyInto(_boneTmp$1, 0, skel.invMeshWorld, 0, worldMat, jointIdx * 16);
-          mat4MultiplyInto(boneData, bi * 16, _boneTmp$1, 0, skel.inverseBindMatrices, ibmOff);
+          mat4MultiplyInto(_boneTmp$2, 0, skel.invMeshWorld, 0, worldMat, jointIdx * 16);
+          mat4MultiplyInto(boneData, bi * 16, _boneTmp$2, 0, skel.inverseBindMatrices, ibmOff);
         }
         const texWidth = skel.boneCount * 4;
         device.queue.writeTexture(
@@ -18982,6 +20462,318 @@ function createAnimationController(clip, nodes, skeletons, morphBindings, nodeTa
 }
 function noopAnimationTick() {
 }
+const TRS_STRIDE$1 = 12;
+const T_OFF$1 = 0;
+const R_OFF$1 = 3;
+const S_OFF$1 = 7;
+const RH_TO_LH$1 = new F32([-1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]);
+const _boneTmp$1 = new F32(16);
+function computeTopoOrder$1(nodes) {
+  const n3 = nodes.length;
+  const order = new I32(n3);
+  const visited = new U8(n3);
+  let cursor = 0;
+  function visit(idx) {
+    if (visited[idx]) {
+      return;
+    }
+    visited[idx] = 1;
+    const p3 = nodes[idx].parentIdx;
+    if (p3 >= 0) {
+      visit(p3);
+    }
+    order[cursor++] = idx;
+  }
+  for (let i = 0; i < n3; i++) {
+    visit(i);
+  }
+  return order;
+}
+function resetTRS(nodes, numNodes, currentTRS) {
+  for (let i = 0; i < numNodes; i++) {
+    const n3 = nodes[i];
+    const off = i * TRS_STRIDE$1;
+    currentTRS[off + T_OFF$1] = n3.tx;
+    currentTRS[off + T_OFF$1 + 1] = n3.ty;
+    currentTRS[off + T_OFF$1 + 2] = n3.tz;
+    currentTRS[off + R_OFF$1] = n3.rx;
+    currentTRS[off + R_OFF$1 + 1] = n3.ry;
+    currentTRS[off + R_OFF$1 + 2] = n3.rz;
+    currentTRS[off + R_OFF$1 + 3] = n3.rw;
+    currentTRS[off + S_OFF$1] = n3.sx;
+    currentTRS[off + S_OFF$1 + 1] = n3.sy;
+    currentTRS[off + S_OFF$1 + 2] = n3.sz;
+  }
+}
+function computeNodeWorldMatrices(nodes, numNodes, topoOrder, currentTRS, localMat, worldMat) {
+  for (let idx = 0; idx < numNodes; idx++) {
+    const nodeIdx = topoOrder[idx];
+    const node = nodes[nodeIdx];
+    const off = nodeIdx * TRS_STRIDE$1;
+    if (node._matrix) {
+      localMat.set(node._matrix, nodeIdx * 16);
+    } else {
+      mat4ComposeInto(
+        localMat,
+        nodeIdx * 16,
+        currentTRS[off + T_OFF$1],
+        currentTRS[off + T_OFF$1 + 1],
+        currentTRS[off + T_OFF$1 + 2],
+        currentTRS[off + R_OFF$1],
+        currentTRS[off + R_OFF$1 + 1],
+        currentTRS[off + R_OFF$1 + 2],
+        currentTRS[off + R_OFF$1 + 3],
+        currentTRS[off + S_OFF$1],
+        currentTRS[off + S_OFF$1 + 1],
+        currentTRS[off + S_OFF$1 + 2]
+      );
+    }
+    const parentIdx = node.parentIdx;
+    if (parentIdx >= 0) {
+      mat4MultiplyInto(worldMat, nodeIdx * 16, worldMat, parentIdx * 16, localMat, nodeIdx * 16);
+    } else {
+      mat4MultiplyInto(worldMat, nodeIdx * 16, RH_TO_LH$1, 0, localMat, nodeIdx * 16);
+    }
+  }
+}
+function writeBoneTextures(device, skeletons, worldMat) {
+  var _a;
+  for (let si = 0; si < skeletons.length; si++) {
+    const skel = skeletons[si];
+    const boneData = skel.boneMatrices;
+    for (let bi = 0; bi < skel.boneCount; bi++) {
+      const jointIdx = skel.jointNodes[bi];
+      const ibmOff = bi * 16;
+      mat4MultiplyInto(_boneTmp$1, 0, skel.invMeshWorld, 0, worldMat, jointIdx * 16);
+      mat4MultiplyInto(boneData, bi * 16, _boneTmp$1, 0, skel.inverseBindMatrices, ibmOff);
+    }
+    const texWidth = skel.boneCount * 4;
+    device.queue.writeTexture(
+      { texture: ((_a = skel.runtimeSkeleton) == null ? void 0 : _a.boneTexture) ?? skel.boneTexture },
+      boneData.buffer,
+      { bytesPerRow: texWidth * 16 },
+      { width: texWidth, height: 1 }
+    );
+  }
+}
+function getBoneByName(skeleton, name) {
+  return skeleton._byName.get(name);
+}
+function ensureOverride(skeleton, bone) {
+  let o3 = skeleton._overrides.get(bone._nodeIndex);
+  if (!o3) {
+    o3 = { mask: 0, tx: 0, ty: 0, tz: 0, rx: 0, ry: 0, rz: 0, rw: 1, sx: 1, sy: 1, sz: 1 };
+    skeleton._overrides.set(bone._nodeIndex, o3);
+  }
+  return o3;
+}
+function setBonePosition(skeleton, bone, x, y, z) {
+  const o3 = ensureOverride(skeleton, bone);
+  o3.tx = x;
+  o3.ty = y;
+  o3.tz = z;
+  o3.mask |= 1;
+  skeleton._bake();
+}
+function setBoneRotationQuaternion(skeleton, bone, x, y, z, w) {
+  const o3 = ensureOverride(skeleton, bone);
+  o3.rx = x;
+  o3.ry = y;
+  o3.rz = z;
+  o3.rw = w;
+  o3.mask |= 2;
+  skeleton._bake();
+}
+function setBoneScaling(skeleton, bone, x, y, z) {
+  const o3 = ensureOverride(skeleton, bone);
+  o3.sx = x;
+  o3.sy = y;
+  o3.sz = z;
+  o3.mask |= 4;
+  skeleton._bake();
+}
+function setBoneVisible(skeleton, bone, visible) {
+  if (!visible) {
+    setBoneScaling(skeleton, bone, 0, 0, 0);
+    return;
+  }
+  const o3 = skeleton._overrides.get(bone._nodeIndex);
+  if (o3) {
+    o3.mask &= -5;
+    if (o3.mask === 0) {
+      skeleton._overrides.delete(bone._nodeIndex);
+    }
+    skeleton._bake();
+  }
+}
+function clearBoneOverride(skeleton, bone) {
+  if (skeleton._overrides.delete(bone._nodeIndex)) {
+    skeleton._bake();
+  }
+}
+function applyOverridesToTRS(overrides, currentTRS, numNodes) {
+  for (const [ni, o3] of overrides) {
+    if (ni < 0 || ni >= numNodes) {
+      continue;
+    }
+    const off = ni * TRS_STRIDE$1;
+    const m2 = o3.mask;
+    if (m2 & 1) {
+      currentTRS[off + T_OFF$1] = o3.tx;
+      currentTRS[off + T_OFF$1 + 1] = o3.ty;
+      currentTRS[off + T_OFF$1 + 2] = o3.tz;
+    }
+    if (m2 & 2) {
+      currentTRS[off + R_OFF$1] = o3.rx;
+      currentTRS[off + R_OFF$1 + 1] = o3.ry;
+      currentTRS[off + R_OFF$1 + 2] = o3.rz;
+      currentTRS[off + R_OFF$1 + 3] = o3.rw;
+    }
+    if (m2 & 4) {
+      currentTRS[off + S_OFF$1] = o3.sx;
+      currentTRS[off + S_OFF$1 + 1] = o3.sy;
+      currentTRS[off + S_OFF$1 + 2] = o3.sz;
+    }
+  }
+}
+function buildRestNodes(json, parentMap) {
+  var _a;
+  const nodeCount = ((_a = json.nodes) == null ? void 0 : _a.length) ?? 0;
+  const nodes = [];
+  for (let i = 0; i < nodeCount; i++) {
+    const n3 = json.nodes[i];
+    const t = n3.translation ?? [0, 0, 0];
+    const r = n3.rotation ?? [0, 0, 0, 1];
+    const s = n3.scale ?? [1, 1, 1];
+    nodes.push({
+      parentIdx: findParent(parentMap, i),
+      _matrix: n3.matrix,
+      tx: t[0],
+      ty: t[1],
+      tz: t[2],
+      rx: r[0],
+      ry: r[1],
+      rz: r[2],
+      rw: r[3],
+      sx: s[0],
+      sy: s[1],
+      sz: s[2]
+    });
+  }
+  return nodes;
+}
+function resolveIBMs(json, binChunk, skin) {
+  const jointCount = skin.joints.length;
+  if (skin.inverseBindMatrices !== void 0) {
+    const ibm = resolveAccessor(json, binChunk, skin.inverseBindMatrices);
+    return new F32(ibm._data.buffer, ibm._data.byteOffset, jointCount * 16);
+  }
+  const out = new F32(jointCount * 16);
+  for (let i = 0; i < jointCount; i++) {
+    const o3 = i * 16;
+    out[o3] = out[o3 + 5] = out[o3 + 10] = out[o3 + 15] = 1;
+  }
+  return out;
+}
+function buildNodeToMeshIndices(json) {
+  var _a;
+  const nodeCount = ((_a = json.nodes) == null ? void 0 : _a.length) ?? 0;
+  const map = /* @__PURE__ */ new Map();
+  let gpuIdx = 0;
+  for (let ni = 0; ni < nodeCount; ni++) {
+    const node = json.nodes[ni];
+    if (node.mesh === void 0) {
+      continue;
+    }
+    const indices = [];
+    for (let p3 = 0; p3 < json.meshes[node.mesh].primitives.length; p3++) {
+      indices.push(gpuIdx++);
+    }
+    map.set(ni, indices);
+  }
+  return map;
+}
+function extractSkinGroups(json, binChunk, meshes, parentMap, worldMatrixCache) {
+  var _a, _b2;
+  const nodeCount = ((_a = json.nodes) == null ? void 0 : _a.length) ?? 0;
+  const nodeToMeshIndices = buildNodeToMeshIndices(json);
+  const groups = [];
+  for (let nodeIdx = 0; nodeIdx < nodeCount; nodeIdx++) {
+    const node = json.nodes[nodeIdx];
+    if (node.skin === void 0 || !json.skins) {
+      continue;
+    }
+    const meshIndices = nodeToMeshIndices.get(nodeIdx);
+    if (!meshIndices) {
+      continue;
+    }
+    const skin = json.skins[node.skin];
+    const jointNodes = skin.joints;
+    const inverseBindMatrices = resolveIBMs(json, binChunk, skin);
+    const meshWorldMatrix = computeNodeWorldMatrix(json, nodeIdx, parentMap, worldMatrixCache);
+    const invMeshWorld = mat4Invert(meshWorldMatrix) ?? mat4Identity();
+    const bindings = [];
+    for (const mi of meshIndices) {
+      const skeleton = (_b2 = meshes[mi]) == null ? void 0 : _b2.skeleton;
+      if (!skeleton) {
+        continue;
+      }
+      bindings.push({
+        jointNodes,
+        inverseBindMatrices,
+        invMeshWorld,
+        boneTexture: skeleton.boneTexture,
+        boneCount: jointNodes.length,
+        boneMatrices: skeleton.boneMatrices,
+        runtimeSkeleton: skeleton
+      });
+    }
+    if (bindings.length > 0) {
+      groups.push({ jointNodes, bindings });
+    }
+  }
+  return groups;
+}
+async function buildSkeletons(ctx, meshes, overrides) {
+  const { _json: json, _binChunk: binChunk, _engine: engine, _parentMap: parentMap, _worldMatrixCache: worldMatrixCache } = ctx;
+  const groups = extractSkinGroups(json, binChunk, meshes, parentMap, worldMatrixCache);
+  if (groups.length === 0) {
+    return {};
+  }
+  const nodes = buildRestNodes(json, parentMap);
+  const numNodes = nodes.length;
+  const topoOrder = computeTopoOrder$1(nodes);
+  const currentTRS = new F32(numNodes * TRS_STRIDE$1);
+  const localMat = new F32(numNodes * 16);
+  const worldMat = new F32(numNodes * 16);
+  const device = engine._device;
+  const allBindings = groups.flatMap((g) => g.bindings);
+  const bake = () => {
+    resetTRS(nodes, numNodes, currentTRS);
+    if (overrides.size > 0) {
+      applyOverridesToTRS(overrides, currentTRS, numNodes);
+    }
+    computeNodeWorldMatrices(nodes, numNodes, topoOrder, currentTRS, localMat, worldMat);
+    writeBoneTextures(device, allBindings, worldMat);
+  };
+  const skeletons = groups.map((g) => {
+    var _a, _b2;
+    const bones = [];
+    const byName = /* @__PURE__ */ new Map();
+    for (const ni of g.jointNodes) {
+      const bone = { name: ((_b2 = (_a = json.nodes) == null ? void 0 : _a[ni]) == null ? void 0 : _b2.name) ?? `bone_${ni}`, _nodeIndex: ni };
+      bones.push(bone);
+      if (!byName.has(bone.name)) {
+        byName.set(bone.name, bone);
+      }
+    }
+    return { bones, _byName: byName, _overrides: overrides, _bake: bake };
+  });
+  return { skeletons };
+}
+function enableBoneControl() {
+  _installBoneControl(buildSkeletons, applyOverridesToTRS);
+}
 const DEFAULT_FRAME_RATE$2 = 60;
 function playAnimation(group) {
   group.isPlaying = true;
@@ -19015,13 +20807,15 @@ function tickAnimation(group, deltaMs, engine) {
   }
 }
 function syncControllerFromGroup(group, ctrl) {
+  var _a;
   ctrl.time = group.currentFrame;
   ctrl.playing = group.isPlaying;
   ctrl.speedRatio = group.speedRatio;
   ctrl.loop = group.loopAnimation;
+  (_a = ctrl._setMask) == null ? void 0 : _a.call(ctrl, group.mask ?? null);
 }
 function createAnimationGroups(animData) {
-  const { clips, nodes, skeletons, morphBindings, nodeTargets, excludedNodeIndices } = animData;
+  const { clips, nodes, skeletons, morphBindings, nodeTargets, excludedNodeIndices, nodeNames, boneOverrides } = animData;
   const hasPointer = clips.some((c2) => c2.channels.some((ch) => ch.path === PATH_POINTER));
   const hasNodeWriteback = clips.some(
     (c2) => c2.channels.some(
@@ -19032,7 +20826,7 @@ function createAnimationGroups(animData) {
     return [];
   }
   return clips.map((clip, clipIndex) => {
-    const ctrl = createAnimationController(clip, nodes, skeletons, morphBindings, nodeTargets, excludedNodeIndices);
+    const ctrl = createAnimationController(clip, nodes, skeletons, morphBindings, nodeTargets, excludedNodeIndices, boneOverrides, nodeNames);
     const group = {
       name: clip.name || `animation_${clipIndex}`,
       duration: clip.duration,
@@ -19060,6 +20854,26 @@ const animationGroup = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defi
   stopAnimation,
   tickAnimation
 }, Symbol.toStringTag, { value: "Module" }));
+var AnimationGroupMaskMode = /* @__PURE__ */ ((AnimationGroupMaskMode2) => {
+  AnimationGroupMaskMode2[AnimationGroupMaskMode2["Include"] = 0] = "Include";
+  AnimationGroupMaskMode2[AnimationGroupMaskMode2["Exclude"] = 1] = "Exclude";
+  return AnimationGroupMaskMode2;
+})(AnimationGroupMaskMode || {});
+function animationGroupMaskRetainsTarget(mask, name) {
+  if (mask.disabled) {
+    return true;
+  }
+  return mask.names.indexOf(name) !== -1 === (mask.mode === 0);
+}
+function resolveAnimationMask(mask, nodeNames, out, numNodes) {
+  for (let i = 0; i < numNodes; i++) {
+    out[i] = animationGroupMaskRetainsTarget(mask, nodeNames[i] ?? "") ? 0 : 1;
+  }
+}
+function createAnimationGroupMask(names = [], mode = 0) {
+  _installAnimationMaskResolver(resolveAnimationMask);
+  return { mode, names: names.slice(), disabled: false };
+}
 function setAnimationWeight(group, weight) {
   if (!Number.isFinite(weight) || weight < 0 || weight > 1) {
     throw new Error(`Animation weight must be a finite number between 0 and 1, got ${weight}`);
@@ -20159,53 +21973,6 @@ const createMorphTargets$1 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Objec
   createMorphTargets,
   setMorphTargetWeights
 }, Symbol.toStringTag, { value: "Module" }));
-const MSH_HAS_TANGENTS = 1 << 0;
-const MSH_HAS_SKELETON = 1 << 1;
-const MSH_HAS_SKELETON_8 = 1 << 2;
-const MSH_HAS_MORPH_TARGETS = 1 << 3;
-const MSH_HAS_THIN_INSTANCES = 1 << 4;
-const MSH_HAS_INSTANCE_COLOR = 1 << 5;
-const MSH_HAS_VERTEX_COLOR = 1 << 6;
-const MSH_HAS_UV2 = 1 << 7;
-const MSH_RECEIVE_SHADOWS = 1 << 8;
-const MSH_VAT = 1 << 9;
-function _computeMeshFeatures(mesh, receiveShadows = false) {
-  const gpu = mesh._gpu;
-  let features = 0;
-  if (gpu.tangentBuffer) {
-    features |= MSH_HAS_TANGENTS;
-  }
-  if (mesh.vat) {
-    features |= MSH_VAT;
-    if (mesh.vat.joints1Buffer) {
-      features |= MSH_HAS_SKELETON_8;
-    }
-  } else if (mesh.skeleton) {
-    features |= MSH_HAS_SKELETON;
-    if (mesh.skeleton.joints1Buffer) {
-      features |= MSH_HAS_SKELETON_8;
-    }
-  }
-  if (mesh.morphTargets) {
-    features |= MSH_HAS_MORPH_TARGETS;
-  }
-  if (mesh.thinInstances) {
-    features |= MSH_HAS_THIN_INSTANCES;
-    if (mesh.thinInstances.colors) {
-      features |= MSH_HAS_INSTANCE_COLOR;
-    }
-  }
-  if (gpu.colorBuffer) {
-    features |= MSH_HAS_VERTEX_COLOR;
-  }
-  if (gpu.uv2Buffer) {
-    features |= MSH_HAS_UV2;
-  }
-  if (receiveShadows) {
-    features |= MSH_RECEIVE_SHADOWS;
-  }
-  return features;
-}
 const STAGE_VERTEX = 1;
 const VAT_HELPERS = `struct vatUniforms {
 params: vec4<f32>,
@@ -20471,6 +22238,24 @@ function writeVec3(out, offset, v2) {
   out[offset + 1] = v2.y;
   out[offset + 2] = v2.z;
 }
+function quatFromLookDirectionRH(forward, up) {
+  let fx2 = forward.x, fy = forward.y, fz = forward.z;
+  const fl = Math.hypot(fx2, fy, fz) || 1;
+  fx2 /= fl;
+  fy /= fl;
+  fz /= fl;
+  let rx2 = up.y * fz - up.z * fy;
+  let ry = up.z * fx2 - up.x * fz;
+  let rz = up.x * fy - up.y * fx2;
+  const rl = Math.hypot(rx2, ry, rz) || 1;
+  rx2 /= rl;
+  ry /= rl;
+  rz /= rl;
+  const ux = fy * rz - fz * ry;
+  const uy = fz * rx2 - fx2 * rz;
+  const uz = fx2 * ry - fy * rx2;
+  return _quatFromRotationBasis(rx2, ux, fx2, ry, uy, fy, rz, uz, fz);
+}
 function setThinInstances(mesh, matrices, count) {
   if (!mesh.thinInstances) {
     mesh.thinInstances = {
@@ -21246,7 +23031,7 @@ async function pickAsync(picker, x, y, options) {
   const gsMeshCount = gsMeshes.length;
   const gsNextIdStart = nextId;
   if (gsMeshCount > 0) {
-    const gsModule = await import("./gs-picking-pipeline-CERN-Trj.js");
+    const gsModule = await import("./gs-picking-pipeline-DlogO8fI.js");
     gsModule.computeGsPickMatrix(_gsPickMatrix, px2, py, w, h);
     gsModule.gsPickWritePickMatrixAndBind(pass, engine, _gsPickMatrix);
     const resMap = picker._gsMeshResources ?? (picker._gsMeshResources = /* @__PURE__ */ new Map());
@@ -21397,7 +23182,7 @@ function disposePicker(picker) {
     picker._sceneBG = null;
   }
   if (picker._gsMeshResources) {
-    void import("./gs-picking-pipeline-CERN-Trj.js").then((m2) => {
+    void import("./gs-picking-pipeline-DlogO8fI.js").then((m2) => {
       if (!picker._gsMeshResources) {
         return;
       }
@@ -26343,7 +28128,7 @@ function isBillboardSpriteHandleAlive(handle) {
 }
 function addBillboardSystem(scene, system) {
   addDeferredSceneRenderables(scene, async (engine) => {
-    const { buildBillboardRenderable } = await import("./billboard-renderable-IJfCpeDS.js");
+    const { buildBillboardRenderable } = await import("./billboard-renderable-CmIfD7IP.js");
     const built = buildBillboardRenderable(engine, system);
     return { renderables: [built.renderable], dispose: built.dispose };
   });
@@ -39039,7 +40824,7 @@ function createHavokWorld(scene, hknp, gravity) {
   return world;
 }
 async function enableHavokFloatingOrigin(world, floatingOriginWorldRadius = 1e5) {
-  const fo = await import("./havok-floating-origin-VVdJRUYc.js");
+  const fo = await import("./havok-floating-origin-CQ7yE-XD.js");
   world._fo = fo.createHavokFloatingOriginContext(world._hkWorld, world._gravity, floatingOriginWorldRadius);
 }
 function _stepWorld(world, deltaMs) {
@@ -39490,7 +41275,7 @@ function addPhysicsShapeChildFromParent(world, container, parentNode, child, chi
     throw new Error("Cannot add physics child shape from a singular parent transform.");
   }
   const childToParent = mat4Multiply(invParent, childNode.worldMatrix);
-  const transform = decomposeMatrix(childToParent);
+  const transform = mat4Decompose(childToParent);
   addPhysicsShapeChild(world, container, child, transform.translation, transform.rotation, transform.scale);
 }
 function setPhysicsShapeMaterial(world, shape, friction, restitution) {
@@ -39535,59 +41320,6 @@ function buildMassProperties(world, body) {
   }
   return [[0, 0, 0], 1, [1, 1, 1], [0, 0, 0, 1]];
 }
-function decomposeMatrix(m2) {
-  const sx = Math.hypot(m2[0], m2[1], m2[2]);
-  const sy = Math.hypot(m2[4], m2[5], m2[6]);
-  const sz = Math.hypot(m2[8], m2[9], m2[10]);
-  const invSx = sx > 1e-8 ? 1 / sx : 0;
-  const invSy = sy > 1e-8 ? 1 / sy : 0;
-  const invSz = sz > 1e-8 ? 1 / sz : 0;
-  const r00 = m2[0] * invSx;
-  const r01 = m2[4] * invSy;
-  const r02 = m2[8] * invSz;
-  const r10 = m2[1] * invSx;
-  const r11 = m2[5] * invSy;
-  const r12 = m2[9] * invSz;
-  const r20 = m2[2] * invSx;
-  const r21 = m2[6] * invSy;
-  const r22 = m2[10] * invSz;
-  let x;
-  let y;
-  let z;
-  let w;
-  const trace = r00 + r11 + r22;
-  if (trace > 0) {
-    const s = Math.sqrt(trace + 1) * 2;
-    w = 0.25 * s;
-    x = (r21 - r12) / s;
-    y = (r02 - r20) / s;
-    z = (r10 - r01) / s;
-  } else if (r00 > r11 && r00 > r22) {
-    const s = Math.sqrt(1 + r00 - r11 - r22) * 2;
-    w = (r21 - r12) / s;
-    x = 0.25 * s;
-    y = (r01 + r10) / s;
-    z = (r02 + r20) / s;
-  } else if (r11 > r22) {
-    const s = Math.sqrt(1 + r11 - r00 - r22) * 2;
-    w = (r02 - r20) / s;
-    x = (r01 + r10) / s;
-    y = 0.25 * s;
-    z = (r12 + r21) / s;
-  } else {
-    const s = Math.sqrt(1 + r22 - r00 - r11) * 2;
-    w = (r10 - r01) / s;
-    x = (r02 + r20) / s;
-    y = (r12 + r21) / s;
-    z = 0.25 * s;
-  }
-  const invLen = 1 / Math.hypot(x, y, z, w);
-  return {
-    translation: { x: m2[12], y: m2[13], z: m2[14] },
-    rotation: { x: x * invLen, y: y * invLen, z: z * invLen, w: w * invLen },
-    scale: { x: sx, y: sy, z: sz }
-  };
-}
 function applyPhysicsImpulse(world, body, impulse, point) {
   const hknp = world._hknp;
   let loc = point;
@@ -42003,705 +43735,738 @@ function _assertTileCache(plugin) {
   }
 }
 export {
-  createEmptyUniformBuffer as $,
-  getSceneBindGroupLayout as A,
+  createBillboardInstanceBuffer as $,
+  applyGsFragments as A,
   BU as B,
-  disposeGaussianSplattingMesh as C,
+  CW$1 as C,
   DV$1 as D,
-  applyGsFragments as E,
+  getRenderTargetSize as E,
   F64 as F,
   GeometryTextureType as G,
-  CW$1 as H,
-  getRenderTargetSize as I,
-  getViewMatrix as J,
-  getProjectionMatrix as K,
-  getCameraPosition as L,
+  getViewMatrix as H,
+  getProjectionMatrix as I,
+  getCameraPosition as J,
+  U8C as K,
+  createMaterialView as L,
   MAX_LIGHTS as M,
   NODE_ESM_SHADOW_OUTPUT as N,
-  U8C as O,
-  createMaterialView as P,
-  ESM_SHADOW_OUTPUT as Q,
-  MATERIAL_ALPHA_BLEND as R,
+  ESM_SHADOW_OUTPUT as O,
+  MATERIAL_ALPHA_BLEND as P,
+  PBR2_ESM_SHADOW_OUTPUT as Q,
+  PBR_HAS_ALPHA_BLEND as R,
   SS as S,
   TU as T,
   U32 as U,
-  PBR2_ESM_SHADOW_OUTPUT as V,
-  PBR_HAS_ALPHA_BLEND as W,
-  encodeIdToColor as X,
-  getPickingSceneBGL as Y,
-  gsGpuPickingFragment as Z,
-  BILLBOARD_INDEX_DATA as _,
+  encodeIdToColor as V,
+  getPickingSceneBGL as W,
+  gsGpuPickingFragment as X,
+  BILLBOARD_INDEX_DATA as Y,
+  createEmptyUniformBuffer as Z,
+  BILLBOARD_SYSTEM_UBO_BYTES as _,
   F32 as a,
-  PBR2_HAS_IRIDESCENCE_THICKNESS_MAP as a$,
-  BILLBOARD_SYSTEM_UBO_BYTES as a0,
-  createBillboardInstanceBuffer as a1,
-  _getBillboardFxHook as a2,
-  createBillboardInstanceSortScratch as a3,
-  getOrCreateBillboardPipeline as a4,
-  createBillboardSystemBindGroup as a5,
-  resetBillboardPipelineCache as a6,
-  ensureBillboardInstanceBuffer as a7,
-  uploadSortedBillboardInstances as a8,
-  uploadBillboardInstances as a9,
-  acquireTexture as aA,
-  releaseTexture as aB,
-  NO_COLOR_OUTPUT as aC,
-  NEEDS_UV as aD,
-  MSH_HAS_INSTANCE_COLOR as aE,
-  NEEDS_UV2 as aF,
-  MSH_HAS_THIN_INSTANCES as aG,
-  MSH_RECEIVE_SHADOWS as aH,
-  _standardShaderVariantKey as aI,
-  WGSL$1 as aJ,
-  getCsmPbrReceiverFactory as aK,
-  PBR_HAS_ALPHA_TEST as aL,
-  PBR_HAS_METALLIC_REFLECTANCE_MAP as aM,
-  PBR_HAS_REFLECTANCE_MAP as aN,
-  PBR2_HAS_REFLECTANCE_FACTORS as aO,
-  PBR2_HAS_UV2 as aP,
-  PBR_HAS_USE_ALPHA_ONLY_MR as aQ,
-  PBR_HAS_CLEARCOAT as aR,
-  PBR2_CC_INT_MAP as aS,
-  PBR2_CC_ROUGH_MAP as aT,
-  PBR2_CC_NORMAL_MAP as aU,
-  PBR2_CC_F0_REMAP_OFF as aV,
-  PBR_HAS_SHEEN_TEXTURE as aW,
-  PBR_HAS_SHEEN as aX,
-  PBR2_HAS_SHEEN_UV_TX as aY,
-  PBR_HAS_SHEEN_ALBEDO_SCALING as aZ,
-  PBR2_HAS_IRIDESCENCE_MAP as a_,
-  buildBillboardSystemUbo as aa,
-  writeBillboardSystemUboIfDirty as ab,
-  createBillboardPipelineCache as ac,
-  PhysicsMotionType as ad,
-  HAS_BUMP_TEXTURE as ae,
-  HAS_EMISSIVE_TEXTURE as af,
-  HAS_DEPTH_EMISSIVE_TEXTURE as ag,
-  HAS_SPECULAR_TEXTURE as ah,
-  SPECULAR_USES_UV2 as ai,
-  HAS_AMBIENT_TEXTURE as aj,
-  AMBIENT_USES_UV2 as ak,
-  HAS_LIGHTMAP_TEXTURE as al,
-  LIGHTMAP_FLIP_V as am,
-  LIGHTMAP_SHADOWMAP as an,
-  LIGHTMAP_USES_UV2 as ao,
-  HAS_OPACITY_TEXTURE as ap,
-  OPACITY_FROM_RGB as aq,
-  HAS_REFLECTION_TEXTURE as ar,
-  HAS_CUBE_REFLECTION as as,
-  getCsmStdReceiverFactory as at,
+  PBR_HAS_USE_ALPHA_ONLY_MR as a$,
+  _getBillboardFxHook as a0,
+  createBillboardInstanceSortScratch as a1,
+  getOrCreateBillboardPipeline as a2,
+  createBillboardSystemBindGroup as a3,
+  resetBillboardPipelineCache as a4,
+  ensureBillboardInstanceBuffer as a5,
+  uploadSortedBillboardInstances as a6,
+  uploadBillboardInstances as a7,
+  buildBillboardSystemUbo as a8,
+  writeBillboardSystemUboIfDirty as a9,
+  writeStdMaterialData as aA,
+  createStandardMeshBindGroup as aB,
+  collectStdBoundTextures as aC,
+  acquireTexture as aD,
+  releaseTexture as aE,
+  NO_COLOR_OUTPUT as aF,
+  getOrCreateStandardPipeline as aG,
+  NEEDS_UV as aH,
+  MSH_HAS_INSTANCE_COLOR as aI,
+  NEEDS_UV2 as aJ,
+  MSH_HAS_THIN_INSTANCES as aK,
+  MSH_RECEIVE_SHADOWS as aL,
+  _standardShaderVariantKey as aM,
+  getOrCreateShaderPipeline as aN,
+  getOrCreateShaderPipelineBindings as aO,
+  _isShaderSystemUniform as aP,
+  getEffectiveAspectRatio as aQ,
+  getViewProjectionMatrix as aR,
+  mat4MultiplyInto as aS,
+  I32 as aT,
+  WGSL$1 as aU,
+  getCsmPbrReceiverFactory as aV,
+  PBR_HAS_ALPHA_TEST as aW,
+  PBR_HAS_METALLIC_REFLECTANCE_MAP as aX,
+  PBR_HAS_REFLECTANCE_MAP as aY,
+  PBR2_HAS_REFLECTANCE_FACTORS as aZ,
+  PBR2_HAS_UV2 as a_,
+  createBillboardPipelineCache as aa,
+  PhysicsMotionType as ab,
+  HAS_BUMP_TEXTURE as ac,
+  WGSL_PERTURB_NORMAL as ad,
+  HAS_EMISSIVE_TEXTURE as ae,
+  HAS_DEPTH_EMISSIVE_TEXTURE as af,
+  HAS_SPECULAR_TEXTURE as ag,
+  SPECULAR_USES_UV2 as ah,
+  HAS_AMBIENT_TEXTURE as ai,
+  AMBIENT_USES_UV2 as aj,
+  HAS_LIGHTMAP_TEXTURE as ak,
+  LIGHTMAP_FLIP_V as al,
+  LIGHTMAP_SHADOWMAP as am,
+  LIGHTMAP_USES_UV2 as an,
+  HAS_OPACITY_TEXTURE as ao,
+  OPACITY_FROM_RGB as ap,
+  HAS_REFLECTION_TEXTURE as aq,
+  HAS_CUBE_REFLECTION as ar,
+  getCsmStdReceiverFactory as as,
+  clearStandardPipelineCache as at,
   clearSamplerCache as au,
   _computeStandardMaterialFeatures as av,
   _computeMeshFeatures as aw,
   _getStdExts as ax,
-  createUniformBuffer$1 as ay,
-  collectStdBoundTextures as az,
+  getOrCreateStandardBindings as ay,
+  createUniformBuffer$1 as az,
   writeMeshLightSelection as b,
-  getTrilinearAnisotropicSampler as b$,
-  PBR2_HAS_IRIDESCENCE as b0,
-  PBR_HAS_THICKNESS_MAP as b1,
-  PBR_HAS_SUBSURFACE as b2,
-  PBR2_HAS_THICKNESS_GLTF_CHANNEL as b3,
-  PBR_HAS_EMISSIVE_COLOR as b4,
-  PBR_HAS_EMISSIVE as b5,
-  PBR2_HAS_UNLIT as b6,
-  MSH_HAS_SKELETON as b7,
-  MSH_HAS_SKELETON_8 as b8,
-  MSH_HAS_MORPH_TARGETS as b9,
-  findBlockByClassName as bA,
-  emitGraph as bB,
-  sanitize as bC,
-  bjsTypeToNodeType as bD,
-  extractDefault as bE,
-  floatCount as bF,
-  NODE_GEOMETRY_OUTPUT as bG,
-  appendMeshLightUboFields as bH,
-  meshLightIndexWGSL as bI,
-  clearSceneBGLCache as bJ,
-  _getStdExtsSorted as bK,
-  _standardFeatureKey as bL,
-  HAS_DIFFUSE_TEXTURE as bM,
-  REVERSE_DEPTH_COMPARE as bN,
-  DOUBLE_SIDED as bO,
-  DISABLE_LIGHTING as bP,
-  DIFFUSE_USES_UV2 as bQ,
-  createSingleUniformBGL as bR,
-  getViewProjectionMatrix as bS,
-  _isShaderSystemUniform as bT,
-  getEffectiveAspectRatio as bU,
-  I32 as bV,
-  I8 as bW,
-  I16 as bX,
-  PATH_POINTER as bY,
-  PBR2_HAS_REFRACTION as bZ,
-  PBR2_HAS_REFRACTION_MAP as b_,
-  uploadKtx2Texture2D as ba,
-  decodeKtx2ImageBitmapFromBuffer as bb,
-  setMaxLights as bc,
-  computeNodeWorldMatrix as bd,
-  setSubtreeVisible as be,
-  mat4Invert as bf,
-  mat4Identity as bg,
-  getLoaderTmpAnim as bh,
-  mat4MultiplyInto as bi,
-  INTERP_CUBICSPLINE as bj,
-  INTERP_STEP as bk,
-  INTERP_LINEAR as bl,
-  PATH_WEIGHTS as bm,
-  PATH_SCALE as bn,
-  PATH_ROTATION as bo,
-  PATH_TRANSLATION as bp,
-  findParent as bq,
-  setThinInstances as br,
-  mat4ComposeInto as bs,
-  getLoaderTmpInstance as bt,
-  mat4Multiply as bu,
-  identityTexWrap as bv,
-  getOrCreateSampler as bw,
-  assembleMaterial as bx,
-  runMatExts as by,
-  makeImageFetcher as bz,
+  PATH_POINTER as b$,
+  PBR_HAS_CLEARCOAT as b0,
+  PBR2_CC_INT_MAP as b1,
+  PBR2_CC_ROUGH_MAP as b2,
+  PBR2_CC_NORMAL_MAP as b3,
+  PBR2_CC_F0_REMAP_OFF as b4,
+  PBR_HAS_SHEEN_TEXTURE as b5,
+  PBR_HAS_SHEEN as b6,
+  PBR2_HAS_SHEEN_UV_TX as b7,
+  PBR_HAS_SHEEN_ALBEDO_SCALING as b8,
+  PBR2_HAS_IRIDESCENCE_MAP as b9,
+  INTERP_LINEAR as bA,
+  PATH_WEIGHTS as bB,
+  PATH_SCALE as bC,
+  PATH_ROTATION as bD,
+  PATH_TRANSLATION as bE,
+  findParent as bF,
+  setThinInstances as bG,
+  mat4ComposeInto as bH,
+  getLoaderTmpInstance as bI,
+  mat4Multiply as bJ,
+  identityTexWrap as bK,
+  getOrCreateSampler as bL,
+  assembleMaterial as bM,
+  runMatExts as bN,
+  makeImageFetcher as bO,
+  findBlockByClassName as bP,
+  emitGraph as bQ,
+  sanitize as bR,
+  bjsTypeToNodeType as bS,
+  extractDefault as bT,
+  floatCount as bU,
+  NODE_GEOMETRY_OUTPUT as bV,
+  SCENE_UBO_WGSL as bW,
+  WGSL_DITHER as bX,
+  createSingleUniformBGL as bY,
+  I8 as bZ,
+  I16 as b_,
+  PBR2_HAS_IRIDESCENCE_THICKNESS_MAP as ba,
+  PBR2_HAS_IRIDESCENCE as bb,
+  PBR_HAS_THICKNESS_MAP as bc,
+  PBR_HAS_SUBSURFACE as bd,
+  PBR2_HAS_THICKNESS_GLTF_CHANNEL as be,
+  PBR_HAS_EMISSIVE_COLOR as bf,
+  PBR_HAS_EMISSIVE as bg,
+  PBR2_HAS_UNLIT as bh,
+  MSH_HAS_SKELETON as bi,
+  MSH_HAS_SKELETON_8 as bj,
+  MSH_HAS_MORPH_TARGETS as bk,
+  WGSL_FOG as bl,
+  getMeshoptDecoder as bm,
+  getDracoBufferViewBytes as bn,
+  decodeDracoPrimitive as bo,
+  uploadKtx2Texture2D as bp,
+  decodeKtx2ImageBitmapFromBuffer as bq,
+  _boneBuilder as br,
+  setMaxLights as bs,
+  computeNodeWorldMatrix as bt,
+  setSubtreeVisible as bu,
+  mat4Invert as bv,
+  mat4Identity as bw,
+  getLoaderTmpAnim as bx,
+  INTERP_CUBICSPLINE as by,
+  INTERP_STEP as bz,
   compileNodePipeline as c,
-  addSprite2DIndex as c$,
-  PBR2_LINEAR_IMAGE_PROCESSING as c0,
-  PBR2_HAS_DISPERSION as c1,
-  PBR2_HAS_VOLUME as c2,
-  enableSceneTransmission as c3,
-  GEOMETRY_OUTPUT as c4,
-  _registerPbrExt as c5,
-  PBR2_GEOMETRY_OUTPUT as c6,
-  PBR_HAS_ENV as c7,
-  _computePbrMaterialFeatures as c8,
-  collectPbrBoundTextures as c9,
-  ObservableQuat as cA,
-  ObservableVec3 as cB,
-  PhysicsCharacterController as cC,
-  PhysicsConstraintAxis as cD,
-  PhysicsConstraintType as cE,
-  PhysicsPrestepType as cF,
-  PhysicsShapeType as cG,
-  VERSION as cH,
-  Vec3Up as cI,
-  addAgent as cJ,
-  addAnimationGroup as cK,
-  addAnimationGroups as cL,
-  addAnimationTask as cM,
-  addAxisLockedBillboardSystem as cN,
-  addBillboardSprite as cO,
-  addBillboardSpriteIndex as cP,
-  addBoxObstacle as cQ,
-  addClusteredLightContainer as cR,
-  addCylinderObstacle as cS,
-  addDepthHostedSpriteLayer as cT,
-  addFacingBillboardSystem as cU,
-  addHierarchyInstance as cV,
-  addPassDependencies as cW,
-  addPhysicsShapeChild as cX,
-  addPhysicsShapeChildFromParent as cY,
-  addRenderPass as cZ,
-  addSprite2D as c_,
-  PBR_HAS_NORMAL_MAP as ca,
-  MSH_HAS_TANGENTS as cb,
-  MSH_HAS_UV2 as cc,
-  MSH_HAS_VERTEX_COLOR as cd,
-  PBR_HAS_DOUBLE_SIDED as ce,
-  getBilinearSampler as cf,
-  _getPbrExtsSorted as cg,
-  PBR_HAS_SPEC_GLOSS as ch,
-  PBR2_NO_COLOR_OUTPUT as ci,
-  _getPbrExts as cj,
-  PBR2_HAS_UV_TRANSFORM as ck,
-  PBR_HAS_ANISOTROPY as cl,
-  PBR_HAS_SKYBOX as cm,
-  PBR_HAS_SPECULAR_AA as cn,
-  PBR_HAS_FOG as co,
-  PBR_HAS_OCCLUSION as cp,
-  PBR2_HAS_BASE_COLOR_FACTOR as cq,
-  PBR_HAS_GAMMA_ALBEDO as cr,
-  PBR_HAS_TONEMAP as cs,
-  CAP_ALL as ct,
-  CAP_END as cu,
-  CAP_NONE as cv,
-  CAP_START as cw,
-  CharacterCollisionObservable as cx,
-  CharacterSupportedState as cy,
-  DepthOfFieldBlurLevel as cz,
+  addAnimationGroups as c$,
+  PBR2_HAS_REFRACTION as c0,
+  PBR2_HAS_REFRACTION_MAP as c1,
+  getTrilinearAnisotropicSampler as c2,
+  PBR2_LINEAR_IMAGE_PROCESSING as c3,
+  PBR2_HAS_DISPERSION as c4,
+  PBR2_HAS_VOLUME as c5,
+  enableSceneTransmission as c6,
+  composeStandardShader as c7,
+  _getStdExtsSorted as c8,
+  HAS_DIFFUSE_TEXTURE as c9,
+  PBR2_HAS_BASE_COLOR_FACTOR as cA,
+  PBR_HAS_GAMMA_ALBEDO as cB,
+  PBR_HAS_TONEMAP as cC,
+  clearPbrPipelineCache as cD,
+  getOrCreatePbrBindings as cE,
+  getOrCreatePbrPipeline as cF,
+  getBilinearSampler as cG,
+  WGSL_NO_DITHER as cH,
+  AnimationGroupMaskMode as cI,
+  CAP_ALL as cJ,
+  CAP_END as cK,
+  CAP_NONE as cL,
+  CAP_START as cM,
+  CharacterCollisionObservable as cN,
+  CharacterSupportedState as cO,
+  DepthOfFieldBlurLevel as cP,
+  ObservableQuat as cQ,
+  ObservableVec3 as cR,
+  PhysicsCharacterController as cS,
+  PhysicsConstraintAxis as cT,
+  PhysicsConstraintType as cU,
+  PhysicsPrestepType as cV,
+  PhysicsShapeType as cW,
+  VERSION as cX,
+  Vec3Up as cY,
+  addAgent as cZ,
+  addAnimationGroup as c_,
+  DOUBLE_SIDED as ca,
+  GEOMETRY_OUTPUT as cb,
+  _registerPbrExt as cc,
+  PBR2_GEOMETRY_OUTPUT as cd,
+  PBR_HAS_ENV as ce,
+  _computePbrMaterialFeatures as cf,
+  createPbrMeshBindGroup as cg,
+  collectPbrBoundTextures as ch,
+  REVERSE_DEPTH_COMPARE as ci,
+  PBR_HAS_NORMAL_MAP as cj,
+  MSH_HAS_TANGENTS as ck,
+  MSH_HAS_UV2 as cl,
+  MSH_HAS_VERTEX_COLOR as cm,
+  PBR_HAS_DOUBLE_SIDED as cn,
+  appendMeshLightUboFields as co,
+  meshLightIndexWGSL as cp,
+  _getPbrExts as cq,
+  composeShader as cr,
+  PBR2_HAS_UV_TRANSFORM as cs,
+  PBR_HAS_ANISOTROPY as ct,
+  PBR_HAS_SKYBOX as cu,
+  PBR_HAS_SPECULAR_AA as cv,
+  PBR_HAS_SPEC_GLOSS as cw,
+  PBR_HAS_FOG as cx,
+  PBR2_NO_COLOR_OUTPUT as cy,
+  PBR_HAS_OCCLUSION as cz,
   NODE_NO_COLOR_OUTPUT as d,
-  createBloomPostProcessTask as d$,
-  addSpriteAnimation as d0,
-  addSpriteAnimationManager as d1,
-  addSpriteRendererLayer as d2,
-  addTask as d3,
-  addTaskAtStart as d4,
-  addTaskBefore as d5,
-  addTextRenderable as d6,
-  addTextRendererLayer as d7,
-  addThinInstance as d8,
-  addToScene as d9,
-  billboardBlendAdditive as dA,
-  billboardBlendAlpha as dB,
-  billboardBlendCutout as dC,
-  billboardBlendPremultiplied as dD,
-  captureScreenshot as dE,
-  clampCenterFromPoles as dF,
-  clampZoomDistance as dG,
-  clearAnimationManager as dH,
-  clearBillboardSprites as dI,
-  clearSprite2DLayer as dJ,
-  clearSpriteAnimations as dK,
-  cloneTransformNode as dL,
-  computeLocalBasis as dM,
-  computeLookAtFromYawPitch as dN,
-  computePath as dO,
-  computeYawPitchFromLookAt as dP,
-  createAnaglyphPostProcessTask as dQ,
-  createAnimationController as dR,
-  createAnimationGroups as dS,
-  createAnimationManager as dT,
-  createAnimationTask as dU,
-  createArcRotateCamera as dV,
-  createAxisDragGizmo as dW,
-  createAxisLockedBillboardSystem as dX,
-  createAxisScaleGizmo as dY,
-  createBillboardCustomShader as dZ,
-  createBlackAndWhitePostProcessTask as d_,
-  addVec3 as da,
-  agentGoto as db,
-  appendSpriteAtlasFrames as dc,
-  applyPhysicsBodyForce as dd,
-  applyPhysicsBodyImpulse as de,
-  applyPhysicsImpulse as df,
-  attachAxisDragGizmoToNode as dg,
-  attachAxisScaleGizmoToNode as dh,
-  attachBoundingBoxGizmoToNode as di,
-  attachCameraGizmoToCamera as dj,
-  attachControl as dk,
-  attachFreeControl as dl,
-  attachGeospatialControls as dm,
-  attachLightGizmoToLight as dn,
-  attachPlaneDragGizmoToNode as dp,
-  attachPlaneRotationGizmoToNode as dq,
-  attachPositionGizmoToNode as dr,
-  attachRotationGizmoToNode as ds,
-  attachScaleGizmoToNode as dt,
-  attachSpriteAnimationsToRenderer as du,
-  attachSpriteAnimationsToScene as dv,
-  attachVat as dw,
-  bakeCurrentTransformIntoVertices as dx,
-  bakeTransformIntoVertices as dy,
-  bakeVat as dz,
+  clearSprite2DLayer as d$,
+  addAnimationTask as d0,
+  addAxisLockedBillboardSystem as d1,
+  addBillboardSprite as d2,
+  addBillboardSpriteIndex as d3,
+  addBoxObstacle as d4,
+  addClusteredLightContainer as d5,
+  addCylinderObstacle as d6,
+  addDepthHostedSpriteLayer as d7,
+  addFacingBillboardSystem as d8,
+  addHierarchyInstance as d9,
+  attachBoundingBoxGizmoToNode as dA,
+  attachCameraGizmoToCamera as dB,
+  attachControl as dC,
+  attachFreeControl as dD,
+  attachGeospatialControls as dE,
+  attachLightGizmoToLight as dF,
+  attachPlaneDragGizmoToNode as dG,
+  attachPlaneRotationGizmoToNode as dH,
+  attachPositionGizmoToNode as dI,
+  attachRotationGizmoToNode as dJ,
+  attachScaleGizmoToNode as dK,
+  attachSpriteAnimationsToRenderer as dL,
+  attachSpriteAnimationsToScene as dM,
+  attachVat as dN,
+  bakeCurrentTransformIntoVertices as dO,
+  bakeTransformIntoVertices as dP,
+  bakeVat as dQ,
+  billboardBlendAdditive as dR,
+  billboardBlendAlpha as dS,
+  billboardBlendCutout as dT,
+  billboardBlendPremultiplied as dU,
+  captureScreenshot as dV,
+  clampCenterFromPoles as dW,
+  clampZoomDistance as dX,
+  clearAnimationManager as dY,
+  clearBillboardSprites as dZ,
+  clearBoneOverride as d_,
+  addPassDependencies as da,
+  addPhysicsShapeChild as db,
+  addPhysicsShapeChildFromParent as dc,
+  addRenderPass as dd,
+  addSprite2D as de,
+  addSprite2DIndex as df,
+  addSpriteAnimation as dg,
+  addSpriteAnimationManager as dh,
+  addSpriteRendererLayer as di,
+  addTask as dj,
+  addTaskAtStart as dk,
+  addTaskBefore as dl,
+  addTextRenderable as dm,
+  addTextRendererLayer as dn,
+  addThinInstance as dp,
+  addToScene as dq,
+  addVec3 as dr,
+  agentGoto as ds,
+  animationGroupMaskRetainsTarget as dt,
+  appendSpriteAtlasFrames as du,
+  applyPhysicsBodyForce as dv,
+  applyPhysicsBodyImpulse as dw,
+  applyPhysicsImpulse as dx,
+  attachAxisDragGizmoToNode as dy,
+  attachAxisScaleGizmoToNode as dz,
   U8 as e,
-  createPhysicsBody as e$,
-  createBlurPostProcessTask as e0,
-  createBoundingBoxGizmo as e1,
-  createBox as e2,
-  createCameraGizmo as e3,
-  createCapsule as e4,
-  createCapsuleData as e5,
-  createChromaticAberrationPostProcessTask as e6,
-  createCircleOfConfusionPostProcessTask as e7,
-  createClusteredLightContainer as e8,
-  createClusteredPointLight as e9,
-  createGpuPicker as eA,
-  createGridMaterial as eB,
-  createGridSpriteAtlas as eC,
-  createGround as eD,
-  createGroundFromHeightMap as eE,
-  createHavokWorld as eF,
-  createHeightFieldShape as eG,
-  createHemisphericLight as eH,
-  createHierarchyInstancePool as eI,
-  createImageProcessingTask as eJ,
-  createLightGizmo as eK,
-  createLinearDepthMaterial as eL,
-  createMeshFromCsg as eM,
-  createMeshFromCsg2 as eN,
-  createMeshFromData as eO,
-  createMeshesFromCsg2 as eP,
-  createMorphTargets as eQ,
-  createNavCrowd as eR,
-  createNavMesh as eS,
-  createNavMeshFromSources as eT,
-  createNavigationPluginAsync as eU,
-  createNodeNoColorMaterialView$1 as eV,
-  createPbrMaterial as eW,
-  createPbrNoColorMaterialView$1 as eX,
-  createPcfDirectionalShadowGenerator as eY,
-  createPcfSpotlightShadowGenerator as eZ,
-  createPhysicsAggregate as e_,
-  createCopyToTextureTask as ea,
-  createCsg2FromMesh as eb,
-  createCsgFromMesh as ec,
-  createCsmDirectionalShadowGenerator as ed,
-  createCylinder as ee,
-  createCylinderData as ef,
-  createDebugNavMeshGeometry as eg,
-  createDefaultCamera as eh,
-  createDefaultTextData as ei,
-  createDepthOfFieldPostProcessTask as ej,
-  createDirectionalLight as ek,
-  createDisc as el,
-  createEffectRenderTask as em,
-  createEffectRenderer as en,
-  createEffectWrapper as eo,
-  createEngine as ep,
-  createEsmDirectionalShadowGenerator as eq,
-  createExtractHighlightsPostProcessTask as er,
-  createExtrudeShape as es,
-  createFacingBillboardSystem as et,
-  createFontFromBuffer as eu,
-  createFrameGraphContext as ev,
-  createGeometryRendererTask as ew,
-  createGeospatialCamera as ex,
-  createGeospatialLimits as ey,
-  createGlyphStorage as ez,
+  createHierarchyInstancePool as e$,
+  clearSpriteAnimations as e0,
+  cloneTransformNode as e1,
+  computeLocalBasis as e2,
+  computeLookAtFromYawPitch as e3,
+  computePath as e4,
+  computeYawPitchFromLookAt as e5,
+  createAnaglyphPostProcessTask as e6,
+  createAnimationController as e7,
+  createAnimationGroupMask as e8,
+  createAnimationGroups as e9,
+  createDefaultCamera as eA,
+  createDefaultTextData as eB,
+  createDepthOfFieldPostProcessTask as eC,
+  createDirectionalLight as eD,
+  createDisc as eE,
+  createEffectRenderTask as eF,
+  createEffectRenderer as eG,
+  createEffectWrapper as eH,
+  createEngine as eI,
+  createEsmDirectionalShadowGenerator as eJ,
+  createExtractHighlightsPostProcessTask as eK,
+  createExtrudeShape as eL,
+  createFacingBillboardSystem as eM,
+  createFontFromBuffer as eN,
+  createFrameGraphContext as eO,
+  createGeometryRendererTask as eP,
+  createGeospatialCamera as eQ,
+  createGeospatialLimits as eR,
+  createGlyphStorage as eS,
+  createGpuPicker as eT,
+  createGridMaterial as eU,
+  createGridSpriteAtlas as eV,
+  createGround as eW,
+  createGroundFromHeightMap as eX,
+  createHavokWorld as eY,
+  createHeightFieldShape as eZ,
+  createHemisphericLight as e_,
+  createAnimationManager as ea,
+  createAnimationTask as eb,
+  createArcRotateCamera as ec,
+  createAxisDragGizmo as ed,
+  createAxisLockedBillboardSystem as ee,
+  createAxisScaleGizmo as ef,
+  createBillboardCustomShader as eg,
+  createBlackAndWhitePostProcessTask as eh,
+  createBloomPostProcessTask as ei,
+  createBlurPostProcessTask as ej,
+  createBoundingBoxGizmo as ek,
+  createBox as el,
+  createCameraGizmo as em,
+  createCapsule as en,
+  createCapsuleData as eo,
+  createChromaticAberrationPostProcessTask as ep,
+  createCircleOfConfusionPostProcessTask as eq,
+  createClusteredLightContainer as er,
+  createClusteredPointLight as es,
+  createCopyToTextureTask as et,
+  createCsg2FromMesh as eu,
+  createCsgFromMesh as ev,
+  createCsmDirectionalShadowGenerator as ew,
+  createCylinder as ex,
+  createCylinderData as ey,
+  createDebugNavMeshGeometry as ez,
   markMaterialUboDirty as f,
-  disposeBoundingBoxGizmo as f$,
-  createPhysicsCharacterController as f0,
-  createPhysicsConstraint as f1,
-  createPhysicsShape as f2,
-  createPhysicsViewer as f3,
-  createPlane as f4,
-  createPlaneDragGizmo as f5,
-  createPlaneRotationGizmo as f6,
-  createPointLight as f7,
-  createPointerDrag as f8,
-  createPolyhedron as f9,
-  createStandardMaterial as fA,
-  createStandardNoColorMaterialView$1 as fB,
-  createSurface as fC,
-  createTextData as fD,
-  createTextLayer as fE,
-  createTextRenderable as fF,
-  createTextRenderer as fG,
-  createTexture2DFromPixels as fH,
-  createTorus as fI,
-  createTorusKnot as fJ,
-  createTorusKnotData as fK,
-  createTransformNode as fL,
-  createTube as fM,
-  createUniformEffectRenderTask as fN,
-  createUniformEffectWrapper as fO,
-  createUtilityLayer as fP,
-  crossFadeAnimationGroups as fQ,
-  crossVec3 as fR,
-  csg2Add as fS,
-  csg2Intersect as fT,
-  csg2Subtract as fU,
-  csgIntersect as fV,
-  csgSubtract as fW,
-  csgUnion as fX,
-  cubicToQuadratics as fY,
-  disposeAxisDragGizmo as fZ,
-  disposeAxisScaleGizmo as f_,
-  createPositionGizmo as fa,
-  createProceduralGaussianSplattingMesh as fb,
-  createPropertyAnimationClip as fc,
-  createPropertyAnimationGroup as fd,
-  createRenderTarget as fe,
-  createRenderTargetTexture as ff,
-  createRenderTask as fg,
-  createRenderTexture2D as fh,
-  createRibbon as fi,
-  createRotationGizmo as fj,
-  createScaleGizmo as fk,
-  createSceneContext as fl,
-  createShaderMaterial as fm,
-  createShaderNoColorMaterialView$1 as fn,
-  createShaderNormalMaterialView as fo,
-  createShadowTask as fp,
-  createSolidTexture2D as fq,
-  createSphere as fr,
-  createSphereData as fs,
-  createSpotLight as ft,
-  createSprite2DCustomShader as fu,
-  createSprite2DLayer as fv,
-  createSpriteAnimationManager as fw,
-  createSpriteAtlasFromFrames as fx,
-  createSpriteFrameAnimation as fy,
-  createSpriteRenderer as fz,
+  createTorus as f$,
+  createImageProcessingTask as f0,
+  createLightGizmo as f1,
+  createLinearDepthMaterial as f2,
+  createMeshFromCsg as f3,
+  createMeshFromCsg2 as f4,
+  createMeshFromData as f5,
+  createMeshesFromCsg2 as f6,
+  createMorphTargets as f7,
+  createNavCrowd as f8,
+  createNavMesh as f9,
+  createRenderTexture2D as fA,
+  createRibbon as fB,
+  createRotationGizmo as fC,
+  createScaleGizmo as fD,
+  createSceneContext as fE,
+  createShaderMaterial as fF,
+  createShaderNoColorMaterialView$1 as fG,
+  createShaderNormalMaterialView as fH,
+  createShadowTask as fI,
+  createSolidTexture2D as fJ,
+  createSphere as fK,
+  createSphereData as fL,
+  createSpotLight as fM,
+  createSprite2DCustomShader as fN,
+  createSprite2DLayer as fO,
+  createSpriteAnimationManager as fP,
+  createSpriteAtlasFromFrames as fQ,
+  createSpriteFrameAnimation as fR,
+  createSpriteRenderer as fS,
+  createStandardMaterial as fT,
+  createStandardNoColorMaterialView$1 as fU,
+  createSurface as fV,
+  createTextData as fW,
+  createTextLayer as fX,
+  createTextRenderable as fY,
+  createTextRenderer as fZ,
+  createTexture2DFromPixels as f_,
+  createNavMeshFromSources as fa,
+  createNavigationPluginAsync as fb,
+  createNodeNoColorMaterialView$1 as fc,
+  createPbrMaterial as fd,
+  createPbrNoColorMaterialView$1 as fe,
+  createPcfDirectionalShadowGenerator as ff,
+  createPcfSpotlightShadowGenerator as fg,
+  createPhysicsAggregate as fh,
+  createPhysicsBody as fi,
+  createPhysicsCharacterController as fj,
+  createPhysicsConstraint as fk,
+  createPhysicsShape as fl,
+  createPhysicsViewer as fm,
+  createPlane as fn,
+  createPlaneDragGizmo as fo,
+  createPlaneRotationGizmo as fp,
+  createPointLight as fq,
+  createPointerDrag as fr,
+  createPolyhedron as fs,
+  createPositionGizmo as ft,
+  createProceduralGaussianSplattingMesh as fu,
+  createPropertyAnimationClip as fv,
+  createPropertyAnimationGroup as fw,
+  createRenderTarget as fx,
+  createRenderTargetTexture as fy,
+  createRenderTask as fz,
   TYPE_SIZES as g,
-  hidePhysicsBody as g$,
-  disposeCameraGizmo as g0,
-  disposeCsg2 as g1,
-  disposeDefaultTextData as g2,
-  disposeEffectRenderer as g3,
-  disposeEffectWrapper as g4,
-  disposeEngine as g5,
-  disposeFrameGraphContext as g6,
-  disposeGlyphStorage as g7,
-  disposeLightGizmo as g8,
-  disposePhysics as g9,
-  fadeAnimationWeight as gA,
-  findRandomPoint as gB,
-  findRandomPointAroundCircle as gC,
-  flushThinInstances as gD,
-  flyGeospatialCameraToAsync as gE,
-  getAgentPosition as gF,
-  getAgentVelocity as gG,
-  getAnimationGroups as gH,
-  getBillboardSpriteHandleIndex as gI,
-  getClosestPoint as gJ,
-  getContainerMeshes as gK,
-  getEffectivePitchMax as gL,
-  getFloatingOriginOffset as gM,
-  getFrameGraph as gN,
-  getNavigationRandomSeed as gO,
-  getPhysicsBodyLinearVelocity as gP,
-  getPhysicsGravity as gQ,
-  getPhysicsTimestep as gR,
-  getPhysicsVelocityLimits as gS,
-  getPickedNormal as gT,
-  getPickedUV as gU,
-  getRenderTaskGpuTimings as gV,
-  getSprite2DHandleIndex as gW,
-  getVariantNames as gX,
-  goToFrame as gY,
-  gsAlphaBlendedDepthFragment as gZ,
-  gsLinearDepthFragment as g_,
-  disposePhysicsViewer as ga,
-  disposePicker as gb,
-  disposePlaneDragGizmo as gc,
-  disposePlaneRotationGizmo as gd,
-  disposePositionGizmo as ge,
-  disposeRotationGizmo as gf,
-  disposeScaleGizmo as gg,
-  disposeScene as gh,
-  disposeSpriteAnimationBinding as gi,
-  disposeSpriteRenderer as gj,
-  disposeSurface as gk,
-  disposeTextData as gl,
-  disposeTextRenderable as gm,
-  disposeTextRenderer as gn,
-  disposeUniformEffectWrapper as go,
-  disposeUtilityLayer as gp,
-  dotVec3 as gq,
-  enableAnimationBlending as gr,
-  enableDetailedPicking as gs,
-  enableHavokFloatingOrigin as gt,
-  enableMaterialPlugins as gu,
-  enableMaterialTracking as gv,
-  enablePropertyAnimationBlending as gw,
-  enableRenderTaskTransmission as gx,
-  enableThinInstanceGpuCulling as gy,
-  extractGlyphCurves as gz,
+  getAgentPosition as g$,
+  createTorusKnot as g0,
+  createTorusKnotData as g1,
+  createTransformNode as g2,
+  createTube as g3,
+  createUniformEffectRenderTask as g4,
+  createUniformEffectWrapper as g5,
+  createUtilityLayer as g6,
+  crossFadeAnimationGroups as g7,
+  crossVec3 as g8,
+  csg2Add as g9,
+  disposeScaleGizmo as gA,
+  disposeScene as gB,
+  disposeSpriteAnimationBinding as gC,
+  disposeSpriteRenderer as gD,
+  disposeSurface as gE,
+  disposeTextData as gF,
+  disposeTextRenderable as gG,
+  disposeTextRenderer as gH,
+  disposeUniformEffectWrapper as gI,
+  disposeUtilityLayer as gJ,
+  dotVec3 as gK,
+  enableAnimationBlending as gL,
+  enableBoneControl as gM,
+  enableDetailedPicking as gN,
+  enableHavokFloatingOrigin as gO,
+  enableMaterialPlugins as gP,
+  enableMaterialStencil as gQ,
+  enableMaterialTracking as gR,
+  enablePropertyAnimationBlending as gS,
+  enableRenderTaskTransmission as gT,
+  enableThinInstanceGpuCulling as gU,
+  extractGlyphCurves as gV,
+  fadeAnimationWeight as gW,
+  findRandomPoint as gX,
+  findRandomPointAroundCircle as gY,
+  flushThinInstances as gZ,
+  flyGeospatialCameraToAsync as g_,
+  csg2Intersect as ga,
+  csg2Subtract as gb,
+  csgIntersect as gc,
+  csgSubtract as gd,
+  csgUnion as ge,
+  cubicToQuadratics as gf,
+  disposeAxisDragGizmo as gg,
+  disposeAxisScaleGizmo as gh,
+  disposeBoundingBoxGizmo as gi,
+  disposeCameraGizmo as gj,
+  disposeCsg2 as gk,
+  disposeDefaultTextData as gl,
+  disposeEffectRenderer as gm,
+  disposeEffectWrapper as gn,
+  disposeEngine as go,
+  disposeFrameGraphContext as gp,
+  disposeGlyphStorage as gq,
+  disposeLightGizmo as gr,
+  disposeMeshGpu as gs,
+  disposePhysics as gt,
+  disposePhysicsViewer as gu,
+  disposePicker as gv,
+  disposePlaneDragGizmo as gw,
+  disposePlaneRotationGizmo as gx,
+  disposePositionGizmo as gy,
+  disposeRotationGizmo as gz,
   computeAabb as h,
-  registerTextRenderer as h$,
-  initializeCsg2Async as h0,
-  invalidateRenderBundles as h1,
-  isBillboardSpriteHandleAlive as h2,
-  isCsg2Ready as h3,
-  isGizmoDragging as h4,
-  isGizmoInteracting as h5,
-  isGizmoPickPending as h6,
-  isGpuTimingSupported as h7,
-  isRenderTaskGpuTimingSupported as h8,
-  isSprite2DHandleAlive as h9,
-  normalizeVec3$1 as hA,
-  normalizeVec3$2 as hB,
-  onBeforeRender as hC,
-  onCsmReceiverUpdate as hD,
-  onPhysicsAfterStep as hE,
-  onPhysicsCollision as hF,
-  onPhysicsTrigger as hG,
-  onSceneDispose as hH,
-  packedSrgbToLinearRgba as hI,
-  parseNodeMaterialFromSnippet as hJ,
-  pauseAnimation as hK,
-  physicsRaycast as hL,
-  pickAsync as hM,
-  playAnimation as hN,
-  playBillboardSpriteAnimation as hO,
-  playBillboardSpriteIndexAnimation as hP,
-  playSprite2DAnimation as hQ,
-  playSprite2DIndexAnimation as hR,
-  playSpriteFrameAnimation as hS,
-  raycast as hT,
-  rebuildMaterial as hU,
-  registerEffectRenderer as hV,
-  registerFrameGraphContext as hW,
-  registerPointerDrag as hX,
-  registerScene as hY,
-  registerSceneWithShadowSupport as hZ,
-  registerSpriteRenderer as h_,
-  lengthVec3 as ha,
-  lerpVec3 as hb,
-  loadBabylon as hc,
-  loadBasisTexture2D as hd,
-  loadDdsEnvironment as he,
-  loadEnvironment as hf,
-  loadFont as hg,
-  loadGltf as hh,
-  loadHdrEnvironment as hi,
-  loadKtxTexture2D as hj,
-  loadNodeBlockEmitterWithGeometry as hk,
-  loadSOG as hl,
-  loadSPZ as hm,
-  loadSkybox as hn,
-  loadSplat as ho,
-  loadSpriteAtlas as hp,
-  loadTexture2D as hq,
-  markClusteredLightContainerDirty as hr,
-  mat4Compose as hs,
-  mat4FromQuat as ht,
-  mat4LookAtLH as hu,
-  mat4PerspectiveLH as hv,
-  mat4Scale as hw,
-  mat4Translation as hx,
-  negateVec3 as hy,
-  normalizeRadians as hz,
+  onBeforeRender as h$,
+  getAgentVelocity as h0,
+  getAnimationGroups as h1,
+  getBillboardSpriteHandleIndex as h2,
+  getBoneByName as h3,
+  getClosestPoint as h4,
+  getContainerMeshes as h5,
+  getEffectivePitchMax as h6,
+  getFloatingOriginOffset as h7,
+  getFrameGraph as h8,
+  getNavigationRandomSeed as h9,
+  loadBasisTexture2D as hA,
+  loadDdsEnvironment as hB,
+  loadEnvironment as hC,
+  loadFont as hD,
+  loadGltf as hE,
+  loadHdrEnvironment as hF,
+  loadKtx2Texture2D as hG,
+  loadKtxTexture2D as hH,
+  loadNodeBlockEmitterWithGeometry as hI,
+  loadSOG as hJ,
+  loadSPZ as hK,
+  loadSkybox as hL,
+  loadSplat as hM,
+  loadSpriteAtlas as hN,
+  loadTexture2D as hO,
+  markClusteredLightContainerDirty as hP,
+  mat4Compose as hQ,
+  mat4Decompose as hR,
+  mat4FromQuat as hS,
+  mat4LookAtLH as hT,
+  mat4PerspectiveLH as hU,
+  mat4Scale as hV,
+  mat4Translation as hW,
+  negateVec3 as hX,
+  normalizeRadians as hY,
+  normalizeVec3$1 as hZ,
+  normalizeVec3$2 as h_,
+  getPhysicsBodyLinearVelocity as ha,
+  getPhysicsGravity as hb,
+  getPhysicsTimestep as hc,
+  getPhysicsVelocityLimits as hd,
+  getPickedNormal as he,
+  getPickedUV as hf,
+  getRenderTaskGpuTimings as hg,
+  getSprite2DHandleIndex as hh,
+  getVariantNames as hi,
+  goToFrame as hj,
+  gsAlphaBlendedDepthFragment as hk,
+  gsLinearDepthFragment as hl,
+  hidePhysicsBody as hm,
+  initializeCsg2Async as hn,
+  invalidateRenderBundles as ho,
+  isBillboardSpriteHandleAlive as hp,
+  isCsg2Ready as hq,
+  isGizmoDragging as hr,
+  isGizmoInteracting as hs,
+  isGizmoPickPending as ht,
+  isGpuTimingSupported as hu,
+  isRenderTaskGpuTimingSupported as hv,
+  isSprite2DHandleAlive as hw,
+  lengthVec3 as hx,
+  lerpVec3 as hy,
+  loadBabylon as hz,
   initMeshTransform as i,
-  setPhysicsTimestep as i$,
-  registerUtilityLayer as i0,
-  releasePhysicsShape as i1,
-  removeAnimationGroup as i2,
-  removeAnimationTask as i3,
-  removeBillboardSprite as i4,
-  removeBillboardSpriteIndex as i5,
-  removeFromScene as i6,
-  removeHierarchyInstance as i7,
-  removeMeshFromTask as i8,
-  removeObstacle as i9,
-  setEffectTexture as iA,
-  setEffectUniforms as iB,
-  setEngineSize as iC,
-  setFog as iD,
-  setGeospatialOrientation as iE,
-  setGpuTimingEnabled as iF,
-  setHierarchyInstanceCount as iG,
-  setHierarchyInstanceMatrix as iH,
-  setKtx2DecoderUrl as iI,
-  setMorphTargetWeights as iJ,
-  setNavigationRandomSeed as iK,
-  setParent as iL,
-  setPhysicsBodyAngularVelocity as iM,
-  setPhysicsBodyCollisionEventsEnabled as iN,
-  setPhysicsBodyLinearVelocity as iO,
-  setPhysicsBodyMass as iP,
-  setPhysicsBodyMassProperties as iQ,
-  setPhysicsBodyMotionType as iR,
-  setPhysicsBodyPreStep as iS,
-  setPhysicsBodyPrestepType as iT,
-  setPhysicsBodyShape as iU,
-  setPhysicsBodyTransform as iV,
-  setPhysicsGravity as iW,
-  setPhysicsShapeFilterCollideMask as iX,
-  setPhysicsShapeFilterMembershipMask as iY,
-  setPhysicsShapeIsTrigger as iZ,
-  setPhysicsShapeMaterial as i_,
-  removePhysicsBody as ia,
-  removeSprite2D as ib,
-  removeSprite2DIndex as ic,
-  removeSpriteAnimation as id,
-  removeSpriteAnimationManager as ie,
-  removeSpriteRendererLayer as ig,
-  removeTextRendererLayer as ih,
-  removeThinInstance as ii,
-  renderFrame as ij,
-  resetVariant as ik,
-  resizeEngine as il,
-  resizeMeshGeometry as im,
-  resizeSurface as io,
-  resolveCameraViewport as ip,
-  scaleVec3 as iq,
-  selectVariant as ir,
-  setAnimationAdditive as is,
-  setAnimationTaskCategoryHandler as it,
-  setAnimationWeight as iu,
-  setBillboardShaderParams as iv,
-  setBillboardSpriteFrame as iw,
-  setBillboardSpriteFrameIndex as ix,
-  setCameraLimits as iy,
-  setClipPlane as iz,
+  setBoneScaling as i$,
+  onCsmReceiverUpdate as i0,
+  onPhysicsAfterStep as i1,
+  onPhysicsCollision as i2,
+  onPhysicsTrigger as i3,
+  onSceneDispose as i4,
+  packedSrgbToLinearRgba as i5,
+  parseNodeMaterialFromSnippet as i6,
+  pauseAnimation as i7,
+  physicsRaycast as i8,
+  pickAsync as i9,
+  removeHierarchyInstance as iA,
+  removeMeshFromTask as iB,
+  removeObstacle as iC,
+  removePhysicsBody as iD,
+  removeSprite2D as iE,
+  removeSprite2DIndex as iF,
+  removeSpriteAnimation as iG,
+  removeSpriteAnimationManager as iH,
+  removeSpriteRendererLayer as iI,
+  removeTextRendererLayer as iJ,
+  removeThinInstance as iK,
+  renderFrame as iL,
+  resetVariant as iM,
+  resizeEngine as iN,
+  resizeMeshGeometry as iO,
+  resizeSurface as iP,
+  resolveCameraViewport as iQ,
+  scaleVec3 as iR,
+  selectVariant as iS,
+  setAnimationAdditive as iT,
+  setAnimationTaskCategoryHandler as iU,
+  setAnimationWeight as iV,
+  setBillboardShaderParams as iW,
+  setBillboardSpriteFrame as iX,
+  setBillboardSpriteFrameIndex as iY,
+  setBonePosition as iZ,
+  setBoneRotationQuaternion as i_,
+  playAnimation as ia,
+  playBillboardSpriteAnimation as ib,
+  playBillboardSpriteIndexAnimation as ic,
+  playSprite2DAnimation as id,
+  playSprite2DIndexAnimation as ie,
+  playSpriteFrameAnimation as ig,
+  quatFromLookDirectionRH as ih,
+  quatFromRotationMatrix as ii,
+  raycast as ij,
+  rebuildMaterial as ik,
+  registerEffectRenderer as il,
+  registerFrameGraphContext as im,
+  registerPointerDrag as io,
+  registerScene as ip,
+  registerSceneWithShadowSupport as iq,
+  registerSpriteRenderer as ir,
+  registerTextRenderer as is,
+  registerUtilityLayer as it,
+  releasePhysicsShape as iu,
+  removeAnimationGroup as iv,
+  removeAnimationTask as iw,
+  removeBillboardSprite as ix,
+  removeBillboardSpriteIndex as iy,
+  removeFromScene as iz,
   U16 as j,
-  updateTextData as j$,
-  setPhysicsVelocityLimits as j0,
-  setPositionGizmoLocalCoordinates as j1,
-  setRenderTaskGpuTimingEnabled as j2,
-  setRotationGizmoLocalCoordinates as j3,
-  setScaleGizmoLocalCoordinates as j4,
-  setShaderFloat as j5,
-  setShaderMatrix as j6,
-  setShaderStorageBuffer as j7,
-  setShaderTexture as j8,
-  setShaderUniform as j9,
-  stopAnimation as jA,
-  stopAnimationManager as jB,
-  stopEngine as jC,
-  stopSpriteAnimation as jD,
-  stopSpriteAnimationManager as jE,
-  subVec3 as jF,
-  unregisterEffectRenderer as jG,
-  unregisterFrameGraphContext as jH,
-  unregisterScene as jI,
-  unregisterSpriteRenderer as jJ,
-  unregisterTextRenderer as jK,
-  updateAnimationManager as jL,
-  updateBillboardSprite as jM,
-  updateBillboardSpriteIndex as jN,
-  updateDefaultTextData as jO,
-  updateGlyphStorage as jP,
-  updateMeshColors as jQ,
-  updateMeshNormals as jR,
-  updateMeshPositions as jS,
-  updateMeshTangents as jT,
-  updateMeshUv2 as jU,
-  updateMeshUvs as jV,
-  updateNavCrowd as jW,
-  updateNavMeshObstacles as jX,
-  updateSprite2D as jY,
-  updateSprite2DIndex as jZ,
-  updateSpriteAnimationManager as j_,
-  setShaderVector3 as ja,
-  setShadowTaskCasterMeshes as jb,
-  setSprite2DFrame as jc,
-  setSprite2DFrameIndex as jd,
-  setSprite2DShaderParams as je,
-  setSprite2DUvOffset as jf,
-  setSpriteRendererTarget as jg,
-  setSurfaceSize as jh,
-  setTextLayerPosition as ji,
-  setThinInstanceColor as jj,
-  setThinInstanceColors as jk,
-  setThinInstanceCount as jl,
-  setThinInstanceMatrix as jm,
-  setUniformEffectUniforms as jn,
-  shapeCast as jo,
-  shapeProximity as jp,
-  showPhysicsBody as jq,
-  showPhysicsConstraint as jr,
-  spriteBlendAdditive as js,
-  spriteBlendAlpha as jt,
-  spriteBlendMultiply as ju,
-  spriteBlendPremultiplied as jv,
-  srgbByteToLinear as jw,
-  startAnimationManager as jx,
-  startEngine as jy,
-  startSpriteAnimationManager as jz,
+  spriteBlendMultiply as j$,
+  setBoneVisible as j0,
+  setCameraLimits as j1,
+  setClipPlane as j2,
+  setDracoBaseUrl as j3,
+  setEffectTexture as j4,
+  setEffectUniforms as j5,
+  setEngineSize as j6,
+  setFog as j7,
+  setGeospatialOrientation as j8,
+  setGpuTimingEnabled as j9,
+  setRotationGizmoLocalCoordinates as jA,
+  setScaleGizmoLocalCoordinates as jB,
+  setShaderFloat as jC,
+  setShaderMatrix as jD,
+  setShaderStorageBuffer as jE,
+  setShaderTexture as jF,
+  setShaderUniform as jG,
+  setShaderVector3 as jH,
+  setShadowTaskCasterMeshes as jI,
+  setSprite2DFrame as jJ,
+  setSprite2DFrameIndex as jK,
+  setSprite2DShaderParams as jL,
+  setSprite2DUvOffset as jM,
+  setSpriteRendererTarget as jN,
+  setSurfaceSize as jO,
+  setTextLayerPosition as jP,
+  setThinInstanceColor as jQ,
+  setThinInstanceColors as jR,
+  setThinInstanceCount as jS,
+  setThinInstanceMatrix as jT,
+  setUniformEffectUniforms as jU,
+  shapeCast as jV,
+  shapeProximity as jW,
+  showPhysicsBody as jX,
+  showPhysicsConstraint as jY,
+  spriteBlendAdditive as jZ,
+  spriteBlendAlpha as j_,
+  setHierarchyInstanceCount as ja,
+  setHierarchyInstanceMatrix as jb,
+  setKtx2DecoderUrl as jc,
+  setMeshoptBaseUrl as jd,
+  setMorphTargetWeights as je,
+  setNavigationRandomSeed as jf,
+  setParent as jg,
+  setPhysicsBodyAngularVelocity as jh,
+  setPhysicsBodyCollisionEventsEnabled as ji,
+  setPhysicsBodyLinearVelocity as jj,
+  setPhysicsBodyMass as jk,
+  setPhysicsBodyMassProperties as jl,
+  setPhysicsBodyMotionType as jm,
+  setPhysicsBodyPreStep as jn,
+  setPhysicsBodyPrestepType as jo,
+  setPhysicsBodyShape as jp,
+  setPhysicsBodyTransform as jq,
+  setPhysicsGravity as jr,
+  setPhysicsShapeFilterCollideMask as js,
+  setPhysicsShapeFilterMembershipMask as jt,
+  setPhysicsShapeIsTrigger as ju,
+  setPhysicsShapeMaterial as jv,
+  setPhysicsTimestep as jw,
+  setPhysicsVelocityLimits as jx,
+  setPositionGizmoLocalCoordinates as jy,
+  setRenderTaskGpuTimingEnabled as jz,
   createMappedBuffer as k,
-  updateTexture2DFromPixels as k0,
-  vec3 as k1,
-  writeVec3 as k2,
-  generateMipmaps$1 as k3,
-  pointLight as k4,
-  directionalLight as k5,
-  spotLight as k6,
-  animationGroup as k7,
-  createMorphTargets$1 as k8,
+  spriteBlendPremultiplied as k0,
+  srgbByteToLinear as k1,
+  startAnimationManager as k2,
+  startEngine as k3,
+  startSpriteAnimationManager as k4,
+  stopAnimation as k5,
+  stopAnimationManager as k6,
+  stopEngine as k7,
+  stopSpriteAnimation as k8,
+  stopSpriteAnimationManager as k9,
+  generateMipmaps$1 as kA,
+  pointLight as kB,
+  directionalLight as kC,
+  spotLight as kD,
+  animationGroup as kE,
+  createMorphTargets$1 as kF,
+  subVec3 as ka,
+  unregisterEffectRenderer as kb,
+  unregisterFrameGraphContext as kc,
+  unregisterScene as kd,
+  unregisterSpriteRenderer as ke,
+  unregisterTextRenderer as kf,
+  updateAnimationManager as kg,
+  updateBillboardSprite as kh,
+  updateBillboardSpriteIndex as ki,
+  updateDefaultTextData as kj,
+  updateGlyphStorage as kk,
+  updateMeshColors as kl,
+  updateMeshNormals as km,
+  updateMeshPositions as kn,
+  updateMeshTangents as ko,
+  updateMeshUv2 as kp,
+  updateMeshUvs as kq,
+  updateNavCrowd as kr,
+  updateNavMeshObstacles as ks,
+  updateSprite2D as kt,
+  updateSprite2DIndex as ku,
+  updateSpriteAnimationManager as kv,
+  updateTextData as kw,
+  updateTexture2DFromPixels as kx,
+  vec3 as ky,
+  writeVec3 as kz,
   anyPrimitive as l,
   makeTimingSnapshot as m,
   needsOrmComposite as n,
-  computeUboLayout as o,
+  pbrGroupBuilder as o,
   packMat4IntoF32 as p,
-  SCENE_UBO_WGSL as q,
+  linearToSrgbByte as q,
   resolveAccessor as r,
-  pbrGroupBuilder as s,
-  linearToSrgbByte as t,
+  cloneTexture2D as s,
+  createFreeCamera as t,
   uploadTex as u,
-  cloneTexture2D as v,
+  targetSignatureKey as v,
   writeNodeUBO as w,
-  createFreeCamera as x,
-  targetSignatureKey as y,
-  createDefaultPipelineDescriptor as z
+  createDefaultPipelineDescriptor as x,
+  getSceneBindGroupLayout as y,
+  disposeGaussianSplattingMesh as z
 };
-//# sourceMappingURL=index-BgY3QEzL.js.map
+//# sourceMappingURL=index-C2sM8ERH.js.map