three-usd-robot 0.9.0 → 0.11.0

package/dist/{chunk-2UD32EGU.js → chunk-AXPMXEQC.js}

@@ -1,4 +1,4 @@
-import { Quat, multiply, makeTranslation, makeRotationFromQuat, identity4, invert, makeEuler, DEG2RAD, makeRotationZ, makeRotationY, makeRotationX, fromUsdMatrix, makeScale, AssetPath, RAD2DEG, UsdMatrix } from './chunk-IYKPVUZ2.js';
+import { Quat, multiply, makeTranslation, makeRotationFromQuat, identity4, invert, makeEuler, DEG2RAD, makeRotationZ, makeRotationY, makeRotationX, fromUsdMatrix, makeScale, RAD2DEG, AssetPath, UsdMatrix } from './chunk-LDO5FKQS.js';
 import { unzipSync } from 'fflate';
 
 // src/schemas/usdGeom.ts
@@ -21,8 +21,22 @@ var SOLID_GPRIM_TYPES = /* @__PURE__ */ new Set([
 function isSolidGprim(prim) {
   return SOLID_GPRIM_TYPES.has(prim.GetTypeName());
 }
+function isPoints(prim) {
+  return prim.GetTypeName() === "Points";
+}
+function isBasisCurves(prim) {
+  return prim.GetTypeName() === "BasisCurves";
+}
+var UNSUPPORTED_GPRIM_TYPES = /* @__PURE__ */ new Set([
+  "NurbsCurves",
+  "HermiteCurves",
+  "NurbsPatch"
+]);
+function isUnsupportedGprim(prim) {
+  return UNSUPPORTED_GPRIM_TYPES.has(prim.GetTypeName());
+}
 function isRenderableGprim(prim) {
-  return isMesh(prim) || isSolidGprim(prim);
+  return isMesh(prim) || isSolidGprim(prim) || isPoints(prim) || isBasisCurves(prim);
 }
 function getPurpose(prim) {
   const v = prim.GetAttribute("purpose").Get();
@@ -268,105 +282,634 @@ function asMatrix(v, where) {
   throw new Error(`${where}: expected a matrix`);
 }
 
+// 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) {
+  const decoder = new TextDecoder();
+  const encoder = new TextEncoder();
+  return {
+    resolve(assetPath, baseUrl) {
+      return joinPosix(baseUrl, assetPath);
+    },
+    fetchText(url) {
+      const v = files[url];
+      if (v === void 0) return Promise.reject(new Error(`asset not found: ${url}`));
+      return Promise.resolve(typeof v === "string" ? v : decoder.decode(v));
+    },
+    fetchBytes(url) {
+      const v = files[url];
+      if (v === void 0) return Promise.reject(new Error(`asset not found: ${url}`));
+      return Promise.resolve(typeof v === "string" ? encoder.encode(v) : v);
+    }
+  };
+}
+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/mdl/parseMdl.ts
+function isMdlTexture(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) && "assetPath" in value;
+}
+function parseMdl(text) {
+  const src = stripNoise(text);
+  const materials = /* @__PURE__ */ new Map();
+  const declRe = /\bexport\s+material\s+([A-Za-z_]\w*)\s*\(/g;
+  let match = declRe.exec(src);
+  while (match) {
+    const open = match.index + match[0].length - 1;
+    const close = matchParen(src, open);
+    if (close === -1) break;
+    const decl = {
+      name: match[1],
+      defaults: parseParamDefaults(src.slice(open + 1, close - 1)),
+      args: /* @__PURE__ */ new Map()
+    };
+    let next = close;
+    let i = close;
+    while (i < src.length && /\s/.test(src[i])) i++;
+    if (src[i] === "=") {
+      const end = statementEnd(src, i + 1);
+      const body = parseWrapperBody(src.slice(i + 1, end));
+      if (body.base) decl.base = body.base;
+      decl.args = body.args;
+      next = end;
+    }
+    materials.set(decl.name, decl);
+    declRe.lastIndex = next;
+    match = declRe.exec(src);
+  }
+  return { materials };
+}
+var NUMBER_RE = /^[+-]?(?:\d+\.?\d*|\.\d+)(?:[eE][+-]?\d+)?[fFdD]?$/;
+var CALL_RE = /^(?:::)?([A-Za-z_]\w*(?:::[A-Za-z_]\w*)*)\s*\(/;
+var VECTOR_RE = /^(?:color|(?:float|double|int)([234]))$/;
+var IDENTIFIER_RE = /^[A-Za-z_]\w*$/;
+function parseMdlLiteral(src) {
+  const s = src.trim();
+  if (s === "true") return true;
+  if (s === "false") return false;
+  if (NUMBER_RE.test(s)) return Number.parseFloat(s.replace(/[fFdD]$/, ""));
+  if (s.startsWith('"')) {
+    if (skipString(s, 0) !== s.length) return void 0;
+    return s.slice(1, -1).replace(/\\(.)/g, "$1");
+  }
+  const call = CALL_RE.exec(s);
+  if (!call) return void 0;
+  const open = call[0].length - 1;
+  if (matchParen(s, open) !== s.length) return void 0;
+  const name = call[1].split("::").pop();
+  const args = splitTopLevel(s.slice(open + 1, s.length - 1), ",").map((a) => a.trim()).filter((a) => a.length > 0);
+  if (name === "texture_2d") {
+    const path = args[0] === void 0 ? void 0 : parseMdlLiteral(args[0]);
+    if (typeof path !== "string" || path.length === 0) return void 0;
+    const texture = { assetPath: path };
+    const gamma = args.slice(1).join(",");
+    if (gamma.includes("gamma_srgb")) texture.sourceColorSpace = "sRGB";
+    else if (gamma.includes("gamma_linear")) texture.sourceColorSpace = "raw";
+    return texture;
+  }
+  const vector = VECTOR_RE.exec(name);
+  if (vector) {
+    const width = vector[1] ? Number(vector[1]) : 3;
+    const values = args.map((a) => parseMdlLiteral(a));
+    if (values.length === 0 || !values.every((v) => typeof v === "number")) return void 0;
+    if (values.length === 1) return new Array(width).fill(values[0]);
+    return values.length === width ? values : void 0;
+  }
+  return void 0;
+}
+function parseParamDefaults(src) {
+  const defaults = /* @__PURE__ */ new Map();
+  const body = src.trim();
+  if (body === "" || body === "*") return defaults;
+  for (const param of splitTopLevel(src, ",")) {
+    const assign = topLevelAssign(param);
+    if (assign === -1) continue;
+    const name = param.slice(0, assign).trim().split(/\s+/).pop();
+    if (!name || !IDENTIFIER_RE.test(name)) continue;
+    const value = parseMdlLiteral(param.slice(assign + 1));
+    if (value !== void 0) defaults.set(name, value);
+  }
+  return defaults;
+}
+function parseWrapperBody(src) {
+  const args = /* @__PURE__ */ new Map();
+  const body = src.trim();
+  const call = CALL_RE.exec(body);
+  if (!call) return { args };
+  const open = call[0].length - 1;
+  if (matchParen(body, open) !== body.length) return { args };
+  const base = call[1].split("::").pop();
+  if (base === "material") return { args };
+  for (const arg of splitTopLevel(body.slice(open + 1, body.length - 1), ",")) {
+    const colon = topLevelColon(arg);
+    if (colon === -1) continue;
+    const name = arg.slice(0, colon).trim();
+    if (!IDENTIFIER_RE.test(name)) continue;
+    const value = parseMdlLiteral(arg.slice(colon + 1));
+    if (value !== void 0) args.set(name, value);
+  }
+  return { base, args };
+}
+function stripNoise(src) {
+  let out = "";
+  let i = 0;
+  while (i < src.length) {
+    const c = src[i];
+    if (c === '"') {
+      const end = skipString(src, i);
+      out += src.slice(i, end);
+      i = end;
+    } else if (c === "/" && src[i + 1] === "/") {
+      while (i < src.length && src[i] !== "\n") i++;
+    } else if (c === "/" && src[i + 1] === "*") {
+      const end = src.indexOf("*/", i + 2);
+      i = end === -1 ? src.length : end + 2;
+      out += " ";
+    } else if (c === "[" && src[i + 1] === "[") {
+      i = skipAnnotation(src, i);
+      out += " ";
+    } else {
+      out += c;
+      i++;
+    }
+  }
+  return out;
+}
+function skipString(src, i) {
+  let j = i + 1;
+  while (j < src.length) {
+    if (src[j] === "\\") j += 2;
+    else if (src[j] === '"') return j + 1;
+    else j++;
+  }
+  return j;
+}
+function skipAnnotation(src, i) {
+  let depth = 0;
+  let j = i;
+  while (j < src.length) {
+    if (src[j] === '"') {
+      j = skipString(src, j);
+    } else if (src[j] === "[" && src[j + 1] === "[") {
+      depth++;
+      j += 2;
+    } else if (src[j] === "]" && src[j + 1] === "]") {
+      depth--;
+      j += 2;
+      if (depth === 0) return j;
+    } else {
+      j++;
+    }
+  }
+  return j;
+}
+function matchParen(src, open) {
+  let depth = 0;
+  let i = open;
+  while (i < src.length) {
+    const c = src[i];
+    if (c === '"') {
+      i = skipString(src, i);
+      continue;
+    }
+    if (c === "(") depth++;
+    else if (c === ")") {
+      depth--;
+      if (depth === 0) return i + 1;
+    }
+    i++;
+  }
+  return -1;
+}
+function isOpener(c) {
+  return c === "(" || c === "[" || c === "{";
+}
+function isCloser(c) {
+  return c === ")" || c === "]" || c === "}";
+}
+function splitTopLevel(src, separator) {
+  const parts = [];
+  let depth = 0;
+  let start = 0;
+  let i = 0;
+  while (i < src.length) {
+    const c = src[i];
+    if (c === '"') {
+      i = skipString(src, i);
+      continue;
+    }
+    if (isOpener(c)) depth++;
+    else if (isCloser(c)) depth--;
+    else if (c === separator && depth === 0) {
+      parts.push(src.slice(start, i));
+      start = i + 1;
+    }
+    i++;
+  }
+  parts.push(src.slice(start));
+  return parts;
+}
+function statementEnd(src, from) {
+  let depth = 0;
+  let i = from;
+  while (i < src.length) {
+    const c = src[i];
+    if (c === '"') {
+      i = skipString(src, i);
+      continue;
+    }
+    if (isOpener(c)) depth++;
+    else if (isCloser(c)) depth--;
+    else if (c === ";" && depth === 0) return i;
+    i++;
+  }
+  return src.length;
+}
+function topLevelAssign(src) {
+  let depth = 0;
+  let i = 0;
+  while (i < src.length) {
+    const c = src[i];
+    if (c === '"') {
+      i = skipString(src, i);
+      continue;
+    }
+    if (isOpener(c)) depth++;
+    else if (isCloser(c)) depth--;
+    else if (c === "=" && depth === 0 && src[i + 1] !== "=" && !"<>!=".includes(src[i - 1] ?? "")) {
+      return i;
+    }
+    i++;
+  }
+  return -1;
+}
+function topLevelColon(src) {
+  let depth = 0;
+  let i = 0;
+  while (i < src.length) {
+    const c = src[i];
+    if (c === '"') {
+      i = skipString(src, i);
+      continue;
+    }
+    if (isOpener(c)) depth++;
+    else if (isCloser(c)) depth--;
+    else if (c === ":" && depth === 0) {
+      if (src[i + 1] === ":") {
+        i += 2;
+        continue;
+      }
+      return i;
+    }
+    i++;
+  }
+  return -1;
+}
+
 // src/three/MaterialBinding.ts
 var DIFFUSE_INPUTS = [
-  "inputs:diffuseColor",
+  "diffuseColor",
   // UsdPreviewSurface
-  "inputs:diffuse_color_constant",
+  "diffuse_color_constant",
   // OmniPBR
-  "inputs:diffuse_tint",
-  "inputs:base_color",
-  "inputs:baseColor"
+  "diffuse_tint",
+  "base_color",
+  "baseColor"
 ];
-var OPACITY_INPUTS = ["inputs:opacity", "inputs:opacity_constant"];
-var OPACITY_THRESHOLD_INPUTS = ["inputs:opacityThreshold", "inputs:opacity_threshold"];
-var METALLIC_INPUTS = ["inputs:metallic", "inputs:metallic_constant"];
-var ROUGHNESS_INPUTS = ["inputs:roughness", "inputs:reflection_roughness_constant"];
-var EMISSIVE_INPUTS = ["inputs:emissiveColor", "inputs:emissive_color"];
+var OPACITY_INPUTS = ["opacity", "opacity_constant"];
+var OPACITY_THRESHOLD_INPUTS = ["opacityThreshold", "opacity_threshold"];
+var METALLIC_INPUTS = ["metallic", "metallic_constant"];
+var ROUGHNESS_INPUTS = ["roughness", "reflection_roughness_constant"];
+var EMISSIVE_INPUTS = ["emissiveColor", "emissive_color"];
 var SURFACE_OUTPUTS = ["outputs:surface", "outputs:mdl:surface"];
 var TEXTURE_LOOKUPS = {
   color: {
-    surface: ["inputs:diffuseColor"],
-    direct: ["inputs:diffuse_texture", "inputs:diffuse_color_texture"]
+    surface: ["diffuseColor"],
+    direct: ["diffuse_texture", "diffuse_color_texture", "glass_color_texture"]
   },
   opacity: {
-    surface: ["inputs:opacity"],
-    direct: ["inputs:opacity_texture", "inputs:opacity_color_texture"]
+    surface: ["opacity"],
+    direct: ["opacity_texture", "opacity_color_texture"]
   },
   normal: {
-    surface: ["inputs:normal"],
-    direct: ["inputs:normalmap_texture", "inputs:normal_texture"]
+    surface: ["normal"],
+    direct: ["normalmap_texture", "normal_texture", "normal_map_texture"]
   },
   roughness: {
-    surface: ["inputs:roughness"],
-    direct: ["inputs:reflectionroughness_texture", "inputs:roughness_texture"]
+    surface: ["roughness"],
+    direct: ["reflectionroughness_texture", "roughness_texture"]
   },
   metalness: {
-    surface: ["inputs:metallic"],
-    direct: ["inputs:metallic_texture"]
+    surface: ["metallic"],
+    direct: ["metallic_texture"]
   },
   occlusion: {
-    surface: ["inputs:occlusion"],
-    direct: ["inputs:ao_texture", "inputs:occlusion_texture"]
+    surface: ["occlusion"],
+    direct: ["ao_texture", "occlusion_texture"]
   },
   emissive: {
-    surface: ["inputs:emissiveColor"],
-    direct: ["inputs:emissive_color_texture", "inputs:emissive_mask_texture"]
+    surface: ["emissiveColor"],
+    direct: ["emissive_color_texture", "emissive_mask_texture"]
   }
 };
-function resolveBoundMaterial(stage, prim) {
+function resolveBoundMaterial(stage, prim, options = {}) {
   const materialPath = findBinding(prim);
   if (!materialPath) return void 0;
   const material = stage.GetPrimAtPath(materialPath);
   if (!material) return void 0;
   const shader = findSurfaceShader(material);
   if (!shader) return void 0;
+  const mdlSource = readMdlShaderSource(shader, options.mdl);
+  if (mdlSource && !mdlSource.family) {
+    options.onWarn?.(
+      `${material.GetPath()}: unknown MDL material "${mdlSource.id}" (${mdlSource.assetPath}); applying the best-effort OmniPBR mapping`
+    );
+  }
+  const sv = { shader };
+  if (mdlSource?.values) sv.mdl = mdlSource.values;
+  if (mdlSource) sv.mdlAssetPath = mdlSource.assetPath;
   const result = { name: material.GetName() };
-  const color = firstColor(shader, DIFFUSE_INPUTS);
+  const color = firstColor(sv, DIFFUSE_INPUTS);
   if (color) result.color = color;
-  const opacity = firstNumber(shader, OPACITY_INPUTS);
+  const opacity = firstNumber(sv, OPACITY_INPUTS);
   if (opacity !== void 0) result.opacity = opacity;
-  const opacityThreshold = firstNumber(shader, OPACITY_THRESHOLD_INPUTS);
+  const opacityThreshold = firstNumber(sv, OPACITY_THRESHOLD_INPUTS);
   if (opacityThreshold !== void 0) result.opacityThreshold = opacityThreshold;
-  const metalness = firstNumber(shader, METALLIC_INPUTS);
+  const metalness = firstNumber(sv, METALLIC_INPUTS);
   if (metalness !== void 0) result.metalness = metalness;
-  const roughness = firstNumber(shader, ROUGHNESS_INPUTS);
+  const roughness = firstNumber(sv, ROUGHNESS_INPUTS);
   if (roughness !== void 0) result.roughness = roughness;
-  const emissive = firstColor(shader, EMISSIVE_INPUTS);
-  if (emissive && shader.GetAttribute("inputs:enable_emission").Get() !== false) {
+  const emissive = firstColor(sv, EMISSIVE_INPUTS);
+  if (emissive && svBoolean(sv, "enable_emission") !== false) {
     result.emissiveColor = emissive;
-  }
-  const colorTex = findTexture(shader, TEXTURE_LOOKUPS.color);
+    const intensity = svNumber(sv, "emissive_intensity");
+    if (intensity !== void 0) result.emissiveIntensity = intensity;
+  }
+  const ior = svNumber(sv, "ior");
+  if (ior !== void 0) result.ior = ior;
+  const clearcoat = svNumber(sv, "clearcoat");
+  if (clearcoat !== void 0) result.clearcoat = clearcoat;
+  const clearcoatRoughness = svNumber(sv, "clearcoatRoughness");
+  if (clearcoatRoughness !== void 0) result.clearcoatRoughness = clearcoatRoughness;
+  if (svNumber(sv, "useSpecularWorkflow") === 1) {
+    const specular = svColor(sv, "specularColor");
+    if (specular) result.specularColor = specular;
+  }
+  const colorTex = findTexture(sv, TEXTURE_LOOKUPS.color);
   if (colorTex !== void 0) result.colorTexture = colorTex;
-  const opacityTex = findTexture(shader, TEXTURE_LOOKUPS.opacity);
+  const opacityTex = findTexture(sv, TEXTURE_LOOKUPS.opacity);
   if (opacityTex !== void 0) result.opacityTexture = opacityTex;
-  const normal = findTexture(shader, TEXTURE_LOOKUPS.normal);
+  const normal = findTexture(sv, TEXTURE_LOOKUPS.normal);
   if (normal !== void 0) result.normalTexture = normal;
-  const roughTex = findTexture(shader, TEXTURE_LOOKUPS.roughness);
+  const roughTex = findTexture(sv, TEXTURE_LOOKUPS.roughness);
   if (roughTex !== void 0) result.roughnessTexture = roughTex;
-  const metalTex = findTexture(shader, TEXTURE_LOOKUPS.metalness);
+  const metalTex = findTexture(sv, TEXTURE_LOOKUPS.metalness);
   if (metalTex !== void 0) result.metalnessTexture = metalTex;
-  const aoTex = findTexture(shader, TEXTURE_LOOKUPS.occlusion);
+  const aoTex = findTexture(sv, TEXTURE_LOOKUPS.occlusion);
   if (aoTex !== void 0) result.occlusionTexture = aoTex;
-  const emissiveTex = findTexture(shader, TEXTURE_LOOKUPS.emissive);
+  const emissiveTex = findTexture(sv, TEXTURE_LOOKUPS.emissive);
   if (emissiveTex !== void 0) result.emissiveTexture = emissiveTex;
+  const orm = directTexture(sv, "ORM_texture") ?? mdlValueTexture(sv, "ORM_texture");
+  if (svBoolean(sv, "enable_ORM_texture") === true && orm) {
+    result.occlusionTexture = { ...orm, outputChannel: "r" };
+    result.roughnessTexture = { ...orm, outputChannel: "g" };
+    result.metalnessTexture = { ...orm, outputChannel: "b" };
+  }
+  switch (mdlSource?.family) {
+    case "glass":
+      readOmniGlass(sv, result);
+      break;
+    case "clearcoat":
+      readOmniClearCoat(sv, result);
+      break;
+    case "surface":
+      readOmniSurface(sv, result);
+      break;
+  }
   return result;
 }
-function findTexture(shader, lookup) {
+function classifyOmniMdl(name) {
+  if (!name) return void 0;
+  if (name.startsWith("OmniGlass")) return "glass";
+  if (name.startsWith("OmniPBR_ClearCoat")) return "clearcoat";
+  if (name.startsWith("OmniPBR")) return "pbr";
+  if (name.startsWith("OmniSurface")) return "surface";
+  return void 0;
+}
+function readMdlShaderSource(shader, provider) {
+  const asset = shader.GetAttribute("info:mdl:sourceAsset").Get();
+  if (!(asset instanceof AssetPath) || !asset.path) return void 0;
+  const sub = shader.GetAttribute("info:mdl:sourceAsset:subIdentifier").Get();
+  const stem = (asset.path.split("/").pop() ?? "").replace(/\.mdl$/i, "");
+  const id = typeof sub === "string" && sub.length > 0 ? sub : stem;
+  const decl = provider?.(asset.path)?.materials.get(id);
+  const family = classifyOmniMdl(decl?.base) ?? classifyOmniMdl(id) ?? classifyOmniMdl(stem);
+  const source = { assetPath: asset.path, id };
+  if (family) source.family = family;
+  if (decl && (decl.defaults.size > 0 || decl.args.size > 0)) {
+    source.values = new Map([...decl.defaults, ...decl.args]);
+  }
+  return source;
+}
+function readOmniGlass(sv, result) {
+  result.transmission = 1;
+  result.metalness = 0;
+  result.color = svColor(sv, "glass_color") ?? [1, 1, 1];
+  result.ior = svNumber(sv, "glass_ior") ?? 1.491;
+  result.roughness = svNumber(sv, "frosting_roughness") ?? 0;
+  const depth = svNumber(sv, "depth");
+  if (svBoolean(sv, "thin_walled") !== true && depth !== void 0) result.thickness = depth;
+  const cutout = svNumber(sv, "cutout_opacity");
+  if (cutout !== void 0 && cutout < 1) result.opacity = cutout;
+}
+function readOmniClearCoat(sv, result) {
+  if (svBoolean(sv, "enable_clearcoat") === false) return;
+  result.clearcoat = 1;
+  const roughness = svNumber(sv, "clearcoat_reflection_roughness");
+  if (roughness !== void 0) result.clearcoatRoughness = roughness;
+  const normal = directTexture(sv, "clearcoat_normalmap_texture") ?? mdlValueTexture(sv, "clearcoat_normalmap_texture");
+  if (normal && svBoolean(sv, "enable_clearcoat_normalmap_texture") !== false) {
+    result.clearcoatNormalTexture = normal;
+  }
+}
+function readOmniSurface(sv, result) {
+  const color = svColor(sv, "diffuse_reflection_color");
+  if (color) result.color = color;
+  const metalness = svNumber(sv, "metalness");
+  if (metalness !== void 0) result.metalness = metalness;
+  const roughness = svNumber(sv, "specular_reflection_roughness");
+  if (roughness !== void 0) result.roughness = roughness;
+  const ior = svNumber(sv, "specular_reflection_ior");
+  if (ior !== void 0) result.ior = ior;
+  const coat = svNumber(sv, "coat_weight");
+  if (coat !== void 0 && coat > 0) {
+    result.clearcoat = coat;
+    const coatRoughness = svNumber(sv, "coat_roughness");
+    if (coatRoughness !== void 0) result.clearcoatRoughness = coatRoughness;
+  }
+  const emissionWeight = svNumber(sv, "emission_weight");
+  const emissionColor = svColor(sv, "emission_color");
+  if (emissionWeight !== void 0 && emissionWeight > 0 && emissionColor) {
+    result.emissiveColor = emissionColor;
+    result.emissiveIntensity = emissionWeight;
+  }
+  if (svBoolean(sv, "enable_opacity") === true) {
+    const opacity = svNumber(sv, "geometry_opacity");
+    if (opacity !== void 0) result.opacity = opacity;
+  }
+}
+function authored(sv, name) {
+  return sv.shader.GetAttribute(`inputs:${name}`).Get();
+}
+function asNumber2(v) {
+  return typeof v === "number" ? v : void 0;
+}
+function asBoolean(v) {
+  return typeof v === "boolean" ? v : void 0;
+}
+function asVec(v, length) {
+  if (Array.isArray(v) && v.length >= length && v.every((n) => typeof n === "number")) {
+    return v.slice(0, length);
+  }
+  return void 0;
+}
+function svNumber(sv, name) {
+  return asNumber2(authored(sv, name)) ?? asNumber2(sv.mdl?.get(name));
+}
+function svBoolean(sv, name) {
+  return asBoolean(authored(sv, name)) ?? asBoolean(sv.mdl?.get(name));
+}
+function svColor(sv, name) {
+  const v = asVec(authored(sv, name), 3) ?? asVec(sv.mdl?.get(name), 3);
+  return v ? v : void 0;
+}
+function svVec2(sv, name) {
+  const v = asVec(authored(sv, name), 2) ?? asVec(sv.mdl?.get(name), 2);
+  return v ? v : void 0;
+}
+function firstNumber(sv, names) {
+  for (const name of names) {
+    const v = asNumber2(authored(sv, name));
+    if (v !== void 0) return v;
+  }
+  for (const name of names) {
+    const v = asNumber2(sv.mdl?.get(name));
+    if (v !== void 0) return v;
+  }
+  return void 0;
+}
+function firstColor(sv, names) {
+  for (const name of names) {
+    const v = asVec(authored(sv, name), 3);
+    if (v) return v;
+  }
+  for (const name of names) {
+    const v = asVec(sv.mdl?.get(name), 3);
+    if (v) return v;
+  }
+  return void 0;
+}
+function directTexture(sv, name) {
+  const v = authored(sv, name);
+  if (v instanceof AssetPath && v.path) return withMdlTransform(sv, { path: v.path });
+  return void 0;
+}
+function mdlValueTexture(sv, name) {
+  const v = sv.mdl?.get(name);
+  if (!isMdlTexture(v)) return void 0;
+  const texture = { path: resolveMdlRelative(sv.mdlAssetPath, v.assetPath) };
+  if (v.sourceColorSpace) texture.sourceColorSpace = v.sourceColorSpace;
+  return withMdlTransform(sv, texture);
+}
+function resolveMdlRelative(modulePath, path) {
+  if (!modulePath || path.startsWith("/") || /^[a-z][a-z0-9+.-]*:/i.test(path)) return path;
+  return joinPosix(modulePath, path);
+}
+function withMdlTransform(sv, texture) {
+  const transform = mdlTextureTransform(sv);
+  return transform ? { ...texture, transform } : texture;
+}
+function findTexture(sv, lookup) {
   for (const name of lookup.direct) {
-    const v = shader.GetAttribute(name).Get();
-    if (v instanceof AssetPath && v.path) return { path: v.path };
+    const texture = directTexture(sv, name);
+    if (texture) return texture;
   }
   for (const name of lookup.surface) {
-    const conn = shader.GetAttribute(name).GetConnections()[0];
+    const conn = sv.shader.GetAttribute(`inputs:${name}`).GetConnections()[0];
     if (!conn) continue;
-    const texPrim = shader.GetStage().GetPrimAtPath(conn.split(".")[0]);
+    const texPrim = sv.shader.GetStage().GetPrimAtPath(conn.split(".")[0]);
     if (!texPrim) continue;
     const file = texPrim.GetAttribute("inputs:file").Get();
-    if (file instanceof AssetPath && file.path) return readUvTexture(texPrim, file.path);
+    if (file instanceof AssetPath && file.path) {
+      const tex = readUvTexture(texPrim, file.path);
+      const channel = outputChannelOf(conn);
+      if (channel) tex.outputChannel = channel;
+      return tex;
+    }
+  }
+  for (const name of lookup.direct) {
+    const texture = mdlValueTexture(sv, name);
+    if (texture) return texture;
   }
   return void 0;
 }
+function outputChannelOf(connection) {
+  const m = /\.outputs:(\w+)$/.exec(connection);
+  switch (m?.[1]) {
+    case "r":
+    case "g":
+    case "b":
+    case "a":
+      return m[1];
+    case "rgb":
+    case "rgba":
+      return "rgb";
+    default:
+      return void 0;
+  }
+}
+function mdlTextureTransform(sv) {
+  const transform = {};
+  const translation = svVec2(sv, "texture_translate");
+  if (translation) transform.translation = translation;
+  const scale = svVec2(sv, "texture_scale");
+  if (scale) transform.scale = scale;
+  const rotation = svNumber(sv, "texture_rotate");
+  if (rotation !== void 0) transform.rotation = rotation;
+  return Object.keys(transform).length > 0 ? transform : void 0;
+}
 var WRAP_VALUES = /* @__PURE__ */ new Set(["repeat", "clamp", "mirror", "black"]);
 function readUvTexture(texPrim, path) {
   const tex = { path };
@@ -378,39 +921,58 @@ function readUvTexture(texPrim, path) {
   if (scale) tex.scale = scale;
   const bias = numArray(texPrim, "inputs:bias", 4);
   if (bias) tex.bias = bias;
-  const transform = readTransform2d(texPrim);
-  if (transform) tex.transform = transform;
+  const sourceColorSpace = texPrim.GetAttribute("inputs:sourceColorSpace").Get();
+  if (sourceColorSpace === "raw" || sourceColorSpace === "sRGB" || sourceColorSpace === "auto") {
+    tex.sourceColorSpace = sourceColorSpace;
+  }
+  const st = readStChain(texPrim);
+  if (st.transform) tex.transform = st.transform;
+  if (st.uvSet) tex.uvSet = st.uvSet;
   return tex;
 }
-function readTransform2d(texPrim) {
-  const conn = texPrim.GetAttribute("inputs:st").GetConnections()[0];
-  if (!conn) return void 0;
-  const node = texPrim.GetStage().GetPrimAtPath(conn.split(".")[0]);
-  if (!node || node.GetAttribute("info:id").Get() !== "UsdTransform2d") return void 0;
-  const transform = {};
-  const translation = numArray(node, "inputs:translation", 2);
-  if (translation) transform.translation = translation;
-  const scale = numArray(node, "inputs:scale", 2);
-  if (scale) transform.scale = scale;
-  const rotation = node.GetAttribute("inputs:rotation").Get();
-  if (typeof rotation === "number") transform.rotation = rotation;
-  return Object.keys(transform).length > 0 ? transform : void 0;
+function connectedPrim(prim, input) {
+  const conn = prim.GetAttribute(input).GetConnections()[0];
+  if (!conn) return null;
+  return prim.GetStage().GetPrimAtPath(conn.split(".")[0]);
 }
-function numArray(prim, name, length) {
-  const v = prim.GetAttribute(name).Get();
-  if (Array.isArray(v) && v.length >= length && v.every((n) => typeof n === "number")) {
-    return v.slice(0, length);
+function readStChain(texPrim) {
+  const out = {};
+  let node = connectedPrim(texPrim, "inputs:st");
+  if (node && node.GetAttribute("info:id").Get() === "UsdTransform2d") {
+    const transform = {};
+    const translation = numArray(node, "inputs:translation", 2);
+    if (translation) transform.translation = translation;
+    const scale = numArray(node, "inputs:scale", 2);
+    if (scale) transform.scale = scale;
+    const rotation = node.GetAttribute("inputs:rotation").Get();
+    if (typeof rotation === "number") transform.rotation = rotation;
+    if (Object.keys(transform).length > 0) out.transform = transform;
+    node = connectedPrim(node, "inputs:in");
+  }
+  if (node && node.GetAttribute("info:id").Get() === "UsdPrimvarReader_float2") {
+    const varname = node.GetAttribute("inputs:varname").Get();
+    if (typeof varname === "string" && varname.length > 0) out.uvSet = varname;
   }
-  return void 0;
+  return out;
+}
+function numArray(prim, name, length) {
+  return asVec(prim.GetAttribute(name).Get(), length);
 }
 function findBinding(prim) {
+  let chosen;
   let p = prim;
   while (p) {
-    const targets = p.GetRelationship("material:binding").GetTargets();
-    if (targets.length > 0) return targets[0];
+    for (const name of ["material:binding:preview", "material:binding"]) {
+      const rel = p.GetRelationship(name);
+      const target = rel.GetTargets()[0];
+      if (!target) continue;
+      const stronger = rel.GetMetadata("bindMaterialAs") === "strongerThanDescendants";
+      if (chosen === void 0 || stronger) chosen = target;
+      break;
+    }
     p = p.GetParent();
   }
-  return void 0;
+  return chosen;
 }
 function findSurfaceShader(material) {
   for (const out of SURFACE_OUTPUTS) {
@@ -423,22 +985,6 @@ function findSurfaceShader(material) {
   }
   return material.GetChildren().find((c) => c.GetTypeName() === "Shader") ?? void 0;
 }
-function firstColor(shader, names) {
-  for (const name of names) {
-    const v = shader.GetAttribute(name).Get();
-    if (Array.isArray(v) && v.length >= 3 && v.every((n) => typeof n === "number")) {
-      return [v[0], v[1], v[2]];
-    }
-  }
-  return void 0;
-}
-function firstNumber(shader, names) {
-  for (const name of names) {
-    const v = shader.GetAttribute(name).Get();
-    if (typeof v === "number") return v;
-  }
-  return void 0;
-}
 
 // src/robot/buildKinematicTree.ts
 var WORLD = "";
@@ -720,61 +1266,6 @@ function leafName(path) {
   return parts[parts.length - 1] ?? path;
 }
 
-// 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) {
-  const decoder = new TextDecoder();
-  const encoder = new TextEncoder();
-  return {
-    resolve(assetPath, baseUrl) {
-      return joinPosix(baseUrl, assetPath);
-    },
-    fetchText(url) {
-      const v = files[url];
-      if (v === void 0) return Promise.reject(new Error(`asset not found: ${url}`));
-      return Promise.resolve(typeof v === "string" ? v : decoder.decode(v));
-    },
-    fetchBytes(url) {
-      const v = files[url];
-      if (v === void 0) return Promise.reject(new Error(`asset not found: ${url}`));
-      return Promise.resolve(typeof v === "string" ? encoder.encode(v) : v);
-    }
-  };
-}
-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/parser/reader.ts
 var ParseError = class extends Error {
   constructor(message, line, col) {
@@ -861,7 +1352,7 @@ var TokenizeError = class extends Error {
 };
 var IDENT_START = /[A-Za-z_]/;
 var IDENT_CONT = /[A-Za-z0-9_:]/;
-var NUMBER_RE = /^[-+]?(?:\d+\.?\d*|\.\d+)(?:[eE][-+]?\d+)?/;
+var NUMBER_RE2 = /^[-+]?(?:\d+\.?\d*|\.\d+)(?:[eE][-+]?\d+)?/;
 var INF_NAN_RE = /^[-+]?(?:inf|nan)\b/i;
 function tokenize(src) {
   const tokens = [];
@@ -933,7 +1424,7 @@ function tokenize(src) {
       continue;
     }
     if (/[0-9]/.test(c) || (c === "-" || c === "+" || c === ".") && /[0-9.]/.test(src[i + 1] ?? "")) {
-      const m = NUMBER_RE.exec(src.slice(i));
+      const m = NUMBER_RE2.exec(src.slice(i));
       if (m) {
         const text = m[0];
         push("number", text, startCol, Number(text));
@@ -1776,6 +2267,10 @@ var Attribute = class {
   GetConnections() {
     return this._spec?.connections ?? [];
   }
+  /** Authored attribute metadata (`interpolation`, `elementSize`, …). */
+  GetMetadata(key) {
+    return this._spec?.metadata[key];
+  }
 };
 var Relationship = class {
   constructor(_prim, _name, _spec) {
@@ -1807,6 +2302,10 @@ var Relationship = class {
   GetTargets() {
     return this._spec?.targets ?? [];
   }
+  /** Authored relationship metadata (`bindMaterialAs`, …). */
+  GetMetadata(key) {
+    return this._spec?.metadata[key];
+  }
 };
 
 // src/usd/Prim.ts
@@ -2159,10 +2658,17 @@ var CrateType = {
   Quatf: 17,
   Vec2d: 19,
   Vec2f: 20,
+  Vec2h: 21,
+  Vec2i: 22,
   Vec3d: 23,
   Vec3f: 24,
+  Vec3h: 25,
+  Vec3i: 26,
   Vec4d: 27,
   Vec4f: 28,
+  Vec4h: 29,
+  Vec4i: 30,
+  Dictionary: 31,
   TokenListOp: 32,
   PathListOp: 34,
   ReferenceListOp: 35,
@@ -2173,6 +2679,8 @@ var CrateType = {
   Permission: 43,
   Variability: 44,
   VariantSelectionMap: 45,
+  TimeSamples: 46,
+  DoubleVector: 48,
   StringVector: 50,
   PayloadListOp: 55};
 var ListOpBits = {
@@ -2207,6 +2715,12 @@ function halfToFloat(h) {
 var MAGIC = "PXR-USDC";
 var scratch = new DataView(new ArrayBuffer(8));
 var FIELDSET_END = -1;
+var MIN_COMPRESSED_ARRAY_SIZE = 16;
+function inlineInt8s(low, n) {
+  const out = new Array(n);
+  for (let i = 0; i < n; i++) out[i] = (low >>> i * 8 & 255) << 24 >> 24;
+  return out;
+}
 var CrateReader = class {
   version;
   view;
@@ -2440,6 +2954,33 @@ var CrateReader = class {
     if (b.isInlined) return this.readInlined(b.type, b.payload);
     return this.readScalar(b.type, Number(b.payload));
   }
+  /**
+   * Decode a `timeSamples` field (a {@link CrateType.TimeSamples} rep) into
+   * parallel times/values arrays; `undefined` if `rep` is some other type.
+   *
+   * Layout (pxr `crateFile.cpp`, `Write(TimeSamples)`): an `int64` offset —
+   * relative to its own position — jumps over the recursively-written times
+   * data to the times `ValueRep` (a `DoubleVector`); a second such offset
+   * jumps over the samples' data to `[u64 count][count × ValueRep]`. Sample
+   * reps decode through {@link getValue}, so every scalar/array type works.
+   */
+  getTimeSamples(rep) {
+    const b = decodeRepBits(rep);
+    if (b.type !== CrateType.TimeSamples || b.isArray || b.isInlined) return void 0;
+    const off = Number(b.payload);
+    let p = off + Number(this.i64(off));
+    const times = this.getValue(this.view.getBigUint64(p, true));
+    p += 8;
+    if (!Array.isArray(times) || !times.every((t) => typeof t === "number")) return void 0;
+    p += Number(this.i64(p));
+    const count = this.u64(p);
+    p += 8;
+    const values = new Array(count);
+    for (let i = 0; i < count; i++) {
+      values[i] = this.getValue(this.view.getBigUint64(p + i * 8, true));
+    }
+    return { times, values };
+  }
   readInlined(type, payload) {
     const low = Number(payload & 0xffffffffn);
     switch (type) {
@@ -2469,6 +3010,62 @@ var CrateReader = class {
       case CrateType.Permission:
       case CrateType.Variability:
         return low;
+      // Vectors whose components are all small integers are inlined as one
+      // int8 per component in the payload's low bytes (crateValueInliners.h).
+      case CrateType.Vec2i:
+      case CrateType.Vec2h:
+      case CrateType.Vec2f:
+      case CrateType.Vec2d:
+        return inlineInt8s(low, 2);
+      case CrateType.Vec3i:
+      case CrateType.Vec3h:
+      case CrateType.Vec3f:
+      case CrateType.Vec3d:
+        return inlineInt8s(low, 3);
+      case CrateType.Vec4i:
+      case CrateType.Vec4h:
+      case CrateType.Vec4f:
+      case CrateType.Vec4d:
+        return inlineInt8s(low, 4);
+      // Matrices inline when off-diagonal is zero and the diagonal fits int8.
+      case CrateType.Matrix3d: {
+        const [a, b, c] = inlineInt8s(low, 3);
+        return new UsdMatrix([
+          a,
+          0,
+          0,
+          0,
+          b,
+          0,
+          0,
+          0,
+          c
+        ], 3);
+      }
+      case CrateType.Matrix4d: {
+        const [a, b, c, d] = inlineInt8s(low, 4);
+        return new UsdMatrix([
+          a,
+          0,
+          0,
+          0,
+          0,
+          b,
+          0,
+          0,
+          0,
+          0,
+          c,
+          0,
+          0,
+          0,
+          0,
+          d
+        ], 4);
+      }
+      // Only the empty dictionary is inlined.
+      case CrateType.Dictionary:
+        return {};
       default:
         return void 0;
     }
@@ -2486,6 +3083,12 @@ var CrateReader = class {
         return v.getInt32(off, true);
       case CrateType.UInt:
         return v.getUint32(off, true);
+      case CrateType.UChar:
+        return v.getUint8(off);
+      case CrateType.Int64:
+        return Number(v.getBigInt64(off, true));
+      case CrateType.UInt64:
+        return Number(v.getBigUint64(off, true));
       case CrateType.Token:
         return this.getToken(v.getUint32(off, true));
       case CrateType.String:
@@ -2504,6 +3107,18 @@ var CrateReader = class {
         return this.readFloat64s(off, 3);
       case CrateType.Vec4d:
         return this.readFloat64s(off, 4);
+      case CrateType.Vec2h:
+        return this.readHalfs(off, 2);
+      case CrateType.Vec3h:
+        return this.readHalfs(off, 3);
+      case CrateType.Vec4h:
+        return this.readHalfs(off, 4);
+      case CrateType.Vec2i:
+        return this.readInt32s(off, 2);
+      case CrateType.Vec3i:
+        return this.readInt32s(off, 3);
+      case CrateType.Vec4i:
+        return this.readInt32s(off, 4);
       case CrateType.Quatf: {
         const q = this.readFloat32s(off, 4);
         return new Quat(q[3], [q[0], q[1], q[2]]);
@@ -2533,41 +3148,176 @@ var CrateReader = class {
         return this.readIndexVector(off, "string").items;
       case CrateType.VariantSelectionMap:
         return this.readVariantSelectionMap(off);
+      case CrateType.DoubleVector: {
+        const count = this.u64(off);
+        return this.readFloat64s(off + 8, count);
+      }
+      case CrateType.Dictionary:
+        return this.readDictionary(off, 0);
       default:
         return void 0;
     }
   }
+  /** Array headers store a u32 count before crate 0.7.0, a u64 from 0.7.0 on. */
+  arrayHeader(off) {
+    if (this.version[0] === 0 && this.version[1] < 7) {
+      return { count: this.view.getUint32(off, true), next: off + 4 };
+    }
+    return { count: this.u64(off), next: off + 8 };
+  }
   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 { count, next: p } = this.arrayHeader(off);
+    if (count === 0) return [];
+    if (compressed) return this.readCompressedArray(type, p, count);
     const v = this.view;
     switch (type) {
+      case CrateType.Bool: {
+        const out = new Array(count);
+        for (let i = 0; i < count; i++) out[i] = this.bytes[p + i] !== 0;
+        return out;
+      }
+      case CrateType.UChar: {
+        const out = new Array(count);
+        for (let i = 0; i < count; i++) out[i] = this.bytes[p + i];
+        return out;
+      }
       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: {
+      case CrateType.Int64: {
         const out = new Array(count);
-        for (let i = 0; i < count; i++) out[i] = v.getFloat32(p + i * 4, true);
+        for (let i = 0; i < count; i++) out[i] = Number(v.getBigInt64(p + i * 8, true));
         return out;
       }
+      case CrateType.UInt64: {
+        const out = new Array(count);
+        for (let i = 0; i < count; i++) out[i] = Number(v.getBigUint64(p + i * 8, true));
+        return out;
+      }
+      case CrateType.Half:
+        return this.readHalfs(p, count);
+      case CrateType.Float:
+        return this.readFloat32s(p, count);
+      case CrateType.Double:
+        return this.readFloat64s(p, count);
       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.String: {
+        const out = new Array(count);
+        for (let i = 0; i < count; i++) {
+          out[i] = this.getToken(this.getStrings()[v.getUint32(p + i * 4, true)] ?? 0);
+        }
+        return out;
+      }
+      case CrateType.AssetPath: {
+        const out = new Array(count);
+        for (let i = 0; i < count; i++) {
+          out[i] = new AssetPath(
+            this.getToken(this.getStrings()[v.getUint32(p + i * 4, true)] ?? 0)
+          );
+        }
+        return out;
+      }
+      case CrateType.Vec2f:
+        return this.readTupleArray(p, count, 2, "f32");
       case CrateType.Vec3f:
-        return this.readVec3fArray(p, count, false);
+        return this.readTupleArray(p, count, 3, "f32");
+      case CrateType.Vec4f:
+        return this.readTupleArray(p, count, 4, "f32");
+      case CrateType.Vec2d:
+        return this.readTupleArray(p, count, 2, "f64");
       case CrateType.Vec3d:
-        return this.readVec3fArray(p, count, true);
+        return this.readTupleArray(p, count, 3, "f64");
+      case CrateType.Vec4d:
+        return this.readTupleArray(p, count, 4, "f64");
+      case CrateType.Vec2h:
+        return this.readTupleArray(p, count, 2, "f16");
+      case CrateType.Vec3h:
+        return this.readTupleArray(p, count, 3, "f16");
+      case CrateType.Vec4h:
+        return this.readTupleArray(p, count, 4, "f16");
+      case CrateType.Vec2i:
+        return this.readTupleArray(p, count, 2, "i32");
+      case CrateType.Vec3i:
+        return this.readTupleArray(p, count, 3, "i32");
+      case CrateType.Vec4i:
+        return this.readTupleArray(p, count, 4, "i32");
+      case CrateType.Quatf: {
+        const out = new Array(count);
+        for (let i = 0; i < count; i++) {
+          const q = this.readFloat32s(p + i * 16, 4);
+          out[i] = new Quat(q[3], [q[0], q[1], q[2]]);
+        }
+        return out;
+      }
+      case CrateType.Quatd: {
+        const out = new Array(count);
+        for (let i = 0; i < count; i++) {
+          const q = this.readFloat64s(p + i * 32, 4);
+          out[i] = new Quat(q[3], [q[0], q[1], q[2]]);
+        }
+        return out;
+      }
+      case CrateType.Matrix3d: {
+        const out = new Array(count);
+        for (let i = 0; i < count; i++) out[i] = new UsdMatrix(this.readFloat64s(p + i * 72, 9), 3);
+        return out;
+      }
+      case CrateType.Matrix4d: {
+        const out = new Array(count);
+        for (let i = 0; i < count; i++)
+          out[i] = new UsdMatrix(this.readFloat64s(p + i * 128, 16), 4);
+        return out;
+      }
+      default:
+        return void 0;
+    }
+  }
+  /**
+   * Decode an array whose rep has the compressed bit. Int arrays are
+   * integer-compressed; half/float/double arrays (crate 0.6.0+) carry a code
+   * byte — `'i'` when every value is integral, `'t'` for a lookup table +
+   * compressed indexes. Arrays under {@link MIN_COMPRESSED_ARRAY_SIZE} elements
+   * are stored raw even when the bit is set (mirrors pxr's writer).
+   */
+  readCompressedArray(type, start, count) {
+    let p = start;
+    switch (type) {
+      case CrateType.Int:
+      case CrateType.UInt: {
+        if (count < MIN_COMPRESSED_ARRAY_SIZE) {
+          const out = new Array(count);
+          for (let i = 0; i < count; i++) out[i] = this.view.getInt32(p + i * 4, true);
+          return out;
+        }
+        return this.readCompressedInts(p, count).values;
+      }
+      case CrateType.Half:
+      case CrateType.Float:
+      case CrateType.Double: {
+        const readRaw = (off, n) => type === CrateType.Double ? this.readFloat64s(off, n) : type === CrateType.Float ? this.readFloat32s(off, n) : this.readHalfs(off, n);
+        if (count < MIN_COMPRESSED_ARRAY_SIZE) return readRaw(p, count);
+        const code = this.bytes[p];
+        p += 1;
+        if (code === 105) {
+          return this.readCompressedInts(p, count).values;
+        }
+        if (code === 116) {
+          const lutSize = this.view.getUint32(p, true);
+          p += 4;
+          const lut = readRaw(p, lutSize);
+          p += lutSize * (type === CrateType.Double ? 8 : type === CrateType.Float ? 4 : 2);
+          return this.readCompressedInts(p, count).values.map((i) => lut[i] ?? 0);
+        }
+        return void 0;
+      }
       default:
         return void 0;
     }
@@ -2582,20 +3332,45 @@ var CrateReader = class {
     for (let i = 0; i < n; i++) out[i] = this.view.getFloat64(off + i * 8, true);
     return out;
   }
-  readVec3fArray(off, count, double) {
+  readHalfs(off, n) {
+    const out = new Array(n);
+    for (let i = 0; i < n; i++) out[i] = halfToFloat(this.view.getUint16(off + i * 2, true));
+    return out;
+  }
+  readInt32s(off, n) {
+    const out = new Array(n);
+    for (let i = 0; i < n; i++) out[i] = this.view.getInt32(off + i * 4, true);
+    return out;
+  }
+  /** Read `count` fixed-size `n`-tuples (vec2/3/4 of the given element kind). */
+  readTupleArray(off, count, n, kind) {
+    const elemSize = kind === "f64" ? 8 : kind === "f16" ? 2 : 4;
     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)
-      ];
+      const o = off + i * n * elemSize;
+      out[i] = kind === "f64" ? this.readFloat64s(o, n) : kind === "f32" ? this.readFloat32s(o, n) : kind === "f16" ? this.readHalfs(o, n) : this.readInt32s(o, n);
+    }
+    return out;
+  }
+  /**
+   * Read a `VtDictionary`: `[u64 count]`, then per entry a string index (key)
+   * followed by a recursive VtValue — an `int64` offset (relative to its own
+   * position) over the value's data to an 8-byte `ValueRep`.
+   */
+  readDictionary(off, depth) {
+    const out = {};
+    if (depth > 16) return out;
+    const count = this.u64(off);
+    let p = off + 8;
+    for (let i = 0; i < count; i++) {
+      const key = this.getToken(this.getStrings()[this.view.getUint32(p, true)] ?? 0);
+      p += 4;
+      const repPos = p + Number(this.i64(p));
+      const rep = this.view.getBigUint64(repPos, true);
+      const b = decodeRepBits(rep);
+      const value = b.type === CrateType.Dictionary && !b.isInlined && !b.isArray ? this.readDictionary(Number(b.payload), depth + 1) : this.getValue(rep);
+      if (key && value !== void 0) out[key] = value;
+      p = repPos + 8;
     }
     return out;
   }
@@ -2750,7 +3525,7 @@ function crateToUsdaFile(crate) {
     if (spec.specType !== SPEC_PRIM) continue;
     const fm = fieldsOf(spec.fieldSetIndex);
     primByPath.set(path, {
-      specifier: SPECIFIERS2[asNumber2(crate, fm.get("specifier")) ?? 0] ?? "def",
+      specifier: SPECIFIERS2[asNumber3(crate, fm.get("specifier")) ?? 0] ?? "def",
       typeName: asString(crate, fm.get("typeName")) ?? "",
       name: leaf(path),
       metadata: buildPrimMetadata(crate, fm),
@@ -2798,13 +3573,14 @@ function buildAttribute(crate, name, fm) {
   const defaultRep = fm.get("default");
   const rawType = asString(crate, fm.get("typeName")) ?? "";
   const isArrayType = rawType.endsWith("[]");
+  const customRep = fm.get("custom");
   const attr = {
     kind: "attribute",
     name,
     typeName: isArrayType ? rawType.slice(0, -2) : rawType,
     isArray: isArrayType || (defaultRep !== void 0 ? decodeRepBits(defaultRep).isArray : false),
-    variability: asNumber2(crate, fm.get("variability")) === 1 ? "uniform" : "varying",
-    custom: false,
+    variability: asNumber3(crate, fm.get("variability")) === 1 ? "uniform" : "varying",
+    custom: customRep !== void 0 && crate.getValue(customRep) === true,
     metadata: {},
     line: 0
   };
@@ -2812,6 +3588,25 @@ function buildAttribute(crate, name, fm) {
     const value = crate.getValue(defaultRep);
     if (value !== void 0) attr.value = value;
   }
+  const connections = fm.has("connectionPaths") ? crate.getValue(fm.get("connectionPaths")) : void 0;
+  if (Array.isArray(connections)) {
+    const paths = connections.filter((c) => typeof c === "string" && c.length > 0);
+    if (paths.length > 0) attr.connections = paths;
+  }
+  const interpolation = asString(crate, fm.get("interpolation"));
+  if (interpolation !== void 0) attr.metadata.interpolation = interpolation;
+  const tsRep = fm.get("timeSamples");
+  if (tsRep !== void 0) {
+    const ts = crate.getTimeSamples(tsRep);
+    if (ts) {
+      const samples = /* @__PURE__ */ new Map();
+      const pairs = ts.times.map((t, i) => [t, ts.values[i]]).sort((a, b) => a[0] - b[0]);
+      for (const [t, v] of pairs) {
+        if (v !== void 0) samples.set(t, v);
+      }
+      if (samples.size > 0) attr.timeSamples = samples;
+    }
+  }
   return attr;
 }
 function buildRelationship(crate, name, fm) {
@@ -2856,8 +3651,16 @@ function buildLayerMetadata(crate, fm) {
   if (upAxis !== void 0) meta.upAxis = upAxis;
   const defaultPrim2 = asString(crate, fm.get("defaultPrim"));
   if (defaultPrim2 !== void 0) meta.defaultPrim = defaultPrim2;
-  const metersPerUnit = asNumber2(crate, fm.get("metersPerUnit"));
+  const metersPerUnit = asNumber3(crate, fm.get("metersPerUnit"));
   if (metersPerUnit !== void 0) meta.metersPerUnit = metersPerUnit;
+  for (const key of ["startTimeCode", "endTimeCode", "timeCodesPerSecond", "framesPerSecond"]) {
+    const value = asNumber3(crate, fm.get(key));
+    if (value !== void 0) meta[key] = value;
+  }
+  const customLayerData = fm.has("customLayerData") ? crate.getValue(fm.get("customLayerData")) : void 0;
+  if (customLayerData && typeof customLayerData === "object" && !Array.isArray(customLayerData)) {
+    meta.customLayerData = customLayerData;
+  }
   return meta;
 }
 function asString(crate, rep) {
@@ -2865,7 +3668,7 @@ function asString(crate, rep) {
   const v = crate.getValue(rep);
   return typeof v === "string" ? v : void 0;
 }
-function asNumber2(crate, rep) {
+function asNumber3(crate, rep) {
   if (rep === void 0) return void 0;
   const v = crate.getValue(rep);
   return typeof v === "number" ? v : void 0;
@@ -3182,6 +3985,33 @@ function stripKeys(meta, keys) {
   }
   return out;
 }
+
+// src/usd/mdl/loadMdlModules.ts
+function collectMdlAssetPaths(stage) {
+  const paths = /* @__PURE__ */ new Set();
+  for (const prim of stage.Traverse()) {
+    if (prim.GetTypeName() !== "Shader") continue;
+    const asset = prim.GetAttribute("info:mdl:sourceAsset").Get();
+    if (asset instanceof AssetPath && asset.path) paths.add(asset.path);
+  }
+  return [...paths];
+}
+async function loadMdlModules(stage, resolver, baseUrl) {
+  const paths = collectMdlAssetPaths(stage);
+  if (paths.length === 0) return void 0;
+  const modules = /* @__PURE__ */ new Map();
+  await Promise.all(
+    paths.map(async (path) => {
+      try {
+        const module = parseMdl(await resolver.fetchText(resolver.resolve(path, baseUrl)));
+        if (module.materials.size > 0) modules.set(path, module);
+      } catch {
+      }
+    })
+  );
+  if (modules.size === 0) return void 0;
+  return (assetPath) => modules.get(assetPath);
+}
 var USD_ENTRY = /\.(usda|usdc|usd)$/i;
 function isZip(bytes) {
   if (bytes.length < 4 || bytes[0] !== 80 || bytes[1] !== 75) return false;
@@ -3218,6 +4048,6 @@ function openUsdz(bytes) {
   return { rootEntry, resolver };
 }
 
-export { ARTICULATION_ROOT_API, Attribute, COLLISION_API, CrateReader, DEFAULT_METERS_PER_UNIT, DefaultAssetResolver, Layer, MASS_API, MESH_COLLISION_API, PHYSICS_MATERIAL_API, ParseError, Prim, RIGID_BODY_API, Relationship, Stage, TokenizeError, buildKinematicTree, composeFile, composeLayer, computeLocalTransform, computeWorldTransform, crateToUsdaFile, createMemoryResolver, driveKindFor, extractRobotDescription, gatherGprimDescendants, gatherMeshDescendants, getJointAxis, getJointBodies, getJointDrive, getJointLimits, getJointLocalFrame, getJointStatePosition, getJointType, getMassProperties, getMaterialSubsets, hasArticulationRootAPI, hasCollisionAPI, hasRigidBodyAPI, isMesh, isNonVisualPurpose, isRenderableGprim, isScope, isSolidGprim, isXform, isZip, iterDescendants, joinPosix, jointValueFromSI, jointValueToSI, normalizeJointLimits, openUsdz, parseOpType, parseUsda, refineJointType, resolveBoundMaterial, serializeUsda, toBytes, tokenize };
-//# sourceMappingURL=chunk-2UD32EGU.js.map
-//# sourceMappingURL=chunk-2UD32EGU.js.map
+export { ARTICULATION_ROOT_API, Attribute, COLLISION_API, CrateReader, DEFAULT_METERS_PER_UNIT, DefaultAssetResolver, Layer, MASS_API, MESH_COLLISION_API, PHYSICS_MATERIAL_API, ParseError, Prim, RIGID_BODY_API, Relationship, Stage, TokenizeError, buildKinematicTree, collectMdlAssetPaths, composeFile, composeLayer, computeLocalTransform, computeWorldTransform, crateToUsdaFile, createMemoryResolver, driveKindFor, extractRobotDescription, gatherGprimDescendants, gatherMeshDescendants, getJointAxis, getJointBodies, getJointDrive, getJointLimits, getJointLocalFrame, getJointStatePosition, getJointType, getMassProperties, getMaterialSubsets, hasArticulationRootAPI, hasCollisionAPI, hasRigidBodyAPI, isBasisCurves, isMdlTexture, isMesh, isNonVisualPurpose, isPoints, isRenderableGprim, isScope, isSolidGprim, isUnsupportedGprim, isXform, isZip, iterDescendants, joinPosix, jointValueFromSI, jointValueToSI, loadMdlModules, normalizeJointLimits, openUsdz, parseMdl, parseMdlLiteral, parseOpType, parseUsda, refineJointType, resolveBoundMaterial, serializeUsda, toBytes, tokenize };
+//# sourceMappingURL=chunk-AXPMXEQC.js.map
+//# sourceMappingURL=chunk-AXPMXEQC.js.map