three-usd-robot 0.5.0 → 0.7.0

package/dist/{chunk-36T6YOEX.js → chunk-4GPCBXUS.js}

@@ -1,5 +1,56 @@
 import { unzipSync } from 'fflate';
 
+// src/parser/ast.ts
+var Quat = class _Quat {
+  constructor(real, imaginary) {
+    this.real = real;
+    this.imaginary = imaginary;
+  }
+  real;
+  imaginary;
+  /** Components in Three.js order `[x, y, z, w]`. */
+  toXYZW() {
+    return [this.imaginary[0], this.imaginary[1], this.imaginary[2], this.real];
+  }
+  static identity() {
+    return new _Quat(1, [0, 0, 0]);
+  }
+};
+var UsdMatrix = class _UsdMatrix {
+  constructor(values, dim) {
+    this.values = values;
+    this.dim = dim;
+  }
+  values;
+  dim;
+  static identity4() {
+    return new _UsdMatrix([
+      1,
+      0,
+      0,
+      0,
+      0,
+      1,
+      0,
+      0,
+      0,
+      0,
+      1,
+      0,
+      0,
+      0,
+      0,
+      1
+    ], 4);
+  }
+};
+var AssetPath = class {
+  constructor(path) {
+    this.path = path;
+  }
+  path;
+};
+
 // src/kinematics/transforms.ts
 var DEG2RAD = Math.PI / 180;
 var RAD2DEG = 180 / Math.PI;
@@ -254,6 +305,226 @@ function fromUsdMatrix(m) {
 function getTranslation(m) {
   return [m[12], m[13], m[14]];
 }
+function toUsdMatrix(m) {
+  if (m.length !== 16) {
+    throw new Error(`expected 16 matrix elements but got ${m.length}`);
+  }
+  return new UsdMatrix([...m], 4);
+}
+function decomposeRigid(m) {
+  const position = [m[12], m[13], m[14]];
+  const b0 = [m[0], m[1], m[2]];
+  const b1 = [m[4], m[5], m[6]];
+  const b2 = [m[8], m[9], m[10]];
+  const EPS = 1e-6;
+  const rigid = Math.abs(norm(b0) - 1) < EPS && Math.abs(norm(b1) - 1) < EPS && Math.abs(norm(b2) - 1) < EPS && Math.abs(dot(b0, b1)) < EPS && Math.abs(dot(b1, b2)) < EPS && Math.abs(dot(b0, b2)) < EPS && dot(cross(b0, b1), b2) > 0;
+  const c0 = normalizeVec(b0);
+  const c1 = normalizeVec(subVec(b1, scaleVec(c0, dot(c0, b1))));
+  const c2 = cross(c0, c1);
+  const r11 = c0[0], r12 = c1[0], r13 = c2[0];
+  const r21 = c0[1], r22 = c1[1], r23 = c2[1];
+  const r31 = c0[2], r32 = c1[2], r33 = c2[2];
+  const trace = r11 + r22 + r33;
+  let w;
+  let x;
+  let y;
+  let z;
+  if (trace > 0) {
+    const s = 0.5 / Math.sqrt(trace + 1);
+    w = 0.25 / s;
+    x = (r32 - r23) * s;
+    y = (r13 - r31) * s;
+    z = (r21 - r12) * s;
+  } else if (r11 > r22 && r11 > r33) {
+    const s = 2 * Math.sqrt(1 + r11 - r22 - r33);
+    w = (r32 - r23) / s;
+    x = 0.25 * s;
+    y = (r12 + r21) / s;
+    z = (r13 + r31) / s;
+  } else if (r22 > r33) {
+    const s = 2 * Math.sqrt(1 + r22 - r11 - r33);
+    w = (r13 - r31) / s;
+    x = (r12 + r21) / s;
+    y = 0.25 * s;
+    z = (r23 + r32) / s;
+  } else {
+    const s = 2 * Math.sqrt(1 + r33 - r11 - r22);
+    w = (r21 - r12) / s;
+    x = (r13 + r31) / s;
+    y = (r23 + r32) / s;
+    z = 0.25 * s;
+  }
+  return { position, orientation: new Quat(w, [x, y, z]), rigid };
+}
+function dot(a, b) {
+  return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+}
+function norm(v) {
+  return Math.hypot(v[0], v[1], v[2]);
+}
+function subVec(a, b) {
+  return [a[0] - b[0], a[1] - b[1], a[2] - b[2]];
+}
+function scaleVec(v, s) {
+  return [v[0] * s, v[1] * s, v[2] * s];
+}
+function normalizeVec(v) {
+  const n = norm(v);
+  return n > 0 ? scaleVec(v, 1 / n) : [1, 0, 0];
+}
+function cross(a, b) {
+  return [a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0]];
+}
+
+// src/schemas/usdGeom.ts
+function isXform(prim) {
+  return prim.GetTypeName() === "Xform";
+}
+function isScope(prim) {
+  return prim.GetTypeName() === "Scope";
+}
+function isMesh(prim) {
+  return prim.GetTypeName() === "Mesh";
+}
+function getPurpose(prim) {
+  const v = prim.GetAttribute("purpose").Get();
+  return typeof v === "string" ? v : "default";
+}
+function isNonVisualPurpose(prim) {
+  const p = getPurpose(prim);
+  return p === "guide" || p === "proxy";
+}
+function getMaterialSubsets(meshPrim) {
+  const out = [];
+  for (const child of meshPrim.GetChildren()) {
+    if (child.GetTypeName() !== "GeomSubset") continue;
+    const elementType = child.GetAttribute("elementType").Get();
+    if (elementType !== void 0 && elementType !== "face") continue;
+    const family = child.GetAttribute("familyName").Get();
+    if (family !== void 0 && family !== "materialBind") continue;
+    const indices = child.GetAttribute("indices").Get();
+    if (!Array.isArray(indices)) continue;
+    const faces = [];
+    for (const i of indices) {
+      if (typeof i === "number") faces.push(i);
+    }
+    if (faces.length > 0) out.push({ prim: child, faces });
+  }
+  return out;
+}
+function* iterDescendants(prim) {
+  for (const child of prim.GetChildren()) {
+    yield child;
+    yield* iterDescendants(child);
+  }
+}
+function gatherMeshDescendants(prim) {
+  const paths = [];
+  for (const d of iterDescendants(prim)) {
+    if (isMesh(d)) paths.push(d.GetPath());
+  }
+  return paths;
+}
+
+// src/schemas/usdPhysics.ts
+var JOINT_TYPE_BY_SCHEMA = {
+  PhysicsFixedJoint: "fixed",
+  PhysicsRevoluteJoint: "revolute",
+  PhysicsPrismaticJoint: "prismatic"
+};
+var ARTICULATION_ROOT_API = "PhysicsArticulationRootAPI";
+var RIGID_BODY_API = "PhysicsRigidBodyAPI";
+var COLLISION_API = "PhysicsCollisionAPI";
+var MASS_API = "PhysicsMassAPI";
+var MESH_COLLISION_API = "PhysicsMeshCollisionAPI";
+var PHYSICS_MATERIAL_API = "PhysicsMaterialAPI";
+function getJointType(prim) {
+  return JOINT_TYPE_BY_SCHEMA[prim.GetTypeName()] ?? null;
+}
+function getJointBodies(prim) {
+  const body0 = prim.GetRelationship("physics:body0").GetTargets()[0];
+  const body1 = prim.GetRelationship("physics:body1").GetTargets()[0];
+  return {
+    ...body0 !== void 0 ? { body0 } : {},
+    ...body1 !== void 0 ? { body1 } : {}
+  };
+}
+function getJointAxis(prim) {
+  const v = prim.GetAttribute("physics:axis").Get();
+  return v === "Y" || v === "Z" ? v : "X";
+}
+function getJointLimits(prim) {
+  const lower = readNumber(prim, "physics:lowerLimit");
+  const upper = readNumber(prim, "physics:upperLimit");
+  return {
+    ...lower !== void 0 ? { lower } : {},
+    ...upper !== void 0 ? { upper } : {}
+  };
+}
+function getJointLocalFrame(prim, index) {
+  const pos = readVec3(prim, `physics:localPos${index}`, [0, 0, 0]);
+  const rot = readQuat(prim, `physics:localRot${index}`, Quat.identity());
+  return multiply(makeTranslation(pos), makeRotationFromQuat(rot));
+}
+function hasArticulationRootAPI(prim) {
+  return prim.HasAPI(ARTICULATION_ROOT_API);
+}
+function hasRigidBodyAPI(prim) {
+  return prim.HasAPI(RIGID_BODY_API);
+}
+function hasCollisionAPI(prim) {
+  return prim.HasAPI(COLLISION_API);
+}
+function driveKindFor(type) {
+  return type === "prismatic" ? "linear" : "angular";
+}
+function getJointDrive(prim, kind) {
+  const targetPosition = readNumber(prim, `drive:${kind}:physics:targetPosition`);
+  const stiffness = readNumber(prim, `drive:${kind}:physics:stiffness`);
+  const damping = readNumber(prim, `drive:${kind}:physics:damping`);
+  const maxForce = readNumber(prim, `drive:${kind}:physics:maxForce`);
+  return {
+    ...targetPosition !== void 0 ? { targetPosition } : {},
+    ...stiffness !== void 0 ? { stiffness } : {},
+    ...damping !== void 0 ? { damping } : {},
+    ...maxForce !== void 0 ? { maxForce } : {}
+  };
+}
+function getJointStatePosition(prim, kind) {
+  return readNumber(prim, `state:${kind}:physics:position`);
+}
+function getMassProperties(prim) {
+  const out = {};
+  const mass = readNumber(prim, "physics:mass");
+  if (mass !== void 0) out.mass = mass;
+  const density = readNumber(prim, "physics:density");
+  if (density !== void 0) out.density = density;
+  const centerOfMass = readVec3Opt(prim, "physics:centerOfMass");
+  if (centerOfMass) out.centerOfMass = centerOfMass;
+  const diagonalInertia = readVec3Opt(prim, "physics:diagonalInertia");
+  if (diagonalInertia) out.diagonalInertia = diagonalInertia;
+  const principalAxes = prim.GetAttribute("physics:principalAxes").Get();
+  if (principalAxes instanceof Quat) out.principalAxes = principalAxes;
+  return Object.keys(out).length > 0 ? out : void 0;
+}
+function readNumber(prim, name) {
+  const v = prim.GetAttribute(name).Get();
+  return typeof v === "number" ? v : void 0;
+}
+function readVec3(prim, name, def) {
+  return readVec3Opt(prim, name) ?? def;
+}
+function readVec3Opt(prim, name) {
+  const v = prim.GetAttribute(name).Get();
+  if (Array.isArray(v) && v.length === 3 && v.every((n) => typeof n === "number")) {
+    return v;
+  }
+  return void 0;
+}
+function readQuat(prim, name, def) {
+  const v = prim.GetAttribute(name).Get();
+  return v instanceof Quat ? v : def;
+}
 
 // src/usd/xformOps.ts
 var INVERT_PREFIX = "!invert!";
