three-usd-robot 0.5.0 → 0.6.0

package/dist/{chunk-36T6YOEX.js → chunk-4MEZM763.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,208 @@ 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* 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 +519,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();
@@ -345,56 +607,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 = {};
+  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 +806,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 +925,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;
@@ -723,13 +997,23 @@ function buildLink(path, prim) {
     if (mp && (hasCollisionAPI(mp) || isNonVisualPurpose(mp))) collisionPrims.push(meshPath);
     else visualPrims.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;
@@ -1523,12 +1807,237 @@ 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)) {
+        out.push(`${pad}${INDENT}${quoteString(variantName)} {`);
+        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 +2221,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 +2284,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 +2328,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;
   }
@@ -2542,11 +3074,13 @@ function crateToUsdaFile(crate) {
 }
 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: {},
@@ -2607,10 +3141,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("/");
@@ -2654,7 +3188,7 @@ async function resolvePrim(spec, parentPath, ctx) {
   let properties = spec.properties;
   let children = spec.children;
   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;
@@ -2881,7 +3415,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 +3455,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, 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