three-usd-robot 0.7.0 → 0.8.1

package/dist/{chunk-FL554IS5.js → chunk-JHOX3VUW.js}

@@ -1,81 +1,14 @@
-import { getMaterialSubsets, resolveBoundMaterial, COLLISION_API, isNonVisualPurpose, computeWorldTransform, identity4, multiply, computeLocalTransform, invert, interpolate, DefaultAssetResolver, CrateReader, openUsdz, extractRobotDescription, buildKinematicTree, Stage, composeLayer, composeFile, crateToUsdaFile } from './chunk-4GPCBXUS.js';
-import * as THREE4 from 'three';
+import { getMaterialSubsets, resolveBoundMaterial, isRenderableGprim, COLLISION_API, isNonVisualPurpose, computeWorldTransform, computeLocalTransform, DefaultAssetResolver, toBytes, extractRobotDescription, isZip, CrateReader, openUsdz, buildKinematicTree, Stage, composeLayer, composeFile, crateToUsdaFile } from './chunk-PHHMWMCA.js';
+import { ThreeUsdRobot } from './chunk-FUPFJOXW.js';
+import { identity4, multiply } from './chunk-IYKPVUZ2.js';
+import * as THREE from 'three';
 
-function axisVector(axis) {
-  switch (axis) {
-    case "X":
-      return new THREE4.Vector3(1, 0, 0);
-    case "Y":
-      return new THREE4.Vector3(0, 1, 0);
-    case "Z":
-      return new THREE4.Vector3(0, 0, 1);
-  }
-}
-var JointObject = class extends THREE4.Object3D {
-  isJointObject = true;
-  jointName;
-  jointType;
-  axisToken;
-  axis;
-  lower;
-  upper;
-  _value = 0;
-  constructor(joint) {
-    super();
-    this.name = joint.name;
-    this.jointName = joint.name;
-    this.jointType = joint.type;
-    this.axisToken = joint.axis;
-    this.axis = axisVector(joint.axis);
-    this.lower = joint.lower;
-    this.upper = joint.upper;
-  }
-  get value() {
-    return this._value;
-  }
-  get articulated() {
-    return this.jointType !== "fixed";
-  }
-  /**
-   * Set the joint value (radians for revolute/continuous, length for prismatic).
-   * Optionally clamps to authored limits. Returns the value actually applied.
-   */
-  setValue(value, clampToLimits = true) {
-    if (!this.articulated) return this._value;
-    let v = value;
-    if (clampToLimits) {
-      if (this.lower !== void 0 && v < this.lower) v = this.lower;
-      if (this.upper !== void 0 && v > this.upper) v = this.upper;
-    }
-    this._value = v;
-    if (this.jointType === "prismatic") {
-      this.position.copy(this.axis).multiplyScalar(v);
-      this.quaternion.identity();
-    } else {
-      this.quaternion.setFromAxisAngle(this.axis, v);
-      this.position.set(0, 0, 0);
-    }
-    return v;
-  }
-};
-var LinkObject = class extends THREE4.Object3D {
-  isLinkObject = true;
-  linkName;
-  primPath;
-  constructor(link) {
-    super();
-    this.name = link.name;
-    this.linkName = link.name;
-    this.primPath = link.primPath;
-    this.matrixAutoUpdate = false;
-  }
-};
 var DEFAULT_COLOR = 10132122;
 function buildMeshGeometry(meshPrim) {
   const points = meshPrim.GetAttribute("points").Get();
   if (!isVec3Array(points) || points.length === 0) return null;
-  const geometry = new THREE4.BufferGeometry();
-  geometry.setAttribute("position", new THREE4.Float32BufferAttribute(flat3(points), 3));
+  const geometry = new THREE.BufferGeometry();
+  geometry.setAttribute("position", new THREE.Float32BufferAttribute(flat3(points), 3));
   const counts = meshPrim.GetAttribute("faceVertexCounts").Get();
   const indices = meshPrim.GetAttribute("faceVertexIndices").Get();
   if (isNumberArray(counts) && isNumberArray(indices)) {
@@ -90,18 +23,57 @@ function buildMeshGeometry(meshPrim) {
   }
   const normals = meshPrim.GetAttribute("normals").Get();
   if (isVec3Array(normals) && normals.length === points.length) {
-    geometry.setAttribute("normal", new THREE4.Float32BufferAttribute(flat3(normals), 3));
+    geometry.setAttribute("normal", new THREE.Float32BufferAttribute(flat3(normals), 3));
   } else {
     geometry.computeVertexNormals();
   }
   const st = meshPrim.GetAttribute("primvars:st").Get();
   if (isVec2Array(st) && st.length === points.length) {
-    geometry.setAttribute("uv", new THREE4.Float32BufferAttribute(flat2(st), 2));
+    geometry.setAttribute("uv", new THREE.Float32BufferAttribute(flat2(st), 2));
   }
   return geometry;
 }
+function buildGprimGeometry(prim) {
+  switch (prim.GetTypeName()) {
+    case "Mesh":
+      return buildMeshGeometry(prim);
+    case "Cube": {
+      const size = getNumber(prim, "size") ?? 2;
+      return new THREE.BoxGeometry(size, size, size);
+    }
+    case "Sphere":
+      return new THREE.SphereGeometry(getNumber(prim, "radius") ?? 1, 32, 16);
+    case "Cylinder": {
+      const radius = getNumber(prim, "radius") ?? 1;
+      const height = getNumber(prim, "height") ?? 2;
+      return orientSpine(new THREE.CylinderGeometry(radius, radius, height, 32), prim);
+    }
+    case "Capsule": {
+      const radius = getNumber(prim, "radius") ?? 0.5;
+      const height = getNumber(prim, "height") ?? 1;
+      return orientSpine(new THREE.CapsuleGeometry(radius, height, 8, 32), prim);
+    }
+    case "Cone": {
+      const radius = getNumber(prim, "radius") ?? 1;
+      const height = getNumber(prim, "height") ?? 2;
+      return orientSpine(new THREE.ConeGeometry(radius, height, 32), prim);
+    }
+    default:
+      return null;
+  }
+}
+function getNumber(prim, name) {
+  const v = prim.GetAttribute(name).Get();
+  return typeof v === "number" ? v : void 0;
+}
+function orientSpine(geometry, prim) {
+  const axis = prim.GetAttribute("axis").Get();
+  if (axis === "Y") return geometry;
+  if (axis === "X") return geometry.rotateZ(-Math.PI / 2);
+  return geometry.rotateX(Math.PI / 2);
+}
 function buildMeshMaterial(meshPrim, stage, textures, bindingPrim) {
-  const color = new THREE4.Color(DEFAULT_COLOR);
+  const color = new THREE.Color(DEFAULT_COLOR);
   let opacity = 1;
   const bound = stage ? resolveBoundMaterial(stage, bindingPrim ?? meshPrim) : void 0;
   if (bound?.color) {
@@ -133,7 +105,7 @@ function buildMeshMaterial(meshPrim, stage, textures, bindingPrim) {
   const emissiveMap = tex(bound?.emissiveTexture, "srgb");
   const metalness = bound?.metalness ?? bound?.metalnessTexture?.scale?.[0] ?? (metalnessMap ? 1 : 0.1);
   const roughness = bound?.roughness ?? bound?.roughnessTexture?.scale?.[0] ?? (roughnessMap ? 1 : 0.8);
-  const emissive = new THREE4.Color(0);
+  const emissive = new THREE.Color(0);
   if (bound?.emissiveColor) {
     emissive.setRGB(bound.emissiveColor[0], bound.emissiveColor[1], bound.emissiveColor[2]);
   } else if (emissiveMap) {
@@ -147,7 +119,7 @@ function buildMeshMaterial(meshPrim, stage, textures, bindingPrim) {
   const alphaTest = threshold !== void 0 && threshold > 0 ? threshold : 0;
   const transparent = alphaTest === 0 && hasAlphaSource;
   const doubleSided = meshPrim.GetAttribute("doubleSided").Get() === true;
-  const material = new THREE4.MeshStandardMaterial({
+  const material = new THREE.MeshStandardMaterial({
     color,
     metalness,
     roughness,
@@ -155,7 +127,7 @@ function buildMeshMaterial(meshPrim, stage, textures, bindingPrim) {
     transparent,
     opacity,
     ...alphaTest > 0 ? { alphaTest } : {},
-    side: doubleSided ? THREE4.DoubleSide : THREE4.FrontSide,
+    side: doubleSided ? THREE.DoubleSide : THREE.FrontSide,
     ...map ? { map } : {},
     ...alphaMap ? { alphaMap } : {},
     ...normalMap ? { normalMap } : {},
@@ -198,12 +170,12 @@ function bindSceneMeshes(stage, robot3d, desc, options = {}) {
   }
   let attached = 0;
   for (const prim of stage.Traverse()) {
-    if (prim.GetTypeName() !== "Mesh" || owned.has(prim.GetPath())) continue;
+    if (!isRenderableGprim(prim) || owned.has(prim.GetPath())) continue;
     if (prim.HasAPI(COLLISION_API) || isNonVisualPurpose(prim)) continue;
     if ([...owned].some((path) => prim.GetPath().startsWith(`${path}/`))) continue;
-    const geometry = buildMeshGeometry(prim);
+    const geometry = buildGprimGeometry(prim);
     if (!geometry) continue;
-    const mesh = new THREE4.Mesh(geometry, buildMeshMaterial(prim, stage, options.textureProvider));
+    const mesh = new THREE.Mesh(geometry, buildMeshMaterial(prim, stage, options.textureProvider));
     mesh.name = prim.GetName();
     mesh.userData.kind = "scene";
     mesh.userData.primPath = prim.GetPath();
@@ -226,9 +198,9 @@ function buildMeshMaterials(meshPrim, stage, textures) {
 function attachMesh(stage, linkPrim, meshPath, parent, kind, textures) {
   const meshPrim = stage.GetPrimAtPath(meshPath);
   if (!meshPrim) return;
-  const geometry = buildMeshGeometry(meshPrim);
+  const geometry = buildGprimGeometry(meshPrim);
   if (!geometry) return;
-  const mesh = new THREE4.Mesh(geometry, buildMeshMaterials(meshPrim, stage, textures));
+  const mesh = new THREE.Mesh(geometry, buildMeshMaterials(meshPrim, stage, textures));
   mesh.name = meshPrim.GetName();
   mesh.userData.kind = kind;
   mesh.userData.primPath = meshPath;
@@ -348,8 +320,8 @@ function createTextureProvider(resolver, baseUrl) {
     } catch {
       return null;
     }
-    const texture = new THREE4.Texture();
-    texture.colorSpace = options.colorSpace === "linear" ? THREE4.NoColorSpace : THREE4.SRGBColorSpace;
+    const texture = new THREE.Texture();
+    texture.colorSpace = options.colorSpace === "linear" ? THREE.NoColorSpace : THREE.SRGBColorSpace;
     texture.wrapS = toThreeWrap(options.wrapS);
     texture.wrapT = toThreeWrap(options.wrapT);
     applyTransform(texture, options.transform);
@@ -380,11 +352,11 @@ function toThreeWrap(wrap) {
   switch (wrap) {
     case "clamp":
     case "black":
-      return THREE4.ClampToEdgeWrapping;
+      return THREE.ClampToEdgeWrapping;
     case "mirror":
-      return THREE4.MirroredRepeatWrapping;
+      return THREE.MirroredRepeatWrapping;
     default:
-      return THREE4.RepeatWrapping;
+      return THREE.RepeatWrapping;
   }
 }
 function applyTransform(texture, t) {
@@ -401,254 +373,6 @@ function mimeOf(url) {
   if (/\.webp$/i.test(url)) return "image/webp";
   return "image/png";
 }
-var ThreeUsdRobot = class extends THREE4.Object3D {
-  isThreeUsdRobot = true;
-  robot;
-  tree;
-  clampJointLimits;
-  linkObjects = /* @__PURE__ */ new Map();
-  jointObjects = /* @__PURE__ */ new Map();
-  dirty = true;
-  helperSize;
-  _showVisual = true;
-  _showCollision = false;
-  _showJointAxes = false;
-  _showLinkFrames = false;
-  jointAxesHelpers = [];
-  linkFrameHelpers = [];
-  constructor(robot, tree, options = {}) {
-    super();
-    this.name = robot.name;
-    this.robot = robot;
-    this.tree = tree;
-    this.clampJointLimits = options.clampJointLimits ?? true;
-    this.helperSize = options.helperSize ?? 0.15;
-    for (const [key, link] of Object.entries(robot.links)) {
-      this.linkObjects.set(key, new LinkObject(link));
-    }
-    this.attachRoot();
-    this.attachTreeEdges();
-    this.attachIsolatedLinks();
-    this.applyStageNormalization(robot, options);
-    if (options.applyInitialPose ?? true) this.applyInitialPose(robot);
-  }
-  /** Orient (Z-up → Y-up) and scale (metersPerUnit × unitScale) the robot root. */
-  applyStageNormalization(robot, options) {
-    const scale = (robot.metersPerUnit || 1) * (options.unitScale ?? 1);
-    if (scale !== 1) this.scale.setScalar(scale);
-    const conv = options.upAxisConversion ?? "none";
-    const toY = conv === "Z" || conv === "auto" && robot.upAxis === "Z";
-    if (toY) this.quaternion.setFromAxisAngle(new THREE4.Vector3(1, 0, 0), -Math.PI / 2);
-  }
-  /** Apply each joint's authored initial value, if any. */
-  applyInitialPose(robot) {
-    for (const [key, joint] of Object.entries(robot.joints)) {
-      if (joint.initialValue === void 0) continue;
-      this.jointObjects.get(key)?.setValue(joint.initialValue, this.clampJointLimits);
-    }
-    this.dirty = true;
-  }
-  attachRoot() {
-    const rootObj = this.linkObjects.get(this.tree.root);
-    if (!rootObj) return;
-    const rootJointKey = this.tree.rootJoint;
-    const rootLink = this.robot.links[this.tree.root];
-    if (rootJointKey) {
-      const j = this.robot.joints[rootJointKey];
-      if (j) setMatrix(rootObj, multiply(j.jointFrame0, invert(j.jointFrame1)));
-    } else if (rootLink?.worldTransform) {
-      setMatrix(rootObj, rootLink.worldTransform);
-    }
-    this.add(rootObj);
-  }
-  attachTreeEdges() {
-    for (const linkKey of this.tree.order) {
-      const node = this.tree.nodes[linkKey];
-      if (!node || node.parent === null || node.jointToParent === null) continue;
-      const parentObj = this.linkObjects.get(node.parent);
-      const childObj = this.linkObjects.get(linkKey);
-      const joint = this.robot.joints[node.jointToParent];
-      if (!parentObj || !childObj || !joint) continue;
-      this.attachJointChain(parentObj, childObj, node.jointToParent, joint);
-    }
-  }
-  /** Build `parent → frame0 → motion → frame1⁻¹ → child` for one joint. */
-  attachJointChain(parent, child, jointKey, joint) {
-    const frame0 = new THREE4.Group();
-    frame0.name = `${joint.name}:frame0`;
-    setMatrix(frame0, joint.jointFrame0);
-    const motion = new JointObject(joint);
-    const frame1Inv = new THREE4.Group();
-    frame1Inv.name = `${joint.name}:frame1Inv`;
-    setMatrix(frame1Inv, invert(joint.jointFrame1));
-    parent.add(frame0);
-    frame0.add(motion);
-    motion.add(frame1Inv);
-    frame1Inv.add(child);
-    this.jointObjects.set(jointKey, motion);
-  }
-  attachIsolatedLinks() {
-    for (const key of this.tree.isolatedLinks) {
-      const obj = this.linkObjects.get(key);
-      if (!obj || obj.parent) continue;
-      const worldTransform = this.robot.links[key]?.worldTransform;
-      if (worldTransform) setMatrix(obj, worldTransform);
-      this.add(obj);
-    }
-  }
-  // -- Joint control -------------------------------------------------------
-  /** Set one joint value. Unknown joints are ignored. Returns whether it applied. */
-  setJointValue(name, value) {
-    const joint = this.jointObjects.get(name);
-    if (!joint) return false;
-    joint.setValue(value, this.clampJointLimits);
-    this.dirty = true;
-    return true;
-  }
-  /** Set several joint values at once (matrix update is coalesced). */
-  setJointValues(values) {
-    for (const [name, value] of Object.entries(values)) {
-      const joint = this.jointObjects.get(name);
-      if (joint) {
-        joint.setValue(value, this.clampJointLimits);
-        this.dirty = true;
-      }
-    }
-  }
-  getJointValue(name) {
-    return this.jointObjects.get(name)?.value;
-  }
-  /** Recompute world matrices. Called lazily by the getters; safe to call directly. */
-  updateKinematics() {
-    this.updateMatrixWorld(true);
-    this.dirty = false;
-  }
-  ensureUpdated() {
-    if (this.dirty) this.updateKinematics();
-  }
-  // -- Queries -------------------------------------------------------------
-  getLinkWorldMatrix(name) {
-    const obj = this.linkObjects.get(name);
-    if (!obj) throw new Error(`unknown link "${name}"`);
-    this.ensureUpdated();
-    return obj.matrixWorld.clone();
-  }
-  getLinkWorldPosition(name) {
-    return new THREE4.Vector3().setFromMatrixPosition(this.getLinkWorldMatrix(name));
-  }
-  getLinkObject(name) {
-    return this.linkObjects.get(name);
-  }
-  getJointObject(name) {
-    return this.jointObjects.get(name);
-  }
-  getJoints() {
-    return Object.values(this.robot.joints);
-  }
-  getLinks() {
-    return Object.values(this.robot.links);
-  }
-  /** Names of the articulated (controllable) joints. */
-  getJointNames() {
-    return [...this.jointObjects.keys()];
-  }
-  getLinkNames() {
-    return [...this.linkObjects.keys()];
-  }
-  getKinematicTree() {
-    return this.tree;
-  }
-  // -- Animation playback --------------------------------------------------
-  /** Playback rate in time codes per second (from the stage; default 24). */
-  getTimeCodesPerSecond() {
-    return this.robot.timeCodesPerSecond ?? 24;
-  }
-  /** Whether any joint has a time-sampled trajectory. */
-  hasAnimation() {
-    return Object.values(this.robot.joints).some((j) => j.valueSamples !== void 0);
-  }
-  /**
-   * Animation range in time codes: the union of authored joint sample ranges,
-   * falling back to the stage `startTimeCode`/`endTimeCode`. `null` if neither.
-   */
-  getTimeRange() {
-    let start = Number.POSITIVE_INFINITY;
-    let end = Number.NEGATIVE_INFINITY;
-    for (const joint of Object.values(this.robot.joints)) {
-      const times = joint.valueSamples?.times;
-      if (!times || times.length === 0) continue;
-      start = Math.min(start, times[0]);
-      end = Math.max(end, times[times.length - 1]);
-    }
-    if (start <= end) return { start, end };
-    const { startTimeCode, endTimeCode } = this.robot;
-    if (startTimeCode !== void 0 && endTimeCode !== void 0) {
-      return { start: startTimeCode, end: endTimeCode };
-    }
-    return null;
-  }
-  /** Sample every animated joint at time code `t` and apply the values. */
-  setTime(t) {
-    for (const [key, joint] of Object.entries(this.robot.joints)) {
-      if (joint.valueSamples) this.setJointValue(key, interpolate(joint.valueSamples, t));
-    }
-  }
-  // -- Display toggles -----------------------------------------------------
-  get showVisual() {
-    return this._showVisual;
-  }
-  set showVisual(v) {
-    this._showVisual = v;
-    this.setKindVisibility("visual", v);
-  }
-  get showCollision() {
-    return this._showCollision;
-  }
-  set showCollision(v) {
-    this._showCollision = v;
-    this.setKindVisibility("collision", v);
-  }
-  get showJointAxes() {
-    return this._showJointAxes;
-  }
-  set showJointAxes(v) {
-    this._showJointAxes = v;
-    if (v && this.jointAxesHelpers.length === 0) {
-      for (const joint of this.jointObjects.values()) {
-        const h = new THREE4.AxesHelper(this.helperSize);
-        h.name = `${joint.jointName}:axes`;
-        joint.add(h);
-        this.jointAxesHelpers.push(h);
-      }
-    }
-    for (const h of this.jointAxesHelpers) h.visible = v;
-  }
-  get showLinkFrames() {
-    return this._showLinkFrames;
-  }
-  set showLinkFrames(v) {
-    this._showLinkFrames = v;
-    if (v && this.linkFrameHelpers.length === 0) {
-      for (const link of this.linkObjects.values()) {
-        const h = new THREE4.AxesHelper(this.helperSize);
-        h.name = `${link.linkName}:frame`;
-        link.add(h);
-        this.linkFrameHelpers.push(h);
-      }
-    }
-    for (const h of this.linkFrameHelpers) h.visible = v;
-  }
-  setKindVisibility(kind, visible) {
-    this.traverse((o) => {
-      if (o.userData.kind === kind) o.visible = visible;
-    });
-  }
-};
-function setMatrix(obj, m) {
-  obj.matrixAutoUpdate = false;
-  obj.matrix.fromArray(m);
-  obj.matrixWorldNeedsUpdate = true;
-}
 
 // src/three/ThreeUsdRobotLoader.ts
 var ThreeUsdRobotLoader = class {
@@ -661,52 +385,76 @@ var ThreeUsdRobotLoader = class {
   }
   /**
    * Fetch an asset by URL and build the robot. `.usdz` packages are unzipped and
-   * composed from their entries; everything else is sniffed for the crate magic
-   * and parsed as binary USDC or USDA text.
+   * composed from their entries; everything else is sniffed for the zip / crate
+   * magic and parsed as USDZ, binary USDC, or USDA text.
    */
   async loadAsync(url) {
     const bytes = await this.fetchRootBytes(url);
     if (/\.usdz$/i.test(url)) return this.parseUsdz(bytes);
-    if (CrateReader.isCrate(bytes)) return this.parseCrate(bytes, url);
-    return this.parse(new TextDecoder().decode(bytes), url);
+    return this.parse(bytes, url);
   }
   async fetchRootBytes(url) {
     const resolver = this.resolver;
     if (resolver.fetchBytes) return resolver.fetchBytes(url);
     return new TextEncoder().encode(await resolver.fetchText(url));
   }
-  /** Build a robot (composed, with meshes) from USDA source text. */
-  async parse(text, baseUrl = "") {
-    return this.buildFromStage(
-      await this.composeStage(text, baseUrl, this.resolver),
-      baseUrl,
-      this.resolver
-    );
+  /**
+   * Build a robot from in-memory content — no fetch involved. Accepts USDA
+   * source text, or an `ArrayBuffer` / typed array / `Blob` (e.g. a dropped
+   * `File`) holding USDA text, a binary crate, or a `.usdz` package; binary
+   * input is sniffed for the zip / crate magic. `baseUrl` anchors relative
+   * references, payloads, and texture paths of non-package input.
+   */
+  async parse(data, baseUrl = "") {
+    return this.buildFromStage(await this.openSource(data, baseUrl));
   }
-  /** Build a robot from the bytes of a `.usdz` package. */
-  async parseUsdz(bytes) {
-    const pkg = openUsdz(bytes);
-    const rootBytes = await pkg.resolver.fetchBytes(pkg.rootEntry);
-    const stage = await this.composeStageFromBytes(rootBytes, pkg.rootEntry, pkg.resolver);
-    return this.buildFromStage(stage, pkg.rootEntry, pkg.resolver);
+  /** Build a robot from a `.usdz` package (bytes, `ArrayBuffer`, or `Blob`). */
+  async parseUsdz(data) {
+    return this.buildFromStage(await this.openUsdzStage(await toBytes(data)));
   }
-  /** Build a robot from the bytes of a binary crate (`.usdc` / binary `.usd`). */
-  async parseCrate(bytes, baseUrl = "") {
-    const stage = await this.composeStageFromBytes(bytes, baseUrl, this.resolver);
-    return this.buildFromStage(stage, baseUrl, this.resolver);
+  /** Build a robot from a binary crate (`.usdc` / binary `.usd`). */
+  async parseCrate(data, baseUrl = "") {
+    const stage = await this.composeStageFromBytes(await toBytes(data), baseUrl, this.resolver);
+    return this.buildFromStage({ stage, baseUrl, resolver: this.resolver });
   }
-  /** Parse + compose USDA source into the Three.js-independent robot IR. */
-  async parseRobotDescription(text, baseUrl = "") {
-    const stage = await this.composeStage(text, baseUrl, this.resolver);
+  /**
+   * Parse + compose in-memory content (same formats as {@link parse}) into the
+   * Three.js-independent robot IR.
+   */
+  async parseRobotDescription(data, baseUrl = "") {
+    const { stage } = await this.openSource(data, baseUrl);
     return extractRobotDescription(stage, this.extractOptions());
   }
-  buildFromStage(stage, baseUrl, resolver) {
+  /** Sniff in-memory content (text / zip / crate) and compose it into a stage. */
+  async openSource(data, baseUrl) {
+    const resolver = this.resolver;
+    if (typeof data === "string") {
+      return { stage: await this.composeStage(data, baseUrl, resolver), baseUrl, resolver };
+    }
+    const bytes = await toBytes(data);
+    if (isZip(bytes)) return this.openUsdzStage(bytes);
+    const stage = CrateReader.isCrate(bytes) ? await this.composeStageFromBytes(bytes, baseUrl, resolver) : await this.composeStage(new TextDecoder().decode(bytes), baseUrl, resolver);
+    return { stage, baseUrl, resolver };
+  }
+  async openUsdzStage(bytes) {
+    const pkg = openUsdz(bytes);
+    const rootBytes = await pkg.resolver.fetchBytes(pkg.rootEntry);
+    const stage = await this.composeStageFromBytes(rootBytes, pkg.rootEntry, pkg.resolver);
+    return { stage, baseUrl: pkg.rootEntry, resolver: pkg.resolver };
+  }
+  buildFromStage({ stage, baseUrl, resolver }) {
     const robot = extractRobotDescription(stage, this.extractOptions());
     const tree = buildKinematicTree(robot);
     const robot3d = new ThreeUsdRobot(robot, tree, this.robotOptions());
     const loadVisuals = this.options.loadVisuals ?? true;
     const loadCollisions = this.options.loadCollisions ?? false;
-    const loadScene = this.options.loadSceneGeometry ?? false;
+    const isStaticScene = Object.keys(robot.links).length === 0 && Object.keys(robot.joints).length === 0;
+    if (isStaticScene && this.options.loadSceneGeometry === void 0) {
+      this.options.onWarn?.(
+        "no articulation found (0 links / 0 joints); rendering the stage as static scene geometry"
+      );
+    }
+    const loadScene = this.options.loadSceneGeometry ?? isStaticScene;
     if (loadVisuals || loadCollisions || loadScene) {
       const textureProvider = this.options.loadTextures ?? true ? createTextureProvider(resolver, baseUrl) : void 0;
       if (loadVisuals || loadCollisions) {
@@ -741,7 +489,7 @@ var ThreeUsdRobotLoader = class {
   }
   robotOptions() {
     return {
-      upAxisConversion: this.options.upAxisConversion ?? "auto",
+      ...this.options.worldUp ? { worldUp: this.options.worldUp } : { upAxisConversion: this.options.upAxisConversion ?? "auto" },
       ...this.options.clampJointLimits !== void 0 ? { clampJointLimits: this.options.clampJointLimits } : {},
       ...this.options.unitScale !== void 0 ? { unitScale: this.options.unitScale } : {},
       ...this.options.applyDriveTargetsAsInitialPose !== void 0 ? { applyInitialPose: this.options.applyDriveTargetsAsInitialPose } : {}
@@ -755,6 +503,6 @@ var ThreeUsdRobotLoader = class {
   }
 };
 
-export { JointObject, LinkObject, ThreeUsdRobot, ThreeUsdRobotLoader, axisVector, bindRobotMeshes, bindSceneMeshes, buildMeshGeometry, buildMeshMaterial, createTextureProvider };
-//# sourceMappingURL=chunk-FL554IS5.js.map
-//# sourceMappingURL=chunk-FL554IS5.js.map
+export { ThreeUsdRobotLoader, bindRobotMeshes, bindSceneMeshes, buildGprimGeometry, buildMeshGeometry, buildMeshMaterial, createTextureProvider };
+//# sourceMappingURL=chunk-JHOX3VUW.js.map
+//# sourceMappingURL=chunk-JHOX3VUW.js.map