three-usd-robot 0.2.0

package/dist/chunk-XCP5GZPY.js

@@ -0,0 +1,2685 @@
+import { unzipSync } from 'fflate';
+
+// src/version.ts
+var PACKAGE_NAME = "three-usd-robot";
+var VERSION = "0.0.0";
+
+// 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/parser/reader.ts
+var ParseError = class extends Error {
+  constructor(message, line, col) {
+    super(`USDA parse error (line ${line}:${col}): ${message}`);
+    this.line = line;
+    this.col = col;
+    this.name = "ParseError";
+  }
+  line;
+  col;
+};
+var TokenReader = class {
+  constructor(tokens) {
+    this.tokens = tokens;
+  }
+  tokens;
+  pos = 0;
+  peek(ahead = 0) {
+    return this.tokens[Math.min(this.pos + ahead, this.tokens.length - 1)];
+  }
+  next() {
+    const t = this.tokens[this.pos];
+    if (this.pos < this.tokens.length - 1) this.pos++;
+    return t;
+  }
+  atEnd() {
+    return this.peek().type === "eof";
+  }
+  is(type, ahead = 0) {
+    return this.peek(ahead).type === type;
+  }
+  /** True when the lookahead token is an identifier with the given text. */
+  isIdent(value, ahead = 0) {
+    const t = this.peek(ahead);
+    return t.type === "ident" && t.value === value;
+  }
+  expect(type) {
+    const t = this.peek();
+    if (t.type !== type) {
+      throw new ParseError(
+        `expected ${type} but found ${t.type} ${JSON.stringify(t.value)}`,
+        t.line,
+        t.col
+      );
+    }
+    return this.next();
+  }
+  /** Consume an identifier token (any value) and return its text. */
+  expectIdent() {
+    return this.expect("ident").value;
+  }
+  /** Consume the given token type if present; return whether it was consumed. */
+  accept(type) {
+    if (this.is(type)) {
+      this.next();
+      return true;
+    }
+    return false;
+  }
+  /** Consume an identifier with the exact text if present. */
+  acceptIdent(value) {
+    if (this.isIdent(value)) {
+      this.next();
+      return true;
+    }
+    return false;
+  }
+  error(message) {
+    const t = this.peek();
+    return new ParseError(message, t.line, t.col);
+  }
+};
+
+// src/parser/tokenize.ts
+var TokenizeError = class extends Error {
+  constructor(message, line, col) {
+    super(`USDA tokenize error (line ${line}:${col}): ${message}`);
+    this.line = line;
+    this.col = col;
+    this.name = "TokenizeError";
+  }
+  line;
+  col;
+};
+var IDENT_START = /[A-Za-z_]/;
+var IDENT_CONT = /[A-Za-z0-9_:]/;
+var NUMBER_RE = /^[-+]?(?:\d+\.?\d*|\.\d+)(?:[eE][-+]?\d+)?/;
+var INF_NAN_RE = /^[-+]?(?:inf|nan)\b/i;
+function tokenize(src) {
+  const tokens = [];
+  let i = 0;
+  let line = 1;
+  let lineStart = 0;
+  const n = src.length;
+  const col = () => i - lineStart + 1;
+  const push = (type, value, startCol, num) => {
+    tokens.push(
+      num === void 0 ? { type, value, line, col: startCol } : { type, value, num, line, col: startCol }
+    );
+  };
+  while (i < n) {
+    const c = src[i];
+    if (c === "\n") {
+      i++;
+      line++;
+      lineStart = i;
+      continue;
+    }
+    if (c === " " || c === "	" || c === "\r" || c === "\f" || c === "\v") {
+      i++;
+      continue;
+    }
+    if (c === "#") {
+      while (i < n && src[i] !== "\n") i++;
+      continue;
+    }
+    const startCol = col();
+    const punct = PUNCT[c];
+    if (punct) {
+      push(punct, c, startCol);
+      i++;
+      continue;
+    }
+    if (c === '"' && src[i + 1] === '"' && src[i + 2] === '"') {
+      const { value, advanced } = readTripleString(src, i, line, startCol);
+      push("string", value, startCol);
+      i = advanced;
+      continue;
+    }
+    if (c === '"' || c === "'") {
+      const { value, advanced } = readString(src, i, c, line, startCol);
+      push("string", value, startCol);
+      i = advanced;
+      continue;
+    }
+    if (c === "@") {
+      const triple = src[i + 1] === "@" && src[i + 2] === "@";
+      const { value, advanced } = readAsset(src, i, triple, line, startCol);
+      push("asset", value, startCol);
+      i = advanced;
+      continue;
+    }
+    if (c === "<") {
+      const { value, advanced } = readPath(src, i, line, startCol);
+      push("path", value, startCol);
+      i = advanced;
+      continue;
+    }
+    const infMatch = INF_NAN_RE.exec(src.slice(i));
+    if (infMatch) {
+      const text = infMatch[0];
+      const lower = text.toLowerCase();
+      const num = lower.includes("nan") ? Number.NaN : lower.startsWith("-") ? Number.NEGATIVE_INFINITY : Number.POSITIVE_INFINITY;
+      push("number", text, startCol, num);
+      i += text.length;
+      continue;
+    }
+    if (/[0-9]/.test(c) || (c === "-" || c === "+" || c === ".") && /[0-9.]/.test(src[i + 1] ?? "")) {
+      const m = NUMBER_RE.exec(src.slice(i));
+      if (m) {
+        const text = m[0];
+        push("number", text, startCol, Number(text));
+        i += text.length;
+        continue;
+      }
+    }
+    if (c === ".") {
+      push("dot", ".", startCol);
+      i++;
+      continue;
+    }
+    if (IDENT_START.test(c)) {
+      const start = i;
+      i++;
+      while (i < n && IDENT_CONT.test(src[i])) i++;
+      push("ident", src.slice(start, i), startCol);
+      continue;
+    }
+    throw new TokenizeError(`unexpected character ${JSON.stringify(c)}`, line, startCol);
+  }
+  tokens.push({ type: "eof", value: "", line, col: col() });
+  return tokens;
+}
+var PUNCT = {
+  "{": "lbrace",
+  "}": "rbrace",
+  "(": "lparen",
+  ")": "rparen",
+  "[": "lbracket",
+  "]": "rbracket",
+  "=": "equals",
+  ",": "comma",
+  ":": "colon"
+};
+function readString(src, start, quote, line, startCol) {
+  let i = start + 1;
+  let out = "";
+  while (i < src.length) {
+    const ch = src[i];
+    if (ch === "\\") {
+      const next = src[i + 1];
+      out += ESCAPES[next ?? ""] ?? next ?? "";
+      i += 2;
+      continue;
+    }
+    if (ch === quote) {
+      return { value: out, advanced: i + 1 };
+    }
+    if (ch === "\n") break;
+    out += ch;
+    i++;
+  }
+  throw new TokenizeError("unterminated string literal", line, startCol);
+}
+function readTripleString(src, start, line, startCol) {
+  let i = start + 3;
+  let out = "";
+  while (i < src.length) {
+    if (src[i] === '"' && src[i + 1] === '"' && src[i + 2] === '"') {
+      return { value: out, advanced: i + 3 };
+    }
+    out += src[i];
+    i++;
+  }
+  throw new TokenizeError("unterminated triple-quoted string", line, startCol);
+}
+function readAsset(src, start, triple, line, startCol) {
+  const delimLen = triple ? 3 : 1;
+  let i = start + delimLen;
+  let out = "";
+  while (i < src.length) {
+    if (triple) {
+      if (src[i] === "@" && src[i + 1] === "@" && src[i + 2] === "@") {
+        return { value: out, advanced: i + 3 };
+      }
+    } else if (src[i] === "@") {
+      return { value: out, advanced: i + 1 };
+    }
+    if (src[i] === "\n") break;
+    out += src[i];
+    i++;
+  }
+  throw new TokenizeError("unterminated asset path", line, startCol);
+}
+function readPath(src, start, line, startCol) {
+  let i = start + 1;
+  let out = "";
+  while (i < src.length) {
+    if (src[i] === ">") {
+      return { value: out, advanced: i + 1 };
+    }
+    if (src[i] === "\n") break;
+    out += src[i];
+    i++;
+  }
+  throw new TokenizeError("unterminated path <...>", line, startCol);
+}
+var ESCAPES = {
+  n: "\n",
+  t: "	",
+  r: "\r",
+  '"': '"',
+  "'": "'",
+  "\\": "\\"
+};
+
+// src/parser/valueParser.ts
+function parseLiteral(r) {
+  const t = r.peek();
+  switch (t.type) {
+    case "number":
+      r.next();
+      return { t: "scalar", v: t.num ?? Number(t.value) };
+    case "string":
+      r.next();
+      return { t: "scalar", v: t.value };
+    case "asset":
+      r.next();
+      return { t: "asset", v: new AssetPath(t.value) };
+    case "path":
+      r.next();
+      return { t: "path", v: t.value };
+    case "ident": {
+      r.next();
+      if (t.value === "true") return { t: "scalar", v: true };
+      if (t.value === "false") return { t: "scalar", v: false };
+      if (t.value === "None" || t.value === "none") return { t: "scalar", v: null };
+      return { t: "scalar", v: t.value };
+    }
+    case "lparen":
+      return parseGroup(r, "lparen", "rparen", "tuple");
+    case "lbracket":
+      return parseGroup(r, "lbracket", "rbracket", "array");
+    default:
+      throw r.error(`unexpected token ${t.type} ${JSON.stringify(t.value)} while parsing a value`);
+  }
+}
+function parseGroup(r, open, close, kind) {
+  r.expect(open);
+  const items = [];
+  while (!r.is(close) && !r.atEnd()) {
+    items.push(parseLiteral(r));
+    if (!r.accept("comma")) break;
+  }
+  r.expect(close);
+  return { t: kind, items };
+}
+function parseTypedValue(r, typeName, isArray) {
+  return coerceValue(typeName, isArray, parseLiteral(r));
+}
+function coerceValue(typeName, isArray, raw) {
+  if (raw.t === "scalar" && raw.v === null) return null;
+  if (isArray) {
+    if (raw.t !== "array") {
+      throw new TypeError(`expected an array literal for ${typeName}[] but got ${raw.t}`);
+    }
+    return raw.items.map((item) => coerceScalar(typeName, item));
+  }
+  return coerceScalar(typeName, raw);
+}
+function coerceScalar(typeName, raw) {
+  if (QUAT_TYPES.has(typeName)) {
+    const nums = expectNumberTuple(raw, 4, typeName);
+    return new Quat(nums[0], [nums[1], nums[2], nums[3]]);
+  }
+  if (typeName === "matrix4d" || typeName === "matrix4f" || typeName === "frame4d") {
+    return flattenMatrix(raw, 4, typeName);
+  }
+  if (typeName === "matrix3d" || typeName === "matrix3f") {
+    return flattenMatrix(raw, 3, typeName);
+  }
+  const dim = VEC_DIM[typeName];
+  if (dim !== void 0) {
+    const nums = expectNumberTuple(raw, dim, typeName);
+    return nums;
+  }
+  if (typeName === "asset") {
+    if (raw.t === "asset") return raw.v;
+    if (raw.t === "scalar" && typeof raw.v === "string") return new AssetPath(raw.v);
+    throw new TypeError(`expected an asset path for ${typeName}`);
+  }
+  if (raw.t === "path") return raw.v;
+  if (raw.t !== "scalar") {
+    if (raw.t === "tuple") return raw.items.map((it) => coerceScalar(typeName, it));
+    throw new TypeError(`expected a scalar for ${typeName} but got ${raw.t}`);
+  }
+  const v = raw.v;
+  if (typeName === "bool") {
+    if (typeof v === "boolean") return v;
+    if (v === 1 || v === 0) return v === 1;
+  }
+  return v;
+}
+function expectNumberTuple(raw, dim, typeName) {
+  if (raw.t !== "tuple") {
+    throw new TypeError(`expected a ${dim}-tuple for ${typeName} but got ${raw.t}`);
+  }
+  if (raw.items.length !== dim) {
+    throw new TypeError(`expected ${dim} components for ${typeName} but got ${raw.items.length}`);
+  }
+  return raw.items.map((it) => {
+    if (it.t !== "scalar" || typeof it.v !== "number") {
+      throw new TypeError(`expected a number component for ${typeName}`);
+    }
+    return it.v;
+  });
+}
+function flattenMatrix(raw, dim, typeName) {
+  if (raw.t !== "tuple" || raw.items.length !== dim) {
+    throw new TypeError(`expected ${dim} rows for ${typeName}`);
+  }
+  const values = [];
+  for (const row of raw.items) {
+    values.push(...expectNumberTuple(row, dim, typeName));
+  }
+  return new UsdMatrix(values, dim);
+}
+function rawToUsdValue(raw) {
+  switch (raw.t) {
+    case "scalar":
+      return raw.v;
+    case "asset":
+      return raw.v;
+    case "path":
+      return raw.v;
+    case "tuple":
+    case "array":
+      return raw.items.map(rawToUsdValue);
+  }
+}
+var QUAT_TYPES = /* @__PURE__ */ new Set(["quatf", "quatd", "quath"]);
+var VEC_DIM = {
+  float2: 2,
+  double2: 2,
+  half2: 2,
+  int2: 2,
+  texCoord2f: 2,
+  texCoord2d: 2,
+  texCoord2h: 2,
+  float3: 3,
+  double3: 3,
+  half3: 3,
+  int3: 3,
+  point3f: 3,
+  point3d: 3,
+  point3h: 3,
+  normal3f: 3,
+  normal3d: 3,
+  normal3h: 3,
+  vector3f: 3,
+  vector3d: 3,
+  vector3h: 3,
+  color3f: 3,
+  color3d: 3,
+  color3h: 3,
+  texCoord3f: 3,
+  float4: 4,
+  double4: 4,
+  half4: 4,
+  int4: 4,
+  color4f: 4,
+  color4d: 4,
+  color4h: 4
+};
+
+// src/parser/parseUsda.ts
+var SPECIFIERS = /* @__PURE__ */ new Set(["def", "over", "class"]);
+var LIST_OPS = /* @__PURE__ */ new Set(["prepend", "append", "add", "delete", "reorder"]);
+var MAGIC_RE = /^\s*#usda\s+(\S+)/;
+function parseUsda(text) {
+  const magic = MAGIC_RE.exec(text);
+  const version = magic?.[1] ?? "1.0";
+  const r = new TokenReader(tokenize(text));
+  const metadata = r.is("lparen") ? parseMetadataBlock(r) : {};
+  const prims = [];
+  while (!r.atEnd()) {
+    prims.push(parsePrim(r));
+  }
+  return { version, metadata, prims };
+}
+function parsePrim(r) {
+  const head = r.peek();
+  const specifier = r.expectIdent();
+  if (!SPECIFIERS.has(specifier)) {
+    throw r.error(
+      `expected a prim specifier (def/over/class) but found ${JSON.stringify(specifier)}`
+    );
+  }
+  let typeName = "";
+  if (r.is("ident")) typeName = r.expectIdent();
+  const name = r.expect("string").value;
+  const metadata = r.is("lparen") ? parseMetadataBlock(r) : {};
+  const properties = [];
+  const children = [];
+  r.expect("lbrace");
+  while (!r.is("rbrace") && !r.atEnd()) {
+    if (r.is("ident") && SPECIFIERS.has(r.peek().value)) {
+      children.push(parsePrim(r));
+    } else {
+      properties.push(parseProperty(r));
+    }
+  }
+  r.expect("rbrace");
+  return {
+    specifier,
+    typeName,
+    name,
+    metadata,
+    properties,
+    children,
+    line: head.line
+  };
+}
+function parseProperty(r) {
+  const line = r.peek().line;
+  let custom = false;
+  let variability = "varying";
+  let listOp = "explicit";
+  for (; ; ) {
+    if (r.acceptIdent("custom")) {
+      custom = true;
+    } else if (r.acceptIdent("uniform")) {
+      variability = "uniform";
+    } else if (r.acceptIdent("varying")) {
+      variability = "varying";
+    } else if (r.is("ident") && LIST_OPS.has(r.peek().value)) {
+      listOp = r.expectIdent();
+    } else {
+      break;
+    }
+  }
+  if (r.isIdent("rel")) {
+    r.next();
+    return parseRelationship(r, custom, listOp, line);
+  }
+  return parseAttribute(r, custom, variability, line);
+}
+function parseAttribute(r, custom, variability, line) {
+  const typeName = r.expectIdent();
+  let isArray = false;
+  if (r.accept("lbracket")) {
+    r.expect("rbracket");
+    isArray = true;
+  }
+  const name = r.expectIdent();
+  const attr = {
+    kind: "attribute",
+    name,
+    typeName,
+    isArray,
+    variability,
+    custom,
+    metadata: {},
+    line
+  };
+  if (r.accept("dot")) {
+    const suffix = r.expectIdent();
+    r.expect("equals");
+    if (suffix === "connect") {
+      attr.connections = parseTargetList(r);
+    } else if (suffix === "timeSamples") {
+      attr.timeSamples = parseTimeSamples(r, typeName, isArray);
+    } else {
+      throw r.error(`unsupported attribute qualifier .${suffix}`);
+    }
+  } else if (r.accept("equals")) {
+    if (r.is("lbrace")) {
+      attr.timeSamples = parseTimeSamples(r, typeName, isArray);
+    } else {
+      attr.value = parseTypedValue(r, typeName, isArray);
+    }
+  }
+  if (r.is("lparen")) attr.metadata = parseMetadataBlock(r);
+  return attr;
+}
+function parseRelationship(r, custom, listOp, line) {
+  const name = r.expectIdent();
+  let targets = [];
+  if (r.accept("equals")) {
+    targets = parseTargetList(r);
+  }
+  const metadata = r.is("lparen") ? parseMetadataBlock(r) : {};
+  return { kind: "relationship", name, custom, listOp, targets, metadata, line };
+}
+function parseTargetList(r) {
+  if (r.acceptIdent("None") || r.acceptIdent("none")) return [];
+  if (r.is("path")) return [r.next().value];
+  if (r.accept("lbracket")) {
+    const targets = [];
+    while (!r.is("rbracket") && !r.atEnd()) {
+      targets.push(r.expect("path").value);
+      if (!r.accept("comma")) break;
+    }
+    r.expect("rbracket");
+    return targets;
+  }
+  throw r.error("expected a relationship/connection target path");
+}
+function parseTimeSamples(r, typeName, isArray) {
+  r.expect("lbrace");
+  const samples = /* @__PURE__ */ new Map();
+  while (!r.is("rbrace") && !r.atEnd()) {
+    const time = r.expect("number").num ?? Number(r.peek().value);
+    r.expect("colon");
+    samples.set(time, parseTypedValue(r, typeName, isArray));
+    if (!r.accept("comma")) break;
+  }
+  r.expect("rbrace");
+  return samples;
+}
+function parseMetadataBlock(r) {
+  r.expect("lparen");
+  const meta = {};
+  while (!r.is("rparen") && !r.atEnd()) {
+    if (r.is("string") && !r.is("equals", 1)) {
+      meta.doc = r.next().value;
+      continue;
+    }
+    if (r.is("ident") && LIST_OPS.has(r.peek().value)) r.next();
+    const key = r.expectIdent();
+    r.expect("equals");
+    meta[key] = parseMetadataValue(r);
+  }
+  r.expect("rparen");
+  return meta;
+}
+function parseMetadataValue(r) {
+  if (r.is("lbrace")) return parseDictionary(r);
+  if (r.is("lbracket")) return parseMetadataList(r);
+  const raw = parseLiteral(r);
+  if (raw.t === "asset" && r.is("path")) {
+    const arc = { assetPath: raw.v, primPath: r.next().value };
+    return arc;
+  }
+  if (raw.t === "asset") {
+    return raw.v;
+  }
+  return rawToUsdValue(raw);
+}
+function parseMetadataList(r) {
+  r.expect("lbracket");
+  const items = [];
+  while (!r.is("rbracket") && !r.atEnd()) {
+    if (r.is("asset")) {
+      const assetPath = new AssetPath(r.next().value);
+      if (r.is("path")) {
+        const arc = { assetPath, primPath: r.next().value };
+        items.push(arc);
+      } else {
+        items.push(assetPath);
+      }
+    } else {
+      items.push(rawToUsdValue(parseLiteral(r)));
+    }
+    if (!r.accept("comma")) break;
+  }
+  r.expect("rbracket");
+  return items;
+}
+function parseDictionary(r) {
+  r.expect("lbrace");
+  const dict = {};
+  while (!r.is("rbrace") && !r.atEnd()) {
+    r.expectIdent();
+    if (r.accept("lbracket")) r.expect("rbracket");
+    const key = r.is("string") ? r.next().value : r.expectIdent();
+    r.expect("equals");
+    dict[key] = parseMetadataValue(r);
+  }
+  r.expect("rbrace");
+  return dict;
+}
+
+// src/usd/names.ts
+function splitName(name) {
+  const idx = name.lastIndexOf(":");
+  if (idx === -1) return { namespace: "", baseName: name };
+  return { namespace: name.slice(0, idx), baseName: name.slice(idx + 1) };
+}
+
+// src/usd/Attribute.ts
+var Attribute = class {
+  constructor(_prim, _name, _spec) {
+    this._prim = _prim;
+    this._name = _name;
+    this._spec = _spec;
+  }
+  _prim;
+  _name;
+  _spec;
+  IsValid() {
+    return this._spec !== null;
+  }
+  GetPrim() {
+    return this._prim;
+  }
+  GetName() {
+    return this._name;
+  }
+  GetBaseName() {
+    return splitName(this._name).baseName;
+  }
+  GetNamespace() {
+    return splitName(this._name).namespace;
+  }
+  /** Scalar type name (without the `[]` suffix); pair with {@link IsArray}. */
+  GetTypeName() {
+    return this._spec?.typeName ?? "";
+  }
+  IsArray() {
+    return this._spec?.isArray ?? false;
+  }
+  GetVariability() {
+    return this._spec?.variability ?? "varying";
+  }
+  IsCustom() {
+    return this._spec?.custom ?? false;
+  }
+  /** True if a default value or any time sample is authored. */
+  HasValue() {
+    return this.HasAuthoredValue();
+  }
+  HasAuthoredValue() {
+    if (!this._spec) return false;
+    return this._spec.value !== void 0 || (this._spec.timeSamples?.size ?? 0) > 0;
+  }
+  /**
+   * Resolve the attribute value. With no `time`, returns the default value (or
+   * the earliest time sample if only samples are authored). With a `time`,
+   * returns the exact sample if present, else the default, else the earliest
+   * sample. Returns `undefined` when nothing is authored.
+   */
+  Get(time) {
+    const spec = this._spec;
+    if (!spec) return void 0;
+    if (time !== void 0 && spec.timeSamples?.has(time)) {
+      return spec.timeSamples.get(time);
+    }
+    if (spec.value !== void 0) return spec.value;
+    if (spec.timeSamples && spec.timeSamples.size > 0) {
+      const firstKey = [...spec.timeSamples.keys()].sort((a, b) => a - b)[0];
+      return spec.timeSamples.get(firstKey);
+    }
+    return void 0;
+  }
+  GetTimeSamples() {
+    return this._spec?.timeSamples ?? /* @__PURE__ */ new Map();
+  }
+  GetConnections() {
+    return this._spec?.connections ?? [];
+  }
+};
+var Relationship = class {
+  constructor(_prim, _name, _spec) {
+    this._prim = _prim;
+    this._name = _name;
+    this._spec = _spec;
+  }
+  _prim;
+  _name;
+  _spec;
+  IsValid() {
+    return this._spec !== null;
+  }
+  GetPrim() {
+    return this._prim;
+  }
+  GetName() {
+    return this._name;
+  }
+  GetBaseName() {
+    return splitName(this._name).baseName;
+  }
+  GetNamespace() {
+    return splitName(this._name).namespace;
+  }
+  IsCustom() {
+    return this._spec?.custom ?? false;
+  }
+  GetTargets() {
+    return this._spec?.targets ?? [];
+  }
+};
+
+// src/usd/Layer.ts
+var Layer = class {
+  constructor(_file) {
+    this._file = _file;
+  }
+  _file;
+  GetVersion() {
+    return this._file.version;
+  }
+  GetPseudoRootMetadata() {
+    return this._file.metadata;
+  }
+  GetMetadata(key) {
+    return this._file.metadata[key];
+  }
+  GetDefaultPrimName() {
+    const v = this._file.metadata.defaultPrim;
+    return typeof v === "string" ? v : void 0;
+  }
+  GetRootPrimSpecs() {
+    return this._file.prims;
+  }
+};
+
+// src/usd/Prim.ts
+var Prim = class {
+  constructor(_stage, _spec, _path, _parent) {
+    this._stage = _stage;
+    this._spec = _spec;
+    this._path = _path;
+    this._parent = _parent;
+  }
+  _stage;
+  _spec;
+  _path;
+  _parent;
+  _children = [];
+  _attributes;
+  _relationships;
+  /** @internal Used by {@link Stage} while building the prim tree. */
+  _addChild(child) {
+    this._children.push(child);
+  }
+  GetStage() {
+    return this._stage;
+  }
+  IsValid() {
+    return true;
+  }
+  IsPseudoRoot() {
+    return this._spec === null;
+  }
+  GetName() {
+    return this._spec?.name ?? "";
+  }
+  GetPath() {
+    return this._path;
+  }
+  GetTypeName() {
+    return this._spec?.typeName ?? "";
+  }
+  GetSpecifier() {
+    return this._spec?.specifier ?? null;
+  }
+  GetParent() {
+    return this._parent;
+  }
+  GetChildren() {
+    return this._children;
+  }
+  GetChild(name) {
+    return this._children.find((c) => c.GetName() === name) ?? null;
+  }
+  // -- Attributes ----------------------------------------------------------
+  attrMap() {
+    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);
+      }
+    }
+    return this._attributes;
+  }
+  /** Always returns an Attribute; check {@link Attribute.IsValid}. */
+  GetAttribute(name) {
+    return new Attribute(this, name, this.attrMap().get(name) ?? null);
+  }
+  HasAttribute(name) {
+    return this.attrMap().has(name);
+  }
+  GetAttributes() {
+    return [...this.attrMap().values()].map((spec) => new Attribute(this, spec.name, spec));
+  }
+  // -- Relationships -------------------------------------------------------
+  relMap() {
+    if (!this._relationships) {
+      this._relationships = /* @__PURE__ */ new Map();
+      for (const p of this._spec?.properties ?? []) {
+        if (p.kind === "relationship") this._relationships.set(p.name, p);
+      }
+    }
+    return this._relationships;
+  }
+  /** Always returns a Relationship; check {@link Relationship.IsValid}. */
+  GetRelationship(name) {
+    return new Relationship(this, name, this.relMap().get(name) ?? null);
+  }
+  HasRelationship(name) {
+    return this.relMap().has(name);
+  }
+  GetRelationships() {
+    return [...this.relMap().values()].map((spec) => new Relationship(this, spec.name, spec));
+  }
+  // -- Metadata / schemas --------------------------------------------------
+  GetMetadata(key) {
+    return this._spec?.metadata[key];
+  }
+  GetAllMetadata() {
+    return this._spec?.metadata ?? {};
+  }
+  /** Applied API schema names from `apiSchemas` (e.g. `PhysicsArticulationRootAPI`). */
+  GetAppliedSchemas() {
+    const raw = this._spec?.metadata.apiSchemas;
+    if (!Array.isArray(raw)) return [];
+    const out = [];
+    for (const v of raw) {
+      if (typeof v === "string") out.push(v);
+    }
+    return out;
+  }
+  /**
+   * Whether the given API schema is applied. Matches the bare schema name as
+   * well as multi-apply instances (e.g. `HasAPI("PhysicsDriveAPI")` is true for
+   * an applied `PhysicsDriveAPI:angular`).
+   */
+  HasAPI(schemaName) {
+    return this.GetAppliedSchemas().some((s) => s === schemaName || s.startsWith(`${schemaName}:`));
+  }
+};
+
+// src/usd/Stage.ts
+var DEFAULT_METERS_PER_UNIT = 0.01;
+var Stage = class _Stage {
+  _layer;
+  _byPath = /* @__PURE__ */ new Map();
+  _pseudoRoot;
+  constructor(file) {
+    this._layer = new Layer(file);
+    this._pseudoRoot = new Prim(this, null, "/", null);
+    this._byPath.set("/", this._pseudoRoot);
+    for (const spec of file.prims) this.buildPrim(spec, this._pseudoRoot);
+  }
+  /** Parse and open a stage from USDA source text. */
+  static OpenFromString(usda) {
+    return new _Stage(parseUsda(usda));
+  }
+  /** Open a stage from an already-parsed layer. */
+  static OpenFromFile(file) {
+    return new _Stage(file);
+  }
+  buildPrim(spec, parent) {
+    const path = parent.IsPseudoRoot() ? `/${spec.name}` : `${parent.GetPath()}/${spec.name}`;
+    const prim = new Prim(this, spec, path, parent);
+    this._byPath.set(path, prim);
+    parent._addChild(prim);
+    for (const child of spec.children) this.buildPrim(child, prim);
+  }
+  GetRootLayer() {
+    return this._layer;
+  }
+  GetPseudoRoot() {
+    return this._pseudoRoot;
+  }
+  /** Returns the prim at the absolute path, or `null` if none exists. */
+  GetPrimAtPath(path) {
+    return this._byPath.get(path) ?? null;
+  }
+  /** The stage's default prim (from layer `defaultPrim` metadata), if any. */
+  GetDefaultPrim() {
+    const name = this._layer.GetDefaultPrimName();
+    return name ? this.GetPrimAtPath(`/${name}`) : null;
+  }
+  /** Depth-first traversal of all prims (excludes the pseudo-root). */
+  Traverse() {
+    const out = [];
+    const visit = (prim) => {
+      for (const child of prim.GetChildren()) {
+        out.push(child);
+        visit(child);
+      }
+    };
+    visit(this._pseudoRoot);
+    return out;
+  }
+  GetMetadata(key) {
+    return this._layer.GetMetadata(key);
+  }
+  /** Stage up axis (`upAxis` metadata); defaults to `"Y"` per OpenUSD. */
+  GetUpAxis() {
+    return this._layer.GetMetadata("upAxis") === "Z" ? "Z" : "Y";
+  }
+  /** Stage linear unit (`metersPerUnit` metadata); defaults to {@link DEFAULT_METERS_PER_UNIT}. */
+  GetMetersPerUnit() {
+    const v = this._layer.GetMetadata("metersPerUnit");
+    return typeof v === "number" ? v : DEFAULT_METERS_PER_UNIT;
+  }
+};
+
+// src/usd/AssetResolver.ts
+var DefaultAssetResolver = class {
+  resolve(assetPath, baseUrl) {
+    try {
+      return new URL(assetPath, baseUrl || void 0).href;
+    } catch {
+      return joinPosix(baseUrl, assetPath);
+    }
+  }
+  async fetchText(url) {
+    const res = await fetch(url);
+    if (!res.ok) throw new Error(`${res.status} ${res.statusText}`);
+    return res.text();
+  }
+  async fetchBytes(url) {
+    const res = await fetch(url);
+    if (!res.ok) throw new Error(`${res.status} ${res.statusText}`);
+    return new Uint8Array(await res.arrayBuffer());
+  }
+};
+function createMemoryResolver(files) {
+  return {
+    resolve(assetPath, baseUrl) {
+      return joinPosix(baseUrl, assetPath);
+    },
+    fetchText(url) {
+      const text = files[url];
+      if (text === void 0) return Promise.reject(new Error(`asset not found: ${url}`));
+      return Promise.resolve(text);
+    }
+  };
+}
+function joinPosix(baseUrl, rel) {
+  if (rel.startsWith("/")) return normalizePosix(rel);
+  const dir = baseUrl.slice(0, baseUrl.lastIndexOf("/") + 1);
+  return normalizePosix(dir + rel);
+}
+function normalizePosix(path) {
+  const isAbsolute = path.startsWith("/");
+  const out = [];
+  for (const part of path.split("/")) {
+    if (part === "" || part === ".") continue;
+    if (part === "..") out.pop();
+    else out.push(part);
+  }
+  return (isAbsolute ? "/" : "") + out.join("/");
+}
+
+// src/usd/composition.ts
+var ARC_KEYS = ["references", "payload", "payloads"];
+async function composeLayer(text, baseUrl, resolver, options = {}, stack = /* @__PURE__ */ new Set()) {
+  const warn = options.onWarn ?? (() => {
+  });
+  const file = parseUsda(text);
+  let weak = [];
+  const subLayers = toArcs(file.metadata.subLayers);
+  for (let i = subLayers.length - 1; i >= 0; i--) {
+    const sub = await loadComposedFile(subLayers[i], baseUrl, resolver, options, stack, warn);
+    if (sub) weak = mergePrimLists(weak, sub.prims);
+  }
+  const resolved = [];
+  for (const prim of file.prims) {
+    resolved.push(await resolvePrimArcs(prim, baseUrl, resolver, options, stack, warn));
+  }
+  const prims = weak.length > 0 ? mergePrimLists(weak, resolved) : resolved;
+  return { version: file.version, metadata: stripKeys(file.metadata, ["subLayers"]), prims };
+}
+async function resolvePrimArcs(spec, baseUrl, resolver, options, stack, warn) {
+  const children = [];
+  for (const child of spec.children) {
+    children.push(await resolvePrimArcs(child, baseUrl, resolver, options, stack, warn));
+  }
+  const local = { ...spec, children, metadata: stripKeys(spec.metadata, ARC_KEYS) };
+  const arcs = ARC_KEYS.flatMap((k) => toArcs(spec.metadata[k]));
+  if (arcs.length === 0) return local;
+  let base = null;
+  for (const arc of arcs) {
+    const target = await loadReferencedPrim(arc, baseUrl, resolver, options, stack, warn);
+    if (!target) continue;
+    base = base ? mergePrim(target, base) : target;
+  }
+  return base ? mergePrim(base, local) : local;
+}
+async function loadReferencedPrim(arc, baseUrl, resolver, options, stack, warn) {
+  if (!arc.assetPath) {
+    warn(`internal references (no asset path) are not supported yet: <${arc.primPath ?? "?"}>`);
+    return null;
+  }
+  const composed = await loadComposedFile(arc, baseUrl, resolver, options, stack, warn);
+  if (!composed) return null;
+  const target = arc.primPath ? findPrimByPath(composed, arc.primPath) : defaultPrim(composed, warn);
+  if (!target) {
+    warn(`reference target ${arc.primPath ?? "(defaultPrim)"} not found in ${arc.assetPath.path}`);
+    return null;
+  }
+  return target;
+}
+async function loadComposedFile(arc, baseUrl, resolver, options, stack, warn) {
+  if (!arc.assetPath) return null;
+  const url = resolver.resolve(arc.assetPath.path, baseUrl);
+  if (stack.has(url)) {
+    warn(`composition cycle detected at ${url}; skipping`);
+    return null;
+  }
+  if (stack.size >= (options.maxDepth ?? 64)) {
+    warn(`composition exceeded max depth at ${url}; skipping`);
+    return null;
+  }
+  let text;
+  try {
+    text = await resolver.fetchText(url);
+  } catch (err) {
+    warn(`cannot resolve "${arc.assetPath.path}" -> ${url}: ${err.message}`);
+    return null;
+  }
+  return composeLayer(text, url, resolver, options, /* @__PURE__ */ new Set([...stack, url]));
+}
+function mergePrim(base, over) {
+  return {
+    // `over` (def) wins; a pure `over` opinion keeps the base's specifier.
+    specifier: over.specifier === "over" ? base.specifier : over.specifier,
+    typeName: over.typeName || base.typeName,
+    name: over.name,
+    metadata: mergeMetadata(base.metadata, over.metadata),
+    properties: mergeProperties(base.properties, over.properties),
+    children: mergePrimLists(base.children, over.children),
+    line: over.line
+  };
+}
+function mergePrimLists(base, over) {
+  const byName = /* @__PURE__ */ new Map();
+  for (const p of base) byName.set(p.name, p);
+  for (const p of over) {
+    const existing = byName.get(p.name);
+    byName.set(p.name, existing ? mergePrim(existing, p) : p);
+  }
+  return [...byName.values()];
+}
+function mergeProperties(base, over) {
+  const byName = /* @__PURE__ */ new Map();
+  for (const p of base) byName.set(p.name, p);
+  for (const p of over) {
+    const existing = byName.get(p.name);
+    byName.set(p.name, existing ? mergeProperty(existing, p) : p);
+  }
+  return [...byName.values()];
+}
+function mergeProperty(base, over) {
+  if (base.kind !== over.kind) return over;
+  if (base.kind === "attribute" && over.kind === "attribute") {
+    const merged = {
+      ...over,
+      typeName: over.typeName || base.typeName,
+      metadata: mergeMetadata(base.metadata, over.metadata)
+    };
+    const value = over.value !== void 0 ? over.value : base.value;
+    if (value !== void 0) merged.value = value;
+    const timeSamples = over.timeSamples ?? base.timeSamples;
+    if (timeSamples) merged.timeSamples = timeSamples;
+    const connections = over.connections ?? base.connections;
+    if (connections) merged.connections = connections;
+    return merged;
+  }
+  if (base.kind === "relationship" && over.kind === "relationship") {
+    return {
+      ...over,
+      targets: over.targets.length > 0 ? over.targets : base.targets,
+      metadata: mergeMetadata(base.metadata, over.metadata)
+    };
+  }
+  return over;
+}
+function mergeMetadata(base, over) {
+  const merged = { ...base, ...over };
+  const a = base.apiSchemas;
+  const b = over.apiSchemas;
+  if (Array.isArray(a) || Array.isArray(b)) {
+    const seen = /* @__PURE__ */ new Set();
+    const union = [];
+    for (const v of [...Array.isArray(a) ? a : [], ...Array.isArray(b) ? b : []]) {
+      if (!seen.has(v)) {
+        seen.add(v);
+        union.push(v);
+      }
+    }
+    merged.apiSchemas = union;
+  }
+  return merged;
+}
+function findPrimByPath(file, path) {
+  const segments = path.split("/").filter(Boolean);
+  let level = file.prims;
+  let found = null;
+  for (const seg of segments) {
+    found = level.find((p) => p.name === seg) ?? null;
+    if (!found) return null;
+    level = found.children;
+  }
+  return found;
+}
+function defaultPrim(file, warn) {
+  const name = file.metadata.defaultPrim;
+  if (typeof name === "string") {
+    return file.prims.find((p) => p.name === name) ?? null;
+  }
+  const first = file.prims[0];
+  if (first) warn(`referenced layer has no defaultPrim; using first root prim "${first.name}"`);
+  return first ?? null;
+}
+function toArcs(value) {
+  if (value === void 0) return [];
+  const list = Array.isArray(value) ? value : [value];
+  const arcs = [];
+  for (const v of list) {
+    if (v instanceof AssetPath) arcs.push({ assetPath: v });
+    else if (v && typeof v === "object" && "assetPath" in v) arcs.push(v);
+  }
+  return arcs;
+}
+function stripKeys(meta, keys) {
+  const out = {};
+  for (const [k, v] of Object.entries(meta)) {
+    if (!keys.includes(k)) out[k] = v;
+  }
+  return out;
+}
+var USD_ENTRY = /\.(usda|usdc|usd)$/i;
+function openUsdz(bytes) {
+  const entries = unzipSync(bytes);
+  const names = Object.keys(entries);
+  const rootEntry = names.find((n) => USD_ENTRY.test(n)) ?? names[0];
+  if (!rootEntry) throw new Error("usdz package contains no entries");
+  const decoder = new TextDecoder();
+  const resolver = {
+    resolve(assetPath, baseUrl) {
+      return joinPosix(baseUrl, assetPath);
+    },
+    fetchText(url) {
+      const data = entries[url] ?? entries[url.replace(/^\/+/, "")];
+      if (!data) return Promise.reject(new Error(`not found in usdz: ${url}`));
+      if (/\.usdc$/i.test(url)) {
+        return Promise.reject(
+          new Error(`USDC (binary crate) entries are not supported yet (M10): ${url}`)
+        );
+      }
+      return Promise.resolve(decoder.decode(data));
+    }
+  };
+  return { rootEntry, resolver };
+}
+
+// src/usd/crate/lz4.ts
+var MAX_CHUNK_INPUT = 2113929216;
+function lz4DecompressBlock(src, dst) {
+  let s = 0;
+  let d = 0;
+  const n = src.length;
+  while (s < n) {
+    const token = src[s++];
+    let literals = token >> 4;
+    if (literals === 15) {
+      let add;
+      do {
+        add = src[s++];
+        literals += add;
+      } while (add === 255);
+    }
+    for (let i = 0; i < literals; i++) dst[d++] = src[s++];
+    if (s >= n) break;
+    const offset = src[s++] | src[s++] << 8;
+    let matchLen = token & 15;
+    if (matchLen === 15) {
+      let add;
+      do {
+        add = src[s++];
+        matchLen += add;
+      } while (add === 255);
+    }
+    matchLen += 4;
+    let m = d - offset;
+    for (let i = 0; i < matchLen; i++) dst[d++] = dst[m++];
+  }
+  return d;
+}
+function fastDecompress(src, decompressedSize) {
+  const out = new Uint8Array(decompressedSize);
+  const view = new DataView(src.buffer, src.byteOffset, src.byteLength);
+  const numWholeChunks = src[0];
+  let s = 1;
+  let d = 0;
+  for (let c = 0; c < numWholeChunks; c++) {
+    const chunkCompressedSize = view.getInt32(s, true);
+    s += 4;
+    lz4DecompressBlock(
+      src.subarray(s, s + chunkCompressedSize),
+      out.subarray(d, d + MAX_CHUNK_INPUT)
+    );
+    s += chunkCompressedSize;
+    d += MAX_CHUNK_INPUT;
+  }
+  if (d < decompressedSize) {
+    lz4DecompressBlock(src.subarray(s), out.subarray(d));
+  }
+  return out;
+}
+
+// src/usd/crate/integerCompression.ts
+function decodeIntegers32(compressed, numInts) {
+  if (numInts === 0) return [];
+  const codeBytes = Math.ceil(numInts / 4);
+  const worstCase = 4 + codeBytes + numInts * 4;
+  const encoded = fastDecompress(compressed, worstCase);
+  const view = new DataView(encoded.buffer, encoded.byteOffset, encoded.byteLength);
+  const commonDelta = view.getInt32(0, true);
+  const codesStart = 4;
+  let p = codesStart + codeBytes;
+  const out = new Array(numInts);
+  let prev = 0;
+  for (let i = 0; i < numInts; i++) {
+    const code = encoded[codesStart + (i >> 2)] >> (i & 3) * 2 & 3;
+    let delta;
+    if (code === 0) {
+      delta = commonDelta;
+    } else if (code === 1) {
+      delta = view.getInt8(p);
+      p += 1;
+    } else if (code === 2) {
+      delta = view.getInt16(p, true);
+      p += 2;
+    } else {
+      delta = view.getInt32(p, true);
+      p += 4;
+    }
+    prev += delta;
+    out[i] = prev;
+  }
+  return out;
+}
+
+// src/usd/crate/valueTypes.ts
+var CrateType = {
+  Bool: 1,
+  UChar: 2,
+  Int: 3,
+  UInt: 4,
+  Int64: 5,
+  UInt64: 6,
+  Half: 7,
+  Float: 8,
+  Double: 9,
+  String: 10,
+  Token: 11,
+  AssetPath: 12,
+  Matrix3d: 14,
+  Matrix4d: 15,
+  Quatd: 16,
+  Quatf: 17,
+  Vec2d: 19,
+  Vec2f: 20,
+  Vec3d: 23,
+  Vec3f: 24,
+  Vec4d: 27,
+  Vec4f: 28,
+  TokenListOp: 32,
+  PathListOp: 34,
+  IntListOp: 36,
+  PathVector: 40,
+  TokenVector: 41,
+  Specifier: 42,
+  Permission: 43,
+  Variability: 44};
+var ListOpBits = {
+  HasExplicit: 1 << 1,
+  HasAdded: 1 << 2,
+  HasDeleted: 1 << 3,
+  HasOrdered: 1 << 4,
+  HasPrepended: 1 << 5,
+  HasAppended: 1 << 6
+};
+function decodeRepBits(rep) {
+  return {
+    isArray: (rep & 1n << 63n) !== 0n,
+    isInlined: (rep & 1n << 62n) !== 0n,
+    isCompressed: (rep & 1n << 61n) !== 0n,
+    type: Number(rep >> 48n & 0xffn),
+    payload: rep & (1n << 48n) - 1n
+  };
+}
+function halfToFloat(h) {
+  const sign = (h & 32768) >> 15;
+  const exp = (h & 31744) >> 10;
+  const frac = h & 1023;
+  let value;
+  if (exp === 0) value = frac / 1024;
+  else if (exp === 31) value = frac ? Number.NaN : Number.POSITIVE_INFINITY;
+  else return (sign ? -1 : 1) * 2 ** (exp - 15) * (1 + frac / 1024);
+  return (sign ? -1 : 1) * (exp === 0 ? 2 ** -14 * value : value);
+}
+
+// src/usd/crate/CrateReader.ts
+var MAGIC = "PXR-USDC";
+var scratch = new DataView(new ArrayBuffer(8));
+var FIELDSET_END = -1;
+var CrateReader = class {
+  version;
+  view;
+  bytes;
+  sections = /* @__PURE__ */ new Map();
+  _tokens;
+  _strings;
+  _fields;
+  _fieldSets;
+  _paths;
+  _specs;
+  constructor(bytes) {
+    this.bytes = bytes;
+    this.view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    const magic = asciiAt(bytes, 0, 8);
+    if (magic !== MAGIC) {
+      throw new Error(`not a USDC crate file (magic ${JSON.stringify(magic)})`);
+    }
+    this.version = [bytes[8] ?? 0, bytes[9] ?? 0, bytes[10] ?? 0];
+    const tocOffset = this.u64(16);
+    this.readToc(tocOffset);
+  }
+  /** True if `bytes` begins with the crate magic. */
+  static isCrate(bytes) {
+    return asciiAt(bytes, 0, 8) === MAGIC;
+  }
+  getSection(name) {
+    return this.sections.get(name);
+  }
+  /** Read a little-endian uint64 as a JS number (safe for crate-sized files). */
+  u64(offset) {
+    return Number(this.view.getBigUint64(offset, true));
+  }
+  i64(offset) {
+    return this.view.getBigInt64(offset, true);
+  }
+  readToc(offset) {
+    const count = this.u64(offset);
+    let p = offset + 8;
+    for (let i = 0; i < count; i++) {
+      const name = asciiAt(this.bytes, p, 16).replace(/\0+$/, "");
+      const start = this.u64(p + 16);
+      const size = this.u64(p + 24);
+      this.sections.set(name, { name, start, size });
+      p += 32;
+    }
+  }
+  // --- TOKENS -------------------------------------------------------------
+  getTokens() {
+    if (!this._tokens) this._tokens = this.readTokens();
+    return this._tokens;
+  }
+  getToken(index) {
+    return this.getTokens()[index] ?? "";
+  }
+  readTokens() {
+    const section = this.sections.get("TOKENS");
+    if (!section) return [];
+    let p = section.start;
+    const numTokens = this.u64(p);
+    p += 8;
+    const uncompressedSize = this.u64(p);
+    p += 8;
+    const compressedSize = this.u64(p);
+    p += 8;
+    const compressed = this.bytes.subarray(p, p + compressedSize);
+    const buffer = fastDecompress(compressed, uncompressedSize);
+    const tokens = [];
+    const decoder = new TextDecoder();
+    let start = 0;
+    for (let i = 0; i < buffer.length && tokens.length < numTokens; i++) {
+      if (buffer[i] === 0) {
+        tokens.push(decoder.decode(buffer.subarray(start, i)));
+        start = i + 1;
+      }
+    }
+    return tokens;
+  }
+  // --- STRINGS ------------------------------------------------------------
+  /** String values are token indices. */
+  getStrings() {
+    if (!this._strings) this._strings = this.readStrings();
+    return this._strings;
+  }
+  readStrings() {
+    const section = this.sections.get("STRINGS");
+    if (!section) return [];
+    const count = this.u64(section.start);
+    const out = new Array(count);
+    let p = section.start + 8;
+    for (let i = 0; i < count; i++) {
+      out[i] = this.view.getUint32(p, true);
+      p += 4;
+    }
+    return out;
+  }
+  /** Read a `TfFastCompression`-wrapped, delta+integer-compressed array of `count` ints. */
+  readCompressedInts(p, count) {
+    const compressedSize = this.u64(p);
+    const dataStart = p + 8;
+    const buf = this.bytes.subarray(dataStart, dataStart + compressedSize);
+    return { values: decodeIntegers32(buf, count), next: dataStart + compressedSize };
+  }
+  // --- FIELDS -------------------------------------------------------------
+  getFields() {
+    if (!this._fields) this._fields = this.readFields();
+    return this._fields;
+  }
+  readFields() {
+    const section = this.sections.get("FIELDS");
+    if (!section) return [];
+    let p = section.start;
+    const numFields = this.u64(p);
+    p += 8;
+    const names = this.readCompressedInts(p, numFields);
+    p = names.next;
+    const repsCompressedSize = this.u64(p);
+    p += 8;
+    const repsBuf = this.bytes.subarray(p, p + repsCompressedSize);
+    const repBytes = fastDecompress(repsBuf, numFields * 8);
+    const repView = new DataView(repBytes.buffer, repBytes.byteOffset, repBytes.byteLength);
+    const fields = new Array(numFields);
+    for (let i = 0; i < numFields; i++) {
+      fields[i] = { nameIndex: names.values[i], rep: repView.getBigUint64(i * 8, true) };
+    }
+    return fields;
+  }
+  // --- FIELDSETS ----------------------------------------------------------
+  getFieldSets() {
+    if (!this._fieldSets) this._fieldSets = this.readFieldSets();
+    return this._fieldSets;
+  }
+  readFieldSets() {
+    const section = this.sections.get("FIELDSETS");
+    if (!section) return [];
+    const numFieldSets = this.u64(section.start);
+    return this.readCompressedInts(section.start + 8, numFieldSets).values;
+  }
+  /** The field indices of the field set starting at `index` (until the sentinel). */
+  getFieldSet(index) {
+    const all = this.getFieldSets();
+    const out = [];
+    for (let i = index; i < all.length && all[i] !== FIELDSET_END; i++) {
+      out.push(all[i]);
+    }
+    return out;
+  }
+  // --- PATHS --------------------------------------------------------------
+  getPaths() {
+    if (!this._paths) this._paths = this.readPaths();
+    return this._paths;
+  }
+  readPaths() {
+    const section = this.sections.get("PATHS");
+    if (!section) return [];
+    let p = section.start;
+    const numPaths = this.u64(p);
+    p += 8;
+    const numEncoded = this.u64(p);
+    p += 8;
+    const pathIndexes = this.readCompressedInts(p, numEncoded);
+    p = pathIndexes.next;
+    const elementTokenIndexes = this.readCompressedInts(p, numEncoded);
+    p = elementTokenIndexes.next;
+    const jumps = this.readCompressedInts(p, numEncoded);
+    const paths = new Array(numPaths).fill("");
+    this.buildPaths(pathIndexes.values, elementTokenIndexes.values, jumps.values, 0, "", paths);
+    return paths;
+  }
+  /** Reconstruct path strings from the compressed path tree (pxr `_BuildDecompressedPathsImpl`). */
+  buildPaths(pathIndexes, elementTokenIndexes, jumps, startIndex, parentPath, paths) {
+    let curIndex = startIndex;
+    let parent = parentPath;
+    let hasChild = false;
+    let hasSibling = false;
+    do {
+      const thisIndex = curIndex++;
+      const pathIdx = pathIndexes[thisIndex];
+      if (parent === "") {
+        paths[pathIdx] = "/";
+        parent = "/";
+      } else {
+        let tokenIndex = elementTokenIndexes[thisIndex];
+        const isProperty = tokenIndex < 0;
+        if (tokenIndex < 0) tokenIndex = -tokenIndex;
+        const elem = this.getToken(tokenIndex);
+        paths[pathIdx] = appendElement(parent, elem, isProperty);
+      }
+      const jump = jumps[thisIndex];
+      hasChild = jump > 0 || jump === -1;
+      hasSibling = jump >= 0;
+      if (hasChild) {
+        if (hasSibling) {
+          this.buildPaths(pathIndexes, elementTokenIndexes, jumps, thisIndex + jump, parent, paths);
+        }
+        parent = paths[pathIdx];
+      }
+    } while (hasChild || hasSibling);
+  }
+  // --- SPECS --------------------------------------------------------------
+  getSpecs() {
+    if (!this._specs) this._specs = this.readSpecs();
+    return this._specs;
+  }
+  readSpecs() {
+    const section = this.sections.get("SPECS");
+    if (!section) return [];
+    let p = section.start;
+    const numSpecs = this.u64(p);
+    p += 8;
+    const pathIndexes = this.readCompressedInts(p, numSpecs);
+    p = pathIndexes.next;
+    const fieldSetIndexes = this.readCompressedInts(p, numSpecs);
+    p = fieldSetIndexes.next;
+    const specTypes = this.readCompressedInts(p, numSpecs);
+    const specs = new Array(numSpecs);
+    for (let i = 0; i < numSpecs; i++) {
+      specs[i] = {
+        pathIndex: pathIndexes.values[i],
+        fieldSetIndex: fieldSetIndexes.values[i],
+        specType: specTypes.values[i]
+      };
+    }
+    return specs;
+  }
+  // --- Values -------------------------------------------------------------
+  /** Decode a `ValueRep` into a {@link UsdValue} (or `undefined` if unsupported). */
+  getValue(rep) {
+    const b = decodeRepBits(rep);
+    if (b.isArray) return this.readArray(b.type, Number(b.payload), b.isCompressed);
+    if (b.isInlined) return this.readInlined(b.type, b.payload);
+    return this.readScalar(b.type, Number(b.payload));
+  }
+  readInlined(type, payload) {
+    const low = Number(payload & 0xffffffffn);
+    switch (type) {
+      case CrateType.Bool:
+        return payload !== 0n;
+      case CrateType.UChar:
+        return low & 255;
+      case CrateType.Int:
+      case CrateType.Int64:
+        return low | 0;
+      case CrateType.UInt:
+      case CrateType.UInt64:
+        return low >>> 0;
+      case CrateType.Half:
+        return halfToFloat(low & 65535);
+      case CrateType.Float:
+      case CrateType.Double:
+        scratch.setUint32(0, low >>> 0, true);
+        return scratch.getFloat32(0, true);
+      case CrateType.Token:
+        return this.getToken(low);
+      case CrateType.String:
+        return this.getToken(this.getStrings()[low] ?? 0);
+      case CrateType.AssetPath:
+        return new AssetPath(this.getToken(low));
+      case CrateType.Specifier:
+      case CrateType.Permission:
+      case CrateType.Variability:
+        return low;
+      default:
+        return void 0;
+    }
+  }
+  readScalar(type, off) {
+    const v = this.view;
+    switch (type) {
+      case CrateType.Float:
+        return v.getFloat32(off, true);
+      case CrateType.Double:
+        return v.getFloat64(off, true);
+      case CrateType.Half:
+        return halfToFloat(v.getUint16(off, true));
+      case CrateType.Int:
+        return v.getInt32(off, true);
+      case CrateType.UInt:
+        return v.getUint32(off, true);
+      case CrateType.Token:
+        return this.getToken(v.getUint32(off, true));
+      case CrateType.String:
+        return this.getToken(this.getStrings()[v.getUint32(off, true)] ?? 0);
+      case CrateType.AssetPath:
+        return new AssetPath(this.getToken(v.getUint32(off, true)));
+      case CrateType.Vec2f:
+        return this.readFloat32s(off, 2);
+      case CrateType.Vec3f:
+        return this.readFloat32s(off, 3);
+      case CrateType.Vec4f:
+        return this.readFloat32s(off, 4);
+      case CrateType.Vec2d:
+        return this.readFloat64s(off, 2);
+      case CrateType.Vec3d:
+        return this.readFloat64s(off, 3);
+      case CrateType.Vec4d:
+        return this.readFloat64s(off, 4);
+      case CrateType.Quatf: {
+        const q = this.readFloat32s(off, 4);
+        return new Quat(q[3], [q[0], q[1], q[2]]);
+      }
+      case CrateType.Quatd: {
+        const q = this.readFloat64s(off, 4);
+        return new Quat(q[3], [q[0], q[1], q[2]]);
+      }
+      case CrateType.Matrix4d:
+        return new UsdMatrix(this.readFloat64s(off, 16), 4);
+      case CrateType.Matrix3d:
+        return new UsdMatrix(this.readFloat64s(off, 9), 3);
+      case CrateType.TokenListOp:
+      case CrateType.IntListOp:
+        return this.readListOp(off, "token");
+      case CrateType.PathListOp:
+        return this.readListOp(off, "path");
+      case CrateType.TokenVector:
+        return this.readIndexVector(off, "token").items;
+      case CrateType.PathVector:
+        return this.readIndexVector(off, "path").items;
+      default:
+        return void 0;
+    }
+  }
+  readArray(type, off, compressed) {
+    if (off === 0) return [];
+    const count = this.u64(off);
+    let p = off + 8;
+    if (compressed) {
+      const compressedSize = this.u64(p);
+      p += 8;
+      return decodeIntegers32(this.bytes.subarray(p, p + compressedSize), count);
+    }
+    const v = this.view;
+    switch (type) {
+      case CrateType.Int:
+      case CrateType.UInt: {
+        const out = new Array(count);
+        for (let i = 0; i < count; i++) out[i] = v.getInt32(p + i * 4, true);
+        return out;
+      }
+      case CrateType.Float: {
+        const out = new Array(count);
+        for (let i = 0; i < count; i++) out[i] = v.getFloat32(p + i * 4, true);
+        return out;
+      }
+      case CrateType.Token: {
+        const out = new Array(count);
+        for (let i = 0; i < count; i++) out[i] = this.getToken(v.getUint32(p + i * 4, true));
+        return out;
+      }
+      case CrateType.Vec3f:
+        return this.readVec3fArray(p, count, false);
+      case CrateType.Vec3d:
+        return this.readVec3fArray(p, count, true);
+      default:
+        return void 0;
+    }
+  }
+  readFloat32s(off, n) {
+    const out = new Array(n);
+    for (let i = 0; i < n; i++) out[i] = this.view.getFloat32(off + i * 4, true);
+    return out;
+  }
+  readFloat64s(off, n) {
+    const out = new Array(n);
+    for (let i = 0; i < n; i++) out[i] = this.view.getFloat64(off + i * 8, true);
+    return out;
+  }
+  readVec3fArray(off, count, double) {
+    const out = new Array(count);
+    const stride = double ? 24 : 12;
+    for (let i = 0; i < count; i++) {
+      const o = off + i * stride;
+      out[i] = double ? [
+        this.view.getFloat64(o, true),
+        this.view.getFloat64(o + 8, true),
+        this.view.getFloat64(o + 16, true)
+      ] : [
+        this.view.getFloat32(o, true),
+        this.view.getFloat32(o + 4, true),
+        this.view.getFloat32(o + 8, true)
+      ];
+    }
+    return out;
+  }
+  /** Read a `[u64 count][count × uint32|int32 index]` vector → resolved strings. */
+  readIndexVector(off, kind) {
+    const count = this.u64(off);
+    let p = off + 8;
+    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] ?? "";
+      p += 4;
+    }
+    return { items, next: p };
+  }
+  /** Read an SdfListOp; returns the effective (explicit ∪ prepended ∪ added ∪ appended) items. */
+  readListOp(off, kind) {
+    const bits = this.bytes[off];
+    let p = off + 1;
+    const explicit = [];
+    const prepended = [];
+    const added = [];
+    const appended = [];
+    const read = (target) => {
+      const r = this.readIndexVector(p, kind);
+      target.push(...r.items);
+      p = r.next;
+    };
+    if (bits & ListOpBits.HasExplicit) read(explicit);
+    if (bits & ListOpBits.HasAdded) read(added);
+    if (bits & ListOpBits.HasPrepended) read(prepended);
+    if (bits & ListOpBits.HasAppended) read(appended);
+    if (bits & ListOpBits.HasDeleted) read([]);
+    if (bits & ListOpBits.HasOrdered) read([]);
+    return [...explicit, ...prepended, ...added, ...appended];
+  }
+};
+function appendElement(parent, elem, isProperty) {
+  if (isProperty) return `${parent}.${elem}`;
+  if (elem.startsWith("{")) return `${parent}${elem}`;
+  return parent === "/" ? `/${elem}` : `${parent}/${elem}`;
+}
+function asciiAt(bytes, offset, length) {
+  let out = "";
+  for (let i = 0; i < length; i++) {
+    const c = bytes[offset + i];
+    if (c === void 0) break;
+    out += String.fromCharCode(c);
+  }
+  return out;
+}
+
+// src/usd/crate/toUsdaFile.ts
+var SPEC_PRIM = 6;
+var SPEC_PSEUDO_ROOT = 7;
+var SPEC_ATTRIBUTE = 1;
+var SPEC_RELATIONSHIP = 8;
+var SPECIFIERS2 = ["def", "over", "class"];
+function crateToUsdaFile(crate) {
+  const paths = crate.getPaths();
+  const specs = crate.getSpecs();
+  const fields = crate.getFields();
+  const fieldsOf = (fieldSetIndex) => {
+    const map = /* @__PURE__ */ new Map();
+    for (const fi of crate.getFieldSet(fieldSetIndex)) {
+      const f = fields[fi];
+      if (f) map.set(crate.getToken(f.nameIndex), f.rep);
+    }
+    return map;
+  };
+  const primByPath = /* @__PURE__ */ new Map();
+  const rootPrims = [];
+  let layerMetadata = {};
+  for (const spec of specs) {
+    const path = paths[spec.pathIndex] ?? "";
+    if (spec.specType === SPEC_PSEUDO_ROOT) {
+      layerMetadata = buildLayerMetadata(crate, fieldsOf(spec.fieldSetIndex));
+      continue;
+    }
+    if (spec.specType !== SPEC_PRIM) continue;
+    const fm = fieldsOf(spec.fieldSetIndex);
+    primByPath.set(path, {
+      specifier: SPECIFIERS2[asNumber(crate, fm.get("specifier")) ?? 0] ?? "def",
+      typeName: asString(crate, fm.get("typeName")) ?? "",
+      name: leaf(path),
+      metadata: buildPrimMetadata(crate, fm),
+      properties: [],
+      children: [],
+      line: 0
+    });
+  }
+  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 fm = fieldsOf(spec.fieldSetIndex);
+    prim.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);
+  }
+  return { version: crate.version.join("."), metadata: layerMetadata, prims: rootPrims };
+}
+function buildAttribute(crate, name, fm) {
+  const defaultRep = fm.get("default");
+  const attr = {
+    kind: "attribute",
+    name,
+    typeName: asString(crate, fm.get("typeName")) ?? "",
+    isArray: defaultRep !== void 0 ? decodeRepBits(defaultRep).isArray : false,
+    variability: asNumber(crate, fm.get("variability")) === 1 ? "uniform" : "varying",
+    custom: false,
+    metadata: {},
+    line: 0
+  };
+  if (defaultRep !== void 0) {
+    const value = crate.getValue(defaultRep);
+    if (value !== void 0) attr.value = value;
+  }
+  return attr;
+}
+function buildRelationship(crate, name, fm) {
+  const targetsValue = fm.has("targetPaths") ? crate.getValue(fm.get("targetPaths")) : void 0;
+  const targets = Array.isArray(targetsValue) ? targetsValue.filter((t) => typeof t === "string") : [];
+  return {
+    kind: "relationship",
+    name,
+    custom: false,
+    listOp: "explicit",
+    targets,
+    metadata: {},
+    line: 0
+  };
+}
+function buildPrimMetadata(crate, fm) {
+  const meta = {};
+  const apiSchemas = fm.has("apiSchemas") ? crate.getValue(fm.get("apiSchemas")) : void 0;
+  if (Array.isArray(apiSchemas)) meta.apiSchemas = apiSchemas;
+  const kind = asString(crate, fm.get("kind"));
+  if (kind !== void 0) meta.kind = kind;
+  return meta;
+}
+function buildLayerMetadata(crate, fm) {
+  const meta = {};
+  const upAxis = asString(crate, fm.get("upAxis"));
+  if (upAxis !== void 0) meta.upAxis = upAxis;
+  const defaultPrim2 = asString(crate, fm.get("defaultPrim"));
+  if (defaultPrim2 !== void 0) meta.defaultPrim = defaultPrim2;
+  const metersPerUnit = asNumber(crate, fm.get("metersPerUnit"));
+  if (metersPerUnit !== void 0) meta.metersPerUnit = metersPerUnit;
+  return meta;
+}
+function asString(crate, rep) {
+  if (rep === void 0) return void 0;
+  const v = crate.getValue(rep);
+  return typeof v === "string" ? v : void 0;
+}
+function asNumber(crate, rep) {
+  if (rep === void 0) return void 0;
+  const v = crate.getValue(rep);
+  return typeof v === "number" ? v : void 0;
+}
+function splitProperty(path) {
+  const slash = path.lastIndexOf("/");
+  const dot = path.indexOf(".", slash < 0 ? 0 : slash);
+  if (dot === -1) return null;
+  if (path.includes("[")) return null;
+  return { primPath: path.slice(0, dot), propName: path.slice(dot + 1) };
+}
+function parentOf(path) {
+  const i = path.lastIndexOf("/");
+  return i <= 0 ? "/" : path.slice(0, i);
+}
+function leaf(path) {
+  return path.slice(path.lastIndexOf("/") + 1);
+}
+
+// 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]];
+}
+
+// src/usd/xformOps.ts
+var INVERT_PREFIX = "!invert!";
+var RESET_STACK = "!resetXformStack!";
+var ROTATE_ORDERS = /* @__PURE__ */ new Set([
+  "rotateXYZ",
+  "rotateXZY",
+  "rotateYXZ",
+  "rotateYZX",
+  "rotateZXY",
+  "rotateZYX"
+]);
+function computeLocalTransform(prim) {
+  const orderAttr = prim.GetAttribute("xformOpOrder");
+  const order = orderAttr.Get();
+  if (!Array.isArray(order)) {
+    return { matrix: identity4(), resetsXformStack: false };
+  }
+  let matrix = identity4();
+  let resetsXformStack = false;
+  for (const entry of order) {
+    if (typeof entry !== "string") continue;
+    if (entry === RESET_STACK) {
+      resetsXformStack = true;
+      continue;
+    }
+    let opName = entry;
+    let doInvert = false;
+    if (opName.startsWith(INVERT_PREFIX)) {
+      doInvert = true;
+      opName = opName.slice(INVERT_PREFIX.length);
+    }
+    const attr = prim.GetAttribute(opName);
+    if (!attr.IsValid()) {
+      throw new Error(`${prim.GetPath()}: xformOpOrder references missing op "${opName}"`);
+    }
+    const opValue = attr.Get();
+    if (opValue === void 0) continue;
+    let opMatrix = opMatrixFor(parseOpType(opName), opValue, `${prim.GetPath()}.${opName}`);
+    if (doInvert) opMatrix = invert(opMatrix);
+    matrix = multiply(matrix, opMatrix);
+  }
+  return { matrix, resetsXformStack };
+}
+function parseOpType(opName) {
+  const body = opName.startsWith("xformOp:") ? opName.slice("xformOp:".length) : opName;
+  return body.split(":")[0] ?? body;
+}
+function opMatrixFor(opType, value, where) {
+  switch (opType) {
+    case "translate":
+      return makeTranslation(asVec3(value, where));
+    case "scale":
+      return makeScale(asVec3(value, where));
+    case "orient":
+      return makeRotationFromQuat(asQuat(value, where));
+    case "transform":
+      return fromUsdMatrix(asMatrix(value, where));
+    case "rotateX":
+      return makeRotationX(asNumber2(value, where) * DEG2RAD);
+    case "rotateY":
+      return makeRotationY(asNumber2(value, where) * DEG2RAD);
+    case "rotateZ":
+      return makeRotationZ(asNumber2(value, where) * DEG2RAD);
+    default:
+      if (ROTATE_ORDERS.has(opType)) {
+        const [x, y, z] = asVec3(value, where);
+        return makeEuler([x * DEG2RAD, y * DEG2RAD, z * DEG2RAD], opType.slice("rotate".length));
+      }
+      throw new Error(`${where}: unsupported xformOp type "${opType}"`);
+  }
+}
+function asVec3(v, where) {
+  if (Array.isArray(v) && v.length === 3 && v.every((n) => typeof n === "number")) {
+    return v;
+  }
+  throw new Error(`${where}: expected a 3-component value`);
+}
+function asNumber2(v, where) {
+  if (typeof v === "number") return v;
+  throw new Error(`${where}: expected a number`);
+}
+function asQuat(v, where) {
+  if (v && typeof v === "object" && "real" in v && "imaginary" in v) return v;
+  throw new Error(`${where}: expected a quaternion`);
+}
+function asMatrix(v, where) {
+  if (v && typeof v === "object" && "values" in v && "dim" in v) return v;
+  throw new Error(`${where}: expected a matrix`);
+}
+
+// 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 = {}) {
+  const warnings = [];
+  const warn = (m) => {
+    warnings.push(m);
+    options.onWarn?.(m);
+  };
+  const links = new Set(Object.keys(robot.links));
+  const outgoing = /* @__PURE__ */ new Map();
+  const worldJointByChild = /* @__PURE__ */ new Map();
+  const inRealDegree = /* @__PURE__ */ new Map();
+  for (const [jointKey, joint] of Object.entries(robot.joints)) {
+    if (!links.has(joint.child)) {
+      warn(`joint "${jointKey}": child link "${joint.child}" is unknown; skipping edge`);
+      continue;
+    }
+    if (joint.parent === WORLD) {
+      if (worldJointByChild.has(joint.child)) {
+        warn(`link "${joint.child}" is fixed to world by multiple joints; keeping "${jointKey}"`);
+      }
+      worldJointByChild.set(joint.child, jointKey);
+      continue;
+    }
+    if (!links.has(joint.parent)) {
+      warn(`joint "${jointKey}": parent link "${joint.parent}" is unknown; skipping edge`);
+      continue;
+    }
+    const edges = outgoing.get(joint.parent) ?? [];
+    edges.push({ joint: jointKey, child: joint.child });
+    outgoing.set(joint.parent, edges);
+    inRealDegree.set(joint.child, (inRealDegree.get(joint.child) ?? 0) + 1);
+  }
+  const root = chooseRoot(links, inRealDegree, worldJointByChild, robot, warn);
+  const nodes = {};
+  const order = [];
+  const loopJoints = [];
+  const visited = /* @__PURE__ */ new Set();
+  if (root !== "") {
+    nodes[root] = { link: root, parent: null, jointToParent: null, children: [], depth: 0 };
+    visited.add(root);
+    order.push(root);
+    const queue = [root];
+    while (queue.length > 0) {
+      const cur = queue.shift();
+      const edges = [...outgoing.get(cur) ?? []].sort((a, b) => a.joint.localeCompare(b.joint));
+      for (const edge of edges) {
+        if (visited.has(edge.child)) {
+          loopJoints.push(edge.joint);
+          continue;
+        }
+        visited.add(edge.child);
+        nodes[edge.child] = {
+          link: edge.child,
+          parent: cur,
+          jointToParent: edge.joint,
+          children: [],
+          depth: nodes[cur].depth + 1
+        };
+        nodes[cur].children.push(edge);
+        order.push(edge.child);
+        queue.push(edge.child);
+      }
+    }
+  }
+  const isolatedLinks = [...links].filter((l) => !visited.has(l)).sort();
+  if (isolatedLinks.length > 0) {
+    warn(
+      `${isolatedLinks.length} link(s) not reachable from root "${root}": ${isolatedLinks.join(", ")}`
+    );
+  }
+  if (loopJoints.length > 0) {
+    warn(`closed loop(s) detected; dropped joints from tree: ${loopJoints.sort().join(", ")}`);
+  }
+  return {
+    root,
+    rootJoint: worldJointByChild.get(root) ?? null,
+    nodes,
+    order,
+    loopJoints: loopJoints.sort(),
+    isolatedLinks,
+    warnings
+  };
+}
+function chooseRoot(links, inRealDegree, worldJointByChild, robot, warn) {
+  if (links.size === 0) return "";
+  const candidates = [...links].filter((l) => (inRealDegree.get(l) ?? 0) === 0).sort();
+  if (candidates.length === 0) {
+    const fallback = [...links].sort()[0];
+    warn(`no root candidate (every link has a parent \u2014 likely a full cycle); using "${fallback}"`);
+    return fallback;
+  }
+  const articulation = (robot.articulationRoots ?? []).filter((a) => candidates.includes(a));
+  const worldFixed = candidates.filter((c) => worldJointByChild.has(c));
+  const chosen = articulation[0] ?? worldFixed[0] ?? candidates[0];
+  if (candidates.length > 1) {
+    warn(`multiple root candidates (${candidates.join(", ")}); using "${chosen}"`);
+  }
+  return chosen;
+}
+
+// src/robot/normalize.ts
+var isFinite_ = (x) => x !== void 0 && Number.isFinite(x);
+function normalizeJointLimits(type, rawLower, rawUpper) {
+  const angular = type === "revolute" || type === "continuous";
+  const conv = (x) => {
+    if (!isFinite_(x)) return void 0;
+    return angular ? x * DEG2RAD : x;
+  };
+  const lower = conv(rawLower);
+  const upper = conv(rawUpper);
+  return {
+    ...lower !== void 0 ? { lower } : {},
+    ...upper !== void 0 ? { upper } : {}
+  };
+}
+function jointValueToSI(angular, raw) {
+  return angular ? raw * DEG2RAD : raw;
+}
+function refineJointType(base, lower, upper) {
+  if (base === "revolute" && lower === void 0 && upper === void 0) return "continuous";
+  return base;
+}
+
+// src/robot/RobotExtractor.ts
+var WORLD2 = "";
+function extractRobotDescription(stage, options = {}) {
+  const warnings = [];
+  const warn = (m) => {
+    warnings.push(m);
+    options.onWarn?.(m);
+  };
+  const jointPrims = stage.Traverse().filter((p) => getJointType(p) !== null);
+  const linkPaths = /* @__PURE__ */ new Set();
+  for (const jp of jointPrims) {
+    const { body0, body1 } = getJointBodies(jp);
+    if (body0) linkPaths.add(body0);
+    if (body1) linkPaths.add(body1);
+  }
+  for (const p of stage.Traverse()) {
+    if (hasRigidBodyAPI(p)) linkPaths.add(p.GetPath());
+  }
+  const linkKeyByPath = buildKeyMap([...linkPaths]);
+  const links = {};
+  const articulationRoots = [];
+  for (const path of linkPaths) {
+    const key = linkKeyByPath.get(path);
+    const prim = stage.GetPrimAtPath(path);
+    links[key] = buildLink(path, prim);
+    if (prim && hasArticulationRootAPI(prim)) articulationRoots.push(key);
+  }
+  const joints = {};
+  const jointKeyByPath = buildKeyMap(jointPrims.map((p) => p.GetPath()));
+  for (const jp of jointPrims) {
+    const joint = buildJoint(jp, linkKeyByPath, warn);
+    if (joint) joints[jointKeyByPath.get(jp.GetPath())] = joint;
+  }
+  const name = options.robotName ?? stage.GetDefaultPrim()?.GetName() ?? stage.GetPseudoRoot().GetChildren()[0]?.GetName() ?? "robot";
+  const robot = {
+    name,
+    rootLink: "",
+    links,
+    joints,
+    upAxis: stage.GetUpAxis(),
+    metersPerUnit: stage.GetMetersPerUnit(),
+    ...articulationRoots.length ? { articulationRoots } : {}
+  };
+  const tree = buildKinematicTree(robot, { onWarn: warn });
+  robot.rootLink = tree.root;
+  if (tree.loopJoints.length) robot.loopJoints = tree.loopJoints;
+  if (warnings.length) robot.warnings = warnings;
+  return robot;
+}
+function buildLink(path, prim) {
+  const name = leafName(path);
+  if (!prim) return { name, primPath: path, visualPrims: [] };
+  const visualPrims = [];
+  const collisionPrims = [];
+  for (const meshPath of gatherMeshDescendants(prim)) {
+    const mp = prim.GetStage().GetPrimAtPath(meshPath);
+    if (mp && (hasCollisionAPI(mp) || isNonVisualPurpose(mp))) collisionPrims.push(meshPath);
+    else visualPrims.push(meshPath);
+  }
+  return {
+    name,
+    primPath: path,
+    visualPrims,
+    ...collisionPrims.length ? { collisionPrims } : {}
+  };
+}
+function buildJoint(prim, linkKeyByPath, warn) {
+  const base = getJointType(prim);
+  if (!base) return null;
+  const path = prim.GetPath();
+  const { body0, body1 } = getJointBodies(prim);
+  if (!body1) {
+    warn(`${path}: joint has no physics:body1 target; skipping`);
+    return null;
+  }
+  const parent = body0 ? linkKeyByPath.get(body0) ?? body0 : WORLD2;
+  const child = linkKeyByPath.get(body1) ?? body1;
+  const raw = getJointLimits(prim);
+  const { lower, upper } = normalizeJointLimits(base, raw.lower, raw.upper);
+  const type = refineJointType(base, lower, upper);
+  const joint = {
+    name: leafName(path),
+    primPath: path,
+    type,
+    parent,
+    child,
+    axis: getJointAxis(prim),
+    jointFrame0: getJointLocalFrame(prim, 0),
+    jointFrame1: getJointLocalFrame(prim, 1),
+    ...lower !== void 0 ? { lower } : {},
+    ...upper !== void 0 ? { upper } : {}
+  };
+  const kind = driveKindFor(type);
+  const angular = kind === "angular";
+  const drive = getJointDrive(prim, kind);
+  const statePos = getJointStatePosition(prim, kind);
+  const initialValue = statePos !== void 0 ? jointValueToSI(angular, statePos) : drive.targetPosition !== void 0 ? jointValueToSI(angular, drive.targetPosition) : void 0;
+  if (initialValue !== void 0) joint.initialValue = initialValue;
+  const driveDesc = {
+    ...drive.targetPosition !== void 0 ? { targetPosition: jointValueToSI(angular, drive.targetPosition) } : {},
+    ...drive.stiffness !== void 0 ? { stiffness: drive.stiffness } : {},
+    ...drive.damping !== void 0 ? { damping: drive.damping } : {},
+    ...drive.maxForce !== void 0 ? { maxForce: drive.maxForce } : {}
+  };
+  if (Object.keys(driveDesc).length > 0) joint.drive = driveDesc;
+  return joint;
+}
+function buildKeyMap(paths) {
+  const leafCounts = /* @__PURE__ */ new Map();
+  for (const p of paths) {
+    const leaf2 = leafName(p);
+    leafCounts.set(leaf2, (leafCounts.get(leaf2) ?? 0) + 1);
+  }
+  const map = /* @__PURE__ */ new Map();
+  for (const p of paths) {
+    const leaf2 = leafName(p);
+    map.set(p, leafCounts.get(leaf2) === 1 ? leaf2 : p);
+  }
+  return map;
+}
+function leafName(path) {
+  const parts = path.split("/").filter(Boolean);
+  return parts[parts.length - 1] ?? path;
+}
+
+export { ARTICULATION_ROOT_API, AssetPath, Attribute, COLLISION_API, CrateReader, DEFAULT_METERS_PER_UNIT, DEG2RAD, DefaultAssetResolver, Layer, PACKAGE_NAME, ParseError, Prim, Quat, RAD2DEG, RIGID_BODY_API, Relationship, Stage, TokenizeError, UsdMatrix, VERSION, buildKinematicTree, composeLayer, computeLocalTransform, crateToUsdaFile, createMemoryResolver, driveKindFor, extractRobotDescription, fromUsdMatrix, gatherMeshDescendants, getJointAxis, getJointBodies, getJointDrive, getJointLimits, getJointLocalFrame, getJointStatePosition, getJointType, getTranslation, hasArticulationRootAPI, hasCollisionAPI, hasRigidBodyAPI, identity4, invert, isMesh, isScope, isXform, iterDescendants, joinPosix, jointValueToSI, makeEuler, makeRotationFromQuat, makeRotationX, makeRotationY, makeRotationZ, makeScale, makeTranslation, multiply, multiplyAll, normalizeJointLimits, openUsdz, parseOpType, parseUsda, refineJointType, tokenize };
+//# sourceMappingURL=chunk-XCP5GZPY.js.map
+//# sourceMappingURL=chunk-XCP5GZPY.js.map