@@ -266,6 +537,15 @@ var ROTATE_ORDERS = /* @__PURE__ */ new Set([
   "rotateZXY",
   "rotateZYX"
 ]);
+function computeWorldTransform(prim) {
+  const chain = [];
+  for (let p = prim; p && !p.IsPseudoRoot(); p = p.GetParent()) chain.push(p);
+  let m = identity4();
+  for (let i = chain.length - 1; i >= 0; i--) {
+    m = multiply(m, computeLocalTransform(chain[i]).matrix);
+  }
+  return m;
+}
 function computeLocalTransform(prim) {
   const orderAttr = prim.GetAttribute("xformOpOrder");
   const order = orderAttr.Get();
@@ -287,9 +567,7 @@ function computeLocalTransform(prim) {
       opName = opName.slice(INVERT_PREFIX.length);
     }
     const attr = prim.GetAttribute(opName);
-    if (!attr.IsValid()) {
-      throw new Error(`${prim.GetPath()}: xformOpOrder references missing op "${opName}"`);
-    }
+    if (!attr.IsValid()) continue;
     const opValue = attr.Get();
     if (opValue === void 0) continue;
     let opMatrix = opMatrixFor(parseOpType(opName), opValue, `${prim.GetPath()}.${opName}`);
@@ -345,56 +623,177 @@ function asMatrix(v, where) {
   throw new Error(`${where}: expected a matrix`);
 }
 
-// src/parser/ast.ts
-var Quat = class _Quat {
-  constructor(real, imaginary) {
-    this.real = real;
-    this.imaginary = imaginary;
+// src/three/MaterialBinding.ts
+var DIFFUSE_INPUTS = [
+  "inputs:diffuseColor",
+  // UsdPreviewSurface
+  "inputs:diffuse_color_constant",
+  // OmniPBR
+  "inputs:diffuse_tint",
+  "inputs:base_color",
+  "inputs:baseColor"
+];
+var OPACITY_INPUTS = ["inputs:opacity", "inputs:opacity_constant"];
+var OPACITY_THRESHOLD_INPUTS = ["inputs:opacityThreshold", "inputs:opacity_threshold"];
+var METALLIC_INPUTS = ["inputs:metallic", "inputs:metallic_constant"];
+var ROUGHNESS_INPUTS = ["inputs:roughness", "inputs:reflection_roughness_constant"];
+var EMISSIVE_INPUTS = ["inputs:emissiveColor", "inputs:emissive_color"];
+var SURFACE_OUTPUTS = ["outputs:surface", "outputs:mdl:surface"];
+var TEXTURE_LOOKUPS = {
+  color: {
+    surface: ["inputs:diffuseColor"],
+    direct: ["inputs:diffuse_texture", "inputs:diffuse_color_texture"]
+  },
+  opacity: {
+    surface: ["inputs:opacity"],
+    direct: ["inputs:opacity_texture", "inputs:opacity_color_texture"]
+  },
+  normal: {
+    surface: ["inputs:normal"],
+    direct: ["inputs:normalmap_texture", "inputs:normal_texture"]
+  },
+  roughness: {
+    surface: ["inputs:roughness"],
+    direct: ["inputs:reflectionroughness_texture", "inputs:roughness_texture"]
+  },
+  metalness: {
+    surface: ["inputs:metallic"],
+    direct: ["inputs:metallic_texture"]
+  },
+  occlusion: {
+    surface: ["inputs:occlusion"],
+    direct: ["inputs:ao_texture", "inputs:occlusion_texture"]
+  },
+  emissive: {
+    surface: ["inputs:emissiveColor"],
+    direct: ["inputs:emissive_color_texture", "inputs:emissive_mask_texture"]
   }
-  real;
-  imaginary;
-  /** Components in Three.js order `[x, y, z, w]`. */
-  toXYZW() {
-    return [this.imaginary[0], this.imaginary[1], this.imaginary[2], this.real];
+};
+function resolveBoundMaterial(stage, prim) {
+  const materialPath = findBinding(prim);
+  if (!materialPath) return void 0;
+  const material = stage.GetPrimAtPath(materialPath);
+  if (!material) return void 0;
+  const shader = findSurfaceShader(material);
+  if (!shader) return void 0;
+  const result = { name: material.GetName() };
+  const color = firstColor(shader, DIFFUSE_INPUTS);
+  if (color) result.color = color;
+  const opacity = firstNumber(shader, OPACITY_INPUTS);
+  if (opacity !== void 0) result.opacity = opacity;
+  const opacityThreshold = firstNumber(shader, OPACITY_THRESHOLD_INPUTS);
+  if (opacityThreshold !== void 0) result.opacityThreshold = opacityThreshold;
+  const metalness = firstNumber(shader, METALLIC_INPUTS);
+  if (metalness !== void 0) result.metalness = metalness;
+  const roughness = firstNumber(shader, ROUGHNESS_INPUTS);
+  if (roughness !== void 0) result.roughness = roughness;
+  const emissive = firstColor(shader, EMISSIVE_INPUTS);
+  if (emissive && shader.GetAttribute("inputs:enable_emission").Get() !== false) {
+    result.emissiveColor = emissive;
+  }
+  const colorTex = findTexture(shader, TEXTURE_LOOKUPS.color);
+  if (colorTex !== void 0) result.colorTexture = colorTex;
+  const opacityTex = findTexture(shader, TEXTURE_LOOKUPS.opacity);
+  if (opacityTex !== void 0) result.opacityTexture = opacityTex;
+  const normal = findTexture(shader, TEXTURE_LOOKUPS.normal);
+  if (normal !== void 0) result.normalTexture = normal;
+  const roughTex = findTexture(shader, TEXTURE_LOOKUPS.roughness);
+  if (roughTex !== void 0) result.roughnessTexture = roughTex;
+  const metalTex = findTexture(shader, TEXTURE_LOOKUPS.metalness);
+  if (metalTex !== void 0) result.metalnessTexture = metalTex;
+  const aoTex = findTexture(shader, TEXTURE_LOOKUPS.occlusion);
+  if (aoTex !== void 0) result.occlusionTexture = aoTex;
+  const emissiveTex = findTexture(shader, TEXTURE_LOOKUPS.emissive);
+  if (emissiveTex !== void 0) result.emissiveTexture = emissiveTex;
+  return result;
+}
+function findTexture(shader, lookup) {
+  for (const name of lookup.direct) {
+    const v = shader.GetAttribute(name).Get();
+    if (v instanceof AssetPath && v.path) return { path: v.path };
+  }
+  for (const name of lookup.surface) {
+    const conn = shader.GetAttribute(name).GetConnections()[0];
+    if (!conn) continue;
+    const texPrim = shader.GetStage().GetPrimAtPath(conn.split(".")[0]);
+    if (!texPrim) continue;
+    const file = texPrim.GetAttribute("inputs:file").Get();
+    if (file instanceof AssetPath && file.path) return readUvTexture(texPrim, file.path);
+  }
+  return void 0;
+}
+var WRAP_VALUES = /* @__PURE__ */ new Set(["repeat", "clamp", "mirror", "black"]);
+function readUvTexture(texPrim, path) {
+  const tex = { path };
+  const wrapS = texPrim.GetAttribute("inputs:wrapS").Get();
+  if (typeof wrapS === "string" && WRAP_VALUES.has(wrapS)) tex.wrapS = wrapS;
+  const wrapT = texPrim.GetAttribute("inputs:wrapT").Get();
+  if (typeof wrapT === "string" && WRAP_VALUES.has(wrapT)) tex.wrapT = wrapT;
+  const scale = numArray(texPrim, "inputs:scale", 4);
+  if (scale) tex.scale = scale;
+  const bias = numArray(texPrim, "inputs:bias", 4);
+  if (bias) tex.bias = bias;
+  const transform = readTransform2d(texPrim);
+  if (transform) tex.transform = transform;
+  return tex;
+}
+function readTransform2d(texPrim) {
+  const conn = texPrim.GetAttribute("inputs:st").GetConnections()[0];
+  if (!conn) return void 0;
+  const node = texPrim.GetStage().GetPrimAtPath(conn.split(".")[0]);
+  if (!node || node.GetAttribute("info:id").Get() !== "UsdTransform2d") return void 0;
+  const transform = {};
+  const translation = numArray(node, "inputs:translation", 2);
+  if (translation) transform.translation = translation;
+  const scale = numArray(node, "inputs:scale", 2);
+  if (scale) transform.scale = scale;
+  const rotation = node.GetAttribute("inputs:rotation").Get();
+  if (typeof rotation === "number") transform.rotation = rotation;
+  return Object.keys(transform).length > 0 ? transform : void 0;
+}
+function numArray(prim, name, length) {
+  const v = prim.GetAttribute(name).Get();
+  if (Array.isArray(v) && v.length >= length && v.every((n) => typeof n === "number")) {
+    return v.slice(0, length);
   }
-  static identity() {
-    return new _Quat(1, [0, 0, 0]);
+  return void 0;
+}
+function findBinding(prim) {
+  let p = prim;
+  while (p) {
+    const targets = p.GetRelationship("material:binding").GetTargets();
+    if (targets.length > 0) return targets[0];
+    p = p.GetParent();
   }
-};
-var UsdMatrix = class _UsdMatrix {
-  constructor(values, dim) {
-    this.values = values;
-    this.dim = dim;
+  return void 0;
+}
+function findSurfaceShader(material) {
+  for (const out of SURFACE_OUTPUTS) {
+    const conn = material.GetAttribute(out).GetConnections()[0];
+    if (conn) {
+      const shaderPath = conn.split(".")[0];
+      const shader = material.GetStage().GetPrimAtPath(shaderPath);
+      if (shader) return shader;
+    }
   }
-  values;
-  dim;
-  static identity4() {
-    return new _UsdMatrix([
-      1,
-      0,
-      0,
-      0,
-      0,
-      1,
-      0,
-      0,
-      0,
-      0,
-      1,
-      0,
-      0,
-      0,
-      0,
-      1
-    ], 4);
+  return material.GetChildren().find((c) => c.GetTypeName() === "Shader") ?? void 0;
+}
+function firstColor(shader, names) {
+  for (const name of names) {
+    const v = shader.GetAttribute(name).Get();
+    if (Array.isArray(v) && v.length >= 3 && v.every((n) => typeof n === "number")) {
+      return [v[0], v[1], v[2]];
+    }
   }
-};
-var AssetPath = class {
-  constructor(path) {
-    this.path = path;
+  return void 0;
+}
+function firstNumber(shader, names) {
+  for (const name of names) {
+    const v = shader.GetAttribute(name).Get();
+    if (typeof v === "number") return v;
   }
-  path;
-};
+  return void 0;
+}
 
 // src/kinematics/sampling.ts
 function interpolate(channel, t) {
@@ -423,118 +822,6 @@ function channelFromSamples(samples) {
   return { times, values };
 }
 
-// src/schemas/usdGeom.ts
-function isXform(prim) {
-  return prim.GetTypeName() === "Xform";
-}
-function isScope(prim) {
-  return prim.GetTypeName() === "Scope";
-}
-function isMesh(prim) {
-  return prim.GetTypeName() === "Mesh";
-}
-function getPurpose(prim) {
-  const v = prim.GetAttribute("purpose").Get();
-  return typeof v === "string" ? v : "default";
-}
-function isNonVisualPurpose(prim) {
-  const p = getPurpose(prim);
-  return p === "guide" || p === "proxy";
-}
-function* iterDescendants(prim) {
-  for (const child of prim.GetChildren()) {
-    yield child;
-    yield* iterDescendants(child);
-  }
-}
-function gatherMeshDescendants(prim) {
-  const paths = [];
-  for (const d of iterDescendants(prim)) {
-    if (isMesh(d)) paths.push(d.GetPath());
-  }
-  return paths;
-}
-
-// src/schemas/usdPhysics.ts
-var JOINT_TYPE_BY_SCHEMA = {
-  PhysicsFixedJoint: "fixed",
-  PhysicsRevoluteJoint: "revolute",
-  PhysicsPrismaticJoint: "prismatic"
-};
-var ARTICULATION_ROOT_API = "PhysicsArticulationRootAPI";
-var RIGID_BODY_API = "PhysicsRigidBodyAPI";
-var COLLISION_API = "PhysicsCollisionAPI";
-function getJointType(prim) {
-  return JOINT_TYPE_BY_SCHEMA[prim.GetTypeName()] ?? null;
-}
-function getJointBodies(prim) {
-  const body0 = prim.GetRelationship("physics:body0").GetTargets()[0];
-  const body1 = prim.GetRelationship("physics:body1").GetTargets()[0];
-  return {
-    ...body0 !== void 0 ? { body0 } : {},
-    ...body1 !== void 0 ? { body1 } : {}
-  };
-}
-function getJointAxis(prim) {
-  const v = prim.GetAttribute("physics:axis").Get();
-  return v === "Y" || v === "Z" ? v : "X";
-}
-function getJointLimits(prim) {
-  const lower = readNumber(prim, "physics:lowerLimit");
-  const upper = readNumber(prim, "physics:upperLimit");
-  return {
-    ...lower !== void 0 ? { lower } : {},
-    ...upper !== void 0 ? { upper } : {}
-  };
-}
-function getJointLocalFrame(prim, index) {
-  const pos = readVec3(prim, `physics:localPos${index}`, [0, 0, 0]);
-  const rot = readQuat(prim, `physics:localRot${index}`, Quat.identity());
-  return multiply(makeTranslation(pos), makeRotationFromQuat(rot));
-}
-function hasArticulationRootAPI(prim) {
-  return prim.HasAPI(ARTICULATION_ROOT_API);
-}
-function hasRigidBodyAPI(prim) {
-  return prim.HasAPI(RIGID_BODY_API);
-}
-function hasCollisionAPI(prim) {
-  return prim.HasAPI(COLLISION_API);
-}
-function driveKindFor(type) {
-  return type === "prismatic" ? "linear" : "angular";
-}
-function getJointDrive(prim, kind) {
-  const targetPosition = readNumber(prim, `drive:${kind}:physics:targetPosition`);
-  const stiffness = readNumber(prim, `drive:${kind}:physics:stiffness`);
-  const damping = readNumber(prim, `drive:${kind}:physics:damping`);
-  const maxForce = readNumber(prim, `drive:${kind}:physics:maxForce`);
-  return {
-    ...targetPosition !== void 0 ? { targetPosition } : {},
-    ...stiffness !== void 0 ? { stiffness } : {},
-    ...damping !== void 0 ? { damping } : {},
-    ...maxForce !== void 0 ? { maxForce } : {}
-  };
-}
-function getJointStatePosition(prim, kind) {
-  return readNumber(prim, `state:${kind}:physics:position`);
-}
-function readNumber(prim, name) {
-  const v = prim.GetAttribute(name).Get();
-  return typeof v === "number" ? v : void 0;
-}
-function readVec3(prim, name, def) {
-  const v = prim.GetAttribute(name).Get();
-  if (Array.isArray(v) && v.length === 3 && v.every((n) => typeof n === "number")) {
-    return v;
-  }
-  return def;
-}
-function readQuat(prim, name, def) {
-  const v = prim.GetAttribute(name).Get();
-  return v instanceof Quat ? v : def;
-}
-
 // src/robot/buildKinematicTree.ts
 var WORLD = "";
 function buildKinematicTree(robot, options = {}) {
@@ -654,6 +941,9 @@ function normalizeJointLimits(type, rawLower, rawUpper) {
 function jointValueToSI(angular, raw) {
   return angular ? raw * DEG2RAD : raw;
 }
+function jointValueFromSI(angular, si) {
+  return angular ? si * RAD2DEG : si;
+}
 function refineJointType(base, lower, upper) {
   if (base === "revolute" && lower === void 0 && upper === void 0) return "continuous";
   return base;
@@ -720,16 +1010,28 @@ function buildLink(path, prim) {
   const collisionPrims = [];
   for (const meshPath of gatherMeshDescendants(prim)) {
     const mp = prim.GetStage().GetPrimAtPath(meshPath);
-    if (mp && (hasCollisionAPI(mp) || isNonVisualPurpose(mp))) collisionPrims.push(meshPath);
-    else visualPrims.push(meshPath);
+    if (!mp) continue;
+    const nonVisual = isNonVisualPurpose(mp);
+    if (!nonVisual) visualPrims.push(meshPath);
+    if (nonVisual || hasCollisionAPI(mp)) collisionPrims.push(meshPath);
   }
+  const inertial = getMassProperties(prim);
+  const worldTransform = computeWorldTransform(prim);
   return {
     name,
     primPath: path,
     visualPrims,
-    ...collisionPrims.length ? { collisionPrims } : {}
+    ...collisionPrims.length ? { collisionPrims } : {},
+    ...inertial ? { inertial } : {},
+    ...isIdentityMat4(worldTransform) ? {} : { worldTransform }
   };
 }
+function isIdentityMat4(m) {
+  for (let i = 0; i < 16; i++) {
+    if (m[i] !== (i % 5 === 0 ? 1 : 0)) return false;
+  }
+  return true;
+}
 function buildJoint(prim, linkKeyByPath, warn) {
   const base = getJointType(prim);
   if (!base) return null;
@@ -1347,11 +1649,11 @@ function parseVariantSet(r) {
   const variants = {};
   while (!r.is("rbrace") && !r.atEnd()) {
     const variantName = r.expect("string").value;
-    if (r.is("lparen")) parseMetadataBlock(r);
+    const metadata = r.is("lparen") ? parseMetadataBlock(r) : {};
     r.expect("lbrace");
     const body = parseBody(r);
     r.expect("rbrace");
-    variants[variantName] = { properties: body.properties, children: body.children };
+    variants[variantName] = { properties: body.properties, children: body.children, metadata };
   }
   r.expect("rbrace");
   return { setName, variants };
@@ -1523,12 +1825,243 @@ function parseDictionary(r) {
   return dict;
 }
 
+// src/writer/writeUsda.ts
+var INDENT = "    ";
+var BARE_KEY_RE = /^[A-Za-z_][A-Za-z0-9_]*$/;
+function serializeUsda(file) {
+  const out = [`#usda ${file.version}`];
+  const meta = Object.entries(file.metadata);
+  if (meta.length > 0) {
+    out.push("(");
+    for (const [key, value] of meta) pushMetaEntry(out, key, value, 1);
+    out.push(")");
+  }
+  for (const prim of file.prims) {
+    out.push("");
+    pushPrim(out, prim, 0);
+  }
+  return `${out.join("\n")}
+`;
+}
+function pushPrim(out, prim, level) {
+  const pad = INDENT.repeat(level);
+  const type = prim.typeName ? `${prim.typeName} ` : "";
+  pushWithMetadata(
+    out,
+    `${pad}${prim.specifier} ${type}${quoteString(prim.name)}`,
+    prim.metadata,
+    level
+  );
+  out.push(`${pad}{`);
+  pushPrimBody(out, prim.properties, prim.children, prim.variantSets, level + 1);
+  out.push(`${pad}}`);
+}
+function pushPrimBody(out, properties, children, variantSets, level) {
+  for (const prop of properties) pushProperty(out, prop, level);
+  if (variantSets) {
+    const pad = INDENT.repeat(level);
+    for (const [setName, variants] of Object.entries(variantSets)) {
+      out.push(`${pad}variantSet ${quoteString(setName)} = {`);
+      for (const [variantName, content] of Object.entries(variants)) {
+        const head = `${pad}${INDENT}${quoteString(variantName)}`;
+        if (Object.keys(content.metadata).length > 0) {
+          pushWithMetadata(out, head, content.metadata, level + 1);
+          out.push(`${pad}${INDENT}{`);
+        } else {
+          out.push(`${head} {`);
+        }
+        pushPrimBody(out, content.properties, content.children, void 0, level + 2);
+        out.push(`${pad}${INDENT}}`);
+      }
+      out.push(`${pad}}`);
+    }
+  }
+  for (let i = 0; i < children.length; i++) {
+    if (i > 0 || properties.length > 0 || variantSets) out.push("");
+    pushPrim(out, children[i], level);
+  }
+}
+function pushProperty(out, prop, level) {
+  if (prop.kind === "relationship") pushRelationship(out, prop, level);
+  else pushAttribute(out, prop, level);
+}
+function pushRelationship(out, rel, level) {
+  const pad = INDENT.repeat(level);
+  const custom = rel.custom ? "custom " : "";
+  const listOp = rel.listOp !== "explicit" ? `${rel.listOp} ` : "";
+  let head = `${pad}${custom}${listOp}rel ${rel.name}`;
+  if (rel.targets.length > 0) head += ` = ${formatTargets(rel.targets)}`;
+  pushWithMetadata(out, head, rel.metadata, level);
+}
+function pushAttribute(out, attr, level) {
+  const pad = INDENT.repeat(level);
+  const custom = attr.custom ? "custom " : "";
+  const uniform = attr.variability === "uniform" ? "uniform " : "";
+  const decl = `${pad}${custom}${uniform}${attr.typeName}${attr.isArray ? "[]" : ""} ${attr.name}`;
+  let first = true;
+  const attach = (head) => {
+    if (first) pushWithMetadata(out, head, attr.metadata, level);
+    else out.push(head);
+    first = false;
+  };
+  if (attr.value !== void 0) {
+    attach(`${decl} = ${formatAttrValue(attr.value, attr.isArray)}`);
+  }
+  if (attr.timeSamples) {
+    out.push(`${decl}.timeSamples = {`);
+    for (const [time, value] of attr.timeSamples) {
+      out.push(`${pad}${INDENT}${formatNumber(time)}: ${formatAttrValue(value, attr.isArray)},`);
+    }
+    attach(`${pad}}`);
+  }
+  if (attr.connections) {
+    attach(
+      `${decl}.connect = ${attr.connections.length > 0 ? formatTargets(attr.connections) : "None"}`
+    );
+  }
+  if (first) attach(decl);
+}
+function formatTargets(targets) {
+  if (targets.length === 1) return `<${targets[0]}>`;
+  return `[${targets.map((t) => `<${t}>`).join(", ")}]`;
+}
+function pushWithMetadata(out, head, meta, level) {
+  const entries = Object.entries(meta);
+  if (entries.length === 0) {
+    out.push(head);
+    return;
+  }
+  out.push(`${head} (`);
+  for (const [key, value] of entries) pushMetaEntry(out, key, value, level + 1);
+  out.push(`${INDENT.repeat(level)})`);
+}
+function pushMetaEntry(out, key, value, level) {
+  const pad = INDENT.repeat(level);
+  if (isDictionary(value)) {
+    out.push(`${pad}${key} = {`);
+    pushDictEntries(out, value, level + 1);
+    out.push(`${pad}}`);
+    return;
+  }
+  out.push(`${pad}${key} = ${formatMetaValue(value)}`);
+}
+function pushDictEntries(out, dict, level) {
+  const pad = INDENT.repeat(level);
+  for (const [key, value] of Object.entries(dict)) {
+    const keyText = BARE_KEY_RE.test(key) ? key : quoteString(key);
+    if (isDictionary(value)) {
+      out.push(`${pad}dictionary ${keyText} = {`);
+      pushDictEntries(out, value, level + 1);
+      out.push(`${pad}}`);
+    } else {
+      out.push(`${pad}${dictEntryTypeName(value)} ${keyText} = ${formatMetaValue(value)}`);
+    }
+  }
+}
+function dictEntryTypeName(v) {
+  if (typeof v === "string") return "string";
+  if (typeof v === "boolean") return "bool";
+  if (typeof v === "number") return isInt32(v) ? "int" : "double";
+  if (typeof v === "bigint") return "int64";
+  if (v instanceof AssetPath) return "asset";
+  if (v instanceof Quat) return "quatd";
+  if (v instanceof UsdMatrix) return v.dim === 4 ? "matrix4d" : "matrix3d";
+  if (Array.isArray(v)) {
+    const elems = v;
+    if (elems.every((e) => typeof e === "boolean")) return "bool[]";
+    let allInt = true;
+    for (const e of elems) {
+      if (typeof e !== "number") return "string[]";
+      if (!isInt32(e)) allInt = false;
+    }
+    return allInt ? "int[]" : "double[]";
+  }
+  return "string";
+}
+function isInt32(v) {
+  return Number.isInteger(v) && Math.abs(v) <= 2147483647;
+}
+function formatMetaValue(v) {
+  if (v === null) return "None";
+  if (typeof v === "number") return formatNumber(v);
+  if (typeof v === "bigint") return String(v);
+  if (typeof v === "boolean") return v ? "true" : "false";
+  if (typeof v === "string") return quoteString(v);
+  if (v instanceof AssetPath) return formatAsset(v.path);
+  if (v instanceof Quat) return formatQuat(v);
+  if (v instanceof UsdMatrix) return formatMatrix(v);
+  if (Array.isArray(v)) return `[${v.map(formatMetaValue).join(", ")}]`;
+  if (isCompositionArc(v)) return formatArc(v);
+  throw new Error("cannot serialize a nested dictionary in list/value context");
+}
+function formatArc(arc) {
+  const asset = arc.assetPath ? formatAsset(arc.assetPath.path) : "";
+  const prim = arc.primPath !== void 0 ? `<${arc.primPath}>` : "";
+  return `${asset}${prim}`;
+}
+function formatAttrValue(v, isArray) {
+  if (v === null) return "None";
+  if (isArray && Array.isArray(v)) {
+    return `[${v.map((el) => formatAttrScalar(el)).join(", ")}]`;
+  }
+  return formatAttrScalar(v);
+}
+function formatAttrScalar(v) {
+  if (v === null) return "None";
+  if (typeof v === "number") return formatNumber(v);
+  if (typeof v === "bigint") return String(v);
+  if (typeof v === "boolean") return v ? "true" : "false";
+  if (typeof v === "string") return quoteString(v);
+  if (v instanceof Quat) return formatQuat(v);
+  if (v instanceof UsdMatrix) return formatMatrix(v);
+  if (v instanceof AssetPath) return formatAsset(v.path);
+  if (Array.isArray(v)) return `(${v.map((el) => formatAttrScalar(el)).join(", ")})`;
+  throw new Error("cannot serialize a dictionary as an attribute value");
+}
+function formatQuat(q) {
+  const [i, j, k] = q.imaginary;
+  return `(${formatNumber(q.real)}, ${formatNumber(i)}, ${formatNumber(j)}, ${formatNumber(k)})`;
+}
+function formatMatrix(m) {
+  const rows = [];
+  for (let r = 0; r < m.dim; r++) {
+    const row = m.values.slice(r * m.dim, (r + 1) * m.dim).map(formatNumber);
+    rows.push(`(${row.join(", ")})`);
+  }
+  return `( ${rows.join(", ")} )`;
+}
+function formatNumber(v) {
+  if (Number.isNaN(v)) return "nan";
+  if (v === Number.POSITIVE_INFINITY) return "inf";
+  if (v === Number.NEGATIVE_INFINITY) return "-inf";
+  if (Object.is(v, -0)) return "-0";
+  return String(v);
+}
+function quoteString(s) {
+  const escaped = s.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/\t/g, "\\t");
+  return `"${escaped}"`;
+}
+function formatAsset(path) {
+  return path.includes("@") ? `@@@${path}@@@` : `@${path}@`;
+}
+function isDictionary(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v) && !(v instanceof Quat) && !(v instanceof UsdMatrix) && !(v instanceof AssetPath) && !isCompositionArc(v);
+}
+function isCompositionArc(v) {
+  const keys = Object.keys(v);
+  return keys.length > 0 && keys.every((k) => k === "assetPath" || k === "primPath");
+}
+
 // src/usd/Layer.ts
 var Layer = class {
   constructor(_file) {
     this._file = _file;
   }
   _file;
+  /** Serialize this layer back to USDA text (`SdfLayer::ExportToString`-like). */
+  ExportToString() {
+    return serializeUsda(this._file);
+  }
   GetVersion() {
     return this._file.version;
   }
@@ -1712,7 +2245,9 @@ var Prim = class {
     if (!this._attributes) {
       this._attributes = /* @__PURE__ */ new Map();
       for (const p of this._spec?.properties ?? []) {
-        if (p.kind === "attribute") this._attributes.set(p.name, p);
+        if (p.kind !== "attribute") continue;
+        const prev = this._attributes.get(p.name);
+        this._attributes.set(p.name, prev ? mergeAttributeSpecs(prev, p) : p);
       }
     }
     return this._attributes;
@@ -1773,6 +2308,19 @@ var Prim = class {
     return this.GetAppliedSchemas().some((s) => s === schemaName || s.startsWith(`${schemaName}:`));
   }
 };
+function mergeAttributeSpecs(a, b) {
+  const merged = { ...a, metadata: { ...a.metadata, ...b.metadata } };
+  if (b.typeName) merged.typeName = b.typeName;
+  if (b.isArray) merged.isArray = true;
+  if (b.variability === "uniform") merged.variability = "uniform";
+  if (b.custom) merged.custom = true;
+  if (b.value !== void 0) merged.value = b.value;
+  if (b.timeSamples) {
+    merged.timeSamples = a.timeSamples ? new Map([...a.timeSamples, ...b.timeSamples]) : b.timeSamples;
+  }
+  if (b.connections) merged.connections = b.connections;
+  return merged;
+}
 
 // src/usd/Stage.ts
 var DEFAULT_METERS_PER_UNIT = 0.01;
@@ -1804,6 +2352,14 @@ var Stage = class _Stage {
   GetRootLayer() {
     return this._layer;
   }
+  /**
+   * Serialize the stage's backing layer to USDA text. Loader-built stages wrap
+   * the fully composed layer, so this is a flattened (`usdcat --flatten`-like)
+   * export of everything that was read — including binary-crate sources.
+   */
+  ExportToString() {
+    return this._layer.ExportToString();
+  }
   GetPseudoRoot() {
     return this._pseudoRoot;
   }
@@ -1978,6 +2534,8 @@ var CrateType = {
   Specifier: 42,
   Permission: 43,
   Variability: 44,
+  VariantSelectionMap: 45,
+  StringVector: 50,
   PayloadListOp: 55};
 var ListOpBits = {
   HasExplicit: 1 << 1,
@@ -2333,6 +2891,10 @@ var CrateReader = class {
         return this.readIndexVector(off, "token").items;
       case CrateType.PathVector:
         return this.readIndexVector(off, "path").items;
+      case CrateType.StringVector:
+        return this.readIndexVector(off, "string").items;
+      case CrateType.VariantSelectionMap:
+        return this.readVariantSelectionMap(off);
       default:
         return void 0;
     }
@@ -2399,6 +2961,24 @@ var CrateReader = class {
     }
     return out;
   }
+  /**
+   * Read an `SdfVariantSelectionMap`: `[u64 count]` then `count` pairs of
+   * string indexes (`variantSetName → variantName`). Surfaces as a dictionary
+   * so it maps straight onto the USDA `variants = { ... }` metadatum.
+   */
+  readVariantSelectionMap(off) {
+    const count = this.u64(off);
+    const strings = this.getStrings();
+    const out = {};
+    let p = off + 8;
+    for (let i = 0; i < count; i++) {
+      const key = this.getToken(strings[this.view.getUint32(p, true)] ?? 0);
+      const value = this.getToken(strings[this.view.getUint32(p + 4, true)] ?? 0);
+      if (key) out[key] = value;
+      p += 8;
+    }
+    return out;
+  }
   /** Read a `[u64 count][count × uint32|int32 index]` vector → resolved strings. */
   readIndexVector(off, kind) {
     const count = this.u64(off);
@@ -2406,7 +2986,7 @@ var CrateReader = class {
     const items = new Array(count);
     for (let i = 0; i < count; i++) {
       const idx = this.view.getInt32(p, true);
-      items[i] = kind === "token" ? this.getToken(idx) : this.getPaths()[idx] ?? "";
+      items[i] = kind === "token" ? this.getToken(idx) : kind === "string" ? this.getToken(this.getStrings()[idx] ?? 0) : this.getPaths()[idx] ?? "";
       p += 4;
     }
     return { items, next: p };
@@ -2488,6 +3068,7 @@ var SPEC_PRIM = 6;
 var SPEC_PSEUDO_ROOT = 7;
 var SPEC_ATTRIBUTE = 1;
 var SPEC_RELATIONSHIP = 8;
+var SPEC_VARIANT = 10;
 var SPECIFIERS2 = ["def", "over", "class"];
 function crateToUsdaFile(crate) {
   const paths = crate.getPaths();
@@ -2502,8 +3083,26 @@ function crateToUsdaFile(crate) {
     return map;
   };
   const primByPath = /* @__PURE__ */ new Map();
+  const variantByPath = /* @__PURE__ */ new Map();
   const rootPrims = [];
   let layerMetadata = {};
+  const containerAt = (path) => {
+    const prim = primByPath.get(path);
+    if (prim) return prim;
+    const cached = variantByPath.get(path);
+    if (cached) return cached;
+    const selection = variantNode(path);
+    if (!selection) return void 0;
+    const owner = primByPath.get(selection.owner);
+    if (!owner) return void 0;
+    owner.variantSets ??= {};
+    owner.variantSets[selection.setName] ??= {};
+    const set = owner.variantSets[selection.setName];
+    set[selection.variantName] ??= { properties: [], children: [], metadata: {} };
+    const content = set[selection.variantName];
+    variantByPath.set(path, content);
+    return content;
+  };
   for (const spec of specs) {
     const path = paths[spec.pathIndex] ?? "";
     if (spec.specType === SPEC_PSEUDO_ROOT) {
@@ -2522,31 +3121,50 @@ function crateToUsdaFile(crate) {
       line: 0
     });
   }
+  for (const spec of specs) {
+    if (spec.specType !== SPEC_VARIANT) continue;
+    const content = containerAt(paths[spec.pathIndex] ?? "");
+    if (content)
+      Object.assign(content.metadata, buildPrimMetadata(crate, fieldsOf(spec.fieldSetIndex)));
+  }
   for (const spec of specs) {
     if (spec.specType !== SPEC_ATTRIBUTE && spec.specType !== SPEC_RELATIONSHIP) continue;
     const split = splitProperty(paths[spec.pathIndex] ?? "");
     if (!split) continue;
-    const prim = primByPath.get(split.primPath);
-    if (!prim) continue;
+    const owner = containerAt(split.primPath);
+    if (!owner) continue;
     const fm = fieldsOf(spec.fieldSetIndex);
-    prim.properties.push(
+    owner.properties.push(
       spec.specType === SPEC_ATTRIBUTE ? buildAttribute(crate, split.propName, fm) : buildRelationship(crate, split.propName, fm)
     );
   }
   for (const [path, prim] of primByPath) {
     const parentPath = parentOf(path);
     if (parentPath === "/") rootPrims.push(prim);
-    else primByPath.get(parentPath)?.children.push(prim);
+    else containerAt(parentPath)?.children.push(prim);
   }
   return { version: crate.version.join("."), metadata: layerMetadata, prims: rootPrims };
 }
+function variantNode(path) {
+  if (!path.endsWith("}")) return null;
+  const open = path.lastIndexOf("{");
+  if (open < 0) return null;
+  const selection = path.slice(open + 1, -1);
+  const eq = selection.indexOf("=");
+  if (eq < 0) return null;
+  const variantName = selection.slice(eq + 1);
+  if (variantName === "") return null;
+  return { owner: path.slice(0, open), setName: selection.slice(0, eq), variantName };
+}
 function buildAttribute(crate, name, fm) {
   const defaultRep = fm.get("default");
+  const rawType = asString(crate, fm.get("typeName")) ?? "";
+  const isArrayType = rawType.endsWith("[]");
   const attr = {
     kind: "attribute",
     name,
-    typeName: asString(crate, fm.get("typeName")) ?? "",
-    isArray: defaultRep !== void 0 ? decodeRepBits(defaultRep).isArray : false,
+    typeName: isArrayType ? rawType.slice(0, -2) : rawType,
+    isArray: isArrayType || (defaultRep !== void 0 ? decodeRepBits(defaultRep).isArray : false),
     variability: asNumber2(crate, fm.get("variability")) === 1 ? "uniform" : "varying",
     custom: false,
     metadata: {},
@@ -2578,6 +3196,10 @@ function buildPrimMetadata(crate, fm) {
   if (Array.isArray(apiSchemas)) meta.apiSchemas = apiSchemas;
   const kind = asString(crate, fm.get("kind"));
   if (kind !== void 0) meta.kind = kind;
+  const variants = fm.has("variantSelection") ? crate.getValue(fm.get("variantSelection")) : void 0;
+  if (variants && typeof variants === "object" && !Array.isArray(variants)) {
+    meta.variants = variants;
+  }
   for (const key of ARC_FIELDS) {
     if (!fm.has(key)) continue;
     const arcs = crate.getValue(fm.get(key));
@@ -2587,6 +3209,11 @@ function buildPrimMetadata(crate, fm) {
 }
 function buildLayerMetadata(crate, fm) {
   const meta = {};
+  const subLayers = fm.has("subLayers") ? crate.getValue(fm.get("subLayers")) : void 0;
+  if (Array.isArray(subLayers)) {
+    const paths = subLayers.filter((s) => typeof s === "string" && s.length > 0);
+    if (paths.length > 0) meta.subLayers = paths.map((p) => new AssetPath(p));
+  }
   const upAxis = asString(crate, fm.get("upAxis"));
   if (upAxis !== void 0) meta.upAxis = upAxis;
   const defaultPrim2 = asString(crate, fm.get("defaultPrim"));
@@ -2607,10 +3234,10 @@ function asNumber2(crate, rep) {
 }
 function splitProperty(path) {
   const slash = path.lastIndexOf("/");
-  const dot = path.indexOf(".", slash < 0 ? 0 : slash);
-  if (dot === -1) return null;
+  const dot2 = path.indexOf(".", slash < 0 ? 0 : slash);
+  if (dot2 === -1) return null;
   if (path.includes("[")) return null;
-  return { primPath: path.slice(0, dot), propName: path.slice(dot + 1) };
+  return { primPath: path.slice(0, dot2), propName: path.slice(dot2 + 1) };
 }
 function parentOf(path) {
   const i = path.lastIndexOf("/");
@@ -2623,16 +3250,24 @@ function leaf(path) {
 // src/usd/composition.ts
 var ARC_KEYS = ["references", "payload", "payloads", "inherits", "specializes"];
 var STRIP_KEYS = [...ARC_KEYS, "variants", "variantSets"];
-async function composeLayer(text, baseUrl, resolver, options = {}, stack = /* @__PURE__ */ new Set()) {
-  return composeFile(parseUsda(text), baseUrl, resolver, options, stack);
+async function composeLayer(text, baseUrl, resolver, options = {}, stack = /* @__PURE__ */ new Set(), cache = /* @__PURE__ */ new Map()) {
+  return composeFile(parseUsda(text), baseUrl, resolver, options, stack, cache);
 }
-async function composeFile(file, baseUrl, resolver, options = {}, stack = /* @__PURE__ */ new Set()) {
+async function composeFile(file, baseUrl, resolver, options = {}, stack = /* @__PURE__ */ new Set(), cache = /* @__PURE__ */ new Map()) {
   const warn = options.onWarn ?? (() => {
   });
   let weak = [];
   const subLayers = toArcs(file.metadata.subLayers);
   for (let i = subLayers.length - 1; i >= 0; i--) {
-    const sub = await loadExternalFile(subLayers[i], baseUrl, resolver, options, stack, warn);
+    const sub = await loadExternalFile(
+      subLayers[i],
+      baseUrl,
+      resolver,
+      options,
+      stack,
+      warn,
+      cache
+    );
     if (sub) weak = mergePrimLists(weak, sub.prims);
   }
   const ctx = {
@@ -2642,7 +3277,8 @@ async function composeFile(file, baseUrl, resolver, options = {}, stack = /* @__
     warn,
     stack,
     index: buildPathIndex(file.prims),
-    resolving: /* @__PURE__ */ new Set()
+    resolving: /* @__PURE__ */ new Set(),
+    cache
   };
   const resolved = [];
   for (const prim of file.prims) resolved.push(await resolvePrim(prim, "", ctx));
@@ -2653,13 +3289,15 @@ async function resolvePrim(spec, parentPath, ctx) {
   const path = `${parentPath}/${spec.name}`;
   let properties = spec.properties;
   let children = spec.children;
+  const variantArcs = [];
   const selection = spec.metadata.variants;
-  if (spec.variantSets && isDictionary(selection)) {
+  if (spec.variantSets && isDictionary2(selection)) {
     for (const [setName, variantName] of Object.entries(selection)) {
       const variant = spec.variantSets[setName]?.[String(variantName)];
       if (!variant) continue;
       properties = mergeProperties(variant.properties, properties);
       children = mergePrimLists(variant.children, children);
+      for (const key of ARC_KEYS) variantArcs.push(...toArcs(variant.metadata[key]));
     }
   }
   const resolvedChildren = [];
@@ -2673,7 +3311,7 @@ async function resolvePrim(spec, parentPath, ctx) {
     children: resolvedChildren,
     line: spec.line
   };
-  const arcs = ARC_KEYS.flatMap((k) => toArcs(spec.metadata[k]));
+  const arcs = [...variantArcs, ...ARC_KEYS.flatMap((k) => toArcs(spec.metadata[k]))];
   let base = null;
   for (const arc of arcs) {
     const target = await loadReferencedPrim(arc, ctx, path);
@@ -2682,20 +3320,21 @@ async function resolvePrim(spec, parentPath, ctx) {
   return base ? mergePrim(base, local) : local;
 }
 async function loadReferencedPrim(arc, ctx, destPath) {
-  if (arc.assetPath) {
+  if (arc.assetPath?.path) {
     const composed = await loadExternalFile(
       arc,
       ctx.baseUrl,
       ctx.resolver,
       ctx.options,
       ctx.stack,
-      ctx.warn
+      ctx.warn,
+      ctx.cache
     );
     if (!composed) return null;
     const target = arc.primPath ? findPrimByPath(composed, arc.primPath) : defaultPrim(composed, ctx.warn);
     if (!target) {
       ctx.warn(
-        `reference target ${arc.primPath ?? "(defaultPrim)"} not found in ${arc.assetPath.path}`
+        `reference target ${arc.primPath ?? "(defaultPrim)"} not found in ${arc.assetPath?.path}`
       );
       return null;
     }
@@ -2721,9 +3360,10 @@ async function loadReferencedPrim(arc, ctx, destPath) {
   }
   return null;
 }
-async function loadExternalFile(arc, baseUrl, resolver, options, stack, warn) {
-  if (!arc.assetPath) return null;
-  const url = resolver.resolve(arc.assetPath.path, baseUrl);
+async function loadExternalFile(arc, baseUrl, resolver, options, stack, warn, cache) {
+  if (!arc.assetPath?.path) return null;
+  const assetPath = arc.assetPath.path;
+  const url = resolver.resolve(assetPath, baseUrl);
   if (stack.has(url)) {
     warn(`composition cycle detected at ${url}; skipping`);
     return null;
@@ -2732,18 +3372,31 @@ async function loadExternalFile(arc, baseUrl, resolver, options, stack, warn) {
     warn(`composition exceeded max depth at ${url}; skipping`);
     return null;
   }
-  let bytes;
-  try {
-    bytes = await fetchLayerBytes(resolver, url);
-  } catch (err) {
-    warn(`cannot resolve "${arc.assetPath.path}" -> ${url}: ${err.message}`);
-    return null;
-  }
-  const childStack = /* @__PURE__ */ new Set([...stack, url]);
-  if (CrateReader.isCrate(bytes)) {
-    return composeFile(crateToUsdaFile(new CrateReader(bytes)), url, resolver, options, childStack);
-  }
-  return composeLayer(new TextDecoder().decode(bytes), url, resolver, options, childStack);
+  const cached = cache.get(url);
+  if (cached) return cached;
+  const pending = (async () => {
+    let bytes;
+    try {
+      bytes = await fetchLayerBytes(resolver, url);
+    } catch (err) {
+      warn(`cannot resolve "${assetPath}" -> ${url}: ${err.message}`);
+      return null;
+    }
+    const childStack = /* @__PURE__ */ new Set([...stack, url]);
+    if (CrateReader.isCrate(bytes)) {
+      return composeFile(
+        crateToUsdaFile(new CrateReader(bytes)),
+        url,
+        resolver,
+        options,
+        childStack,
+        cache
+      );
+    }
+    return composeLayer(new TextDecoder().decode(bytes), url, resolver, options, childStack, cache);
+  })();
+  cache.set(url, pending);
+  return pending;
 }
 async function fetchLayerBytes(resolver, url) {
   if (resolver.fetchBytes) return resolver.fetchBytes(url);
@@ -2881,7 +3534,7 @@ function toArcs(value) {
   }
   return arcs;
 }
-function isDictionary(v) {
+function isDictionary2(v) {
   return typeof v === "object" && v !== null && !Array.isArray(v) && !(v instanceof Quat) && !(v instanceof UsdMatrix) && !(v instanceof AssetPath);
 }
 function stripKeys(meta, keys) {
@@ -2921,6 +3574,6 @@ function openUsdz(bytes) {
   return { rootEntry, resolver };
 }
 
-export { ARTICULATION_ROOT_API, AssetPath, Attribute, COLLISION_API, CrateReader, DEFAULT_METERS_PER_UNIT, DEG2RAD, DefaultAssetResolver, Layer, ParseError, Prim, Quat, RAD2DEG, RIGID_BODY_API, Relationship, Stage, TokenizeError, UsdMatrix, buildKinematicTree, channelFromSamples, composeFile, composeLayer, computeLocalTransform, crateToUsdaFile, createMemoryResolver, driveKindFor, extractRobotDescription, fromUsdMatrix, gatherMeshDescendants, getJointAxis, getJointBodies, getJointDrive, getJointLimits, getJointLocalFrame, getJointStatePosition, getJointType, getTranslation, hasArticulationRootAPI, hasCollisionAPI, hasRigidBodyAPI, identity4, interpolate, invert, isMesh, isScope, isXform, iterDescendants, joinPosix, jointValueToSI, makeEuler, makeRotationFromQuat, makeRotationX, makeRotationY, makeRotationZ, makeScale, makeTranslation, multiply, multiplyAll, normalizeJointLimits, openUsdz, parseOpType, parseUsda, refineJointType, tokenize };
-//# sourceMappingURL=chunk-36T6YOEX.js.map
-//# sourceMappingURL=chunk-36T6YOEX.js.map
+export { ARTICULATION_ROOT_API, AssetPath, Attribute, COLLISION_API, CrateReader, DEFAULT_METERS_PER_UNIT, DEG2RAD, DefaultAssetResolver, Layer, MASS_API, MESH_COLLISION_API, PHYSICS_MATERIAL_API, ParseError, Prim, Quat, RAD2DEG, RIGID_BODY_API, Relationship, Stage, TokenizeError, UsdMatrix, buildKinematicTree, channelFromSamples, composeFile, composeLayer, computeLocalTransform, computeWorldTransform, crateToUsdaFile, createMemoryResolver, decomposeRigid, driveKindFor, extractRobotDescription, fromUsdMatrix, gatherMeshDescendants, getJointAxis, getJointBodies, getJointDrive, getJointLimits, getJointLocalFrame, getJointStatePosition, getJointType, getMassProperties, getMaterialSubsets, getTranslation, hasArticulationRootAPI, hasCollisionAPI, hasRigidBodyAPI, identity4, interpolate, invert, isMesh, isNonVisualPurpose, isScope, isXform, iterDescendants, joinPosix, jointValueFromSI, jointValueToSI, makeEuler, makeRotationFromQuat, makeRotationX, makeRotationY, makeRotationZ, makeScale, makeTranslation, multiply, multiplyAll, normalizeJointLimits, openUsdz, parseOpType, parseUsda, refineJointType, resolveBoundMaterial, serializeUsda, toUsdMatrix, tokenize };
+//# sourceMappingURL=chunk-4GPCBXUS.js.map
+//# sourceMappingURL=chunk-4GPCBXUS.js.map