three-usd-robot 0.8.1 → 0.10.0

package/dist/{chunk-PHHMWMCA.js → chunk-NFKK5LJK.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-IYKPVUZ2.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();
@@ -335,6 +349,18 @@ function resolveBoundMaterial(stage, prim) {
   const emissive = firstColor(shader, EMISSIVE_INPUTS);
   if (emissive && shader.GetAttribute("inputs:enable_emission").Get() !== false) {
     result.emissiveColor = emissive;
+    const intensity = firstNumber(shader, ["inputs:emissive_intensity"]);
+    if (intensity !== void 0) result.emissiveIntensity = intensity;
+  }
+  const ior = firstNumber(shader, ["inputs:ior"]);
+  if (ior !== void 0) result.ior = ior;
+  const clearcoat = firstNumber(shader, ["inputs:clearcoat"]);
+  if (clearcoat !== void 0) result.clearcoat = clearcoat;
+  const clearcoatRoughness = firstNumber(shader, ["inputs:clearcoatRoughness"]);
+  if (clearcoatRoughness !== void 0) result.clearcoatRoughness = clearcoatRoughness;
+  if (shader.GetAttribute("inputs:useSpecularWorkflow").Get() === 1) {
+    const specular = firstColor(shader, ["inputs:specularColor"]);
+    if (specular) result.specularColor = specular;
   }
   const colorTex = findTexture(shader, TEXTURE_LOOKUPS.color);
   if (colorTex !== void 0) result.colorTexture = colorTex;
@@ -350,12 +376,23 @@ function resolveBoundMaterial(stage, prim) {
   if (aoTex !== void 0) result.occlusionTexture = aoTex;
   const emissiveTex = findTexture(shader, TEXTURE_LOOKUPS.emissive);
   if (emissiveTex !== void 0) result.emissiveTexture = emissiveTex;
+  const ormFile = shader.GetAttribute("inputs:ORM_texture").Get();
+  if (shader.GetAttribute("inputs:enable_ORM_texture").Get() === true && ormFile instanceof AssetPath && ormFile.path) {
+    const transform = mdlTextureTransform(shader);
+    const orm = { path: ormFile.path, ...transform ? { transform } : {} };
+    result.occlusionTexture = { ...orm, outputChannel: "r" };
+    result.roughnessTexture = { ...orm, outputChannel: "g" };
+    result.metalnessTexture = { ...orm, outputChannel: "b" };
+  }
   return result;
 }
 function findTexture(shader, lookup) {
   for (const name of lookup.direct) {
     const v = shader.GetAttribute(name).Get();
-    if (v instanceof AssetPath && v.path) return { path: v.path };
+    if (v instanceof AssetPath && v.path) {
+      const transform = mdlTextureTransform(shader);
+      return { path: v.path, ...transform ? { transform } : {} };
+    }
   }
   for (const name of lookup.surface) {
     const conn = shader.GetAttribute(name).GetConnections()[0];
@@ -363,10 +400,40 @@ function findTexture(shader, lookup) {
     const texPrim = shader.GetStage().GetPrimAtPath(conn.split(".")[0]);
     if (!texPrim) continue;
     const file = texPrim.GetAttribute("inputs:file").Get();
-    if (file instanceof AssetPath && file.path) return readUvTexture(texPrim, file.path);
+    if (file instanceof AssetPath && file.path) {
+      const tex = readUvTexture(texPrim, file.path);
+      const channel = outputChannelOf(conn);
+      if (channel) tex.outputChannel = channel;
+      return tex;
+    }
   }
   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(shader) {
+  const transform = {};
+  const translation = numArray(shader, "inputs:texture_translate", 2);
+  if (translation) transform.translation = translation;
+  const scale = numArray(shader, "inputs:texture_scale", 2);
+  if (scale) transform.scale = scale;
+  const rotation = shader.GetAttribute("inputs:texture_rotate").Get();
+  if (typeof rotation === "number") 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,23 +445,39 @@ 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 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 out;
 }
 function numArray(prim, name, length) {
   const v = prim.GetAttribute(name).Get();
@@ -404,13 +487,20 @@ function numArray(prim, name, length) {
   return void 0;
 }
 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) {
@@ -1776,6 +1866,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 +1901,10 @@ var Relationship = class {
   GetTargets() {
     return this._spec?.targets ?? [];
   }
+  /** Authored relationship metadata (`bindMaterialAs`, …). */
+  GetMetadata(key) {
+    return this._spec?.metadata[key];
+  }
 };
 
 // src/usd/Prim.ts
@@ -1907,6 +2005,15 @@ var Prim = class {
   GetAllMetadata() {
     return this._spec?.metadata ?? {};
   }
+  /**
+   * Model-hierarchy kind from the `kind` metadata — `"component"`, `"group"`,
+   * `"assembly"`, `"subcomponent"`, … — or `""` when unauthored. The standard
+   * signal for selection granularity (usdview's "select by kind").
+   */
+  GetKind() {
+    const kind = this._spec?.metadata.kind;
+    return typeof kind === "string" ? kind : "";
+  }
   /** Applied API schema names from `apiSchemas` (e.g. `PhysicsArticulationRootAPI`). */
   GetAppliedSchemas() {
     const raw = this._spec?.metadata.apiSchemas;
@@ -2150,10 +2257,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,
@@ -2164,6 +2278,8 @@ var CrateType = {
   Permission: 43,
   Variability: 44,
   VariantSelectionMap: 45,
+  TimeSamples: 46,
+  DoubleVector: 48,
   StringVector: 50,
   PayloadListOp: 55};
 var ListOpBits = {
@@ -2198,6 +2314,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;
@@ -2431,6 +2553,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) {
@@ -2460,6 +2609,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;
     }
@@ -2477,6 +2682,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:
@@ -2495,6 +2706,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]]);
@@ -2524,41 +2747,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;
     }
@@ -2573,20 +2931,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;
   }
@@ -2789,13 +3172,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,
+    custom: customRep !== void 0 && crate.getValue(customRep) === true,
     metadata: {},
     line: 0
   };
@@ -2803,6 +3187,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) {
@@ -2849,6 +3252,14 @@ function buildLayerMetadata(crate, fm) {
   if (defaultPrim2 !== void 0) meta.defaultPrim = defaultPrim2;
   const metersPerUnit = asNumber2(crate, fm.get("metersPerUnit"));
   if (metersPerUnit !== void 0) meta.metersPerUnit = metersPerUnit;
+  for (const key of ["startTimeCode", "endTimeCode", "timeCodesPerSecond", "framesPerSecond"]) {
+    const value = asNumber2(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) {
@@ -3209,6 +3620,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-PHHMWMCA.js.map
-//# sourceMappingURL=chunk-PHHMWMCA.js.map
+export { ARTICULATION_ROOT_API, Attribute, COLLISION_API, CrateReader, DEFAULT_METERS_PER_UNIT, DefaultAssetResolver, Layer, MASS_API, MESH_COLLISION_API, PHYSICS_MATERIAL_API, ParseError, Prim, RIGID_BODY_API, Relationship, Stage, TokenizeError, buildKinematicTree, composeFile, composeLayer, computeLocalTransform, computeWorldTransform, crateToUsdaFile, createMemoryResolver, driveKindFor, extractRobotDescription, gatherGprimDescendants, gatherMeshDescendants, getJointAxis, getJointBodies, getJointDrive, getJointLimits, getJointLocalFrame, getJointStatePosition, getJointType, getMassProperties, getMaterialSubsets, hasArticulationRootAPI, hasCollisionAPI, hasRigidBodyAPI, isBasisCurves, isMesh, isNonVisualPurpose, isPoints, isRenderableGprim, isScope, isSolidGprim, isUnsupportedGprim, isXform, isZip, iterDescendants, joinPosix, jointValueFromSI, jointValueToSI, normalizeJointLimits, openUsdz, parseOpType, parseUsda, refineJointType, resolveBoundMaterial, serializeUsda, toBytes, tokenize };
+//# sourceMappingURL=chunk-NFKK5LJK.js.map
+//# sourceMappingURL=chunk-NFKK5LJK.js.map