@vizij/render 0.0.7 → 0.1.1

package/dist/index.mjs

@@ -1,19 +1,10 @@
 // src/vizij.tsx
-import {
-  Suspense,
-  memo as memo6,
-  useContext as useContext3,
-  useEffect as useEffect6
-} from "react";
+import { Suspense, memo as memo6, useContext as useContext3, useEffect as useEffect7 } from "react";
 import { ErrorBoundary } from "react-error-boundary";
-import {
-  Object3D as Object3D4,
-  SRGBColorSpace,
-  NoToneMapping
-} from "three";
+import { Object3D as Object3D4, SRGBColorSpace, NoToneMapping } from "three";
 import { Canvas, useThree } from "@react-three/fiber";
 import { Line as Line3, OrthographicCamera, Text } from "@react-three/drei";
-import { useShallow as useShallow6 } from "zustand/react/shallow";
+import { useShallow as useShallow7 } from "zustand/react/shallow";
 
 // src/renderables/renderable.tsx
 import { memo as memo5, useMemo as useMemo5 } from "react";
@@ -35,13 +26,7 @@ function useVizijStore(selector) {
 }
 
 // src/renderables/group.tsx
-import {
-  memo,
-  useCallback,
-  useEffect as useEffect2,
-  useRef,
-  useMemo
-} from "react";
+import { memo, useCallback, useEffect as useEffect2, useRef, useMemo } from "react";
 import * as THREE from "three";
 import { useShallow } from "zustand/react/shallow";
 import {
@@ -138,7 +123,7 @@ function InnerRenderedGroup({
   namespace,
   chain
 }) {
-  const ref = useRef();
+  const ref = useRef(null);
   const group = useVizijStore(useShallow((state) => state.world[id]));
   const refIsNull = !group.refs[namespace]?.current;
   const animatables = useVizijStore(useShallow((state) => state.animatables));
@@ -249,13 +234,7 @@ function InnerRenderedGroup({
 var RenderedGroup = memo(InnerRenderedGroup);
 
 // src/renderables/ellipse.tsx
-import {
-  memo as memo2,
-  useCallback as useCallback2,
-  useEffect as useEffect3,
-  useRef as useRef2,
-  useMemo as useMemo2
-} from "react";
+import { memo as memo2, useCallback as useCallback2, useEffect as useEffect3, useRef as useRef2, useMemo as useMemo2 } from "react";
 import { useShallow as useShallow2 } from "zustand/react/shallow";
 import {
   instanceOfRawNumber as instanceOfRawNumber2,
@@ -272,9 +251,11 @@ function InnerRenderedEllipse({
   namespace,
   chain
 }) {
-  const ellipseRef = useRef2();
-  const materialRef = useRef2();
-  const lineRef = useRef2();
+  const ellipseRef = useRef2(null);
+  const materialRef = useRef2(
+    null
+  );
+  const lineRef = useRef2(null);
   const strokeOffsetRef = useRef2(0);
   const strokeWidthRef = useRef2(0);
   const onElementClick = useVizijStore(
@@ -547,13 +528,7 @@ var showLine = (ellipse) => {
 };
 
 // src/renderables/rectangle.tsx
-import {
-  memo as memo3,
-  useCallback as useCallback3,
-  useEffect as useEffect4,
-  useRef as useRef3,
-  useMemo as useMemo3
-} from "react";
+import { memo as memo3, useCallback as useCallback3, useEffect as useEffect4, useRef as useRef3, useMemo as useMemo3 } from "react";
 import { useShallow as useShallow3 } from "zustand/react/shallow";
 import {
   instanceOfRawNumber as instanceOfRawNumber3,
@@ -570,9 +545,11 @@ function InnerRenderedRectangle({
   namespace,
   chain
 }) {
-  const rectangleRef = useRef3();
-  const materialRef = useRef3();
-  const lineRef = useRef3();
+  const rectangleRef = useRef3(null);
+  const materialRef = useRef3(
+    null
+  );
+  const lineRef = useRef3(null);
   const strokeOffsetRef = useRef3(0);
   const strokeWidthRef = useRef3(0);
   const onElementClick = useVizijStore(
@@ -846,13 +823,7 @@ var showLine2 = (rectangle) => {
 };
 
 // src/renderables/shape.tsx
-import {
-  memo as memo4,
-  useCallback as useCallback4,
-  useRef as useRef4,
-  useMemo as useMemo4,
-  useEffect as useEffect5
-} from "react";
+import { memo as memo4, useCallback as useCallback4, useRef as useRef4, useMemo as useMemo4, useEffect as useEffect5 } from "react";
 import * as THREE2 from "three";
 import { useShallow as useShallow4 } from "zustand/react/shallow";
 import {
@@ -869,8 +840,8 @@ function InnerRenderedShape({
   namespace,
   chain
 }) {
-  const refGroup = useRef4();
-  const ref = useRef4();
+  const refGroup = useRef4(null);
+  const ref = useRef4(null);
   const shape = useVizijStore(useShallow4((state) => state.world[id]));
   const refs = useVizijStore(
     useShallow4((state) => state.world[id].refs)
@@ -911,7 +882,7 @@ function InnerRenderedShape({
     }),
     [shape, animatableValues, selectionData]
   );
-  const material = useRef4();
+  const material = useRef4(null);
   const morphTargetSettings = useMemo4(() => {
     if (shape.morphTargets) {
       const dictionary = shape.morphTargets.reduce(
@@ -1432,6 +1403,35 @@ function createAnimatable(value) {
 }
 createAnimatable({ type: "euler", name: "Rotation" });
 
+// src/functions/exportable-bodies.ts
+function asGroupEntries(world) {
+  return Object.values(world).filter((entry) => entry.type === "group");
+}
+function selectExportableGroupEntries(world, filterIds) {
+  const groupEntries = asGroupEntries(world);
+  const filterSet = Array.isArray(filterIds) && filterIds.length > 0 ? new Set(filterIds) : null;
+  if (filterSet) {
+    return groupEntries.filter((entry) => filterSet.has(entry.id));
+  }
+  const rootBoundsGroups = groupEntries.filter(
+    (entry) => Boolean(entry.rootBounds)
+  );
+  if (rootBoundsGroups.length > 0) {
+    return rootBoundsGroups;
+  }
+  const explicitRootGroups = groupEntries.filter(
+    (entry) => entry.root === true
+  );
+  if (explicitRootGroups.length > 0) {
+    return explicitRootGroups;
+  }
+  const topLevelGroups = groupEntries.filter((entry) => !entry.parent);
+  if (topLevelGroups.length > 0) {
+    return topLevelGroups;
+  }
+  return groupEntries;
+}
+
 // src/store.ts
 THREE3.Object3D.DEFAULT_UP.set(0, 0, 1);
 enableMapSet();
@@ -1507,23 +1507,17 @@ var VizijSlice = (set, get) => ({
   },
   getExportableBodies: (filterIds) => {
     const worldData = get().world;
-    if (!filterIds) {
-      const bodies = Object.values(worldData).filter((entry) => entry.type === "group" && entry.rootBounds).map((entry) => {
-        const firstNs = Object.keys(entry.refs)[0];
-        const refGroup = entry.refs[firstNs].current;
-        return refGroup;
-      });
-      return bodies;
-    } else {
-      const bodies = Object.values(worldData).filter(
-        (entry) => entry.type === "group" && entry.rootBounds && filterIds.includes(entry.id)
-      ).map((entry) => {
-        const firstNs = Object.keys(entry.refs)[0];
-        const refGroup = entry.refs[firstNs].current;
-        return refGroup;
-      });
-      return bodies;
-    }
+    const candidateGroups = selectExportableGroupEntries(
+      worldData,
+      filterIds
+    );
+    return candidateGroups.flatMap((entry) => {
+      const refs = Object.values(
+        entry.refs ?? {}
+      );
+      const resolved = refs.find((ref) => ref?.current)?.current ?? null;
+      return resolved ? [resolved] : [];
+    });
   },
   setGeometry: (id, geometry) => {
     set(
@@ -1557,6 +1551,19 @@ var VizijSlice = (set, get) => ({
       })
     );
   },
+  setValues: (writes = []) => {
+    if (writes.length === 0) {
+      return;
+    }
+    set(
+      produce((state) => {
+        writes.forEach(({ id, namespace, value }) => {
+          const lookupId = getLookup2(namespace, id);
+          state.values.set(lookupId, value);
+        });
+      })
+    );
+  },
   setWorldElementName: (id, value) => {
     set(
       produce((state) => {
@@ -1751,8 +1758,117 @@ var createVizijStore = (initial) => create()(
   }))
 );
 
+// src/effects/selection-glow-effect.tsx
+import { Fragment as Fragment4, useEffect as useEffect6, useMemo as useMemo6, useRef as useRef5 } from "react";
+import { useFrame } from "@react-three/fiber";
+import { useShallow as useShallow6 } from "zustand/react/shallow";
+import {
+  AdditiveBlending,
+  Color,
+  EdgesGeometry,
+  LineBasicMaterial,
+  Matrix4,
+  Quaternion,
+  Vector3
+} from "three";
+import { jsx as jsx6 } from "react/jsx-runtime";
+function SelectionGlowEffect({
+  enabled = false,
+  color = "#ff1010ff",
+  opacity = 0.9,
+  thresholdAngle = 2
+}) {
+  const selections = useVizijStore(
+    useShallow6(
+      (state) => enabled ? state.elementSelection ?? [] : []
+    )
+  );
+  if (!enabled || selections.length === 0) {
+    return null;
+  }
+  return /* @__PURE__ */ jsx6(Fragment4, { children: selections.map((selection) => /* @__PURE__ */ jsx6(
+    SelectionOutline,
+    {
+      selection,
+      color: selection.color ?? color,
+      opacity,
+      thresholdAngle
+    },
+    `${selection.namespace}:${selection.id}`
+  )) });
+}
+function SelectionOutline({
+  selection,
+  color,
+  opacity,
+  thresholdAngle
+}) {
+  const target = useVizijStore(
+    useShallow6((state) => {
+      const entry = state.world[selection.id];
+      const ref = entry?.refs?.[selection.namespace];
+      const geometry = entry?.geometry ?? null;
+      return { ref, geometry };
+    })
+  );
+  const sourceRef = target.ref;
+  const edgesGeometry = useMemo6(() => {
+    if (!target.geometry) return null;
+    const edges = new EdgesGeometry(target.geometry, thresholdAngle);
+    return edges;
+  }, [target.geometry, thresholdAngle]);
+  useEffect6(() => () => edgesGeometry?.dispose(), [edgesGeometry]);
+  const material = useMemo6(() => {
+    const mat = new LineBasicMaterial({
+      color: new Color(color),
+      transparent: true,
+      opacity,
+      blending: AdditiveBlending,
+      depthTest: false,
+      depthWrite: false,
+      toneMapped: false
+    });
+    return mat;
+  }, [color, opacity]);
+  useEffect6(() => () => material.dispose(), [material]);
+  const lineRef = useRef5(null);
+  useFrame(() => {
+    const source = sourceRef?.current;
+    const line = lineRef.current;
+    if (!source || !line) return;
+    copyWorldTransform(source, line);
+    line.visible = source.visible;
+  });
+  if (!sourceRef || !edgesGeometry) {
+    return null;
+  }
+  return /* @__PURE__ */ jsx6(
+    "lineSegments",
+    {
+      ref: lineRef,
+      geometry: edgesGeometry,
+      material,
+      frustumCulled: false,
+      renderOrder: 1e3
+    }
+  );
+}
+var tempMatrix = new Matrix4();
+var tempPosition = new Vector3();
+var tempQuaternion = new Quaternion();
+var tempScale = new Vector3();
+function copyWorldTransform(source, target) {
+  source.updateWorldMatrix(true, false);
+  tempMatrix.copy(source.matrixWorld);
+  tempMatrix.decompose(tempPosition, tempQuaternion, tempScale);
+  target.position.copy(tempPosition);
+  target.quaternion.copy(tempQuaternion);
+  target.scale.copy(tempScale);
+  target.updateMatrix();
+}
+
 // src/vizij.tsx
-import { Fragment as Fragment4, jsx as jsx6, jsxs as jsxs4 } from "react/jsx-runtime";
+import { Fragment as Fragment5, jsx as jsx7, jsxs as jsxs4 } from "react/jsx-runtime";
 Object3D4.DEFAULT_UP.set(0, 0, 1);
 function Vizij({
   style,
@@ -1760,11 +1876,12 @@ function Vizij({
   rootId,
   namespace = "default",
   showSafeArea = false,
+  showSelectionGlow = false,
   onPointerMissed
 }) {
   const ctx = useContext3(VizijContext);
   if (ctx) {
-    return /* @__PURE__ */ jsx6(
+    return /* @__PURE__ */ jsx7(
       Canvas,
       {
         shadows: false,
@@ -1776,18 +1893,19 @@ function Vizij({
           toneMapping: NoToneMapping,
           antialias: true
         },
-        children: /* @__PURE__ */ jsx6(
+        children: /* @__PURE__ */ jsx7(
           MemoizedInnerVizij,
           {
             rootId,
             namespace,
-            showSafeArea
+            showSafeArea,
+            showSelectionGlow
           }
         )
       }
     );
   } else {
-    return /* @__PURE__ */ jsx6(VizijContext.Provider, { value: useDefaultVizijStore, children: /* @__PURE__ */ jsx6(
+    return /* @__PURE__ */ jsx7(VizijContext.Provider, { value: useDefaultVizijStore, children: /* @__PURE__ */ jsx7(
       Canvas,
       {
         style,
@@ -1798,12 +1916,13 @@ function Vizij({
           toneMapping: NoToneMapping,
           antialias: true
         },
-        children: /* @__PURE__ */ jsx6(
+        children: /* @__PURE__ */ jsx7(
           MemoizedInnerVizij,
           {
             rootId,
             namespace,
-            showSafeArea
+            showSafeArea,
+            showSelectionGlow
           }
         )
       }
@@ -1814,15 +1933,16 @@ function InnerVizij({
   rootId,
   namespace = "default",
   container,
-  showSafeArea
+  showSafeArea,
+  showSelectionGlow
 }) {
   const sceneParentSizing = container ? {
     width: container.width * container.resolution,
     height: container.height * container.resolution
   } : void 0;
-  return /* @__PURE__ */ jsxs4(Fragment4, { children: [
-    /* @__PURE__ */ jsx6("ambientLight", { intensity: Math.PI / 2 }),
-    /* @__PURE__ */ jsx6(
+  return /* @__PURE__ */ jsxs4(Fragment5, { children: [
+    /* @__PURE__ */ jsx7("ambientLight", { intensity: Math.PI / 2 }),
+    /* @__PURE__ */ jsx7(
       OrthographicCamera,
       {
         makeDefault: true,
@@ -1831,7 +1951,7 @@ function InnerVizij({
         far: 101
       }
     ),
-    /* @__PURE__ */ jsx6(Suspense, { fallback: null, children: /* @__PURE__ */ jsx6(
+    /* @__PURE__ */ jsx7(Suspense, { fallback: null, children: /* @__PURE__ */ jsx7(
       World,
       {
         rootId,
@@ -1839,7 +1959,8 @@ function InnerVizij({
         parentSizing: sceneParentSizing
       }
     ) }),
-    showSafeArea && /* @__PURE__ */ jsx6(SafeAreaRenderer, { rootId })
+    showSelectionGlow && /* @__PURE__ */ jsx7(SelectionGlowEffect, { enabled: true }),
+    showSafeArea && /* @__PURE__ */ jsx7(SafeAreaRenderer, { rootId })
   ] });
 }
 var MemoizedInnerVizij = memo6(InnerVizij);
@@ -1849,7 +1970,7 @@ function InnerWorld({
   parentSizing
 }) {
   const [present, rootBounds] = useVizijStore(
-    useShallow6((state) => {
+    useShallow7((state) => {
       const group = state.world[rootId];
       const bounds = group?.rootBounds ?? defaultRootBounds;
       return [group !== void 0, bounds];
@@ -1859,7 +1980,7 @@ function InnerWorld({
     camera: state.camera,
     size: state.size
   }));
-  useEffect6(() => {
+  useEffect7(() => {
     const width = rootBounds.size.x;
     const height = rootBounds.size.y;
     if (camera && parentSizing === void 0 && camera.isOrthographicCamera) {
@@ -1888,8 +2009,8 @@ function InnerWorld({
     }
   }, [rootBounds, camera, parentSizing, size]);
   return /* @__PURE__ */ jsxs4(ErrorBoundary, { fallback: null, children: [
-    present && /* @__PURE__ */ jsx6(Renderable, { id: rootId, namespace, chain: [] }),
-    !present && /* @__PURE__ */ jsx6(
+    present && /* @__PURE__ */ jsx7(Renderable, { id: rootId, namespace, chain: [] }),
+    !present && /* @__PURE__ */ jsx7(
       Text,
       {
         position: [0, 0, 0],
@@ -1912,7 +2033,7 @@ function SafeAreaRenderer({ rootId }) {
   const right = rootBounds.center.x + rootBounds.size.x / 2;
   const top = rootBounds.center.y + rootBounds.size.y / 2;
   const bottom = rootBounds.center.y - rootBounds.size.y / 2;
-  return /* @__PURE__ */ jsx6(
+  return /* @__PURE__ */ jsx7(
     Line3,
     {
       points: [
@@ -1943,11 +2064,11 @@ var ShapeMaterial = /* @__PURE__ */ ((ShapeMaterial2) => {
 })(ShapeMaterial || {});
 
 // src/hooks/use-vizij-store-subscription.ts
-import { useContext as useContext4, useEffect as useEffect7 } from "react";
+import { useContext as useContext4, useEffect as useEffect8 } from "react";
 function useVizijStoreSubscription(selector, listener) {
   const store = useContext4(VizijContext);
   if (!store) throw new Error("Missing VizijProvider in the tree");
-  useEffect7(() => {
+  useEffect8(() => {
     const initialValue = selector(store.getState());
     listener(initialValue);
     return store.subscribe(selector, listener);
@@ -2013,9 +2134,7 @@ function namespaceArrayToRefs(namespaces) {
 }
 
 // src/functions/gltf-loading/import-mesh.ts
-import {
-  Object3D as Object3D5
-} from "three";
+import { Object3D as Object3D5 } from "three";
 
 // src/functions/gltf-loading/import-geometry.ts
 function sanitizeMorphKey(name, fallbackIndex, used) {
@@ -2055,7 +2174,7 @@ function importGeometry(geometry, mesh) {
           type: "number",
           default: mesh.morphTargetInfluences?.[index] ?? 0,
           constraints: {
-            min: 0,
+            min: -1,
             max: 1
           },
           pub: {
@@ -2185,6 +2304,15 @@ function importMesh(mesh, namespaces, colorLookup) {
       world = { ...world, ...newWorldItems };
       animatables = { ...animatables, ...newAnimatables };
       children.push(childId);
+    } else if (shouldImportAsGroupChild(child)) {
+      const [newWorldItems, newAnimatables, childId, newMeshColors] = importGroup(child, namespaces, {
+        ...colorLookup,
+        ...newColorLookup
+      });
+      newColorLookup = { ...newColorLookup, ...newMeshColors };
+      world = { ...world, ...newWorldItems };
+      animatables = { ...animatables, ...newAnimatables };
+      children.push(childId);
     }
   });
   const newShape = {
@@ -2228,6 +2356,24 @@ function getShapeMaterial(mesh, useEmissive) {
     return "standard" /* Standard */;
   }
 }
+function shouldImportAsGroupChild(child) {
+  if (!child.isObject3D) {
+    return false;
+  }
+  if (child.isMesh) {
+    return false;
+  }
+  if (child.isCamera) {
+    return false;
+  }
+  if (child.isLight) {
+    return false;
+  }
+  if (child.isBone) {
+    return false;
+  }
+  return true;
+}
 
 // src/functions/gltf-loading/import-group.ts
 Object3D6.DEFAULT_UP.set(0, 0, 1);
@@ -2287,7 +2433,7 @@ function importGroup(group, namespaces, colorLookup, rootBounds) {
       world = { ...world, ...newWorldItems };
       animatables = { ...animatables, ...newAnimatables };
       children.push(childId);
-    } else if (child.isGroup || child.isObject3D && child.children.length !== 0) {
+    } else if (shouldImportAsGroupChild2(child)) {
       const [newWorldItems, newAnimatables, childId, newMeshColors] = importGroup(child, namespaces, {
         ...colorLookup,
         ...newColorLookup
@@ -2316,6 +2462,24 @@ function importGroup(group, namespaces, colorLookup, rootBounds) {
   world = { ...world, [newGroup.id]: newGroup };
   return [world, animatables, newGroup.id, newColorLookup];
 }
+function shouldImportAsGroupChild2(child) {
+  if (!child.isObject3D) {
+    return false;
+  }
+  if (child.isMesh) {
+    return false;
+  }
+  if (child.isCamera) {
+    return false;
+  }
+  if (child.isLight) {
+    return false;
+  }
+  if (child.isBone) {
+    return false;
+  }
+  return true;
+}
 
 // src/functions/gltf-loading/import-scene.ts
 Object3D7.DEFAULT_UP.set(0, 0, 1);
@@ -2589,9 +2753,10 @@ function deriveRootBounds(group) {
 }
 
 // src/functions/vizij-bundle.ts
+import { cloneDeepSafe } from "@vizij/utils";
 var BUNDLE_KEYS = ["VIZIJ_bundle"];
 function cloneBundle(value) {
-  return JSON.parse(JSON.stringify(value));
+  return cloneDeepSafe(value);
 }
 function readExtensionValue(extensionContainer) {
   for (const key of BUNDLE_KEYS) {
@@ -2625,6 +2790,13 @@ function searchParserJsonForBundle(parserJson) {
   if (!parserJson || typeof parserJson !== "object") {
     return null;
   }
+  const rootExtensions = parserJson && typeof parserJson === "object" ? parserJson.extensions : null;
+  if (rootExtensions && typeof rootExtensions === "object") {
+    const match = readExtensionValue(rootExtensions);
+    if (match) {
+      return cloneBundle(match.value);
+    }
+  }
   const nodes = Array.isArray(parserJson.nodes) ? parserJson.nodes : [];
   for (const node of nodes) {
     const extensions = node && typeof node === "object" ? node.extensions : null;
@@ -2689,6 +2861,7 @@ function applyVizijBundle(object, bundle) {
 }
 
 // src/functions/gltf-loading/extract-animations.ts
+import { cloneDeepSafe as cloneDeepSafe2 } from "@vizij/utils";
 var CHANNEL_PATH_TO_TRACK_PROPERTY = {
   translation: "position",
   rotation: "quaternion",
@@ -2704,7 +2877,7 @@ function clonePlainObject(value) {
   if (!value) {
     return void 0;
   }
-  return JSON.parse(JSON.stringify(value));
+  return cloneDeepSafe2(value);
 }
 function inferValueSize(valueType) {
   switch (valueType) {
@@ -3059,23 +3232,94 @@ function extractVizijAnimations(parserJson, clips) {
 
 // src/functions/load-gltf.ts
 THREE5.Object3D.DEFAULT_UP.set(0, 0, 1);
+var GLB_MAGIC = 1179937895;
+var GLB_VERSION = 2;
+var GLB_HEADER_BYTES = 12;
+var GLB_CHUNK_HEADER_BYTES = 8;
+var GLB_JSON_CHUNK_TYPE = 1313821514;
 var EmptyModelError = class extends Error {
   constructor(message) {
     super(message);
     this.name = "EmptyModelError";
   }
 };
+function parseGlbJsonChunk(buffer) {
+  if (buffer.byteLength < GLB_HEADER_BYTES + GLB_CHUNK_HEADER_BYTES) {
+    return void 0;
+  }
+  const view = new DataView(buffer);
+  const magic = view.getUint32(0, true);
+  const version = view.getUint32(4, true);
+  if (magic !== GLB_MAGIC || version !== GLB_VERSION) {
+    return void 0;
+  }
+  const chunkLength = view.getUint32(GLB_HEADER_BYTES, true);
+  const chunkType = view.getUint32(GLB_HEADER_BYTES + 4, true);
+  if (chunkType !== GLB_JSON_CHUNK_TYPE) {
+    return void 0;
+  }
+  const chunkStart = GLB_HEADER_BYTES + GLB_CHUNK_HEADER_BYTES;
+  const chunkEnd = chunkStart + chunkLength;
+  if (chunkEnd > buffer.byteLength) {
+    return void 0;
+  }
+  try {
+    const chunkBytes = new Uint8Array(buffer, chunkStart, chunkLength);
+    const jsonText = new TextDecoder().decode(chunkBytes);
+    return JSON.parse(jsonText);
+  } catch {
+    return void 0;
+  }
+}
+async function resolveParserJson(parserJson, fallback) {
+  if (parserJson && typeof parserJson === "object") {
+    return parserJson;
+  }
+  if (fallback.arrayBuffer) {
+    const fromArrayBuffer = parseGlbJsonChunk(fallback.arrayBuffer);
+    if (fromArrayBuffer && typeof fromArrayBuffer === "object") {
+      return fromArrayBuffer;
+    }
+  }
+  if (fallback.blob) {
+    try {
+      const blobBuffer = typeof fallback.blob.arrayBuffer === "function" ? await fallback.blob.arrayBuffer() : await new Response(fallback.blob).arrayBuffer();
+      const fromBlob = parseGlbJsonChunk(blobBuffer);
+      if (fromBlob && typeof fromBlob === "object") {
+        return fromBlob;
+      }
+    } catch {
+    }
+  }
+  if (fallback.url && typeof fetch === "function") {
+    try {
+      const response = await fetch(fallback.url);
+      if (response.ok) {
+        const binary = await response.arrayBuffer();
+        const fromUrl = parseGlbJsonChunk(binary);
+        if (fromUrl && typeof fromUrl === "object") {
+          return fromUrl;
+        }
+      }
+    } catch {
+    }
+  }
+  return parserJson;
+}
 async function loadGLTF(url, namespaces, aggressiveImport = false, rootBounds) {
   const modelLoader = new GLTFLoader();
   modelLoader.setDRACOLoader(new DRACOLoader());
   const modelData = await modelLoader.loadAsync(url);
+  const parserJson = await resolveParserJson(modelData?.parser?.json, {
+    url
+  });
   const actualizedNamespaces = namespaces.length > 0 ? namespaces : ["default"];
   const asset = parseScene(
     modelData.scene,
     actualizedNamespaces,
     aggressiveImport,
     rootBounds,
-    modelData?.parser?.json,
+    parserJson,
     modelData.animations
   );
   return [asset.world, asset.animatables, asset.animations];
@@ -3089,7 +3333,8 @@ async function loadGLTFFromBlob(blob, namespaces, aggressiveImport = false, root
         objectUrl,
         actualizedNamespaces,
         aggressiveImport,
-        rootBounds
+        rootBounds,
+        { blob }
       );
       return [asset.world, asset.animatables, asset.animations];
     } finally {
@@ -3103,14 +3348,18 @@ async function loadGLTFFromBlob(blob, namespaces, aggressiveImport = false, root
     loader.parse(
       arrayBuffer,
       "",
-      (gltf) => {
+      async (gltf) => {
         try {
+          const parserJson = await resolveParserJson(
+            gltf?.parser?.json,
+            { arrayBuffer }
+          );
           const asset = parseScene(
             gltf.scene,
             actualizedNamespaces,
             aggressiveImport,
             rootBounds,
-            gltf?.parser?.json,
+            parserJson,
             gltf.animations
           );
           resolve([asset.world, asset.animatables, asset.animations]);
@@ -3137,19 +3386,23 @@ function parseScene(scene, namespaces, aggressiveImport, rootBounds, parserJson,
   );
   const bundle = extractVizijBundle(scene, parserJson);
   const animations = extractVizijAnimations(parserJson, clips);
-  return { world, animatables, bundle, animations };
+  return { world, animatables, bundle, animations, scene };
 }
-async function loadGLTFWithBundle(url, namespaces, aggressiveImport = false, rootBounds) {
+async function loadGLTFWithBundle(url, namespaces, aggressiveImport = false, rootBounds, parserJsonFallback) {
   const modelLoader = new GLTFLoader();
   modelLoader.setDRACOLoader(new DRACOLoader());
   const modelData = await modelLoader.loadAsync(url);
+  const parserJson = await resolveParserJson(modelData?.parser?.json, {
+    url,
+    ...parserJsonFallback
+  });
   const actualizedNamespaces = namespaces.length > 0 ? namespaces : ["default"];
   return parseScene(
     modelData.scene,
     actualizedNamespaces,
     aggressiveImport,
     rootBounds,
-    modelData?.parser?.json,
+    parserJson,
     modelData.animations
   );
 }
@@ -3162,7 +3415,8 @@ async function loadGLTFFromBlobWithBundle(blob, namespaces, aggressiveImport = f
         objectUrl,
         actualizedNamespaces,
         aggressiveImport,
-        rootBounds
+        rootBounds,
+        { blob }
       );
     } finally {
       URL.revokeObjectURL(objectUrl);
@@ -3175,14 +3429,18 @@ async function loadGLTFFromBlobWithBundle(blob, namespaces, aggressiveImport = f
     loader.parse(
       arrayBuffer,
       "",
-      (gltf) => {
+      async (gltf) => {
         try {
+          const parserJson = await resolveParserJson(
+            gltf?.parser?.json,
+            { arrayBuffer }
+          );
           const asset = parseScene(
             gltf.scene,
             actualizedNamespaces,
             aggressiveImport,
             rootBounds,
-            gltf?.parser?.json,
+            parserJson,
             gltf.animations
           );
           resolve(asset);
@@ -3234,6 +3492,160 @@ var loadGltfFromBlob = (blob, namespaces) => {
 import { GLTFExporter } from "three-stdlib";
 import * as THREE6 from "three";
 THREE6.Object3D.DEFAULT_UP.set(0, 0, 1);
+function normalizeExportError(error) {
+  if (error instanceof Error) {
+    return error;
+  }
+  if (typeof error === "string") {
+    return new Error(error);
+  }
+  return new Error("Failed to export scene.");
+}
+function triggerBlobDownload(blob, filename) {
+  const url = URL.createObjectURL(blob);
+  const link = document.createElement("a");
+  link.href = url;
+  link.download = filename;
+  link.style.display = "none";
+  document.body.appendChild(link);
+  link.click();
+  document.body.removeChild(link);
+  setTimeout(() => URL.revokeObjectURL(url), 0);
+}
+var GLB_MAGIC2 = 1179937895;
+var GLB_VERSION2 = 2;
+var GLB_JSON_CHUNK_TYPE2 = 1313821514;
+var GLB_HEADER_BYTES2 = 12;
+var GLB_CHUNK_HEADER_BYTES2 = 8;
+var GLB_JSON_PADDING_BYTE = 32;
+function isNearlyEqual(a, b, epsilon = 1e-6) {
+  return Math.abs(a - b) <= epsilon;
+}
+function isIdentityTransformNode(node) {
+  const translation = node.translation;
+  if (Array.isArray(translation) && (translation.length !== 3 || !isNearlyEqual(Number(translation[0]), 0) || !isNearlyEqual(Number(translation[1]), 0) || !isNearlyEqual(Number(translation[2]), 0))) {
+    return false;
+  }
+  const rotation = node.rotation;
+  if (Array.isArray(rotation) && (rotation.length !== 4 || !isNearlyEqual(Number(rotation[0]), 0) || !isNearlyEqual(Number(rotation[1]), 0) || !isNearlyEqual(Number(rotation[2]), 0) || !isNearlyEqual(Number(rotation[3]), 1))) {
+    return false;
+  }
+  const scale = node.scale;
+  if (Array.isArray(scale) && (scale.length !== 3 || !isNearlyEqual(Number(scale[0]), 1) || !isNearlyEqual(Number(scale[1]), 1) || !isNearlyEqual(Number(scale[2]), 1))) {
+    return false;
+  }
+  return true;
+}
+function isPassThroughWrapperNode(node) {
+  if (!node || typeof node !== "object") {
+    return false;
+  }
+  if (!Array.isArray(node.children) || node.children.length === 0) {
+    return false;
+  }
+  const hasOnlyNumericChildren = node.children.every(
+    (index) => Number.isInteger(index)
+  );
+  if (!hasOnlyNumericChildren) {
+    return false;
+  }
+  if (node.mesh !== void 0 || node.camera !== void 0 || node.skin !== void 0) {
+    return false;
+  }
+  if (node.extensions && typeof node.extensions === "object" && Object.keys(node.extensions).length > 0) {
+    return false;
+  }
+  return isIdentityTransformNode(node);
+}
+function normalizeExportedSceneJson(json, fallbackSceneName) {
+  if (!json || typeof json !== "object") {
+    return false;
+  }
+  if (!Array.isArray(json.scenes) || !Array.isArray(json.nodes)) {
+    return false;
+  }
+  const sceneIndexRaw = json.scene;
+  const sceneIndex = typeof sceneIndexRaw === "number" && Number.isInteger(sceneIndexRaw) ? sceneIndexRaw : 0;
+  const sceneDef = json.scenes[sceneIndex];
+  if (!sceneDef || typeof sceneDef !== "object") {
+    return false;
+  }
+  let changed = false;
+  let wrapperNodeName;
+  if (Array.isArray(sceneDef.nodes) && sceneDef.nodes.length === 1) {
+    const wrapperIndex = sceneDef.nodes[0];
+    if (Number.isInteger(wrapperIndex)) {
+      const wrapperNode = json.nodes[wrapperIndex];
+      if (isPassThroughWrapperNode(wrapperNode)) {
+        sceneDef.nodes = [...wrapperNode.children];
+        wrapperNodeName = typeof wrapperNode.name === "string" ? wrapperNode.name : void 0;
+        changed = true;
+      }
+    }
+  }
+  const currentSceneName = typeof sceneDef.name === "string" ? sceneDef.name.trim() : "";
+  if (currentSceneName === "AuxScene") {
+    const nextSceneName = (wrapperNodeName?.trim() || fallbackSceneName?.trim() || "Scene").trim();
+    if (nextSceneName.length > 0 && nextSceneName !== currentSceneName) {
+      sceneDef.name = nextSceneName;
+      changed = true;
+    }
+  }
+  return changed;
+}
+function sanitizeExportedGlb(buffer, fallbackSceneName) {
+  if (buffer.byteLength < GLB_HEADER_BYTES2 + GLB_CHUNK_HEADER_BYTES2) {
+    return buffer;
+  }
+  const originalBytes = new Uint8Array(buffer);
+  const view = new DataView(buffer);
+  const magic = view.getUint32(0, true);
+  const version = view.getUint32(4, true);
+  if (magic !== GLB_MAGIC2 || version !== GLB_VERSION2) {
+    return buffer;
+  }
+  const jsonChunkLength = view.getUint32(GLB_HEADER_BYTES2, true);
+  const jsonChunkType = view.getUint32(GLB_HEADER_BYTES2 + 4, true);
+  if (jsonChunkType !== GLB_JSON_CHUNK_TYPE2) {
+    return buffer;
+  }
+  const jsonChunkStart = GLB_HEADER_BYTES2 + GLB_CHUNK_HEADER_BYTES2;
+  const jsonChunkEnd = jsonChunkStart + jsonChunkLength;
+  if (jsonChunkEnd > originalBytes.length) {
+    return buffer;
+  }
+  let jsonPayload;
+  try {
+    const jsonText = new TextDecoder().decode(
+      originalBytes.slice(jsonChunkStart, jsonChunkEnd)
+    );
+    jsonPayload = JSON.parse(jsonText);
+  } catch {
+    return buffer;
+  }
+  const changed = normalizeExportedSceneJson(jsonPayload, fallbackSceneName);
+  if (!changed) {
+    return buffer;
+  }
+  const encodedJson = new TextEncoder().encode(JSON.stringify(jsonPayload));
+  const paddedJsonLength = encodedJson.length + 3 & ~3;
+  const paddedJson = new Uint8Array(paddedJsonLength);
+  paddedJson.fill(GLB_JSON_PADDING_BYTE);
+  paddedJson.set(encodedJson);
+  const remainingChunks = originalBytes.slice(jsonChunkEnd);
+  const totalLength = GLB_HEADER_BYTES2 + GLB_CHUNK_HEADER_BYTES2 + paddedJsonLength + remainingChunks.length;
+  const sanitized = new ArrayBuffer(totalLength);
+  const sanitizedBytes = new Uint8Array(sanitized);
+  const sanitizedView = new DataView(sanitized);
+  sanitizedView.setUint32(0, GLB_MAGIC2, true);
+  sanitizedView.setUint32(4, GLB_VERSION2, true);
+  sanitizedView.setUint32(8, totalLength, true);
+  sanitizedView.setUint32(GLB_HEADER_BYTES2, paddedJsonLength, true);
+  sanitizedView.setUint32(GLB_HEADER_BYTES2 + 4, GLB_JSON_CHUNK_TYPE2, true);
+  sanitizedBytes.set(paddedJson, jsonChunkStart);
+  sanitizedBytes.set(remainingChunks, jsonChunkStart + paddedJsonLength);
+  return sanitized;
+}
 function exportScene(data, fileNameOrOptions = "scene.glb") {
   const options = typeof fileNameOrOptions === "string" ? { fileName: fileNameOrOptions } : fileNameOrOptions ?? {};
   const fileName = options.fileName ?? "scene.glb";
@@ -3248,7 +3660,15 @@ function exportScene(data, fileNameOrOptions = "scene.glb") {
       }
     }
   }));
-  const detachBundle = shouldAttachBundle && options.bundle ? applyVizijBundle(data, options.bundle) : () => {
+  const sourceRoot = data;
+  const exportRoot = sourceRoot instanceof THREE6.Scene ? sourceRoot : sourceRoot.clone(true);
+  const exportTarget = exportRoot instanceof THREE6.Scene ? exportRoot : (() => {
+    const scene = new THREE6.Scene();
+    scene.name = data.name?.trim() || "Scene";
+    scene.add(exportRoot);
+    return scene;
+  })();
+  const detachBundle = shouldAttachBundle && options.bundle ? applyVizijBundle(exportRoot, options.bundle) : () => {
   };
   const binary = options.binary ?? true;
   const exporterOptions = {
@@ -3262,33 +3682,40 @@ function exportScene(data, fileNameOrOptions = "scene.glb") {
   }
   try {
     exporter.parse(
-      data,
+      exportTarget,
       (gltf) => {
         detachBundle();
         if (!(gltf instanceof ArrayBuffer)) {
-          throw new Error("Failed to export scene!");
+          const error = new Error("Failed to export scene.");
+          options.onError?.(error);
+          return;
         }
-        const link = document.createElement("a");
-        link.href = URL.createObjectURL(
-          new Blob([gltf], {
-            type: "application/octet-stream"
-          })
+        const sanitizedGltf = sanitizeExportedGlb(
+          gltf,
+          data.name?.trim() || void 0
         );
         const trimmed = fileName.trim();
         const safeFileName = trimmed.length > 0 ? trimmed : "scene.glb";
         const downloadName = safeFileName.toLowerCase().endsWith(".glb") ? safeFileName : `${safeFileName}.glb`;
-        link.download = downloadName;
-        link.click();
-        URL.revokeObjectURL(link.href);
+        triggerBlobDownload(
+          new Blob([sanitizedGltf], {
+            type: "application/octet-stream"
+          }),
+          downloadName
+        );
+        options.onComplete?.();
       },
-      () => {
+      (error) => {
         detachBundle();
+        options.onError?.(normalizeExportError(error));
       },
       exporterOptions
     );
   } catch (error) {
     detachBundle();
-    throw error;
+    const normalizedError = normalizeExportError(error);
+    options.onError?.(normalizedError);
+    throw normalizedError;
   }
 }
 export {
@@ -3307,6 +3734,7 @@ export {
   loadGLTFFromBlobWithBundle,
   loadGLTFWithBundle,
   loadGltfFromBlob,
+  parseGlbJsonChunk,
   useDefaultVizijStore,
   useFeatures,
   useVizijStore,