three-usd-robot 0.6.0 → 0.8.0

package/dist/{chunk-4MEZM763.js → chunk-PHHMWMCA.js}

@@ -1,381 +1,6 @@
+import { Quat, multiply, makeTranslation, makeRotationFromQuat, identity4, invert, makeEuler, DEG2RAD, makeRotationZ, makeRotationY, makeRotationX, fromUsdMatrix, makeScale, AssetPath, RAD2DEG, UsdMatrix } from './chunk-IYKPVUZ2.js';
 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;
-function identity4() {
-  return [
-    1,
-    0,
-    0,
-    0,
-    0,
-    1,
-    0,
-    0,
-    0,
-    0,
-    1,
-    0,
-    0,
-    0,
-    0,
-    1
-  ];
-}
-function multiply(a, b) {
-  const a11 = a[0], a21 = a[1], a31 = a[2], a41 = a[3];
-  const a12 = a[4], a22 = a[5], a32 = a[6], a42 = a[7];
-  const a13 = a[8], a23 = a[9], a33 = a[10], a43 = a[11];
-  const a14 = a[12], a24 = a[13], a34 = a[14], a44 = a[15];
-  const b11 = b[0], b21 = b[1], b31 = b[2], b41 = b[3];
-  const b12 = b[4], b22 = b[5], b32 = b[6], b42 = b[7];
-  const b13 = b[8], b23 = b[9], b33 = b[10], b43 = b[11];
-  const b14 = b[12], b24 = b[13], b34 = b[14], b44 = b[15];
-  return [
-    a11 * b11 + a12 * b21 + a13 * b31 + a14 * b41,
-    a21 * b11 + a22 * b21 + a23 * b31 + a24 * b41,
-    a31 * b11 + a32 * b21 + a33 * b31 + a34 * b41,
-    a41 * b11 + a42 * b21 + a43 * b31 + a44 * b41,
-    a11 * b12 + a12 * b22 + a13 * b32 + a14 * b42,
-    a21 * b12 + a22 * b22 + a23 * b32 + a24 * b42,
-    a31 * b12 + a32 * b22 + a33 * b32 + a34 * b42,
-    a41 * b12 + a42 * b22 + a43 * b32 + a44 * b42,
-    a11 * b13 + a12 * b23 + a13 * b33 + a14 * b43,
-    a21 * b13 + a22 * b23 + a23 * b33 + a24 * b43,
-    a31 * b13 + a32 * b23 + a33 * b33 + a34 * b43,
-    a41 * b13 + a42 * b23 + a43 * b33 + a44 * b43,
-    a11 * b14 + a12 * b24 + a13 * b34 + a14 * b44,
-    a21 * b14 + a22 * b24 + a23 * b34 + a24 * b44,
-    a31 * b14 + a32 * b24 + a33 * b34 + a34 * b44,
-    a41 * b14 + a42 * b24 + a43 * b34 + a44 * b44
-  ];
-}
-function multiplyAll(matrices) {
-  let m = identity4();
-  for (const next of matrices) m = multiply(m, next);
-  return m;
-}
-function invert(m) {
-  const n11 = m[0], n21 = m[1], n31 = m[2], n41 = m[3];
-  const n12 = m[4], n22 = m[5], n32 = m[6], n42 = m[7];
-  const n13 = m[8], n23 = m[9], n33 = m[10], n43 = m[11];
-  const n14 = m[12], n24 = m[13], n34 = m[14], n44 = m[15];
-  const t11 = n23 * n34 * n42 - n24 * n33 * n42 + n24 * n32 * n43 - n22 * n34 * n43 - n23 * n32 * n44 + n22 * n33 * n44;
-  const t12 = n14 * n33 * n42 - n13 * n34 * n42 - n14 * n32 * n43 + n12 * n34 * n43 + n13 * n32 * n44 - n12 * n33 * n44;
-  const t13 = n13 * n24 * n42 - n14 * n23 * n42 + n14 * n22 * n43 - n12 * n24 * n43 - n13 * n22 * n44 + n12 * n23 * n44;
-  const t14 = n14 * n23 * n32 - n13 * n24 * n32 - n14 * n22 * n33 + n12 * n24 * n33 + n13 * n22 * n34 - n12 * n23 * n34;
-  const det = n11 * t11 + n21 * t12 + n31 * t13 + n41 * t14;
-  if (det === 0) throw new Error("cannot invert a singular matrix");
-  const idet = 1 / det;
-  return [
-    t11 * idet,
-    (n24 * n33 * n41 - n23 * n34 * n41 - n24 * n31 * n43 + n21 * n34 * n43 + n23 * n31 * n44 - n21 * n33 * n44) * idet,
-    (n22 * n34 * n41 - n24 * n32 * n41 + n24 * n31 * n42 - n21 * n34 * n42 - n22 * n31 * n44 + n21 * n32 * n44) * idet,
-    (n23 * n32 * n41 - n22 * n33 * n41 - n23 * n31 * n42 + n21 * n33 * n42 + n22 * n31 * n43 - n21 * n32 * n43) * idet,
-    t12 * idet,
-    (n13 * n34 * n41 - n14 * n33 * n41 + n14 * n31 * n43 - n11 * n34 * n43 - n13 * n31 * n44 + n11 * n33 * n44) * idet,
-    (n14 * n32 * n41 - n12 * n34 * n41 - n14 * n31 * n42 + n11 * n34 * n42 + n12 * n31 * n44 - n11 * n32 * n44) * idet,
-    (n12 * n33 * n41 - n13 * n32 * n41 + n13 * n31 * n42 - n11 * n33 * n42 - n12 * n31 * n43 + n11 * n32 * n43) * idet,
-    t13 * idet,
-    (n14 * n23 * n41 - n13 * n24 * n41 - n14 * n21 * n43 + n11 * n24 * n43 + n13 * n21 * n44 - n11 * n23 * n44) * idet,
-    (n12 * n24 * n41 - n14 * n22 * n41 + n14 * n21 * n42 - n11 * n24 * n42 - n12 * n21 * n44 + n11 * n22 * n44) * idet,
-    (n13 * n22 * n41 - n12 * n23 * n41 - n13 * n21 * n42 + n11 * n23 * n42 + n12 * n21 * n43 - n11 * n22 * n43) * idet,
-    t14 * idet,
-    (n13 * n24 * n31 - n14 * n23 * n31 + n14 * n21 * n33 - n11 * n24 * n33 - n13 * n21 * n34 + n11 * n23 * n34) * idet,
-    (n14 * n22 * n31 - n12 * n24 * n31 - n14 * n21 * n32 + n11 * n24 * n32 + n12 * n21 * n34 - n11 * n22 * n34) * idet,
-    (n12 * n23 * n31 - n13 * n22 * n31 + n13 * n21 * n32 - n11 * n23 * n32 - n12 * n21 * n33 + n11 * n22 * n33) * idet
-  ];
-}
-function makeTranslation([x, y, z]) {
-  return [
-    1,
-    0,
-    0,
-    0,
-    0,
-    1,
-    0,
-    0,
-    0,
-    0,
-    1,
-    0,
-    x,
-    y,
-    z,
-    1
-  ];
-}
-function makeScale([x, y, z]) {
-  return [
-    x,
-    0,
-    0,
-    0,
-    0,
-    y,
-    0,
-    0,
-    0,
-    0,
-    z,
-    0,
-    0,
-    0,
-    0,
-    1
-  ];
-}
-function makeRotationX(rad) {
-  const c = Math.cos(rad);
-  const s = Math.sin(rad);
-  return [
-    1,
-    0,
-    0,
-    0,
-    0,
-    c,
-    s,
-    0,
-    0,
-    -s,
-    c,
-    0,
-    0,
-    0,
-    0,
-    1
-  ];
-}
-function makeRotationY(rad) {
-  const c = Math.cos(rad);
-  const s = Math.sin(rad);
-  return [
-    c,
-    0,
-    -s,
-    0,
-    0,
-    1,
-    0,
-    0,
-    s,
-    0,
-    c,
-    0,
-    0,
-    0,
-    0,
-    1
-  ];
-}
-function makeRotationZ(rad) {
-  const c = Math.cos(rad);
-  const s = Math.sin(rad);
-  return [
-    c,
-    s,
-    0,
-    0,
-    -s,
-    c,
-    0,
-    0,
-    0,
-    0,
-    1,
-    0,
-    0,
-    0,
-    0,
-    1
-  ];
-}
-function makeRotationFromQuat(q) {
-  let x = q.imaginary[0];
-  let y = q.imaginary[1];
-  let z = q.imaginary[2];
-  let w = q.real;
-  const len = Math.hypot(x, y, z, w);
-  if (len > 0 && Math.abs(len - 1) > 1e-9) {
-    x /= len;
-    y /= len;
-    z /= len;
-    w /= len;
-  }
-  const x2 = x + x, y2 = y + y, z2 = z + z;
-  const xx = x * x2, xy = x * y2, xz = x * z2;
-  const yy = y * y2, yz = y * z2, zz = z * z2;
-  const wx = w * x2, wy = w * y2, wz = w * z2;
-  return [
-    1 - (yy + zz),
-    xy + wz,
-    xz - wy,
-    0,
-    xy - wz,
-    1 - (xx + zz),
-    yz + wx,
-    0,
-    xz + wy,
-    yz - wx,
-    1 - (xx + yy),
-    0,
-    0,
-    0,
-    0,
-    1
-  ];
-}
-function makeEuler(angles, order) {
-  const perAxis = {
-    X: makeRotationX(angles[0]),
-    Y: makeRotationY(angles[1]),
-    Z: makeRotationZ(angles[2])
-  };
-  let m = identity4();
-  for (let i = order.length - 1; i >= 0; i--) {
-    const axis = perAxis[order[i]];
-    if (!axis)
-      throw new Error(
-        `invalid euler axis ${JSON.stringify(order[i])} in order ${JSON.stringify(order)}`
-      );
-    m = multiply(m, axis);
-  }
-  return m;
-}
-function fromUsdMatrix(m) {
-  if (m.dim !== 4 || m.values.length !== 16) {
-    throw new Error(`expected a 4x4 matrix but got dim=${m.dim}, length=${m.values.length}`);
-  }
-  return [...m.values];
-}
-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";
@@ -386,6 +11,19 @@ function isScope(prim) {
 function isMesh(prim) {
   return prim.GetTypeName() === "Mesh";
 }
+var SOLID_GPRIM_TYPES = /* @__PURE__ */ new Set([
+  "Cube",
+  "Sphere",
+  "Cylinder",
+  "Capsule",
+  "Cone"
+]);
+function isSolidGprim(prim) {
+  return SOLID_GPRIM_TYPES.has(prim.GetTypeName());
+}
+function isRenderableGprim(prim) {
+  return isMesh(prim) || isSolidGprim(prim);
+}
 function getPurpose(prim) {
   const v = prim.GetAttribute("purpose").Get();
   return typeof v === "string" ? v : "default";
@@ -394,6 +32,24 @@ 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;
@@ -407,6 +63,13 @@ function gatherMeshDescendants(prim) {
   }
   return paths;
 }
+function gatherGprimDescendants(prim) {
+  const paths = [];
+  for (const d of iterDescendants(prim)) {
+    if (isRenderableGprim(d)) paths.push(d.GetPath());
+  }
+  return paths;
+}
 
 // src/schemas/usdPhysics.ts
 var JOINT_TYPE_BY_SCHEMA = {
@@ -549,9 +212,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}`);
@@ -660,7 +321,7 @@ function resolveBoundMaterial(stage, prim) {
   if (!material) return void 0;
   const shader = findSurfaceShader(material);
   if (!shader) return void 0;
-  const result = {};
+  const result = { name: material.GetName() };
   const color = firstColor(shader, DIFFUSE_INPUTS);
   if (color) result.color = color;
   const opacity = firstNumber(shader, OPACITY_INPUTS);
@@ -779,33 +440,6 @@ function firstNumber(shader, names) {
   return void 0;
 }
 
-// src/kinematics/sampling.ts
-function interpolate(channel, t) {
-  const { times, values } = channel;
-  const n = times.length;
-  if (n === 0) return 0;
-  if (t <= times[0]) return values[0];
-  if (t >= times[n - 1]) return values[n - 1];
-  let lo = 0;
-  let hi = n - 1;
-  while (lo < hi) {
-    const mid = lo + hi >> 1;
-    if (times[mid] <= t) lo = mid + 1;
-    else hi = mid;
-  }
-  const i = lo - 1;
-  const t0 = times[i];
-  const t1 = times[i + 1];
-  const span = t1 - t0;
-  const f = span > 0 ? (t - t0) / span : 0;
-  return values[i] + (values[i + 1] - values[i]) * f;
-}
-function channelFromSamples(samples) {
-  const times = [...samples.keys()].sort((a, b) => a - b);
-  const values = times.map((t) => samples.get(t) ?? 0);
-  return { times, values };
-}
-
 // src/robot/buildKinematicTree.ts
 var WORLD = "";
 function buildKinematicTree(robot, options = {}) {
@@ -992,10 +626,12 @@ function buildLink(path, prim) {
   if (!prim) return { name, primPath: path, visualPrims: [] };
   const visualPrims = [];
   const collisionPrims = [];
-  for (const meshPath of gatherMeshDescendants(prim)) {
+  for (const meshPath of gatherGprimDescendants(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);
@@ -1631,11 +1267,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 };
@@ -1845,7 +1481,13 @@ function pushPrimBody(out, properties, children, variantSets, level) {
     for (const [setName, variants] of Object.entries(variantSets)) {
       out.push(`${pad}variantSet ${quoteString(setName)} = {`);
       for (const [variantName, content] of Object.entries(variants)) {
-        out.push(`${pad}${INDENT}${quoteString(variantName)} {`);
+        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}}`);
       }
@@ -2389,6 +2031,17 @@ var Stage = class _Stage {
   }
 };
 
