three-usd-robot 0.4.0 → 0.6.0

package/dist/chunk-JZMCABQO.js

@@ -0,0 +1,864 @@
+import { buildKinematicTree, multiply, invert, identity4, ARTICULATION_ROOT_API, Quat, COLLISION_API, MESH_COLLISION_API, PHYSICS_MATERIAL_API, AssetPath, toUsdMatrix, driveKindFor, jointValueFromSI, decomposeRigid, resolveBoundMaterial, computeLocalTransform, RIGID_BODY_API, MASS_API } from './chunk-4MEZM763.js';
+import { strToU8, zipSync } from 'fflate';
+
+// src/version.ts
+var PACKAGE_NAME = "three-usd-robot";
+var VERSION = "0.0.0";
+
+// src/export/exportRobot.ts
+var PHYSX_ARTICULATION_API = "PhysxArticulationAPI";
+var JOINT_SCHEMA_BY_TYPE = {
+  fixed: "PhysicsFixedJoint",
+  revolute: "PhysicsRevoluteJoint",
+  continuous: "PhysicsRevoluteJoint",
+  prismatic: "PhysicsPrismaticJoint"
+};
+function exportRobotUsda(desc, options = {}) {
+  const warn = (m) => options.onWarn?.(m);
+  const tree = buildKinematicTree(desc, { onWarn: warn });
+  const robotName = sanitizeName(options.robotName ?? desc.name ?? "robot");
+  const alloc = nameAllocator(warn);
+  const linkNames = /* @__PURE__ */ new Map();
+  for (const key of Object.keys(desc.links)) linkNames.set(key, alloc(key, `link "${key}"`));
+  const jointNames = /* @__PURE__ */ new Map();
+  for (const key of Object.keys(desc.joints)) jointNames.set(key, alloc(key, `joint "${key}"`));
+  const linkPath = (key) => `/${robotName}/${linkNames.get(key)}`;
+  const authoredWorld = (key) => desc.links[key]?.worldTransform ?? identity4();
+  const worldByLink = /* @__PURE__ */ new Map();
+  for (const key of tree.order) {
+    const node = tree.nodes[key];
+    if (node.parent === null || node.jointToParent === null) {
+      const rootJoint = tree.rootJoint ? desc.joints[tree.rootJoint] : void 0;
+      worldByLink.set(
+        key,
+        rootJoint ? multiply(rootJoint.jointFrame0, invert(rootJoint.jointFrame1)) : authoredWorld(key)
+      );
+      continue;
+    }
+    const joint = desc.joints[node.jointToParent];
+    const parentWorld = worldByLink.get(node.parent) ?? identity4();
+    worldByLink.set(
+      key,
+      multiply(multiply(parentWorld, joint.jointFrame0), invert(joint.jointFrame1))
+    );
+  }
+  for (const key of tree.isolatedLinks) worldByLink.set(key, authoredWorld(key));
+  const articulationLinks = new Set(desc.articulationRoots ?? []);
+  const meshesByLink = /* @__PURE__ */ new Map();
+  const materials = /* @__PURE__ */ new Map();
+  const physicsMaterials = /* @__PURE__ */ new Map();
+  for (const [key, link] of Object.entries(desc.links)) {
+    const meshes = options.geometry?.(key, link) ?? [];
+    meshesByLink.set(key, meshes);
+    for (const mesh of meshes) {
+      if (mesh.material && !materials.has(mesh.material.name)) {
+        materials.set(mesh.material.name, mesh.material);
+      }
+      if (mesh.physicsMaterial && !physicsMaterials.has(mesh.physicsMaterial.name)) {
+        physicsMaterials.set(mesh.physicsMaterial.name, mesh.physicsMaterial);
+      }
+    }
+  }
+  const looksName = materials.size > 0 ? alloc("Looks") : void 0;
+  const materialAlloc = nameAllocator();
+  const materialNames = /* @__PURE__ */ new Map();
+  for (const name of materials.keys()) materialNames.set(name, materialAlloc(name));
+  const materialPath = (name) => looksName ? `/${robotName}/${looksName}/${materialNames.get(name)}` : void 0;
+  const physicsScopeName = physicsMaterials.size > 0 ? alloc("PhysicsMaterials") : void 0;
+  const physicsMaterialAlloc = nameAllocator();
+  const physicsMaterialNames = /* @__PURE__ */ new Map();
+  for (const name of physicsMaterials.keys()) {
+    physicsMaterialNames.set(name, physicsMaterialAlloc(name));
+  }
+  const physicsMaterialPath = (name) => physicsScopeName ? `/${robotName}/${physicsScopeName}/${physicsMaterialNames.get(name)}` : void 0;
+  const isaac = options.isaacRobotSchema === true;
+  const children = [];
+  for (const [key, link] of Object.entries(desc.links)) {
+    const apiSchemas = [RIGID_BODY_API];
+    if (articulationLinks.has(key)) apiSchemas.push(ARTICULATION_ROOT_API);
+    if (link.inertial) apiSchemas.push(MASS_API);
+    if (isaac) apiSchemas.push("IsaacLinkAPI");
+    const selfCollision = articulationLinks.has(key) ? options.enabledSelfCollisions : void 0;
+    if (selfCollision !== void 0) apiSchemas.push(PHYSX_ARTICULATION_API);
+    children.push(
+      buildLinkPrim({
+        name: linkNames.get(key),
+        world: worldByLink.get(key) ?? identity4(),
+        apiSchemas,
+        meshes: meshesByLink.get(key) ?? [],
+        materialPath,
+        physicsMaterialPath,
+        warn,
+        ...link.inertial ? { inertial: link.inertial } : {},
+        ...selfCollision !== void 0 ? { selfCollision } : {}
+      })
+    );
+  }
+  const emittedJoints = /* @__PURE__ */ new Set();
+  for (const [key, joint] of Object.entries(desc.joints)) {
+    if (!desc.links[joint.child] || joint.parent !== "" && !desc.links[joint.parent]) {
+      warn(`joint "${key}" references an unknown link; skipped`);
+      continue;
+    }
+    emittedJoints.add(key);
+    children.push(buildJointPrim(jointNames.get(key), key, joint, linkPath, isaac, warn));
+  }
+  if (looksName) {
+    children.push(buildLooksPrim(looksName, materials, materialNames, materialPath));
+  }
+  if (physicsScopeName) {
+    children.push(
+      buildPhysicsMaterialsPrim(physicsScopeName, physicsMaterials, physicsMaterialNames)
+    );
+  }
+  const rootApiSchemas = [];
+  const rootProperties = [];
+  if (articulationLinks.size === 0) {
+    rootApiSchemas.push(ARTICULATION_ROOT_API);
+    if (options.enabledSelfCollisions !== void 0) {
+      rootApiSchemas.push(PHYSX_ARTICULATION_API);
+      rootProperties.push(
+        attr("physxArticulation:enabledSelfCollisions", "bool", options.enabledSelfCollisions)
+      );
+    }
+  }
+  if (isaac) {
+    rootApiSchemas.push("IsaacRobotAPI");
+    const orderedLinks = [...tree.order, ...tree.isolatedLinks];
+    const orderedJoints = [];
+    const pushJoint = (key) => {
+      if (key && emittedJoints.has(key) && !orderedJoints.includes(key)) orderedJoints.push(key);
+    };
+    pushJoint(tree.rootJoint);
+    for (const linkKey of tree.order) pushJoint(tree.nodes[linkKey]?.jointToParent);
+    for (const jointKey of tree.loopJoints) pushJoint(jointKey);
+    for (const jointKey of Object.keys(desc.joints)) pushJoint(jointKey);
+    rootProperties.push(rel("isaac:physics:robotLinks", orderedLinks.map(linkPath)));
+    rootProperties.push(
+      rel(
+        "isaac:physics:robotJoints",
+        orderedJoints.map((key) => `/${robotName}/${jointNames.get(key)}`)
+      )
+    );
+  }
+  const root = {
+    specifier: "def",
+    typeName: "Xform",
+    name: robotName,
+    metadata: rootApiSchemas.length > 0 ? { apiSchemas: rootApiSchemas } : {},
+    properties: rootProperties,
+    children,
+    line: 0
+  };
+  const metadata = {
+    defaultPrim: robotName,
+    metersPerUnit: desc.metersPerUnit,
+    upAxis: desc.upAxis,
+    ...desc.timeCodesPerSecond !== void 0 ? { timeCodesPerSecond: desc.timeCodesPerSecond } : {},
+    ...desc.startTimeCode !== void 0 ? { startTimeCode: desc.startTimeCode } : {},
+    ...desc.endTimeCode !== void 0 ? { endTimeCode: desc.endTimeCode } : {}
+  };
+  return { version: "1.0", metadata, prims: [root] };
+}
+function buildLinkPrim(args) {
+  const meshAlloc = nameAllocator();
+  const properties = transformProps(args.world);
+  if (args.inertial) properties.push(...massProps(args.inertial, args.name, args.warn));
+  if (args.selfCollision !== void 0) {
+    properties.push(attr("physxArticulation:enabledSelfCollisions", "bool", args.selfCollision));
+  }
+  return {
+    specifier: "def",
+    typeName: "Xform",
+    name: args.name,
+    metadata: { apiSchemas: args.apiSchemas },
+    properties,
+    children: args.meshes.map(
+      (mesh) => buildMeshPrim(mesh, meshAlloc(mesh.name), args.materialPath, args.physicsMaterialPath)
+    ),
+    line: 0
+  };
+}
+function massProps(inertial, linkName, warn) {
+  const out = [];
+  if (inertial.mass !== void 0) out.push(attr("physics:mass", "float", inertial.mass));
+  if (inertial.density !== void 0) out.push(attr("physics:density", "float", inertial.density));
+  if (inertial.centerOfMass) {
+    out.push(attr("physics:centerOfMass", "point3f", inertial.centerOfMass));
+  }
+  if (inertial.diagonalInertia) {
+    out.push(attr("physics:diagonalInertia", "float3", inertial.diagonalInertia));
+    out.push(attr("physics:principalAxes", "quatf", inertial.principalAxes ?? Quat.identity()));
+  } else if (inertial.principalAxes) {
+    warn(`link "${linkName}": principalAxes without diagonalInertia is meaningless; dropped`);
+  }
+  return out;
+}
+function buildMeshPrim(mesh, name, materialPath, physicsMaterialPath) {
+  const properties = [];
+  if (mesh.transform) properties.push(...transformProps(mesh.transform));
+  properties.push(
+    arrayAttr("faceVertexCounts", "int", mesh.faceVertexCounts),
+    arrayAttr("faceVertexIndices", "int", mesh.faceVertexIndices),
+    arrayAttr("points", "point3f", mesh.points)
+  );
+  if (mesh.normals) properties.push(arrayAttr("normals", "normal3f", mesh.normals));
+  if (mesh.st) {
+    properties.push(arrayAttr("primvars:st", "texCoord2f", mesh.st, { interpolation: "vertex" }));
+  }
+  if (mesh.displayColor) {
+    properties.push(arrayAttr("primvars:displayColor", "color3f", [mesh.displayColor]));
+  }
+  if (mesh.doubleSided) properties.push(attr("doubleSided", "bool", true));
+  properties.push(uniformToken("subdivisionScheme", "none"));
+  const apiSchemas = [];
+  if (mesh.kind === "collision") {
+    apiSchemas.push(COLLISION_API);
+    properties.push(uniformToken("purpose", "guide"));
+    if (mesh.collisionApproximation) {
+      apiSchemas.push(MESH_COLLISION_API);
+      properties.push(uniformToken("physics:approximation", mesh.collisionApproximation));
+    }
+  }
+  const binding = mesh.material ? materialPath(mesh.material.name) : void 0;
+  if (binding) properties.push(rel("material:binding", [binding]));
+  const physicsBinding = mesh.kind === "collision" && mesh.physicsMaterial ? physicsMaterialPath(mesh.physicsMaterial.name) : void 0;
+  if (physicsBinding) properties.push(rel("material:binding:physics", [physicsBinding]));
+  if (binding || physicsBinding) apiSchemas.push("MaterialBindingAPI");
+  return {
+    specifier: "def",
+    typeName: "Mesh",
+    name,
+    metadata: apiSchemas.length > 0 ? { apiSchemas } : {},
+    properties,
+    children: [],
+    line: 0
+  };
+}
+function buildPhysicsMaterialsPrim(scopeName, materials, names) {
+  const children = [];
+  for (const [key, material] of materials) {
+    children.push(buildPhysicsMaterialPrim(names.get(key), material));
+  }
+  return {
+    specifier: "def",
+    typeName: "Scope",
+    name: scopeName,
+    metadata: {},
+    properties: [],
+    children,
+    line: 0
+  };
+}
+function buildPhysicsMaterialPrim(name, material) {
+  const properties = [];
+  if (material.staticFriction !== void 0) {
+    properties.push(attr("physics:staticFriction", "float", material.staticFriction));
+  }
+  if (material.dynamicFriction !== void 0) {
+    properties.push(attr("physics:dynamicFriction", "float", material.dynamicFriction));
+  }
+  if (material.restitution !== void 0) {
+    properties.push(attr("physics:restitution", "float", material.restitution));
+  }
+  if (material.density !== void 0) {
+    properties.push(attr("physics:density", "float", material.density));
+  }
+  return {
+    specifier: "def",
+    typeName: "Material",
+    name,
+    metadata: { apiSchemas: [PHYSICS_MATERIAL_API] },
+    properties,
+    children: [],
+    line: 0
+  };
+}
+function buildLooksPrim(looksName, materials, materialNames, materialPath) {
+  const children = [];
+  for (const [key, material] of materials) {
+    children.push(buildMaterialPrim(materialNames.get(key), material, materialPath(key)));
+  }
+  return {
+    specifier: "def",
+    typeName: "Scope",
+    name: looksName,
+    metadata: {},
+    properties: [],
+    children,
+    line: 0
+  };
+}
+var TEXTURE_WIRING = {
+  color: {
+    input: "inputs:diffuseColor",
+    inputType: "color3f",
+    output: "outputs:rgb",
+    outputType: "float3",
+    colorSpace: "sRGB"
+  },
+  emissive: {
+    input: "inputs:emissiveColor",
+    inputType: "color3f",
+    output: "outputs:rgb",
+    outputType: "float3",
+    colorSpace: "sRGB"
+  },
+  normal: {
+    input: "inputs:normal",
+    inputType: "normal3f",
+    output: "outputs:rgb",
+    outputType: "float3",
+    colorSpace: "raw"
+  },
+  opacity: {
+    input: "inputs:opacity",
+    inputType: "float",
+    output: "outputs:a",
+    outputType: "float",
+    colorSpace: "raw"
+  },
+  roughness: {
+    input: "inputs:roughness",
+    inputType: "float",
+    output: "outputs:r",
+    outputType: "float",
+    colorSpace: "raw"
+  },
+  metalness: {
+    input: "inputs:metallic",
+    inputType: "float",
+    output: "outputs:r",
+    outputType: "float",
+    colorSpace: "raw"
+  },
+  occlusion: {
+    input: "inputs:occlusion",
+    inputType: "float",
+    output: "outputs:r",
+    outputType: "float",
+    colorSpace: "raw"
+  }
+};
+function buildMaterialPrim(name, material, selfPath) {
+  const textures = material.textures ?? {};
+  const shaderProps = [uniformToken("info:id", "UsdPreviewSurface")];
+  const input = (channel, value) => {
+    const wiring = TEXTURE_WIRING[channel];
+    const texturePath = textures[channel];
+    if (value === void 0 && texturePath === void 0) return;
+    const spec = attr(wiring.input, wiring.inputType, value);
+    if (texturePath !== void 0) {
+      spec.connections = [`${selfPath}/${channel}Texture.${wiring.output}`];
+    }
+    shaderProps.push(spec);
+  };
+  input("color", material.diffuseColor);
+  input("metalness", material.metallic);
+  input("roughness", material.roughness);
+  input("opacity", material.opacity);
+  input("emissive", material.emissiveColor);
+  input("normal");
+  input("occlusion");
+  shaderProps.push(attr("outputs:surface", "token", void 0));
+  const children = [shaderPrim("PreviewSurface", shaderProps)];
+  const textureEntries = Object.entries(textures);
+  if (textureEntries.length > 0) {
+    children.push(
+      shaderPrim("stReader", [
+        uniformToken("info:id", "UsdPrimvarReader_float2"),
+        attr("inputs:varname", "string", "st"),
+        attr("outputs:result", "float2", void 0)
+      ])
+    );
+    for (const [channel, path] of textureEntries) {
+      children.push(buildUvTexturePrim(channel, path, selfPath));
+    }
+  }
+  const surfaceConnect = attr("outputs:surface", "token", void 0);
+  surfaceConnect.connections = [`${selfPath}/PreviewSurface.outputs:surface`];
+  return {
+    specifier: "def",
+    typeName: "Material",
+    name,
+    metadata: {},
+    properties: [surfaceConnect],
+    children,
+    line: 0
+  };
+}
+function buildUvTexturePrim(channel, path, selfPath) {
+  const wiring = TEXTURE_WIRING[channel];
+  const st = attr("inputs:st", "float2", void 0);
+  st.connections = [`${selfPath}/stReader.outputs:result`];
+  return shaderPrim(`${channel}Texture`, [
+    uniformToken("info:id", "UsdUVTexture"),
+    attr("inputs:file", "asset", new AssetPath(path)),
+    uniformToken("inputs:sourceColorSpace", wiring.colorSpace),
+    st,
+    attr(wiring.output, wiring.outputType, void 0)
+  ]);
+}
+function shaderPrim(name, properties) {
+  return {
+    specifier: "def",
+    typeName: "Shader",
+    name,
+    metadata: {},
+    properties,
+    children: [],
+    line: 0
+  };
+}
+function transformProps(m) {
+  return [
+    attr("xformOp:transform", "matrix4d", toUsdMatrix(m)),
+    arrayAttr("xformOpOrder", "token", ["xformOp:transform"], void 0, "uniform")
+  ];
+}
+function buildJointPrim(name, key, joint, linkPath, isaac, warn) {
+  const kind = driveKindFor(joint.type);
+  const angular = kind === "angular";
+  const properties = [];
+  const apiSchemas = [];
+  if (joint.parent !== "") properties.push(rel("physics:body0", [linkPath(joint.parent)]));
+  properties.push(rel("physics:body1", [linkPath(joint.child)]));
+  if (joint.type !== "fixed") properties.push(uniformToken("physics:axis", joint.axis));
+  if (joint.lower !== void 0) {
+    properties.push(attr("physics:lowerLimit", "float", jointValueFromSI(angular, joint.lower)));
+  }
+  if (joint.upper !== void 0) {
+    properties.push(attr("physics:upperLimit", "float", jointValueFromSI(angular, joint.upper)));
+  }
+  for (const index of [0, 1]) {
+    const frame = index === 0 ? joint.jointFrame0 : joint.jointFrame1;
+    const { position, orientation, rigid } = decomposeRigid(frame);
+    if (!rigid) {
+      warn(`joint "${key}": jointFrame${index} is not rigid; scale/shear was discarded`);
+    }
+    properties.push(attr(`physics:localPos${index}`, "point3f", position));
+    properties.push(attr(`physics:localRot${index}`, "quatf", orientation));
+  }
+  if (joint.initialValue !== void 0 || joint.valueSamples) {
+    const state = attr(
+      `state:${kind}:physics:position`,
+      "float",
+      joint.initialValue !== void 0 ? jointValueFromSI(angular, joint.initialValue) : void 0
+    );
+    if (joint.valueSamples) {
+      state.timeSamples = new Map(
+        joint.valueSamples.times.map((t, i) => [
+          t,
+          jointValueFromSI(angular, joint.valueSamples.values[i] ?? 0)
+        ])
+      );
+    }
+    properties.push(state);
+    apiSchemas.push(`PhysicsJointStateAPI:${kind}`);
+  }
+  if (joint.drive) {
+    const d = joint.drive;
+    if (d.targetPosition !== void 0) {
+      properties.push(
+        attr(
+          `drive:${kind}:physics:targetPosition`,
+          "float",
+          jointValueFromSI(angular, d.targetPosition)
+        )
+      );
+    }
+    if (d.stiffness !== void 0) {
+      properties.push(attr(`drive:${kind}:physics:stiffness`, "float", d.stiffness));
+    }
+    if (d.damping !== void 0) {
+      properties.push(attr(`drive:${kind}:physics:damping`, "float", d.damping));
+    }
+    if (d.maxForce !== void 0) {
+      properties.push(attr(`drive:${kind}:physics:maxForce`, "float", d.maxForce));
+    }
+    apiSchemas.push(`PhysicsDriveAPI:${kind}`);
+  }
+  if (isaac) {
+    apiSchemas.push("IsaacJointAPI");
+    if (joint.type !== "fixed") {
+      const prefix = joint.type === "prismatic" ? "Trans" : "Rot";
+      properties.push(
+        arrayAttr("isaac:physics:DofOffsetOpOrder", "token", [`${prefix}${joint.axis}`])
+      );
+    }
+  }
+  return {
+    specifier: "def",
+    typeName: JOINT_SCHEMA_BY_TYPE[joint.type],
+    name,
+    metadata: apiSchemas.length > 0 ? { apiSchemas } : {},
+    properties,
+    children: [],
+    line: 0
+  };
+}
+function sanitizeName(raw) {
+  const cleaned = raw.replace(/[^A-Za-z0-9_]/g, "_");
+  const named = cleaned.length > 0 ? cleaned : "_";
+  return /^[0-9]/.test(named) ? `_${named}` : named;
+}
+function nameAllocator(warn) {
+  const used = /* @__PURE__ */ new Set();
+  return (raw, label) => {
+    let name = sanitizeName(raw);
+    for (let i = 2; used.has(name); i++) name = `${sanitizeName(raw)}_${i}`;
+    used.add(name);
+    if (name !== raw && label && warn) warn(`${label} exported as prim "${name}"`);
+    return name;
+  };
+}
+function attr(name, typeName, value, metadata = {}) {
+  return {
+    kind: "attribute",
+    name,
+    typeName,
+    isArray: false,
+    variability: "varying",
+    custom: false,
+    ...value !== void 0 ? { value } : {},
+    metadata,
+    line: 0
+  };
+}
+function arrayAttr(name, typeName, value, metadata = {}, variability = "varying") {
+  return {
+    kind: "attribute",
+    name,
+    typeName,
+    isArray: true,
+    variability,
+    custom: false,
+    value,
+    metadata,
+    line: 0
+  };
+}
+function uniformToken(name, value) {
+  return {
+    kind: "attribute",
+    name,
+    typeName: "token",
+    isArray: false,
+    variability: "uniform",
+    custom: false,
+    value,
+    metadata: {},
+    line: 0
+  };
+}
+function rel(name, targets) {
+  return {
+    kind: "relationship",
+    name,
+    custom: false,
+    listOp: "explicit",
+    targets,
+    metadata: {},
+    line: 0
+  };
+}
+
+// src/export/GeometryProvider.ts
+function stageGeometryProvider(stage) {
+  return (_linkKey, link) => {
+    const linkPrim = stage.GetPrimAtPath(link.primPath);
+    if (!linkPrim) return [];
+    const collisionSet = new Set(link.collisionPrims ?? []);
+    const out = [];
+    for (const path of link.visualPrims) {
+      if (collisionSet.has(path)) continue;
+      const mesh = readMesh(stage, linkPrim, path, "visual");
+      if (mesh) out.push(mesh);
+    }
+    for (const path of link.collisionPrims ?? []) {
+      const mesh = readMesh(stage, linkPrim, path, "collision");
+      if (mesh) out.push(mesh);
+    }
+    return out;
+  };
+}
+function readMesh(stage, linkPrim, meshPath, kind) {
+  const prim = stage.GetPrimAtPath(meshPath);
+  if (!prim) return null;
+  const points = prim.GetAttribute("points").Get();
+  if (!isVec3Array(points) || points.length === 0) return null;
+  const counts = prim.GetAttribute("faceVertexCounts").Get();
+  const indices = prim.GetAttribute("faceVertexIndices").Get();
+  const normals = prim.GetAttribute("normals").Get();
+  const st = prim.GetAttribute("primvars:st").Get();
+  const displayColor = prim.GetAttribute("primvars:displayColor").Get();
+  const mesh = {
+    name: prim.GetName(),
+    kind,
+    points: points.slice(),
+    faceVertexCounts: isNumberArray(counts) ? counts.slice() : [],
+    faceVertexIndices: isNumberArray(indices) ? indices.slice() : []
+  };
+  if (isVec3Array(normals) && normals.length === points.length) mesh.normals = normals.slice();
+  if (isVec2Array(st) && st.length === points.length) mesh.st = st.slice();
+  if (isVec3Array(displayColor) && displayColor[0]) mesh.displayColor = displayColor[0];
+  if (prim.GetAttribute("doubleSided").Get() === true) mesh.doubleSided = true;
+  const transform = relativeTransform(linkPrim, prim);
+  if (!isIdentity(transform)) mesh.transform = transform;
+  const material = readBoundMaterial(stage, prim);
+  if (material) mesh.material = material;
+  if (kind === "collision") {
+    const approximation = prim.GetAttribute("physics:approximation").Get();
+    if (typeof approximation === "string" && APPROXIMATIONS.has(approximation)) {
+      mesh.collisionApproximation = approximation;
+    }
+    const physicsMaterial = readBoundPhysicsMaterial(stage, prim);
+    if (physicsMaterial) mesh.physicsMaterial = physicsMaterial;
+  }
+  return mesh;
+}
+var APPROXIMATIONS = /* @__PURE__ */ new Set([
+  "none",
+  "convexHull",
+  "convexDecomposition",
+  "boundingSphere",
+  "boundingCube",
+  "meshSimplification"
+]);
+function readBoundPhysicsMaterial(stage, prim) {
+  const target = firstBindingTarget(prim, "material:binding:physics");
+  if (!target) return void 0;
+  const materialPrim = stage.GetPrimAtPath(target);
+  if (!materialPrim) return void 0;
+  const out = {
+    name: target.split("/").filter(Boolean).pop() ?? "PhysicsMaterial"
+  };
+  const read = (attr2) => {
+    const v = materialPrim.GetAttribute(attr2).Get();
+    return typeof v === "number" ? v : void 0;
+  };
+  const staticFriction = read("physics:staticFriction");
+  if (staticFriction !== void 0) out.staticFriction = staticFriction;
+  const dynamicFriction = read("physics:dynamicFriction");
+  if (dynamicFriction !== void 0) out.dynamicFriction = dynamicFriction;
+  const restitution = read("physics:restitution");
+  if (restitution !== void 0) out.restitution = restitution;
+  const density = read("physics:density");
+  if (density !== void 0) out.density = density;
+  return Object.keys(out).length > 1 ? out : void 0;
+}
+function firstBindingTarget(prim, relName) {
+  let p = prim;
+  while (p) {
+    const targets = p.GetRelationship(relName).GetTargets();
+    if (targets.length > 0) return targets[0];
+    p = p.GetParent();
+  }
+  return void 0;
+}
+function readBoundMaterial(stage, prim) {
+  const bound = resolveBoundMaterial(stage, prim);
+  if (!bound) return void 0;
+  const material = { name: boundMaterialName(prim) ?? "Material" };
+  if (bound.color) material.diffuseColor = bound.color;
+  if (bound.metalness !== void 0) material.metallic = bound.metalness;
+  if (bound.roughness !== void 0) material.roughness = bound.roughness;
+  if (bound.opacity !== void 0) material.opacity = bound.opacity;
+  if (bound.emissiveColor) material.emissiveColor = bound.emissiveColor;
+  const textures = {};
+  if (bound.colorTexture) textures.color = bound.colorTexture.path;
+  if (bound.opacityTexture) textures.opacity = bound.opacityTexture.path;
+  if (bound.normalTexture) textures.normal = bound.normalTexture.path;
+  if (bound.roughnessTexture) textures.roughness = bound.roughnessTexture.path;
+  if (bound.metalnessTexture) textures.metalness = bound.metalnessTexture.path;
+  if (bound.occlusionTexture) textures.occlusion = bound.occlusionTexture.path;
+  if (bound.emissiveTexture) textures.emissive = bound.emissiveTexture.path;
+  if (Object.keys(textures).length > 0) material.textures = textures;
+  return Object.keys(material).length > 1 ? material : void 0;
+}
+function boundMaterialName(prim) {
+  let p = prim;
+  while (p) {
+    const targets = p.GetRelationship("material:binding").GetTargets();
+    if (targets.length > 0) return targets[0].split("/").filter(Boolean).pop();
+    p = p.GetParent();
+  }
+  return void 0;
+}
+function relativeTransform(linkPrim, meshPrim) {
+  const chain = [];
+  let p = meshPrim;
+  const stop = linkPrim.GetPath();
+  while (p && p.GetPath() !== stop) {
+    chain.push(p);
+    p = p.GetParent();
+  }
+  chain.reverse();
+  let m = identity4();
+  for (const prim of chain) {
+    m = multiply(m, computeLocalTransform(prim).matrix);
+  }
+  return m;
+}
+function isIdentity(m) {
+  for (let i = 0; i < 16; i++) {
+    if (m[i] !== (i % 5 === 0 ? 1 : 0)) return false;
+  }
+  return true;
+}
+function isNumberArray(v) {
+  return Array.isArray(v) && v.every((n) => typeof n === "number");
+}
+function isVec3Array(v) {
+  return Array.isArray(v) && v.every((e) => Array.isArray(e) && e.length === 3);
+}
+function isVec2Array(v) {
+  return Array.isArray(v) && v.every((e) => Array.isArray(e) && e.length === 2);
+}
+var USD_ENTRY = /\.(usda|usdc|usd)$/i;
+var PAD_EXTRA_ID = 12345;
+var LOCAL_HEADER_SIZE = 30;
+var EXTRA_HEADER_SIZE = 4;
+function writeUsdz(entries) {
+  const names = Object.keys(entries);
+  const root = names.find((n) => USD_ENTRY.test(n));
+  if (!root) {
+    throw new Error("writeUsdz: entries must include a root USD layer (.usda/.usdc/.usd)");
+  }
+  const ordered = [root, ...names.filter((n) => n !== root)];
+  const files = {};
+  let offset = 0;
+  for (const name of ordered) {
+    const raw = entries[name];
+    const data = typeof raw === "string" ? strToU8(raw) : raw;
+    const nameLength = strToU8(name).length;
+    const dataStart = offset + LOCAL_HEADER_SIZE + nameLength;
+    if ((dataStart & 63) === 0) {
+      files[name] = data;
+      offset = dataStart + data.length;
+    } else {
+      const padLength = 64 - (dataStart + EXTRA_HEADER_SIZE & 63) & 63;
+      files[name] = [data, { extra: { [PAD_EXTRA_ID]: new Uint8Array(padLength) } }];
+      offset = dataStart + EXTRA_HEADER_SIZE + padLength + data.length;
+    }
+  }
+  return zipSync(files, { level: 0 });
+}
+
+// src/robot/RobotValidator.ts
+function validateRobotDescription(desc, options = {}) {
+  const issues = [];
+  const add = (severity, code, message, subject) => issues.push({ severity, code, message, ...subject !== void 0 ? { subject } : {} });
+  if (Object.keys(desc.links).length === 0) {
+    add("error", "no-links", "robot has no links");
+  }
+  for (const [key, joint] of Object.entries(desc.joints)) {
+    if (joint.parent !== "" && !desc.links[joint.parent]) {
+      add(
+        "error",
+        "unknown-link",
+        `joint "${key}" references unknown parent "${joint.parent}"`,
+        key
+      );
+    }
+    if (!desc.links[joint.child]) {
+      add("error", "unknown-link", `joint "${key}" references unknown child "${joint.child}"`, key);
+    }
+    if (joint.lower !== void 0 && joint.upper !== void 0 && joint.lower > joint.upper) {
+      add(
+        "error",
+        "invalid-limits",
+        `joint "${key}" lower limit ${joint.lower} exceeds upper ${joint.upper}`,
+        key
+      );
+    }
+    if (joint.initialValue !== void 0 && (joint.lower !== void 0 && joint.initialValue < joint.lower || joint.upper !== void 0 && joint.initialValue > joint.upper)) {
+      add(
+        "warning",
+        "initial-out-of-limits",
+        `joint "${key}" initial value ${joint.initialValue} is outside its limits`,
+        key
+      );
+    }
+    const frames = [
+      ["jointFrame0", joint.jointFrame0],
+      ["jointFrame1", joint.jointFrame1]
+    ];
+    for (const [label, frame] of frames) {
+      if (!decomposeRigid(frame).rigid) {
+        add(
+          "warning",
+          "non-rigid-frame",
+          `joint "${key}" ${label} carries scale/shear/reflection (discarded on export)`,
+          key
+        );
+      }
+    }
+  }
+  const tree = buildKinematicTree(desc);
+  for (const jointKey of tree.loopJoints) {
+    add(
+      "warning",
+      "closed-loop",
+      `joint "${jointKey}" closes a kinematic loop (dropped from the spanning tree)`,
+      jointKey
+    );
+  }
+  for (const linkKey of tree.isolatedLinks) {
+    add(
+      "warning",
+      "isolated-link",
+      `link "${linkKey}" is unreachable from root "${tree.root}"`,
+      linkKey
+    );
+  }
+  if ((desc.articulationRoots ?? []).length === 0 && !tree.rootJoint) {
+    add(
+      "warning",
+      "no-articulation-root",
+      "no ArticulationRootAPI link and no world-fixed joint \u2014 the base will float"
+    );
+  }
+  for (const [key, link] of Object.entries(desc.links)) {
+    const inertial = link.inertial;
+    if (!inertial || inertial.mass === void 0 && inertial.density === void 0) {
+      add("warning", "no-inertial", `link "${key}" has no mass or density (PhysicsMassAPI)`, key);
+    }
+    if (inertial?.mass !== void 0 && inertial.mass <= 0) {
+      add("error", "bad-mass", `link "${key}" has non-positive mass ${inertial.mass}`, key);
+    }
+    if (inertial?.diagonalInertia?.some((v) => v < 0)) {
+      add("error", "bad-inertia", `link "${key}" has a negative diagonal-inertia component`, key);
+    }
+    if (inertial?.principalAxes && !inertial.diagonalInertia) {
+      add(
+        "warning",
+        "inertia-pairing",
+        `link "${key}" authors principalAxes without diagonalInertia (dropped on export)`,
+        key
+      );
+    }
+    if (options.geometry) {
+      const meshes = options.geometry(key, link);
+      const collisions = meshes.filter((mesh) => mesh.kind === "collision");
+      if (collisions.length === 0) {
+        add("warning", "no-collision", `link "${key}" has no collision geometry`, key);
+      }
+      for (const mesh of collisions) {
+        if (!mesh.collisionApproximation) {
+          add(
+            "warning",
+            "collision-approximation",
+            `link "${key}" collision mesh "${mesh.name}" has no physics:approximation (PhysX dynamic bodies need a convex or primitive approximation)`,
+            key
+          );
+        }
+      }
+    }
+  }
+  return issues.sort((a, b) => a.severity === b.severity ? 0 : a.severity === "error" ? -1 : 1);
+}
+
+export { PACKAGE_NAME, VERSION, exportRobotUsda, stageGeometryProvider, validateRobotDescription, writeUsdz };
+//# sourceMappingURL=chunk-JZMCABQO.js.map
+//# sourceMappingURL=chunk-JZMCABQO.js.map