+// src/usd/bytes.ts
+async function toBytes(data) {
+  if (data instanceof Uint8Array) return data;
+  if (ArrayBuffer.isView(data))
+    return new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+  if (typeof data.arrayBuffer === "function") {
+    return new Uint8Array(await data.arrayBuffer());
+  }
+  return new Uint8Array(data);
+}
+
 // src/usd/crate/lz4.ts
 var MAX_CHUNK_INPUT = 2113929216;
 function lz4DecompressBlock(src, dst) {
@@ -2510,6 +2163,8 @@ var CrateType = {
   Specifier: 42,
   Permission: 43,
   Variability: 44,
+  VariantSelectionMap: 45,
+  StringVector: 50,
   PayloadListOp: 55};
 var ListOpBits = {
   HasExplicit: 1 << 1,
@@ -2865,6 +2520,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;
     }
@@ -2931,6 +2590,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);
@@ -2938,7 +2615,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 };
@@ -3020,6 +2697,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();
@@ -3034,8 +2712,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) {
@@ -3054,24 +2750,41 @@ 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")) ?? "";
@@ -3112,6 +2825,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));
@@ -3121,6 +2838,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"));
@@ -3141,10 +2863,10 @@ function asNumber2(crate, rep) {
 }
 function splitProperty(path) {
   const slash = path.lastIndexOf("/");
-  const dot2 = path.indexOf(".", slash < 0 ? 0 : slash);
-  if (dot2 === -1) return null;
+  const dot = path.indexOf(".", slash < 0 ? 0 : slash);
+  if (dot === -1) return null;
   if (path.includes("[")) return null;
-  return { primPath: path.slice(0, dot2), propName: path.slice(dot2 + 1) };
+  return { primPath: path.slice(0, dot), propName: path.slice(dot + 1) };
 }
 function parentOf(path) {
   const i = path.lastIndexOf("/");
@@ -3157,16 +2879,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 = {
@@ -3176,7 +2906,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));
@@ -3187,6 +2918,7 @@ 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 && isDictionary2(selection)) {
     for (const [setName, variantName] of Object.entries(selection)) {
@@ -3194,6 +2926,7 @@ async function resolvePrim(spec, parentPath, ctx) {
       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 = [];
@@ -3207,7 +2940,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);
@@ -3216,20 +2949,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;
     }
@@ -3255,9 +2989,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;
@@ -3266,18 +3001,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);
@@ -3426,6 +3174,12 @@ function stripKeys(meta, keys) {
   return out;
 }
 var USD_ENTRY = /\.(usda|usdc|usd)$/i;
+function isZip(bytes) {
+  if (bytes.length < 4 || bytes[0] !== 80 || bytes[1] !== 75) return false;
+  const a = bytes[2];
+  const b = bytes[3];
+  return a === 3 && b === 4 || a === 5 && b === 6 || a === 7 && b === 8;
+}
 function openUsdz(bytes) {
   const entries = unzipSync(bytes);
   const names = Object.keys(entries);
@@ -3455,6 +3209,6 @@ function openUsdz(bytes) {
   return { rootEntry, resolver };
 }
 
-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, 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-4MEZM763.js.map
-//# sourceMappingURL=chunk-4MEZM763.js.map
+export { ARTICULATION_ROOT_API, Attribute, COLLISION_API, CrateReader, DEFAULT_METERS_PER_UNIT, DefaultAssetResolver, Layer, MASS_API, MESH_COLLISION_API, PHYSICS_MATERIAL_API, ParseError, Prim, RIGID_BODY_API, Relationship, Stage, TokenizeError, buildKinematicTree, composeFile, composeLayer, computeLocalTransform, computeWorldTransform, crateToUsdaFile, createMemoryResolver, driveKindFor, extractRobotDescription, gatherGprimDescendants, gatherMeshDescendants, getJointAxis, getJointBodies, getJointDrive, getJointLimits, getJointLocalFrame, getJointStatePosition, getJointType, getMassProperties, getMaterialSubsets, hasArticulationRootAPI, hasCollisionAPI, hasRigidBodyAPI, isMesh, isNonVisualPurpose, isRenderableGprim, isScope, isSolidGprim, isXform, isZip, iterDescendants, joinPosix, jointValueFromSI, jointValueToSI, normalizeJointLimits, openUsdz, parseOpType, parseUsda, refineJointType, resolveBoundMaterial, serializeUsda, toBytes, tokenize };
+//# sourceMappingURL=chunk-PHHMWMCA.js.map
+//# sourceMappingURL=chunk-PHHMWMCA.js.map