@loaders.gl/scene 5.0.0-beta.4 → 5.0.0-beta.5

package/dist/dist.dev.js

@@ -56,6 +56,1417 @@ var __exports__ = (() => {
     }
   });
 
+  // src/usd/libs/usdc-parser.js
+  function checkedLength(length4, bytesPerElement = 8) {
+    const byteLength = length4 * bytesPerElement;
+    if (!Number.isSafeInteger(length4) || length4 < 0 || !Number.isSafeInteger(byteLength) || byteLength > 256 * 1024 * 1024 - allocationBytes)
+      throw new Error("USDC: decoded allocation limit exceeded");
+    allocationBytes += byteLength;
+    return length4;
+  }
+  function checkedCount(count) {
+    if (!Number.isSafeInteger(count) || count < 0 || count > 4e6)
+      throw new Error("USDC: decoded allocation limit exceeded");
+    return checkedLength(count);
+  }
+  function lz4DecompressBlock(input, inputOffset, inputEnd, output, outputOffset, outputEnd) {
+    while (inputOffset < inputEnd) {
+      const token = input[inputOffset++];
+      if (inputOffset > inputEnd) throw new Error("USDC: truncated LZ4 token");
+      let literalLength = token >> 4;
+      if (literalLength === 15) {
+        let b;
+        do {
+          if (inputOffset >= inputEnd) throw new Error("USDC: truncated LZ4 length");
+          b = input[inputOffset++];
+          literalLength += b;
+        } while (b === 255);
+      }
+      if (literalLength > 0) {
+        if (inputOffset + literalLength > inputEnd) {
+          throw new Error("USDC: truncated LZ4 literal");
+        }
+        for (let i = 0; i < literalLength; i++) {
+          if (outputOffset >= outputEnd) throw new Error("USDC: LZ4 output overflow");
+          output[outputOffset++] = input[inputOffset++];
+        }
+      }
+      if (inputOffset >= inputEnd) break;
+      if (inputOffset + 2 > inputEnd) throw new Error("USDC: truncated LZ4 offset");
+      const matchOffset = input[inputOffset++] | input[inputOffset++] << 8;
+      if (matchOffset === 0) {
+        throw new Error("USDC: invalid LZ4 match offset");
+      }
+      let matchLength = (token & 15) + 4;
+      if (matchLength === 19) {
+        let b;
+        do {
+          if (inputOffset >= inputEnd) throw new Error("USDC: truncated LZ4 length");
+          b = input[inputOffset++];
+          matchLength += b;
+        } while (b === 255);
+      }
+      const matchPos = outputOffset - matchOffset;
+      if (matchPos < 0) {
+        throw new Error("USDC: invalid LZ4 match position");
+      }
+      for (let i = 0; i < matchLength; i++) {
+        if (outputOffset >= outputEnd) throw new Error("USDC: LZ4 output overflow");
+        output[outputOffset++] = output[matchPos + i];
+      }
+    }
+    return outputOffset;
+  }
+  function decompressLZ4(input, uncompressedSize, allowShortOutput = false) {
+    const output = new Uint8Array(checkedLength(uncompressedSize, 1));
+    if (!input.length) throw new Error("USDC: missing LZ4 chunk header");
+    const numChunks = input[0];
+    if (numChunks === 0) {
+      const written = lz4DecompressBlock(input, 1, input.length, output, 0, uncompressedSize);
+      if (!allowShortOutput && written !== uncompressedSize)
+        throw new Error("USDC: incomplete LZ4 output");
+      return output.subarray(0, written);
+    } else {
+      const CHUNK_SIZE = 65536;
+      if (1 + numChunks * 4 > input.length) throw new Error("USDC: truncated LZ4 chunk sizes");
+      let headerOffset = 1;
+      const compressedSizes = [];
+      for (let i = 0; i < numChunks; i++) {
+        const size = (input[headerOffset] | input[headerOffset + 1] << 8 | input[headerOffset + 2] << 16 | input[headerOffset + 3] << 24) >>> 0;
+        compressedSizes.push(size);
+        headerOffset += 4;
+      }
+      let inputOffset = headerOffset;
+      let outputOffset = 0;
+      for (let i = 0; i < numChunks; i++) {
+        const chunkCompressedSize = compressedSizes[i];
+        const chunkOutputSize = Math.min(CHUNK_SIZE, uncompressedSize - outputOffset);
+        if (chunkCompressedSize > input.length - inputOffset)
+          throw new Error("USDC: truncated LZ4 chunk");
+        const written = lz4DecompressBlock(
+          input,
+          inputOffset,
+          inputOffset + chunkCompressedSize,
+          output,
+          outputOffset,
+          outputOffset + chunkOutputSize
+        );
+        inputOffset += chunkCompressedSize;
+        if (i < numChunks - 1 && written !== outputOffset + chunkOutputSize)
+          throw new Error("USDC: incomplete LZ4 chunk");
+        outputOffset = written;
+      }
+      if (inputOffset !== input.length || !allowShortOutput && outputOffset !== uncompressedSize)
+        throw new Error("USDC: incomplete LZ4 output");
+      return output.subarray(0, outputOffset);
+    }
+  }
+  function decompressIntegers32(compressedData, numInts) {
+    const encodedSize = numInts * 4 + (numInts * 2 + 7 >> 3) + 4;
+    const encoded = decompressLZ4(new Uint8Array(compressedData), encodedSize, true);
+    return decodeIntegers32(encoded, numInts);
+  }
+  function decodeIntegers32(data, numInts) {
+    const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+    let offset = 0;
+    const commonValue = view.getInt32(offset, true);
+    offset += 4;
+    const numCodesBytes = numInts * 2 + 7 >> 3;
+    if (data.length < offset + numCodesBytes) throw new Error("USDC: truncated integer codes");
+    const codesStart = offset;
+    const vintsStart = offset + numCodesBytes;
+    const result = new Int32Array(checkedLength(numInts));
+    let prevVal = 0;
+    let codesOffset = codesStart;
+    let vintsOffset = vintsStart;
+    for (let i = 0; i < numInts; ) {
+      const codeByte = data[codesOffset++];
+      for (let j = 0; j < 4 && i < numInts; j++, i++) {
+        const code = codeByte >> j * 2 & 3;
+        let delta = 0;
+        switch (code) {
+          case 0:
+            delta = commonValue;
+            break;
+          case 1:
+            delta = view.getInt8(vintsOffset);
+            vintsOffset += 1;
+            break;
+          case 2:
+            delta = view.getInt16(vintsOffset, true);
+            vintsOffset += 2;
+            break;
+          case 3:
+            delta = view.getInt32(vintsOffset, true);
+            vintsOffset += 4;
+            break;
+        }
+        prevVal += delta;
+        result[i] = prevVal;
+      }
+    }
+    return result;
+  }
+  var allocationBytes, textDecoder, HALF_EXPONENT_TABLE, HALF_DENORM_SCALE, TypeEnum, DICTIONARY_ARRAY_TYPES, FIELD_SET_TERMINATOR, FLOAT_COMPRESSION_INT, FLOAT_COMPRESSION_LUT, BinaryReader, ValueRep, USDCParser;
+  var init_usdc_parser = __esm({
+    "src/usd/libs/usdc-parser.js"() {
+      "use strict";
+      allocationBytes = 0;
+      textDecoder = new TextDecoder();
+      HALF_EXPONENT_TABLE = new Float32Array(32);
+      for (let i = 0; i < 32; i++) {
+        HALF_EXPONENT_TABLE[i] = Math.pow(2, i - 15);
+      }
+      HALF_DENORM_SCALE = Math.pow(2, -14);
+      TypeEnum = {
+        Invalid: 0,
+        Bool: 1,
+        UChar: 2,
+        Int: 3,
+        UInt: 4,
+        Int64: 5,
+        UInt64: 6,
+        Half: 7,
+        Float: 8,
+        Double: 9,
+        String: 10,
+        Token: 11,
+        AssetPath: 12,
+        Matrix2d: 13,
+        Matrix3d: 14,
+        Matrix4d: 15,
+        Quatd: 16,
+        Quatf: 17,
+        Quath: 18,
+        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,
+        StringListOp: 33,
+        PathListOp: 34,
+        ReferenceListOp: 35,
+        IntListOp: 36,
+        Int64ListOp: 37,
+        UIntListOp: 38,
+        UInt64ListOp: 39,
+        PathVector: 40,
+        TokenVector: 41,
+        Specifier: 42,
+        Permission: 43,
+        Variability: 44,
+        VariantSelectionMap: 45,
+        TimeSamples: 46,
+        Payload: 47,
+        DoubleVector: 48,
+        LayerOffsetVector: 49,
+        StringVector: 50,
+        ValueBlock: 51,
+        Value: 52,
+        UnregisteredValue: 53,
+        UnregisteredValueListOp: 54,
+        PayloadListOp: 55,
+        TimeCode: 56,
+        PathExpression: 57,
+        Relocates: 58,
+        Spline: 59,
+        AnimationBlock: 60
+      };
+      DICTIONARY_ARRAY_TYPES = /* @__PURE__ */ new Set([
+        TypeEnum.Int,
+        TypeEnum.UInt,
+        TypeEnum.Float,
+        TypeEnum.Double,
+        TypeEnum.Half,
+        TypeEnum.String,
+        TypeEnum.Token
+      ]);
+      FIELD_SET_TERMINATOR = 4294967295;
+      FLOAT_COMPRESSION_INT = 105;
+      FLOAT_COMPRESSION_LUT = 116;
+      BinaryReader = class {
+        constructor(buffer) {
+          this.buffer = buffer;
+          this.view = new DataView(buffer);
+          this.offset = 0;
+        }
+        seek(offset) {
+          if (!Number.isSafeInteger(offset) || offset < 0 || offset > this.buffer.byteLength)
+            throw new Error("USDC: invalid seek");
+          this.offset = offset;
+        }
+        tell() {
+          return this.offset;
+        }
+        readUint8() {
+          const value = this.view.getUint8(this.offset);
+          this.offset += 1;
+          return value;
+        }
+        readInt8() {
+          const value = this.view.getInt8(this.offset);
+          this.offset += 1;
+          return value;
+        }
+        readUint16() {
+          const value = this.view.getUint16(this.offset, true);
+          this.offset += 2;
+          return value;
+        }
+        readInt16() {
+          const value = this.view.getInt16(this.offset, true);
+          this.offset += 2;
+          return value;
+        }
+        readUint32() {
+          const value = this.view.getUint32(this.offset, true);
+          this.offset += 4;
+          return value;
+        }
+        readInt32() {
+          const value = this.view.getInt32(this.offset, true);
+          this.offset += 4;
+          return value;
+        }
+        readUint64() {
+          const lo = this.view.getUint32(this.offset, true);
+          const hi = this.view.getUint32(this.offset + 4, true);
+          this.offset += 8;
+          const result = hi * 4294967296 + lo;
+          if (!Number.isSafeInteger(result)) throw new Error("USDC: integer exceeds safe precision");
+          return result;
+        }
+        readInt64() {
+          const lo = this.view.getUint32(this.offset, true);
+          const hi = this.view.getInt32(this.offset + 4, true);
+          this.offset += 8;
+          const result = hi * 4294967296 + lo;
+          if (!Number.isSafeInteger(result)) throw new Error("USDC: integer exceeds safe precision");
+          return result;
+        }
+        readFloat32() {
+          const value = this.view.getFloat32(this.offset, true);
+          this.offset += 4;
+          return value;
+        }
+        readFloat64() {
+          const value = this.view.getFloat64(this.offset, true);
+          this.offset += 8;
+          return value;
+        }
+        readBytes(length4) {
+          const bytes = new Uint8Array(this.buffer, this.offset, length4);
+          this.offset += length4;
+          return bytes;
+        }
+        readString(length4) {
+          const bytes = this.readBytes(length4);
+          let end = 0;
+          while (end < length4 && bytes[end] !== 0) end++;
+          return textDecoder.decode(bytes.subarray(0, end));
+        }
+      };
+      ValueRep = class {
+        constructor(lo, hi) {
+          this.lo = lo;
+          this.hi = hi;
+        }
+        get isArray() {
+          return (this.hi & 2147483648) !== 0;
+        }
+        get isInlined() {
+          return (this.hi & 1073741824) !== 0;
+        }
+        get isCompressed() {
+          return (this.hi & 536870912) !== 0;
+        }
+        get typeEnum() {
+          return this.hi >> 16 & 255;
+        }
+        get payload() {
+          return this.lo + (this.hi & 65535) * 4294967296;
+        }
+        getInlinedValue() {
+          return this.lo;
+        }
+      };
+      USDCParser = class {
+        /**
+         * Parse USDC file and return raw spec data without building Three.js scene.
+         * Used by USDComposer for unified scene composition.
+         */
+        parseData(buffer) {
+          allocationBytes = 0;
+          this._valueReadCount = 0;
+          this._activeDictionaries = /* @__PURE__ */ new Set();
+          this.buffer = buffer instanceof ArrayBuffer ? buffer : buffer.buffer;
+          this.reader = new BinaryReader(this.buffer);
+          this.version = { major: 0, minor: 0, patch: 0 };
+          this._conversionBuffer = new ArrayBuffer(4);
+          this._conversionView = new DataView(this._conversionBuffer);
+          this._readBootstrap();
+          this._readTOC();
+          this._readTokens();
+          this._readStrings();
+          this._readFields();
+          this._readFieldSets();
+          this._readPaths();
+          this._readSpecs();
+          this.specsByPath = /* @__PURE__ */ Object.create(null);
+          for (const spec of this.specs) {
+            const path2 = this.paths[spec.pathIndex];
+            if (!path2) continue;
+            const fields = this._getFieldsForSpec(spec);
+            this.specsByPath[path2] = { specType: spec.specType, fields };
+          }
+          return { specsByPath: this.specsByPath };
+        }
+        _readBootstrap() {
+          const reader = this.reader;
+          reader.seek(0);
+          const magic = reader.readString(8);
+          if (magic !== "PXR-USDC") {
+            throw new Error("THREE.USDCParser: Not a valid USDC file.");
+          }
+          this.version.major = reader.readUint8();
+          this.version.minor = reader.readUint8();
+          this.version.patch = reader.readUint8();
+          reader.readBytes(5);
+          this.tocOffset = reader.readUint64();
+        }
+        _readTOC() {
+          const reader = this.reader;
+          reader.seek(this.tocOffset);
+          const numSections = reader.readUint64();
+          if (numSections > 16) throw new Error("USDC: invalid section count");
+          this.sections = /* @__PURE__ */ Object.create(null);
+          for (let i = 0; i < numSections; i++) {
+            const name22 = reader.readString(16);
+            const start = reader.readUint64();
+            const size = reader.readUint64();
+            this.sections[name22] = { start, size };
+          }
+        }
+        _readTokens() {
+          const section = this.sections["TOKENS"];
+          if (!section) return;
+          const reader = this.reader;
+          reader.seek(section.start);
+          const numTokens = checkedCount(reader.readUint64());
+          this.tokens = [];
+          if (this.version.major === 0 && this.version.minor < 4) {
+            const tokensNumBytes = reader.readUint64();
+            const tokensData = reader.readBytes(tokensNumBytes);
+            let strStart = 0;
+            for (let i = 0; i < numTokens; i++) {
+              let strEnd = strStart;
+              while (strEnd < tokensData.length && tokensData[strEnd] !== 0) strEnd++;
+              if (strEnd >= tokensData.length) throw new Error("USDC: unterminated token data");
+              this.tokens.push(textDecoder.decode(tokensData.subarray(strStart, strEnd)));
+              strStart = strEnd + 1;
+            }
+          } else {
+            const uncompressedSize = reader.readUint64();
+            const compressedSize = reader.readUint64();
+            const compressedData = reader.readBytes(compressedSize);
+            const tokensData = decompressLZ4(compressedData, uncompressedSize);
+            checkedLength(tokensData.length, 2);
+            let strStart = 0;
+            for (let i = 0; i < numTokens; i++) {
+              let strEnd = strStart;
+              while (strEnd < tokensData.length && tokensData[strEnd] !== 0) strEnd++;
+              if (strEnd >= tokensData.length) throw new Error("USDC: unterminated token data");
+              this.tokens.push(textDecoder.decode(tokensData.subarray(strStart, strEnd)));
+              strStart = strEnd + 1;
+            }
+          }
+        }
+        _readStrings() {
+          const section = this.sections["STRINGS"];
+          if (!section) {
+            this.strings = [];
+            return;
+          }
+          const reader = this.reader;
+          reader.seek(section.start);
+          const numStrings = checkedCount(reader.readUint64());
+          this.strings = [];
+          for (let i = 0; i < numStrings; i++) {
+            this.strings.push(reader.readUint32());
+          }
+        }
+        _readFields() {
+          const section = this.sections["FIELDS"];
+          if (!section) return;
+          const reader = this.reader;
+          reader.seek(section.start);
+          this.fields = [];
+          if (this.version.major === 0 && this.version.minor < 4) {
+            const numFields = Math.floor(section.size / 12);
+            for (let i = 0; i < numFields; i++) {
+              const tokenIndex = reader.readUint32();
+              const repLo = reader.readUint32();
+              const repHi = reader.readUint32();
+              this.fields.push({
+                tokenIndex,
+                valueRep: new ValueRep(repLo, repHi)
+              });
+            }
+          } else {
+            const numFields = checkedCount(reader.readUint64());
+            const tokenIndicesCompressedSize = reader.readUint64();
+            const tokenIndicesCompressed = reader.readBytes(tokenIndicesCompressedSize);
+            const tokenIndices = decompressIntegers32(
+              tokenIndicesCompressed.buffer.slice(
+                tokenIndicesCompressed.byteOffset,
+                tokenIndicesCompressed.byteOffset + tokenIndicesCompressedSize
+              ),
+              numFields
+            );
+            const repsCompressedSize = reader.readUint64();
+            const repsCompressed = reader.readBytes(repsCompressedSize);
+            const repsData = decompressLZ4(repsCompressed, numFields * 8);
+            const repsView = new DataView(repsData.buffer, repsData.byteOffset, repsData.byteLength);
+            for (let i = 0; i < numFields; i++) {
+              const repLo = repsView.getUint32(i * 8, true);
+              const repHi = repsView.getUint32(i * 8 + 4, true);
+              this.fields.push({
+                tokenIndex: tokenIndices[i],
+                valueRep: new ValueRep(repLo, repHi)
+              });
+            }
+          }
+        }
+        _readFieldSets() {
+          const section = this.sections["FIELDSETS"];
+          if (!section) return;
+          const reader = this.reader;
+          reader.seek(section.start);
+          this.fieldSets = [];
+          if (this.version.major === 0 && this.version.minor < 4) {
+            const numFieldSets = Math.floor(section.size / 4);
+            for (let i = 0; i < numFieldSets; i++) {
+              this.fieldSets.push(reader.readUint32());
+            }
+          } else {
+            const numFieldSets = checkedCount(reader.readUint64());
+            const compressedSize = reader.readUint64();
+            const compressed = reader.readBytes(compressedSize);
+            const indices = decompressIntegers32(
+              compressed.buffer.slice(compressed.byteOffset, compressed.byteOffset + compressedSize),
+              numFieldSets
+            );
+            for (let i = 0; i < numFieldSets; i++) {
+              this.fieldSets.push(indices[i]);
+            }
+          }
+        }
+        _readPaths() {
+          const section = this.sections["PATHS"];
+          if (!section) return;
+          const reader = this.reader;
+          reader.seek(section.start);
+          const numPaths = checkedCount(reader.readUint64());
+          this.paths = new Array(checkedLength(numPaths)).fill("");
+          if (this.version.major === 0 && this.version.minor < 4) {
+            this._readPathsRecursive("");
+          } else {
+            reader.readUint64();
+            const compressedSize1 = reader.readUint64();
+            const pathIndicesCompressed = reader.readBytes(compressedSize1);
+            const pathIndices = decompressIntegers32(
+              pathIndicesCompressed.buffer.slice(
+                pathIndicesCompressed.byteOffset,
+                pathIndicesCompressed.byteOffset + compressedSize1
+              ),
+              numPaths
+            );
+            const compressedSize2 = reader.readUint64();
+            const elementTokenIndicesCompressed = reader.readBytes(compressedSize2);
+            const elementTokenIndices = decompressIntegers32(
+              elementTokenIndicesCompressed.buffer.slice(
+                elementTokenIndicesCompressed.byteOffset,
+                elementTokenIndicesCompressed.byteOffset + compressedSize2
+              ),
+              numPaths
+            );
+            const compressedSize3 = reader.readUint64();
+            const jumpsCompressed = reader.readBytes(compressedSize3);
+            const jumps = decompressIntegers32(
+              jumpsCompressed.buffer.slice(
+                jumpsCompressed.byteOffset,
+                jumpsCompressed.byteOffset + compressedSize3
+              ),
+              numPaths
+            );
+            this._buildPathsFromCompressed(pathIndices, elementTokenIndices, jumps);
+          }
+        }
+        _readPathsRecursive(parentPath, depth = 0) {
+          const reader = this.reader;
+          if (depth > 1e3) return;
+          const index = reader.readUint32();
+          const elementTokenIndex = reader.readUint32();
+          const bits = reader.readUint8();
+          const hasChild = (bits & 1) !== 0;
+          const hasSibling = (bits & 2) !== 0;
+          const isPrimProperty = (bits & 4) !== 0;
+          let path2;
+          if (parentPath === "") {
+            path2 = "/";
+          } else {
+            const elemToken = this.tokens[elementTokenIndex] || "";
+            if (isPrimProperty) {
+              path2 = parentPath + "." + elemToken;
+            } else {
+              path2 = parentPath === "/" ? "/" + elemToken : parentPath + "/" + elemToken;
+            }
+          }
+          checkedLength(path2.length, 2);
+          this.paths[index] = path2;
+          if (hasChild && hasSibling) {
+            const siblingOffset = reader.readUint64();
+            this._readPathsRecursive(path2, depth + 1);
+            reader.seek(siblingOffset);
+            this._readPathsRecursive(parentPath, depth + 1);
+          } else if (hasChild) {
+            this._readPathsRecursive(path2, depth + 1);
+          } else if (hasSibling) {
+            this._readPathsRecursive(parentPath, depth + 1);
+          }
+        }
+        /** Rebuilds compressed paths with an explicit stack instead of sibling recursion. */
+        _buildPathsFromCompressed(pathIndices, elementTokenIndices, jumps) {
+          let traversalCount = 0;
+          const pendingPaths = [{ startIndex: 0, parentPath: "" }];
+          while (pendingPaths.length) {
+            const pendingPath = pendingPaths.pop();
+            let currentIndex = pendingPath.startIndex;
+            let parentPath = pendingPath.parentPath;
+            while (currentIndex < pathIndices.length) {
+              if (++traversalCount > pathIndices.length * 2)
+                throw new Error("USDC: path traversal limit exceeded");
+              const nodeIndex = currentIndex++;
+              const pathIndex = pathIndices[nodeIndex];
+              const elementTokenIndex = elementTokenIndices[nodeIndex];
+              const jump = jumps[nodeIndex];
+              if (pathIndex < 0 || pathIndex >= this.paths.length || Math.abs(elementTokenIndex) >= this.tokens.length || jump < -2)
+                throw new Error("USDC: invalid compressed path index");
+              let path2;
+              if (parentPath === "") {
+                path2 = "/";
+                parentPath = path2;
+              } else {
+                const elementToken = this.tokens[Math.abs(elementTokenIndex)];
+                path2 = elementTokenIndex < 0 ? parentPath + "." + elementToken : parentPath === "/" ? "/" + elementToken : parentPath + "/" + elementToken;
+              }
+              checkedLength(path2.length, 2);
+              this.paths[pathIndex] = path2;
+              const hasChild = jump > 0 || jump === -1;
+              const hasSibling = jump >= 0;
+              if ((hasChild || hasSibling) && currentIndex >= pathIndices.length)
+                throw new Error("USDC: missing compressed path entry");
+              if (hasChild && hasSibling) {
+                const siblingIndex = nodeIndex + jump;
+                if (siblingIndex <= currentIndex || siblingIndex >= pathIndices.length)
+                  throw new Error("USDC: invalid compressed path jump");
+                pendingPaths.push({ startIndex: siblingIndex, parentPath });
+              }
+              if (hasChild) parentPath = path2;
+              else if (!hasSibling) break;
+            }
+          }
+        }
+        _readSpecs() {
+          const section = this.sections["SPECS"];
+          if (!section) return;
+          const reader = this.reader;
+          reader.seek(section.start);
+          this.specs = [];
+          if (this.version.major === 0 && this.version.minor < 4) {
+            const specSize = this.version.minor === 0 && this.version.patch === 1 ? 16 : 12;
+            const numSpecs = Math.floor(section.size / specSize);
+            for (let i = 0; i < numSpecs; i++) {
+              const pathIndex = reader.readUint32();
+              const fieldSetIndex = reader.readUint32();
+              const specType = reader.readUint32();
+              if (specSize === 16) reader.readUint32();
+              this.specs.push({ pathIndex, fieldSetIndex, specType });
+            }
+          } else {
+            const numSpecs = checkedCount(reader.readUint64());
+            const compressedSize1 = reader.readUint64();
+            const pathIndicesCompressed = reader.readBytes(compressedSize1);
+            const pathIndices = decompressIntegers32(
+              pathIndicesCompressed.buffer.slice(
+                pathIndicesCompressed.byteOffset,
+                pathIndicesCompressed.byteOffset + compressedSize1
+              ),
+              numSpecs
+            );
+            const compressedSize2 = reader.readUint64();
+            const fieldSetIndicesCompressed = reader.readBytes(compressedSize2);
+            const fieldSetIndices = decompressIntegers32(
+              fieldSetIndicesCompressed.buffer.slice(
+                fieldSetIndicesCompressed.byteOffset,
+                fieldSetIndicesCompressed.byteOffset + compressedSize2
+              ),
+              numSpecs
+            );
+            const compressedSize3 = reader.readUint64();
+            const specTypesCompressed = reader.readBytes(compressedSize3);
+            const specTypes = decompressIntegers32(
+              specTypesCompressed.buffer.slice(
+                specTypesCompressed.byteOffset,
+                specTypesCompressed.byteOffset + compressedSize3
+              ),
+              numSpecs
+            );
+            for (let i = 0; i < numSpecs; i++) {
+              this.specs.push({
+                pathIndex: pathIndices[i],
+                fieldSetIndex: fieldSetIndices[i],
+                specType: specTypes[i]
+              });
+            }
+          }
+        }
+        // ========================================================================
+        // Value Reading
+        // ========================================================================
+        _readValue(valueRep) {
+          this._valueReadCount = (this._valueReadCount || 0) + 1;
+          if (this._valueReadCount > 1e6) throw new Error("USDC: value traversal limit exceeded");
+          const type = valueRep.typeEnum;
+          const isArray2 = valueRep.isArray;
+          const isInlined = valueRep.isInlined;
+          if (type === TypeEnum.TimeSamples) {
+            return this._readTimeSamples(valueRep);
+          }
+          if (isInlined) {
+            return this._readInlinedValue(valueRep);
+          }
+          const offset = valueRep.payload;
+          if (offset === 0 && isArray2) {
+            return [];
+          }
+          if (offset < 0 || offset >= this.buffer.byteLength) {
+            throw new RangeError(
+              "USDCParser: Invalid payload offset " + offset + " for type " + type + "."
+            );
+          }
+          const savedOffset = this.reader.tell();
+          this.reader.seek(offset);
+          let value;
+          if (isArray2) {
+            value = this._readArrayValue(valueRep);
+          } else {
+            value = this._readScalarValue(type);
+          }
+          this.reader.seek(savedOffset);
+          return value;
+        }
+        _readInlinedValue(valueRep) {
+          const type = valueRep.typeEnum;
+          const payload = valueRep.getInlinedValue();
+          const view = this._conversionView;
+          switch (type) {
+            case TypeEnum.Dictionary:
+              if (payload !== 0) throw new Error("USDC: invalid inline dictionary");
+              return /* @__PURE__ */ Object.create(null);
+            case TypeEnum.Bool:
+              return payload !== 0;
+            case TypeEnum.UChar:
+              return payload & 255;
+            case TypeEnum.Int:
+            case TypeEnum.Int64:
+              return payload | 0;
+            case TypeEnum.UInt:
+            case TypeEnum.UInt64:
+              return payload >>> 0;
+            case TypeEnum.Half:
+              return this._halfToFloat(payload & 65535);
+            case TypeEnum.Float: {
+              view.setUint32(0, payload, true);
+              return view.getFloat32(0, true);
+            }
+            case TypeEnum.Double: {
+              view.setUint32(0, payload, true);
+              return view.getFloat32(0, true);
+            }
+            case TypeEnum.Token:
+              return this.tokens[payload] || "";
+            case TypeEnum.String:
+              return this.tokens[this.strings[payload]] || "";
+            case TypeEnum.AssetPath:
+              return this.tokens[payload] || "";
+            case TypeEnum.Specifier:
+              return payload;
+            // 0=def, 1=over, 2=class
+            case TypeEnum.Permission:
+            case TypeEnum.Variability:
+              return payload;
+            // Vec2h: Two half-floats fit in 4 bytes, stored directly
+            case TypeEnum.Vec2h: {
+              view.setUint32(0, payload, true);
+              return [
+                this._halfToFloat(view.getUint16(0, true)),
+                this._halfToFloat(view.getUint16(2, true))
+              ];
+            }
+            // Inlined vectors that don't fit in 4 bytes are encoded as signed 8-bit integers
+            // Vec2f = 8 bytes (2x float32), Vec3f = 12 bytes, Vec4f = 16 bytes, etc.
+            case TypeEnum.Vec2f:
+            case TypeEnum.Vec2i: {
+              view.setUint32(0, payload, true);
+              return [view.getInt8(0), view.getInt8(1)];
+            }
+            case TypeEnum.Vec3f:
+            case TypeEnum.Vec3i: {
+              view.setUint32(0, payload, true);
+              return [view.getInt8(0), view.getInt8(1), view.getInt8(2)];
+            }
+            case TypeEnum.Vec4f:
+            case TypeEnum.Vec4i: {
+              view.setUint32(0, payload, true);
+              return [view.getInt8(0), view.getInt8(1), view.getInt8(2), view.getInt8(3)];
+            }
+            case TypeEnum.Matrix2d: {
+              view.setUint32(0, payload, true);
+              const d0 = view.getInt8(0), d1 = view.getInt8(1);
+              return [d0, 0, 0, d1];
+            }
+            case TypeEnum.Matrix3d: {
+              view.setUint32(0, payload, true);
+              const d0 = view.getInt8(0), d1 = view.getInt8(1), d2 = view.getInt8(2);
+              return [d0, 0, 0, 0, d1, 0, 0, 0, d2];
+            }
+            case TypeEnum.Matrix4d: {
+              view.setUint32(0, payload, true);
+              const d0 = view.getInt8(0), d1 = view.getInt8(1), d2 = view.getInt8(2), d3 = view.getInt8(3);
+              return [d0, 0, 0, 0, 0, d1, 0, 0, 0, 0, d2, 0, 0, 0, 0, d3];
+            }
+            default:
+              throw new Error("USDC: unsupported inline value type " + type);
+          }
+        }
+        _readTimeSamples(valueRep) {
+          const reader = this.reader;
+          const offset = valueRep.payload;
+          const savedOffset = reader.tell();
+          reader.seek(offset);
+          const timesStart = reader.tell();
+          const timesRelOffset = reader.readInt64();
+          reader.seek(timesStart + timesRelOffset);
+          const timesRepLo = reader.readUint32();
+          const timesRepHi = reader.readUint32();
+          const timesRep = new ValueRep(timesRepLo, timesRepHi);
+          const times = this._readValue(timesRep);
+          const afterTimesRep = timesStart + timesRelOffset + 8;
+          reader.seek(afterTimesRep);
+          const valuesStart = reader.tell();
+          const valuesRelOffset = reader.readInt64();
+          reader.seek(valuesStart + valuesRelOffset);
+          const numValues = checkedCount(reader.readUint64());
+          const valueReps = [];
+          for (let i = 0; i < numValues; i++) {
+            const repLo = reader.readUint32();
+            const repHi = reader.readUint32();
+            valueReps.push(new ValueRep(repLo, repHi));
+          }
+          const values = [];
+          for (let i = 0; i < numValues; i++) {
+            values.push(this._readValue(valueReps[i]));
+          }
+          reader.seek(savedOffset);
+          const timesArray = times instanceof Float64Array ? Array.from(times) : Array.isArray(times) ? times : [times];
+          return { times: timesArray, values };
+        }
+        _readScalarValue(type) {
+          const reader = this.reader;
+          switch (type) {
+            case TypeEnum.Invalid:
+              return null;
+            case TypeEnum.Bool:
+              return reader.readUint8() !== 0;
+            case TypeEnum.UChar:
+              return reader.readUint8();
+            case TypeEnum.Int:
+              return reader.readInt32();
+            case TypeEnum.UInt:
+              return reader.readUint32();
+            case TypeEnum.Int64:
+              return reader.readInt64();
+            case TypeEnum.UInt64:
+              return reader.readUint64();
+            case TypeEnum.Half:
+              return this._readHalf();
+            case TypeEnum.Float:
+              return reader.readFloat32();
+            case TypeEnum.Double:
+              return reader.readFloat64();
+            case TypeEnum.String:
+            case TypeEnum.Token: {
+              const index = reader.readUint32();
+              return this.tokens[index] || "";
+            }
+            case TypeEnum.AssetPath: {
+              const index = reader.readUint32();
+              return this.tokens[index] || "";
+            }
+            case TypeEnum.Vec2f:
+              return [reader.readFloat32(), reader.readFloat32()];
+            case TypeEnum.Vec2d:
+              return [reader.readFloat64(), reader.readFloat64()];
+            case TypeEnum.Vec2i:
+              return [reader.readInt32(), reader.readInt32()];
+            case TypeEnum.Vec3f:
+              return [reader.readFloat32(), reader.readFloat32(), reader.readFloat32()];
+            case TypeEnum.Vec3d:
+              return [reader.readFloat64(), reader.readFloat64(), reader.readFloat64()];
+            case TypeEnum.Vec3i:
+              return [reader.readInt32(), reader.readInt32(), reader.readInt32()];
+            case TypeEnum.Vec4f:
+              return [
+                reader.readFloat32(),
+                reader.readFloat32(),
+                reader.readFloat32(),
+                reader.readFloat32()
+              ];
+            case TypeEnum.Vec4d:
+              return [
+                reader.readFloat64(),
+                reader.readFloat64(),
+                reader.readFloat64(),
+                reader.readFloat64()
+              ];
+            case TypeEnum.Quatf:
+              return [
+                reader.readFloat32(),
+                reader.readFloat32(),
+                reader.readFloat32(),
+                reader.readFloat32()
+              ];
+            case TypeEnum.Quatd:
+              return [
+                reader.readFloat64(),
+                reader.readFloat64(),
+                reader.readFloat64(),
+                reader.readFloat64()
+              ];
+            case TypeEnum.Matrix4d: {
+              const m = [];
+              for (let i = 0; i < 16; i++) m.push(reader.readFloat64());
+              return m;
+            }
+            case TypeEnum.TokenVector: {
+              const count = checkedCount(reader.readUint64());
+              const tokens = [];
+              for (let i = 0; i < count; i++) {
+                const index = reader.readUint32();
+                tokens.push(this.tokens[index] || "");
+              }
+              return tokens;
+            }
+            case TypeEnum.PathVector: {
+              const count = checkedCount(reader.readUint64());
+              const paths = [];
+              for (let i = 0; i < count; i++) {
+                const index = reader.readUint32();
+                paths.push(this.paths[index] || "");
+              }
+              return paths;
+            }
+            case TypeEnum.DoubleVector: {
+              const count = checkedCount(reader.readUint64());
+              const arr = new Float64Array(checkedLength(count));
+              for (let i = 0; i < count; i++) arr[i] = reader.readFloat64();
+              return arr;
+            }
+            case TypeEnum.Dictionary:
+              return this._readDictionary();
+            case TypeEnum.TokenListOp:
+            case TypeEnum.StringListOp:
+            case TypeEnum.IntListOp:
+            case TypeEnum.Int64ListOp:
+            case TypeEnum.UIntListOp:
+            case TypeEnum.UInt64ListOp:
+              throw new Error("USDC: value list operations are unsupported");
+            case TypeEnum.PathListOp: {
+              const flags = reader.readUint8();
+              if (flags & 24 || (flags & 102).toString(2).replaceAll("0", "").length > 1)
+                throw new Error("USDC: compound path list operations are unsupported");
+              const hasExplicitItems = (flags & 2) !== 0;
+              const hasAddItems = (flags & 4) !== 0;
+              const hasDeleteItems = (flags & 8) !== 0;
+              const hasReorderItems = (flags & 16) !== 0;
+              const hasPrependItems = (flags & 32) !== 0;
+              const hasAppendItems = (flags & 64) !== 0;
+              const readPathList = () => {
+                const itemCount = checkedCount(reader.readUint64());
+                const paths = [];
+                for (let i = 0; i < itemCount; i++) {
+                  const pathIdx = reader.readUint32();
+                  paths.push(this.paths[pathIdx]);
+                }
+                return paths;
+              };
+              let explicitPaths = null;
+              let addPaths = null;
+              let prependPaths = null;
+              let appendPaths = null;
+              if (hasExplicitItems) explicitPaths = readPathList();
+              if (hasAddItems) addPaths = readPathList();
+              if (hasPrependItems) prependPaths = readPathList();
+              if (hasAppendItems) appendPaths = readPathList();
+              if (hasDeleteItems) readPathList();
+              if (hasReorderItems) readPathList();
+              if (prependPaths && prependPaths.length > 0) return prependPaths;
+              if (explicitPaths && explicitPaths.length > 0) return explicitPaths;
+              if (appendPaths && appendPaths.length > 0) return appendPaths;
+              if (addPaths && addPaths.length > 0) return addPaths;
+              return null;
+            }
+            case TypeEnum.VariantSelectionMap: {
+              const elementCount = checkedCount(reader.readUint64());
+              const map = /* @__PURE__ */ Object.create(null);
+              for (let i = 0; i < elementCount; i++) {
+                const keyIdx = reader.readUint32();
+                const valueIdx = reader.readUint32();
+                const key = this.tokens[this.strings[keyIdx]];
+                const value = this.tokens[this.strings[valueIdx]];
+                if (key && value) map[key] = value;
+              }
+              return map;
+            }
+            default:
+              throw new Error(
+                "USDC: unsupported encoding: " + ["USDCParser: Unsupported scalar type", type].join(" ")
+              );
+          }
+        }
+        /** Reads bounded string-keyed dictionary entries and their recursive value representations. */
+        _readDictionary() {
+          const reader = this.reader;
+          const dictionaryOffset = reader.tell();
+          this._activeDictionaries ||= /* @__PURE__ */ new Set();
+          if (this._activeDictionaries.has(dictionaryOffset))
+            throw new Error("USDC: cyclic dictionary value");
+          if (this._activeDictionaries.size >= 64)
+            throw new Error("USDC: dictionary depth limit exceeded");
+          this._activeDictionaries.add(dictionaryOffset);
+          try {
+            const count = checkedCount(reader.readUint64());
+            if (count > Math.floor((this.buffer.byteLength - reader.tell()) / 20))
+              throw new Error("USDC: truncated dictionary entries");
+            const dictionary = /* @__PURE__ */ Object.create(null);
+            for (let index = 0; index < count; index++) {
+              const stringIndex = reader.readUint32();
+              const key = this.tokens[this.strings[stringIndex]];
+              if (typeof key !== "string" || Object.hasOwn(dictionary, key))
+                throw new Error("USDC: invalid dictionary key");
+              const offsetLocation = reader.tell();
+              const relativeOffset = reader.readInt64();
+              if (relativeOffset < 8) throw new Error("USDC: invalid dictionary value offset");
+              reader.seek(offsetLocation + relativeOffset);
+              const representation = new ValueRep(reader.readUint32(), reader.readUint32());
+              if (representation.typeEnum < TypeEnum.Bool || representation.typeEnum > TypeEnum.AssetPath && representation.typeEnum !== TypeEnum.Dictionary || representation.isArray && !DICTIONARY_ARRAY_TYPES.has(representation.typeEnum))
+                throw new Error("USDC: unsupported dictionary value type");
+              const nextEntry = reader.tell();
+              const value = this._readValue(representation);
+              dictionary[key] = representation.typeEnum === TypeEnum.AssetPath ? { assetPath: value } : value;
+              reader.seek(nextEntry);
+            }
+            return dictionary;
+          } finally {
+            this._activeDictionaries.delete(dictionaryOffset);
+          }
+        }
+        _readArrayValue(valueRep) {
+          const reader = this.reader;
+          const type = valueRep.typeEnum;
+          const isCompressed = valueRep.isCompressed;
+          let size;
+          if (this.version.major === 0 && this.version.minor < 7) {
+            size = reader.readUint32();
+          } else {
+            size = reader.readUint64();
+          }
+          if (!Number.isSafeInteger(size) || size < 0) {
+            throw new RangeError("USDCParser: Invalid array size " + size + " for type " + type + ".");
+          }
+          if (size > 2147483647) {
+            throw new RangeError("USDCParser: Array size " + size + " exceeds implementation limits.");
+          }
+          size = checkedCount(size);
+          if (size === 0) return [];
+          if (isCompressed) {
+            return this._readCompressedArray(type, size);
+          }
+          switch (type) {
+            case TypeEnum.Int: {
+              const arr = new Int32Array(checkedLength(size));
+              for (let i = 0; i < size; i++) arr[i] = reader.readInt32();
+              return arr;
+            }
+            case TypeEnum.UInt: {
+              const arr = new Uint32Array(checkedLength(size));
+              for (let i = 0; i < size; i++) arr[i] = reader.readUint32();
+              return arr;
+            }
+            case TypeEnum.Float: {
+              const arr = new Float32Array(checkedLength(size));
+              for (let i = 0; i < size; i++) arr[i] = reader.readFloat32();
+              return arr;
+            }
+            case TypeEnum.Double: {
+              const arr = new Float64Array(checkedLength(size));
+              for (let i = 0; i < size; i++) arr[i] = reader.readFloat64();
+              return arr;
+            }
+            case TypeEnum.Vec2f: {
+              const arr = new Float32Array(checkedLength(size * 2));
+              for (let i = 0; i < size * 2; i++) arr[i] = reader.readFloat32();
+              return arr;
+            }
+            case TypeEnum.Vec3f: {
+              const arr = new Float32Array(checkedLength(size * 3));
+              for (let i = 0; i < size * 3; i++) arr[i] = reader.readFloat32();
+              return arr;
+            }
+            case TypeEnum.Vec4f: {
+              const arr = new Float32Array(checkedLength(size * 4));
+              for (let i = 0; i < size * 4; i++) arr[i] = reader.readFloat32();
+              return arr;
+            }
+            case TypeEnum.Vec3h: {
+              const arr = new Float32Array(checkedLength(size * 3));
+              for (let i = 0; i < size * 3; i++) arr[i] = this._readHalf();
+              return arr;
+            }
+            case TypeEnum.Quatf: {
+              const arr = new Float32Array(checkedLength(size * 4));
+              for (let i = 0; i < size * 4; i++) arr[i] = reader.readFloat32();
+              return arr;
+            }
+            case TypeEnum.Quath: {
+              const arr = new Float32Array(checkedLength(size * 4));
+              for (let i = 0; i < size * 4; i++) arr[i] = this._readHalf();
+              return arr;
+            }
+            case TypeEnum.Matrix4d: {
+              const arr = new Float64Array(checkedLength(size * 16));
+              for (let i = 0; i < size * 16; i++) arr[i] = reader.readFloat64();
+              return arr;
+            }
+            case TypeEnum.String:
+            case TypeEnum.Token: {
+              const arr = [];
+              for (let i = 0; i < size; i++) {
+                const index = reader.readUint32();
+                const tokenIndex = type === TypeEnum.String ? this.strings[index] : index;
+                const value = this.tokens[tokenIndex];
+                if (typeof value !== "string") throw new Error("USDC: invalid string array index");
+                arr.push(value);
+              }
+              return arr;
+            }
+            case TypeEnum.Half: {
+              const arr = new Float32Array(checkedLength(size));
+              for (let i = 0; i < size; i++) arr[i] = this._readHalf();
+              return arr;
+            }
+            default:
+              throw new Error(
+                "USDC: unsupported encoding: " + ["USDCParser: Unsupported array type", type].join(" ")
+              );
+          }
+        }
+        _readCompressedArray(type, size) {
+          const reader = this.reader;
+          switch (type) {
+            case TypeEnum.Int:
+            case TypeEnum.UInt: {
+              const compressedSize = reader.readUint64();
+              const compressed = reader.readBytes(compressedSize);
+              const values = decompressIntegers32(
+                compressed.buffer.slice(compressed.byteOffset, compressed.byteOffset + compressedSize),
+                size
+              );
+              return type === TypeEnum.UInt ? new Uint32Array(values.buffer, values.byteOffset, values.length) : values;
+            }
+            case TypeEnum.Half:
+            case TypeEnum.Double:
+            case TypeEnum.Float: {
+              const code = reader.readInt8();
+              if (code === FLOAT_COMPRESSION_INT) {
+                const compressedSize = reader.readUint64();
+                const compressed = reader.readBytes(compressedSize);
+                const ints = decompressIntegers32(
+                  compressed.buffer.slice(compressed.byteOffset, compressed.byteOffset + compressedSize),
+                  size
+                );
+                const floats = type === TypeEnum.Double ? new Float64Array(checkedLength(size)) : new Float32Array(checkedLength(size));
+                for (let i = 0; i < size; i++)
+                  floats[i] = type === TypeEnum.Half ? this._convertHalfInteger(ints[i]) : ints[i];
+                return floats;
+              } else if (code === FLOAT_COMPRESSION_LUT) {
+                const lutSize = checkedCount(reader.readUint32());
+                if (lutSize === 0) throw new Error("USDC: invalid float lookup table");
+                const lut = type === TypeEnum.Double ? new Float64Array(checkedLength(lutSize)) : new Float32Array(checkedLength(lutSize));
+                for (let i = 0; i < lutSize; i++)
+                  lut[i] = type === TypeEnum.Half ? this._readHalf() : type === TypeEnum.Double ? reader.readFloat64() : reader.readFloat32();
+                const compressedSize = reader.readUint64();
+                const compressed = reader.readBytes(compressedSize);
+                const indices = decompressIntegers32(
+                  compressed.buffer.slice(compressed.byteOffset, compressed.byteOffset + compressedSize),
+                  size
+                );
+                const floats = type === TypeEnum.Double ? new Float64Array(checkedLength(size)) : new Float32Array(checkedLength(size));
+                for (let i = 0; i < size; i++) {
+                  if (indices[i] < 0 || indices[i] >= lutSize)
+                    throw new Error("USDC: invalid float lookup index");
+                  floats[i] = lut[indices[i]];
+                }
+                return floats;
+              }
+              throw new Error(
+                "USDC: unsupported encoding: " + ["USDCParser: Unknown float compression code", code].join(" ")
+              );
+            }
+            default:
+              throw new Error(
+                "USDC: unsupported encoding: " + ["USDCParser: Unsupported compressed array type", type].join(" ")
+              );
+          }
+        }
+        /** Rounds integer-compressed half samples using IEEE ties-to-even semantics. */
+        _convertHalfInteger(value) {
+          const absoluteValue = Math.abs(value);
+          if (absoluteValue <= 2048) return value;
+          if (absoluteValue >= 65520) return Math.sign(value) * Infinity;
+          const spacing = 2 ** (Math.floor(Math.log2(absoluteValue)) - 10);
+          const scaledValue = absoluteValue / spacing;
+          const lowerValue = Math.floor(scaledValue);
+          const fractionValue = scaledValue - lowerValue;
+          const roundedValue = fractionValue > 0.5 || fractionValue === 0.5 && lowerValue % 2 !== 0 ? lowerValue + 1 : lowerValue;
+          return Math.sign(value) * roundedValue * spacing;
+        }
+        _readHalf() {
+          return this._halfToFloat(this.reader.readUint16());
+        }
+        _halfToFloat(h) {
+          const sign = (h & 32768) >> 15;
+          const exp = (h & 31744) >> 10;
+          const frac = h & 1023;
+          if (exp === 0) {
+            if (frac === 0) {
+              return sign ? -0 : 0;
+            }
+            return (sign ? -1 : 1) * HALF_DENORM_SCALE * (frac / 1024);
+          } else if (exp === 31) {
+            return frac ? NaN : sign ? -Infinity : Infinity;
+          }
+          return (sign ? -1 : 1) * HALF_EXPONENT_TABLE[exp] * (1 + frac / 1024);
+        }
+        _getFieldsForSpec(spec) {
+          const fields = /* @__PURE__ */ Object.create(null);
+          let fieldSetIndex = spec.fieldSetIndex;
+          const maxIterations = 1e4;
+          let iterations = 0;
+          while (fieldSetIndex < this.fieldSets.length && iterations < maxIterations) {
+            const fieldIndex = this.fieldSets[fieldSetIndex];
+            if (fieldIndex === FIELD_SET_TERMINATOR || fieldIndex === -1) break;
+            const field = this.fields[fieldIndex];
+            if (!field) throw new Error("USDC: invalid field index");
+            if (field) {
+              const name22 = this.tokens[field.tokenIndex];
+              const value = this._readValue(field.valueRep);
+              fields[name22] = value;
+            }
+            fieldSetIndex++;
+            iterations++;
+          }
+          if (iterations >= maxIterations) throw new Error("USDC: field traversal limit exceeded");
+          return fields;
+        }
+      };
+    }
+  });
+
+  // src/usd/lib/parse-usdc.ts
+  function parseUSDC(data, url) {
+    if (data.byteLength < 88 || data.byteLength > 64 * 1024 * 1024)
+      throw new Error("USDC: invalid input size");
+    const bytes = new Uint8Array(data);
+    if (bytes[8] !== 0 || bytes[9] !== 8 || bytes[10] !== 0)
+      throw new Error("USDC: initial decoder requires crate version 0.8.0");
+    const reader = new DataView(data);
+    const table = reader.getBigUint64(16, true);
+    if (table > BigInt(data.byteLength - 8)) throw new Error("USDC: invalid section table");
+    const offset = Number(table), count = reader.getBigUint64(offset, true);
+    if (count > 16n || offset + 8 + Number(count) * 32 > data.byteLength)
+      throw new Error("USDC: invalid section table length");
+    const sectionNames = /* @__PURE__ */ new Set();
+    for (let index = 0; index < Number(count); index++) {
+      const entry = offset + 8 + index * 32;
+      const nameBytes = bytes.subarray(entry, entry + 16);
+      const terminator = nameBytes.indexOf(0);
+      const name22 = new TextDecoder().decode(
+        nameBytes.subarray(0, terminator < 0 ? nameBytes.length : terminator)
+      );
+      if (sectionNames.has(name22)) throw new Error("USDC: duplicate section");
+      sectionNames.add(name22);
+      const start = reader.getBigUint64(entry + 16, true), size = reader.getBigUint64(entry + 24, true);
+      if (start < 88n || start + size > BigInt(data.byteLength))
+        throw new Error("USDC: section out of bounds");
+    }
+    for (const name22 of ["TOKENS", "STRINGS", "FIELDS", "FIELDSETS", "PATHS", "SPECS"])
+      if (!sectionNames.has(name22)) throw new Error("USDC: missing required section");
+    const { specsByPath } = new USDCParser().parseData(data);
+    const prims = /* @__PURE__ */ new Map();
+    for (const [path2, specification] of Object.entries(specsByPath)) {
+      if (specification.specType === 7 && path2 === "/") continue;
+      if (specification.specType === 1 || specification.specType === 8) continue;
+      if (specification.specType !== 6 || !/^\/(?:[A-Za-z_][\w:]*\/)*[A-Za-z_][\w:]*$/.test(path2))
+        throw new Error("USDC: unsupported prim specification");
+      const fields = specification.fields;
+      const specifier = fields.specifier ?? 0;
+      if (specifier !== 0 && specifier !== 1 && specifier !== 2)
+        throw new Error("USDC: invalid prim specifier");
+      const metadata3 = convertFields(
+        fields,
+        /* @__PURE__ */ new Set(["specifier", "typeName", "primChildren", "properties"])
+      );
+      prims.set(path2, {
+        name: path2.slice(path2.lastIndexOf("/") + 1),
+        path: path2,
+        sourceUrl: url,
+        type: String(fields.typeName || ""),
+        specifier: ["def", "over", "class"][specifier],
+        attributes: /* @__PURE__ */ Object.create(null),
+        metadata: metadata3,
+        variants: /* @__PURE__ */ Object.create(null),
+        children: []
+      });
+    }
+    const roots = [];
+    for (const prim of prims.values()) {
+      const parentPath = prim.path.slice(0, prim.path.lastIndexOf("/"));
+      if (!parentPath) roots.push(prim);
+      else {
+        const parent = prims.get(parentPath);
+        if (!parent) throw new Error("USDC: missing parent prim");
+        parent.children.push(prim);
+      }
+    }
+    orderPrims(roots, specsByPath["/"]?.fields.primChildren);
+    for (const prim of prims.values())
+      orderPrims(prim.children, specsByPath[prim.path]?.fields.primChildren);
+    for (const [path2, specification] of Object.entries(specsByPath)) {
+      if (specification.specType !== 1 && specification.specType !== 8) continue;
+      const separator = path2.indexOf(".");
+      const prim = prims.get(path2.slice(0, separator));
+      if (separator < 0 || !prim) throw new Error("USDC: property has no owning prim");
+      const name22 = path2.slice(separator + 1), fields = specification.fields;
+      const type = specification.specType === 8 ? "rel" : String(fields.typeName || "");
+      const value = convertAttributeValue(
+        specification.specType === 8 ? fields.targetPaths : fields.default,
+        type
+      );
+      const metadata3 = convertFields(
+        fields,
+        /* @__PURE__ */ new Set(["typeName", "default", "targetPaths", "timeSamples"])
+      );
+      if (fields.timeSamples !== void 0)
+        metadata3.timeSamples = convertTimeSamples(fields.timeSamples, type);
+      prim.attributes[name22] = {
+        name: name22,
+        type,
+        value,
+        metadata: metadata3
+      };
+    }
+    return {
+      format: "usdc",
+      url,
+      metadata: convertFields(specsByPath["/"]?.fields || {}, /* @__PURE__ */ new Set(["primChildren"])),
+      rootPrims: roots,
+      layers: []
+    };
+  }
+  function convertFields(fields, excluded) {
+    const result = /* @__PURE__ */ Object.create(null);
+    for (const [name22, value] of Object.entries(fields))
+      if (!excluded.has(name22)) result[name22] = convertValue(value);
+    return result;
+  }
+  function convertValue(value) {
+    if (value === void 0 || value === null) return null;
+    if (typeof value === "number" || typeof value === "string" || typeof value === "boolean")
+      return value;
+    if (Array.isArray(value)) return value.map(convertValue);
+    if (ArrayBuffer.isView(value) && !(value instanceof DataView))
+      return Array.from(value);
+    if (typeof value === "object") return convertFields(value, /* @__PURE__ */ new Set());
+    throw new Error("USDC: unsupported decoded value");
+  }
+  function convertAttributeValue(raw, type) {
+    const value = convertValue(raw);
+    if (type === "asset" && typeof value === "string") return { assetPath: value };
+    if (type === "rel" && Array.isArray(value))
+      return value.map((path2) => typeof path2 === "string" ? { path: path2 } : path2);
+    const tuple = /^(?:(?:point|normal|vector|color|texCoord)([234])[fdh]|(?:float|double|half|int)([234]))\[\]$/.exec(
+      type
+    );
+    if (tuple && Array.isArray(value)) {
+      const components = Number(tuple[1] || tuple[2]);
+      if (value.length % components) throw new Error("USDC: incomplete vector tuple");
+      const tuples = [];
+      for (let offset = 0; offset < value.length; offset += components)
+        tuples.push(value.slice(offset, offset + components));
+      return tuples;
+    }
+    return value;
+  }
+  function orderPrims(prims, names) {
+    if (names === void 0) return;
+    if (!Array.isArray(names)) throw new Error("USDC: invalid primChildren order");
+    const remaining = new Map(prims.map((prim) => [prim.name, prim]));
+    const ordered = [];
+    for (const name22 of names) {
+      const prim = typeof name22 === "string" ? remaining.get(name22) : void 0;
+      if (!prim) throw new Error("USDC: invalid primChildren reference");
+      ordered.push(prim);
+      remaining.delete(name22);
+    }
+    for (const prim of remaining.values()) ordered.push(prim);
+    for (let index = 0; index < ordered.length; index++) prims[index] = ordered[index];
+  }
+  function convertTimeSamples(raw, type) {
+    if (!raw || typeof raw !== "object") throw new Error("USDC: invalid time samples");
+    const samples = raw;
+    const times = convertValue(samples.times);
+    if (!Array.isArray(times) || !Array.isArray(samples.values) || times.length !== samples.values.length)
+      throw new Error("USDC: invalid time samples");
+    return { times, values: samples.values.map((value) => convertAttributeValue(value, type)) };
+  }
+  var init_parse_usdc = __esm({
+    "src/usd/lib/parse-usdc.ts"() {
+      "use strict";
+      init_usdc_parser();
+    }
+  });
+
   // src/usd/lib/parse-usda.ts
   function parseUSDA(source, url) {
     if (!source.trimStart().startsWith("#usda")) {
@@ -90,7 +1501,7 @@ var __exports__ = (() => {
         }
         /** Parses the complete USDA layer. */
         parse() {
-          const metadata2 = this.tokenizer.match("(") ? this.parseMetadata(")") : {};
+          const metadata3 = this.tokenizer.match("(") ? this.parseMetadata(")") : {};
           const rootPrims = [];
           while (!this.tokenizer.isAtEnd()) {
             if (this.isPrimDeclaration()) {
@@ -102,7 +1513,7 @@ var __exports__ = (() => {
           return {
             format: "usda",
             url: this.url,
-            metadata: metadata2,
+            metadata: metadata3,
             rootPrims,
             layers: this.url ? [this.url] : []
           };
@@ -116,7 +1527,7 @@ var __exports__ = (() => {
           const type = hasExplicitType ? firstToken.value : "";
           const name22 = hasExplicitType ? this.tokenizer.read().value : firstToken.value;
           const path2 = `${parentPath}/${name22}`;
-          const metadata2 = this.tokenizer.match("(") ? this.parseMetadata(")") : {};
+          const metadata3 = this.tokenizer.match("(") ? this.parseMetadata(")") : {};
           this.tokenizer.expect("{");
           const contents = this.parsePrimContents(path2);
           return {
@@ -126,7 +1537,7 @@ var __exports__ = (() => {
             type,
             specifier,
             attributes: contents.attributes,
-            metadata: { ...metadata2, ...contents.metadata },
+            metadata: { ...metadata3, ...contents.metadata },
             variants: contents.variants,
             children: contents.children
           };
@@ -134,7 +1545,7 @@ var __exports__ = (() => {
         /** Parses the attributes, variants, and child prims inside a prim body. */
         parsePrimContents(parentPath) {
           const attributes = {};
-          const metadata2 = {};
+          const metadata3 = {};
           const children = [];
           const variants = {};
           while (!this.tokenizer.isAtEnd() && !this.tokenizer.match("}")) {
@@ -149,7 +1560,7 @@ var __exports__ = (() => {
               }
             }
           }
-          return { attributes, metadata: metadata2, children, variants };
+          return { attributes, metadata: metadata3, children, variants };
         }
         /** Parses one named variant set. */
         parseVariantSet(parentPath, variants) {
@@ -199,12 +1610,12 @@ var __exports__ = (() => {
           const name22 = significantTokens[significantTokens.length - 1].value;
           const type = significantTokens.slice(0, -1).map((token) => token.value).join("");
           const value = this.parseValue();
-          const metadata2 = this.tokenizer.match("(") ? this.parseMetadata(")") : {};
-          return { name: name22, type, value, metadata: metadata2 };
+          const metadata3 = this.tokenizer.match("(") ? this.parseMetadata(")") : {};
+          return { name: name22, type, value, metadata: metadata3 };
         }
         /** Parses a metadata dictionary through the requested terminator. */
         parseMetadata(terminator) {
-          const metadata2 = {};
+          const metadata3 = {};
           while (!this.tokenizer.isAtEnd() && !this.tokenizer.match(terminator)) {
             this.tokenizer.match(",");
             if (this.tokenizer.peek().value === terminator) {
@@ -227,10 +1638,10 @@ var __exports__ = (() => {
               continue;
             }
             const name22 = declarationTokens[declarationTokens.length - 1].value;
-            metadata2[name22] = this.parseValue();
+            metadata3[name22] = this.parseValue();
             this.tokenizer.match(",");
           }
-          return metadata2;
+          return metadata3;
         }
         /** Parses one scalar, list, tuple, dictionary, asset path, or scene path value. */
         parseValue() {
@@ -446,30 +1857,52 @@ var __exports__ = (() => {
     const directoryOffset = findCentralDirectory(view);
     const entryCount = view.getUint16(directoryOffset + 10, true);
     let entryOffset = view.getUint32(directoryOffset + 16, true);
+    const dataLimit = entryOffset;
     const files = /* @__PURE__ */ new Map();
-    const textDecoder = new TextDecoder();
+    const textDecoder2 = new TextDecoder();
+    let extractedByteLength = 0;
     for (let entryIndex = 0; entryIndex < entryCount; entryIndex++) {
+      if (entryOffset + 46 > directoryOffset) {
+        throw new Error("USDZ archive contains a truncated ZIP central-directory entry.");
+      }
       if (view.getUint32(entryOffset, true) !== CENTRAL_DIRECTORY_ENTRY) {
         throw new Error("USDZ archive contains an invalid ZIP central-directory entry.");
       }
       const compression = view.getUint16(entryOffset + 10, true);
       const compressedLength = view.getUint32(entryOffset + 20, true);
+      const uncompressedLength = view.getUint32(entryOffset + 24, true);
       const filenameLength = view.getUint16(entryOffset + 28, true);
       const extraLength = view.getUint16(entryOffset + 30, true);
       const commentLength = view.getUint16(entryOffset + 32, true);
       const localOffset = view.getUint32(entryOffset + 42, true);
-      const filename = textDecoder.decode(
+      if (entryOffset + 46 + filenameLength + extraLength + commentLength > directoryOffset) {
+        throw new Error("USDZ archive contains a truncated ZIP filename or extra field.");
+      }
+      const filename = textDecoder2.decode(
         new Uint8Array(arrayBuffer, entryOffset + 46, filenameLength)
       );
       if (compression !== 0) {
         throw new Error(`USDZ entry "${filename}" is compressed; USDZ requires stored ZIP entries.`);
       }
+      if (localOffset + 30 > dataLimit || compressedLength !== uncompressedLength) {
+        throw new Error(`USDZ entry "${filename}" has invalid stored ZIP bounds.`);
+      }
       if (view.getUint32(localOffset, true) !== LOCAL_FILE_HEADER) {
         throw new Error(`USDZ entry "${filename}" has an invalid local ZIP header.`);
       }
       const localNameLength = view.getUint16(localOffset + 26, true);
       const localExtraLength = view.getUint16(localOffset + 28, true);
       const contentOffset = localOffset + 30 + localNameLength + localExtraLength;
+      if ((view.getUint16(entryOffset + 8, true) | view.getUint16(localOffset + 6, true)) & 1) {
+        throw new Error(`USDZ entry "${filename}" is encrypted.`);
+      }
+      if (contentOffset + compressedLength > dataLimit || view.getUint16(localOffset + 8, true) !== 0 || textDecoder2.decode(new Uint8Array(arrayBuffer, localOffset + 30, localNameLength)) !== filename || files.has(filename)) {
+        throw new Error(`USDZ entry "${filename}" has invalid or duplicate stored ZIP data.`);
+      }
+      extractedByteLength += compressedLength;
+      if (extractedByteLength > arrayBuffer.byteLength) {
+        throw new Error("USDZ archive exceeds its stored data budget.");
+      }
       files.set(filename, arrayBuffer.slice(contentOffset, contentOffset + compressedLength));
       entryOffset += 46 + filenameLength + extraLength + commentLength;
     }
@@ -519,21 +1952,32 @@ var __exports__ = (() => {
     let stage;
     if (isZIPArchive(data)) {
       const archive = parseUSDZArchive(data);
-      const rootFilename = Array.from(archive.keys()).find((filename) => /\.usda?$/i.test(filename));
-      if (!rootFilename) {
-        throw new Error("USDZ archives with binary USDC root layers are not implemented yet.");
+      const rootFilename = archive.keys().next().value;
+      if (!rootFilename || !/\.(?:usd[ac]?)$/i.test(rootFilename)) {
+        throw new Error("USDZ archive has no supported USD root layer.");
       }
       const archiveBase = "https://usd.archive/";
+      const assets = /* @__PURE__ */ Object.create(null);
       for (const [filename, content] of archive) {
-        environment.archiveFiles.set(new URL(filename, archiveBase).href, content);
+        const assetUrl = new URL(filename, archiveBase);
+        if (filename.startsWith("/") || /^[a-z][a-z\d+.-]*:/i.test(filename) || filename.includes("\\") || /[\u0000-\u001f\u007f]/.test(filename) || filename.trim() !== filename || filename.split("/").some((segment) => {
+          const normalizedSegment = segment.replace(/%2e/gi, ".");
+          return normalizedSegment === "." || normalizedSegment === "..";
+        }) || assetUrl.origin !== new URL(archiveBase).origin || assetUrl.search || assetUrl.hash || assets[assetUrl.href]) {
+          throw new Error(`USDZ entry "${filename}" has an ambiguous package URL.`);
+        }
+        environment.archiveFiles.set(assetUrl.href, content);
+        assets[assetUrl.href] = createEmbeddedAsset(filename, content);
       }
       const rootUrl = new URL(rootFilename, archiveBase).href;
       stage = parseUSDLayer(archive.get(rootFilename), rootUrl);
       stage.format = "usdz";
+      stage.assets = assets;
     } else {
       stage = parseUSDLayer(data, url);
     }
     if (stage.url) {
+      setAttributeSourceUrls(stage, stage.url);
       environment.layers.add(stage.url);
     }
     if (environment.options.usd?.compose !== false) {
@@ -545,6 +1989,11 @@ var __exports__ = (() => {
     }
     return stage;
   }
+  function createEmbeddedAsset(path2, data) {
+    const extension = path2.slice(path2.lastIndexOf(".") + 1).toLowerCase();
+    const mimeType = extension === "png" ? "image/png" : /^(?:jpe?g)$/.test(extension) ? "image/jpeg" : void 0;
+    return mimeType ? { path: path2, data, mimeType } : { path: path2, data };
+  }
   function getSourceLocation(configuredLocation, contextLocation) {
     const configuredUrl = getAbsoluteUrl(configuredLocation);
     if (configuredUrl) {
@@ -571,10 +2020,29 @@ var __exports__ = (() => {
   function parseUSDLayer(data, url) {
     const signature = TEXT_DECODER.decode(data.slice(0, 8));
     if (signature === CRATE_SIGNATURE) {
-      throw new Error("Binary USDC crate layers are not implemented yet; use ASCII USDA layers.");
+      return parseUSDC(data, url);
     }
     return parseUSDA(TEXT_DECODER.decode(data), url);
   }
+  function setAttributeSourceUrls(stage, sourceUrl) {
+    const pendingContents = [...stage.rootPrims];
+    while (pendingContents.length) {
+      const contents = pendingContents.pop();
+      for (const attribute of Object.values(contents.attributes)) {
+        attribute.sourceUrl = sourceUrl;
+      }
+      for (const child of contents.children) {
+        pendingContents.push(child);
+      }
+      if ("variants" in contents) {
+        for (const variants of Object.values(contents.variants)) {
+          for (const variant of Object.values(variants)) {
+            pendingContents.push(variant);
+          }
+        }
+      }
+    }
+  }
   async function composePrims(prims, sourceUrl, inheritedVariants, environment, depth) {
     if (depth > (environment.options.usd?.maxReferenceDepth ?? 12)) {
       throw new Error("OpenUSD reference composition exceeded the configured depth limit.");
@@ -653,6 +2121,7 @@ var __exports__ = (() => {
           content = response.arrayBuffer();
         }
         const stage = parseUSDLayer(await content, url);
+        setAttributeSourceUrls(stage, url);
         environment.layers.add(url);
         return stage;
       })();
@@ -752,6 +2221,7 @@ var __exports__ = (() => {
   var init_parse_usd = __esm({
     "src/usd/lib/parse-usd.ts"() {
       "use strict";
+      init_parse_usdc();
       init_parse_usda();
       init_parse_usdz();
       TEXT_DECODER = new TextDecoder();
@@ -814,11 +2284,11 @@ var __exports__ = (() => {
         id: "usd",
         module: "scene",
         version: VERSION,
-        extensions: ["usd", "usda", "usdz"],
-        mimeTypes: ["model/vnd.usd", "model/vnd.usda", "model/vnd.usdz+zip"],
+        extensions: ["usd", "usda", "usdc", "usdz"],
+        mimeTypes: ["model/vnd.usd", "model/vnd.usda", "model/vnd.usdc", "model/vnd.usdz+zip"],
         text: true,
         binary: true,
-        tests: ["#usda", "PK"],
+        tests: ["#usda", "PXR-USDC", "PK"],
         options: {
           usd: {
             compose: true,
@@ -8733,9 +10203,9 @@ return true;`);
         static isSchema(x) {
           return (x === null || x === void 0 ? void 0 : x[kSchemaSymbol]) === true;
         }
-        constructor(fields = [], metadata2, dictionaries, metadataVersion = MetadataVersion.V5) {
+        constructor(fields = [], metadata3, dictionaries, metadataVersion = MetadataVersion.V5) {
           this.fields = fields || [];
-          this.metadata = metadata2 || /* @__PURE__ */ new Map();
+          this.metadata = metadata3 || /* @__PURE__ */ new Map();
           if (!dictionaries) {
             dictionaries = generateDictionaryMap(this.fields);
           }
@@ -8775,7 +10245,7 @@ return true;`);
         assign(...args) {
           const other = args[0] instanceof _Schema ? args[0] : Array.isArray(args[0]) ? new _Schema(args[0]) : new _Schema(args);
           const curFields = [...this.fields];
-          const metadata2 = mergeMaps(mergeMaps(/* @__PURE__ */ new Map(), this.metadata), other.metadata);
+          const metadata3 = mergeMaps(mergeMaps(/* @__PURE__ */ new Map(), this.metadata), other.metadata);
           const newFields = other.fields.filter((f2) => {
             const i = curFields.findIndex((f) => f.name === f2.name);
             return ~i ? (curFields[i] = f2.clone({
@@ -8783,7 +10253,7 @@ return true;`);
             })) && false : true;
           });
           const newDictionaries = generateDictionaryMap(newFields, /* @__PURE__ */ new Map());
-          return new _Schema([...curFields, ...newFields], metadata2, new Map([...this.dictionaries, ...newDictionaries]));
+          return new _Schema([...curFields, ...newFields], metadata3, new Map([...this.dictionaries, ...newDictionaries]));
         }
       };
       Schema2.prototype.fields = null;
@@ -8806,20 +10276,20 @@ return true;`);
         }
         /** @nocollapse */
         static new(...args) {
-          let [name22, type, nullable, metadata2] = args;
+          let [name22, type, nullable, metadata3] = args;
           if (args[0] && typeof args[0] === "object") {
             ({ name: name22 } = args[0]);
             type === void 0 && (type = args[0].type);
             nullable === void 0 && (nullable = args[0].nullable);
-            metadata2 === void 0 && (metadata2 = args[0].metadata);
+            metadata3 === void 0 && (metadata3 = args[0].metadata);
           }
-          return new _Field(`${name22}`, type, nullable, metadata2);
+          return new _Field(`${name22}`, type, nullable, metadata3);
         }
-        constructor(name22, type, nullable = false, metadata2) {
+        constructor(name22, type, nullable = false, metadata3) {
           this.name = name22;
           this.type = type;
           this.nullable = nullable;
-          this.metadata = metadata2 || /* @__PURE__ */ new Map();
+          this.metadata = metadata3 || /* @__PURE__ */ new Map();
         }
         get typeId() {
           return this.type.typeId;
@@ -8831,9 +10301,9 @@ return true;`);
           return `${this.name}: ${this.type}`;
         }
         clone(...args) {
-          let [name22, type, nullable, metadata2] = args;
-          !args[0] || typeof args[0] !== "object" ? [name22 = this.name, type = this.type, nullable = this.nullable, metadata2 = this.metadata] = args : { name: name22 = this.name, type = this.type, nullable = this.nullable, metadata: metadata2 = this.metadata } = args[0];
-          return _Field.new(name22, type, nullable, metadata2);
+          let [name22, type, nullable, metadata3] = args;
+          !args[0] || typeof args[0] !== "object" ? [name22 = this.name, type = this.type, nullable = this.nullable, metadata3 = this.metadata] = args : { name: name22 = this.name, type = this.type, nullable = this.nullable, metadata: metadata3 = this.metadata } = args[0];
+          return _Field.new(name22, type, nullable, metadata3);
         }
       };
       Field2.prototype.type = null;
@@ -9311,8 +10781,8 @@ return true;`);
     }
     return field || null;
   }
-  function customMetadataFromJSON(metadata2 = []) {
-    return new Map(metadata2.map(({ key, value }) => [key, value]));
+  function customMetadataFromJSON(metadata3 = []) {
+    return new Map(metadata3.map(({ key, value }) => [key, value]));
   }
   function indexTypeFromJSON(_type) {
     return new Int_(_type["isSigned"], _type["bitWidth"]);
@@ -9794,8 +11264,8 @@ return true;`);
           const bodyLength = _message.bodyLength();
           const version = _message.version();
           const headerType = _message.headerType();
-          const metadata2 = decodeMessageCustomMetadata(_message);
-          const message = new _Message(bodyLength, version, headerType, void 0, metadata2);
+          const metadata3 = decodeMessageCustomMetadata(_message);
+          const message = new _Message(bodyLength, version, headerType, void 0, metadata3);
           message._createHeader = decodeMessageHeader(_message, headerType);
           return message;
         }
@@ -9872,14 +11342,14 @@ return true;`);
         isDictionaryBatch() {
           return this.headerType === MessageHeader.DictionaryBatch;
         }
-        constructor(bodyLength, version, headerType, header, metadata2) {
+        constructor(bodyLength, version, headerType, header, metadata3) {
           this._version = version;
           this._headerType = headerType;
           this.body = new Uint8Array(0);
           this._compression = header === null || header === void 0 ? void 0 : header.compression;
           header && (this._createHeader = () => header);
           this._bodyLength = bigIntToNumber(bodyLength);
-          this._metadata = metadata2 || /* @__PURE__ */ new Map();
+          this._metadata = metadata3 || /* @__PURE__ */ new Map();
         }
       };
       RecordBatch2 = class {
@@ -9901,13 +11371,13 @@ return true;`);
         get metadata() {
           return this._metadata;
         }
-        constructor(length4, nodes, buffers, compression, variadicBufferCounts = [], metadata2) {
+        constructor(length4, nodes, buffers, compression, variadicBufferCounts = [], metadata3) {
           this._nodes = nodes;
           this._buffers = buffers;
           this._length = bigIntToNumber(length4);
           this._compression = compression;
           this._variadicBufferCounts = variadicBufferCounts;
-          this._metadata = metadata2 || /* @__PURE__ */ new Map();
+          this._metadata = metadata3 || /* @__PURE__ */ new Map();
         }
       };
       DictionaryBatch2 = class {
@@ -13145,10 +14615,10 @@ return true;`);
         }
       });
       _InternalEmptyPlaceholderRecordBatch = class extends RecordBatch3 {
-        constructor(schema, metadata2) {
+        constructor(schema, metadata3) {
           const children = schema.fields.map((f) => makeData({ type: f.type }));
           const data = makeData({ type: new Struct(schema.fields), length: 0, nullCount: 0, children });
-          super(schema, data, metadata2 || /* @__PURE__ */ new Map());
+          super(schema, data, metadata3 || /* @__PURE__ */ new Map());
         }
       };
     }
@@ -15749,442 +17219,29 @@ return true;`);
     }
   });
 
-  // ../core/src/schema-utils/lib/schema/convert-arrow-schema.ts
-  function serializeArrowSchema(arrowSchema) {
-    return {
-      fields: arrowSchema.fields.map((arrowField) => serializeArrowField(arrowField)),
-      metadata: serializeArrowMetadata(arrowSchema.metadata)
-    };
+  // ../../node_modules/@math.gl/arrow/dist/arrow/arrow-data.js
+  function getArrowVariadicBuffers(data) {
+    return data.variadicBuffers ?? [];
   }
-  function deserializeArrowSchema(schema, options) {
-    return new Schema2(
-      schema.fields.map((field) => deserializeArrowField(field, options)),
-      deserializeArrowMetadata(schema.metadata)
-    );
-  }
-  function serializeArrowMetadata(arrowMetadata) {
-    return Object.fromEntries(arrowMetadata);
-  }
-  function deserializeArrowMetadata(metadata2) {
-    return metadata2 ? new Map(Object.entries(metadata2)) : /* @__PURE__ */ new Map();
-  }
-  function serializeArrowField(field) {
-    return {
-      name: field.name,
-      type: serializeArrowType(field.type),
-      nullable: field.nullable,
-      metadata: serializeArrowMetadata(field.metadata)
-    };
-  }
-  function deserializeArrowField(field, options) {
-    return new Field2(
-      field.name,
-      deserializeArrowType(field.type, options),
-      field.nullable,
-      deserializeArrowMetadata(field.metadata)
-    );
-  }
-  function serializeArrowType(arrowType) {
-    if (isArrowViewType(arrowType, "BinaryView")) {
-      return "binary-view";
-    }
-    if (isArrowViewType(arrowType, "Utf8View")) {
-      return "utf8-view";
-    }
-    if (isOptionalArrowType(arrowType, "LargeList")) {
-      const largeListType = arrowType;
-      return {
-        type: "large-list",
-        children: [serializeArrowField(largeListType.valueField)]
-      };
-    }
-    switch (arrowType.constructor) {
-      case Null2:
-        return "null";
-      case Binary2:
-        return "binary";
-      case FixedSizeBinary2:
-        return {
-          type: "fixed-size-binary",
-          byteWidth: arrowType.byteWidth
-        };
-      case Bool2:
-        return "bool";
-      case Int_:
-        const intType = arrowType;
-        return `${intType.isSigned ? "" : "u"}int${intType.bitWidth}`;
-      case Int8:
-        return "int8";
-      case Int16:
-        return "int16";
-      case Int32:
-        return "int32";
-      case Int64:
-        return "int64";
-      case Uint8:
-        return "uint8";
-      case Uint16:
-        return "uint16";
-      case Uint32:
-        return "uint32";
-      case Uint64:
-        return "uint64";
-      case Float:
-        const precision = arrowType.precision;
-        switch (precision) {
-          case Precision.HALF:
-            return "float16";
-          case Precision.SINGLE:
-            return "float32";
-          case Precision.DOUBLE:
-            return "float64";
-          default:
-            return "float16";
-        }
-      case Float16:
-        return "float16";
-      case Float32:
-        return "float32";
-      case Float64:
-        return "float64";
-      case Utf82:
-        return "utf8";
-      case Decimal2:
-        const decimal = arrowType;
-        return {
-          type: "decimal",
-          bitWidth: decimal.bitWidth,
-          precision: decimal.precision,
-          scale: decimal.scale
-        };
-      case Date_:
-        const dateUnit = arrowType.unit;
-        return dateUnit === DateUnit.DAY ? "date-day" : "date-millisecond";
-      case DateDay:
-        return "date-day";
-      case DateMillisecond:
-        return "date-millisecond";
-      case Time_:
-        const timeUnit = arrowType.unit;
-        switch (timeUnit) {
-          case TimeUnit.SECOND:
-            return "time-second";
-          case TimeUnit.MILLISECOND:
-            return "time-millisecond";
-          case TimeUnit.MICROSECOND:
-            return "time-microsecond";
-          case TimeUnit.NANOSECOND:
-            return "time-nanosecond";
-          default:
-            return "time-second";
-        }
-      case TimeMillisecond:
-        return "time-millisecond";
-      case TimeSecond:
-        return "time-second";
-      case TimeMicrosecond:
-        return "time-microsecond";
-      case TimeNanosecond:
-        return "time-nanosecond";
-      case Timestamp_:
-        const timeStampUnit = arrowType.unit;
-        switch (timeStampUnit) {
-          case TimeUnit.SECOND:
-            return "timestamp-second";
-          case TimeUnit.MILLISECOND:
-            return "timestamp-millisecond";
-          case TimeUnit.MICROSECOND:
-            return "timestamp-microsecond";
-          case TimeUnit.NANOSECOND:
-            return "timestamp-nanosecond";
-          default:
-            return "timestamp-second";
-        }
-      case TimestampSecond:
-        return "timestamp-second";
-      case TimestampMillisecond:
-        return "timestamp-millisecond";
-      case TimestampMicrosecond:
-        return "timestamp-microsecond";
-      case TimestampNanosecond:
-        return "timestamp-nanosecond";
-      case Interval_:
-        const intervalUnit = arrowType.unit;
-        switch (intervalUnit) {
-          case IntervalUnit.DAY_TIME:
-            return "interval-daytime";
-          case IntervalUnit.YEAR_MONTH:
-            return "interval-yearmonth";
-          default:
-            return "interval-daytime";
-        }
-      case IntervalDayTime:
-        return "interval-daytime";
-      case IntervalYearMonth:
-        return "interval-yearmonth";
-      case Map_:
-        const mapType = arrowType;
-        return {
-          type: "map",
-          keysSorted: mapType.keysSorted,
-          children: mapType.children.map((arrowField) => serializeArrowField(arrowField))
-        };
-      case List2:
-        const listType = arrowType;
-        const listField = listType.valueField;
-        return {
-          type: "list",
-          children: [serializeArrowField(listField)]
-        };
-      case FixedSizeList2:
-        const fixedSizeList = arrowType;
-        return {
-          type: "fixed-size-list",
-          listSize: fixedSizeList.listSize,
-          children: [serializeArrowField(fixedSizeList.children[0])]
-        };
-      case Struct:
-        const structType = arrowType;
-        return {
-          type: "struct",
-          children: structType.children.map((arrowField) => serializeArrowField(arrowField))
-        };
-      case SparseUnion:
-      case DenseUnion:
-        const unionType = arrowType;
-        return {
-          type: unionType instanceof DenseUnion ? "dense-union" : "sparse-union",
-          typeIds: unionType.typeIds,
-          children: unionType.children.map((arrowField) => serializeArrowField(arrowField)),
-          typeIdToChildIndex: { ...unionType.typeIdToChildIndex }
-        };
-      case Dictionary:
-        const dictionaryType = arrowType;
-        return {
-          type: "dictionary",
-          id: dictionaryType.id,
-          indices: serializeArrowDictionaryKeyType(dictionaryType.indices),
-          dictionary: serializeArrowType(dictionaryType.dictionary),
-          isOrdered: dictionaryType.isOrdered
-        };
-      default:
-        throw new Error(`arrow type not supported: ${arrowType.constructor.name}`);
-    }
-  }
-  function deserializeArrowType(dataType, options) {
-    if (typeof dataType === "object") {
-      switch (dataType.type) {
-        case "decimal":
-          return new Decimal2(dataType.scale, dataType.precision, dataType.bitWidth);
-        case "map": {
-          const children = dataType.children.map(
-            (arrowField) => deserializeArrowField(arrowField, options)
-          );
-          return new Map_(children[0], dataType.keysSorted);
-        }
-        case "list": {
-          const field = deserializeArrowField(dataType.children[0], options);
-          return new List2(field);
-        }
-        case "large-list": {
-          const field = deserializeArrowField(dataType.children[0], options);
-          const LargeList3 = getOptionalArrowConstructor("LargeList");
-          if (!LargeList3) {
-            throw new Error(
-              "LargeList requires an Apache Arrow runtime that exports the LargeList constructor"
-            );
-          }
-          return new LargeList3(field);
-        }
-        case "fixed-size-list": {
-          const child = deserializeArrowField(dataType.children[0], options);
-          return new FixedSizeList2(dataType.listSize, child);
-        }
-        case "fixed-size-binary":
-          return new FixedSizeBinary2(dataType.byteWidth);
-        case "struct": {
-          const children = dataType.children.map(
-            (arrowField) => deserializeArrowField(arrowField, options)
-          );
-          return new Struct(children);
-        }
-        case "sparse-union":
-        case "dense-union": {
-          const children = dataType.children.map(
-            (arrowField) => deserializeArrowField(arrowField, options)
-          );
-          return dataType.type === "dense-union" ? new DenseUnion(dataType.typeIds, children) : new SparseUnion(dataType.typeIds, children);
-        }
-        case "dictionary": {
-          return new Dictionary(
-            deserializeArrowType(dataType.dictionary, options),
-            deserializeArrowDictionaryKeyType(dataType.indices),
-            dataType.id,
-            dataType.isOrdered
-          );
-        }
-        default:
-          throw new Error("array type not supported");
-      }
-    }
-    switch (dataType) {
-      case "null":
-        return new Null2();
-      case "binary":
-        return makeVariableWidthArrowType("BinaryView", new Binary2(), options);
-      case "binary-view":
-        return makeRequiredArrowViewType("BinaryView");
-      case "bool":
-        return new Bool2();
-      case "int8":
-        return new Int8();
-      case "int16":
-        return new Int16();
-      case "int32":
-        return new Int32();
-      case "int64":
-        return new Int64();
-      case "uint8":
-        return new Uint8();
-      case "uint16":
-        return new Uint16();
-      case "uint32":
-        return new Uint32();
-      case "uint64":
-        return new Uint64();
-      case "float16":
-        return new Float16();
-      case "float32":
-        return new Float32();
-      case "float64":
-        return new Float64();
-      case "utf8":
-        return makeVariableWidthArrowType("Utf8View", new Utf82(), options);
-      case "utf8-view":
-        return makeRequiredArrowViewType("Utf8View");
-      case "date-day":
-        return new DateDay();
-      case "date-millisecond":
-        return new DateMillisecond();
-      case "time-second":
-        return new TimeSecond();
-      case "time-millisecond":
-        return new TimeMillisecond();
-      case "time-microsecond":
-        return new TimeMicrosecond();
-      case "time-nanosecond":
-        return new TimeNanosecond();
-      case "timestamp-second":
-        return new TimestampSecond();
-      case "timestamp-millisecond":
-        return new TimestampMillisecond();
-      case "timestamp-microsecond":
-        return new TimestampMicrosecond();
-      case "timestamp-nanosecond":
-        return new TimestampNanosecond();
-      case "interval-daytime":
-        return new IntervalDayTime();
-      case "interval-yearmonth":
-        return new IntervalYearMonth();
-      default:
-        throw new Error("array type not supported");
-    }
-  }
-  function getOptionalArrowConstructor(typeName) {
-    return Arrow_dom_exports[typeName];
-  }
-  function isArrowViewType(arrowType, viewTypeName) {
-    const constructor = getOptionalArrowConstructor(viewTypeName);
-    if (constructor && arrowType instanceof constructor) {
-      return true;
-    }
-    const guards = DataType;
-    const guard = viewTypeName === "BinaryView" ? guards.isBinaryView : guards.isUtf8View;
-    return Boolean(guard?.(arrowType));
-  }
-  function isOptionalArrowType(arrowType, typeName) {
-    const constructor = getOptionalArrowConstructor(typeName);
-    return Boolean(constructor && arrowType instanceof constructor);
-  }
-  function makeVariableWidthArrowType(viewTypeName, fallbackType, options) {
-    const viewTypeMode = options?.viewTypes || "never";
-    if (viewTypeMode === "never") {
-      return fallbackType;
-    }
-    const constructor = getOptionalArrowConstructor(viewTypeName);
-    if (constructor) {
-      return new constructor();
-    }
-    if (viewTypeMode === "require") {
-      throw new Error(
-        `${viewTypeName} requires apache-arrow 21.2.0 or later; the installed runtime does not support it`
-      );
-    }
-    return fallbackType;
-  }
-  function makeRequiredArrowViewType(viewTypeName) {
-    const constructor = getOptionalArrowConstructor(viewTypeName);
-    if (!constructor) {
-      throw new Error(
-        `${viewTypeName} requires apache-arrow 21.2.0 or later; the installed runtime does not support it`
-      );
-    }
-    return new constructor();
-  }
-  function serializeArrowDictionaryKeyType(arrowType) {
-    if (arrowType instanceof Int_) {
-      const prefix = arrowType.isSigned ? "int" : "uint";
-      const keyType = `${prefix}${arrowType.bitWidth}`;
-      if (isSchemaDictionaryKeyType(keyType)) {
-        return keyType;
-      }
-    }
-    switch (arrowType.constructor) {
-      case Int8:
-        return "int8";
-      case Int16:
-        return "int16";
-      case Int32:
-        return "int32";
-      case Uint8:
-        return "uint8";
-      case Uint16:
-        return "uint16";
-      case Uint32:
-        return "uint32";
-      default:
-        throw new Error(`arrow dictionary index type not supported: ${arrowType.constructor.name}`);
-    }
-  }
-  function isSchemaDictionaryKeyType(keyType) {
-    return ["int8", "int16", "int32", "uint8", "uint16", "uint32"].includes(keyType);
-  }
-  function deserializeArrowDictionaryKeyType(keyType) {
-    switch (keyType) {
-      case "int8":
-        return new Int8();
-      case "int16":
-        return new Int16();
-      case "int32":
-        return new Int32();
-      case "uint8":
-        return new Uint8();
-      case "uint16":
-        return new Uint16();
-      case "uint32":
-        return new Uint32();
-      default:
-        throw new Error(`schema dictionary index type not supported: ${keyType}`);
-    }
+  function createArrowData(type, offset, length4, nullCount, buffers, children, dictionary, variadicBuffers) {
+    return Reflect.construct(Data, [
+      type,
+      offset,
+      length4,
+      nullCount,
+      buffers,
+      children,
+      dictionary,
+      variadicBuffers
+    ]);
   }
-  var init_convert_arrow_schema = __esm({
-    "../core/src/schema-utils/lib/schema/convert-arrow-schema.ts"() {
-      "use strict";
+  var init_arrow_data = __esm({
+    "../../node_modules/@math.gl/arrow/dist/arrow/arrow-data.js"() {
       init_Arrow_dom();
     }
   });
 
-  // ../core/src/schema-utils/lib/arrow/split-arrow-buffers.ts
+  // ../../node_modules/@math.gl/arrow/dist/arrow/split-arrow-buffers.js
   function splitArrowBuffers(input, options = {}) {
     const context = { ...options, copies: /* @__PURE__ */ new WeakMap() };
     if (isArrowTable2(input)) {
@@ -16207,17 +17264,12 @@ return true;`);
   function isArrowVector2(input) {
     return "data" in input && Array.isArray(input.data);
   }
-  function splitArrowTableBuffersInternal(table, options) {
-    const recordBatches = table.batches.map(
-      (recordBatch) => splitArrowRecordBatchBuffers(recordBatch, options)
-    );
-    return new Table(table.schema, recordBatches);
+  function splitArrowTableBuffersInternal(arrowTable, options) {
+    const recordBatches = arrowTable.batches.map((recordBatch) => splitArrowRecordBatchBuffers(recordBatch, options));
+    return new Table(arrowTable.schema, recordBatches);
   }
   function splitArrowRecordBatchBuffers(recordBatch, options) {
-    return new RecordBatch3(
-      recordBatch.schema,
-      splitArrowDataBuffers(recordBatch.data, options)
-    );
+    return new RecordBatch3(recordBatch.schema, splitArrowDataBuffers(recordBatch.data, options));
   }
   function splitArrowDataBuffers(data, options) {
     const children = data.children.map((childData) => splitArrowDataBuffers(childData, options));
@@ -16228,7 +17280,7 @@ return true;`);
       [BufferType.VALIDITY]: splitArrowBuffer(data.buffers[BufferType.VALIDITY], options),
       [BufferType.TYPE]: splitArrowBuffer(data.buffers[BufferType.TYPE], options)
     };
-    return new Data(
+    return createArrowData(
       data.type,
       data.offset,
       data.length,
@@ -16236,7 +17288,8 @@ return true;`);
       data._nullCount,
       buffers,
       children,
-      dictionary
+      dictionary,
+      getArrowVariadicBuffers(data).map((buffer) => splitArrowBuffer(buffer, options))
     );
   }
   function splitArrowVectorBuffers(vector, options) {
@@ -16254,7 +17307,7 @@ return true;`);
     }
     let copy2 = options.copies.get(array);
     if (!copy2) {
-      copy2 = array.slice();
+      copy2 = array instanceof Uint8Array ? new Uint8Array(array) : array.slice();
       options.copies.set(array, copy2);
     }
     return copy2;
@@ -16263,36 +17316,113 @@ return true;`);
     return ArrayBuffer.isView(value) && !(value instanceof DataView);
   }
   var init_split_arrow_buffers = __esm({
-    "../core/src/schema-utils/lib/arrow/split-arrow-buffers.ts"() {
-      "use strict";
+    "../../node_modules/@math.gl/arrow/dist/arrow/split-arrow-buffers.js"() {
       init_Arrow_dom();
+      init_arrow_data();
     }
   });
 
-  // ../core/src/schema-utils/lib/arrow/arrow-table-transport.ts
-  function dehydrateArrowTable(table, options) {
-    const splitTable = splitArrowBuffers(table, options);
+  // ../../node_modules/@math.gl/arrow/dist/arrow/indexed-arrow-vector.js
+  var init_indexed_arrow_vector = __esm({
+    "../../node_modules/@math.gl/arrow/dist/arrow/indexed-arrow-vector.js"() {
+    }
+  });
+
+  // ../../node_modules/@math.gl/arrow/dist/arrow/indexed-arrow-table.js
+  var init_indexed_arrow_table = __esm({
+    "../../node_modules/@math.gl/arrow/dist/arrow/indexed-arrow-table.js"() {
+    }
+  });
+
+  // ../../node_modules/@math.gl/arrow/dist/arrow/mapped-arrow-table.js
+  var init_mapped_arrow_table = __esm({
+    "../../node_modules/@math.gl/arrow/dist/arrow/mapped-arrow-table.js"() {
+    }
+  });
+
+  // ../../node_modules/@math.gl/arrow/dist/arrow/rename-arrow-columns.js
+  var init_rename_arrow_columns = __esm({
+    "../../node_modules/@math.gl/arrow/dist/arrow/rename-arrow-columns.js"() {
+    }
+  });
+
+  // ../../node_modules/@math.gl/arrow/dist/arrow/arrow-table-transport.js
+  function dehydrateArrowTable(arrowTable, options) {
+    const splitTable = splitArrowBuffers(arrowTable, options);
     return {
-      shape: "arrow-table",
       transport: "arrow-js",
-      schema: serializeArrowSchema(splitTable.schema),
-      batches: splitTable.batches.map((recordBatch) => dehydrateArrowRecordBatch(recordBatch))
+      version: 1,
+      schema: tableToIPC(new Table(splitTable.schema, [])),
+      metadataVersion: splitTable.schema.metadataVersion,
+      batches: splitTable.batches.map((batch) => dehydrateArrowData(batch.data))
     };
   }
   function hydrateArrowTable(table) {
-    const schema = deserializeArrowSchema(table.schema);
-    const recordBatches = table.batches.map(
-      (recordBatch) => new RecordBatch3(schema, hydrateArrowData(recordBatch.data))
-    );
-    return new Table(schema, recordBatches);
+    if (table.transport !== "arrow-js" || table.version !== 1) {
+      throw new Error("Unsupported Arrow column-buffer transport protocol.");
+    }
+    const decodedSchema = tableFromIPC(table.schema).schema;
+    const schema = new Schema2(decodedSchema.fields, decodedSchema.metadata, decodedSchema.dictionaries, table.metadataVersion);
+    const type = new Struct(schema.fields);
+    const batches = table.batches.map((data) => new RecordBatch3(schema, hydrateArrowData(data, type)));
+    return new Table(schema, batches);
+  }
+  function dehydrateArrowData(data) {
+    return {
+      offset: data.offset,
+      length: data.length,
+      nullCount: data.nullCount,
+      buffers: {
+        [BufferType.OFFSET]: data.buffers[BufferType.OFFSET],
+        [BufferType.DATA]: data.buffers[BufferType.DATA],
+        [BufferType.VALIDITY]: data.buffers[BufferType.VALIDITY],
+        [BufferType.TYPE]: data.buffers[BufferType.TYPE]
+      },
+      children: data.children.map((child) => dehydrateArrowData(child)),
+      variadicBuffers: getArrowVariadicBuffers(data),
+      dictionary: data.dictionary?.data.map((chunk) => dehydrateArrowData(chunk))
+    };
   }
+  function hydrateArrowData(data, type) {
+    const children = data.children.map((child, index) => hydrateArrowData(child, type.children[index].type));
+    const dictionary = data.dictionary && DataType.isDictionary(type) ? new Vector(data.dictionary.map((chunk) => hydrateArrowData(chunk, type.dictionary))) : void 0;
+    return createArrowData(type, data.offset, data.length, data.nullCount, data.buffers, children, dictionary, data.variadicBuffers);
+  }
+  var init_arrow_table_transport = __esm({
+    "../../node_modules/@math.gl/arrow/dist/arrow/arrow-table-transport.js"() {
+      init_Arrow_dom();
+      init_arrow_data();
+      init_split_arrow_buffers();
+    }
+  });
+
+  // ../../node_modules/@math.gl/arrow/dist/arrow/index.js
+  var init_arrow = __esm({
+    "../../node_modules/@math.gl/arrow/dist/arrow/index.js"() {
+      init_indexed_arrow_table();
+      init_indexed_arrow_vector();
+      init_mapped_arrow_table();
+      init_rename_arrow_columns();
+      init_split_arrow_buffers();
+      init_arrow_table_transport();
+    }
+  });
+
+  // ../../node_modules/@math.gl/arrow/dist/index.js
+  var init_dist = __esm({
+    "../../node_modules/@math.gl/arrow/dist/index.js"() {
+      init_arrow();
+    }
+  });
+
+  // ../core/src/arrow-worker-transport.ts
   function serializeArrowWorkerTable(result) {
     if (!isArrowTableWrapper(result)) {
       throw new Error("Workers require Arrow table output");
     }
-    const { data, ...metadata2 } = result;
+    const { data, ...metadata3 } = result;
     return {
-      ...structuredClone(metadata2),
+      ...structuredClone(metadata3),
       data: dehydrateArrowTable(data, { copy: "all" })
     };
   }
@@ -16331,60 +17461,10 @@ return true;`);
       table && table.shape === "arrow-table" && table.data && table.data.transport === "arrow-js" && Array.isArray(table.data.batches)
     );
   }
-  function dehydrateArrowRecordBatch(recordBatch) {
-    return { data: dehydrateArrowData(recordBatch.data) };
-  }
-  function dehydrateArrowData(data) {
-    return {
-      type: serializeArrowType(data.type),
-      offset: data.offset,
-      length: data.length,
-      // @ts-expect-error _nullCount is protected. Preserve the Arrow lazy null-count state.
-      nullCount: data._nullCount,
-      buffers: {
-        [BufferType.OFFSET]: data.buffers[BufferType.OFFSET],
-        [BufferType.DATA]: data.buffers[BufferType.DATA],
-        [BufferType.VALIDITY]: data.buffers[BufferType.VALIDITY],
-        [BufferType.TYPE]: data.buffers[BufferType.TYPE]
-      },
-      children: data.children.map((childData) => dehydrateArrowData(childData)),
-      dictionary: data.dictionary ? dehydrateArrowVector(data.dictionary) : void 0
-    };
-  }
-  function dehydrateArrowVector(vector) {
-    return { data: vector.data.map((data) => dehydrateArrowData(data)) };
-  }
-  function hydrateArrowData(data) {
-    const children = data.children.map((childData) => hydrateArrowData(childData));
-    const dictionary = data.dictionary ? hydrateArrowVector(data.dictionary) : void 0;
-    return new Data(
-      deserializeArrowType(data.type),
-      data.offset,
-      data.length,
-      data.nullCount,
-      data.buffers,
-      children,
-      dictionary
-    );
-  }
-  function hydrateArrowVector(vector) {
-    return new Vector(vector.data.map((data) => hydrateArrowData(data)));
-  }
-  var init_arrow_table_transport = __esm({
-    "../core/src/schema-utils/lib/arrow/arrow-table-transport.ts"() {
+  var init_arrow_worker_transport = __esm({
+    "../core/src/arrow-worker-transport.ts"() {
       "use strict";
-      init_Arrow_dom();
-      init_convert_arrow_schema();
-      init_split_arrow_buffers();
-    }
-  });
-
-  // ../core/src/schema-utils/arrow-transport.ts
-  var init_arrow_transport = __esm({
-    "../core/src/schema-utils/arrow-transport.ts"() {
-      "use strict";
-      init_arrow_table_transport();
-      init_split_arrow_buffers();
+      init_dist();
     }
   });
 
@@ -16564,41 +17644,41 @@ return true;`);
     }
   });
 
-  // ../../node_modules/@math.gl/core/dist/worker-utils/lib/npm-tag.js
+  // ../../node_modules/@math.gl/tasks/dist/worker-utils/lib/npm-tag.js
   var NPM_TAG2;
   var init_npm_tag2 = __esm({
-    "../../node_modules/@math.gl/core/dist/worker-utils/lib/npm-tag.js"() {
+    "../../node_modules/@math.gl/tasks/dist/worker-utils/lib/npm-tag.js"() {
       NPM_TAG2 = "latest";
     }
   });
 
-  // ../../node_modules/@math.gl/core/dist/worker-utils/lib/env-utils/version.js
+  // ../../node_modules/@math.gl/tasks/dist/worker-utils/lib/env-utils/version.js
   function getVersion2() {
     return typeof __VERSION__ === "undefined" ? NPM_TAG2 : __VERSION__;
   }
   var VERSION3;
   var init_version2 = __esm({
-    "../../node_modules/@math.gl/core/dist/worker-utils/lib/env-utils/version.js"() {
+    "../../node_modules/@math.gl/tasks/dist/worker-utils/lib/env-utils/version.js"() {
       init_npm_tag2();
       VERSION3 = getVersion2();
     }
   });
 
-  // ../../node_modules/@math.gl/core/dist/worker-utils/lib/env-utils/assert.js
+  // ../../node_modules/@math.gl/tasks/dist/worker-utils/lib/env-utils/assert.js
   function assert3(condition, message) {
     if (!condition) {
       throw new Error(message || "loaders.gl assertion failed.");
     }
   }
   var init_assert3 = __esm({
-    "../../node_modules/@math.gl/core/dist/worker-utils/lib/env-utils/assert.js"() {
+    "../../node_modules/@math.gl/tasks/dist/worker-utils/lib/env-utils/assert.js"() {
     }
   });
 
-  // ../../node_modules/@math.gl/core/dist/worker-utils/lib/env-utils/globals.js
+  // ../../node_modules/@math.gl/tasks/dist/worker-utils/lib/env-utils/globals.js
   var globals3, self_3, window_3, global_3, document_3, isBrowser3, isMobile2, matches3, nodeVersion3;
   var init_globals3 = __esm({
-    "../../node_modules/@math.gl/core/dist/worker-utils/lib/env-utils/globals.js"() {
+    "../../node_modules/@math.gl/tasks/dist/worker-utils/lib/env-utils/globals.js"() {
       globals3 = {
         self: typeof self !== "undefined" && self,
         window: typeof window !== "undefined" && window,
@@ -16617,7 +17697,7 @@ return true;`);
     }
   });
 
-  // ../../node_modules/@math.gl/core/dist/worker-utils/lib/worker-farm/worker-job.js
+  // ../../node_modules/@math.gl/tasks/dist/worker-utils/lib/worker-farm/worker-job.js
   function createAbortError(message) {
     const error = new Error(message);
     error.name = "AbortError";
@@ -16625,7 +17705,7 @@ return true;`);
   }
   var WorkerJob;
   var init_worker_job = __esm({
-    "../../node_modules/@math.gl/core/dist/worker-utils/lib/worker-farm/worker-job.js"() {
+    "../../node_modules/@math.gl/tasks/dist/worker-utils/lib/worker-farm/worker-job.js"() {
       WorkerJob = class {
         constructor(jobName, workerThread) {
           this.isRunning = true;
@@ -16739,10 +17819,10 @@ return true;`);
     }
   });
 
-  // ../../node_modules/@math.gl/core/dist/worker-utils/lib/node/worker_threads-browser.js
+  // ../../node_modules/@math.gl/tasks/dist/worker-utils/lib/node/worker_threads-browser.js
   var NodeWorker, parentPort;
   var init_worker_threads_browser = __esm({
-    "../../node_modules/@math.gl/core/dist/worker-utils/lib/node/worker_threads-browser.js"() {
+    "../../node_modules/@math.gl/tasks/dist/worker-utils/lib/node/worker_threads-browser.js"() {
       NodeWorker = class {
         /** Restores the native worker constructor when this browser shim is embedded in a Node bundle. */
         constructor(...arguments_) {
@@ -16760,7 +17840,7 @@ return true;`);
     }
   });
 
-  // ../../node_modules/@math.gl/core/dist/worker-utils/lib/worker-utils/get-loadable-worker-url.js
+  // ../../node_modules/@math.gl/tasks/dist/worker-utils/lib/worker-utils/get-loadable-worker-url.js
   function getLoadableWorkerURL(props) {
     assert3(props.source && !props.url || !props.source && props.url);
     if (props.url && props.workerType === "module") {
@@ -16809,13 +17889,13 @@ return true;`);
   }
   var workerURLCache;
   var init_get_loadable_worker_url = __esm({
-    "../../node_modules/@math.gl/core/dist/worker-utils/lib/worker-utils/get-loadable-worker-url.js"() {
+    "../../node_modules/@math.gl/tasks/dist/worker-utils/lib/worker-utils/get-loadable-worker-url.js"() {
       init_assert3();
       workerURLCache = /* @__PURE__ */ new Map();
     }
   });
 
-  // ../../node_modules/@math.gl/core/dist/worker-utils/lib/worker-utils/get-transfer-list.js
+  // ../../node_modules/@math.gl/tasks/dist/worker-utils/lib/worker-utils/get-transfer-list.js
   function getTransferList(object, recursive = true, transfers) {
     const transfersSet = transfers || /* @__PURE__ */ new Set();
     const seen = /* @__PURE__ */ new Set();
@@ -16899,14 +17979,14 @@ return true;`);
     return object === null ? {} : clone2(object);
   }
   var init_get_transfer_list = __esm({
-    "../../node_modules/@math.gl/core/dist/worker-utils/lib/worker-utils/get-transfer-list.js"() {
+    "../../node_modules/@math.gl/tasks/dist/worker-utils/lib/worker-utils/get-transfer-list.js"() {
     }
   });
 
-  // ../../node_modules/@math.gl/core/dist/worker-utils/lib/worker-farm/worker-thread.js
+  // ../../node_modules/@math.gl/tasks/dist/worker-utils/lib/worker-farm/worker-thread.js
   var NOOP, WorkerThread;
   var init_worker_thread = __esm({
-    "../../node_modules/@math.gl/core/dist/worker-utils/lib/worker-farm/worker-thread.js"() {
+    "../../node_modules/@math.gl/tasks/dist/worker-utils/lib/worker-farm/worker-thread.js"() {
       init_worker_threads_browser();
       init_globals3();
       init_assert3();
@@ -17094,10 +18174,10 @@ return true;`);
     }
   });
 
-  // ../../node_modules/@math.gl/core/dist/worker-utils/lib/worker-farm/worker-pool.js
+  // ../../node_modules/@math.gl/tasks/dist/worker-utils/lib/worker-farm/worker-pool.js
   var WorkerPool;
   var init_worker_pool = __esm({
-    "../../node_modules/@math.gl/core/dist/worker-utils/lib/worker-farm/worker-pool.js"() {
+    "../../node_modules/@math.gl/tasks/dist/worker-utils/lib/worker-farm/worker-pool.js"() {
       init_globals3();
       init_worker_thread();
       init_worker_job();
@@ -17628,7 +18708,7 @@ return true;`);
     }
   });
 
-  // ../../node_modules/@math.gl/core/dist/worker-utils/lib/worker-farm/worker-farm.js
+  // ../../node_modules/@math.gl/tasks/dist/worker-utils/lib/worker-farm/worker-farm.js
   function getWorkerPoolKey(options) {
     const { name: name22, source, url, urlKey, loadWorker, workerType } = options;
     const sourceKey = source ? `source:${source}` : "";
@@ -17646,7 +18726,7 @@ return true;`);
   }
   var DEFAULT_PROPS, loadWorkerIds, nextLoadWorkerId, WorkerFarm;
   var init_worker_farm = __esm({
-    "../../node_modules/@math.gl/core/dist/worker-utils/lib/worker-farm/worker-farm.js"() {
+    "../../node_modules/@math.gl/tasks/dist/worker-utils/lib/worker-farm/worker-farm.js"() {
       init_worker_pool();
       init_worker_thread();
       DEFAULT_PROPS = {
@@ -17756,10 +18836,10 @@ return true;`);
     }
   });
 
-  // ../../node_modules/@math.gl/core/dist/worker-utils/lib/async-queue/async-queue.js
+  // ../../node_modules/@math.gl/tasks/dist/worker-utils/lib/async-queue/async-queue.js
   var AsyncQueue2;
   var init_async_queue = __esm({
-    "../../node_modules/@math.gl/core/dist/worker-utils/lib/async-queue/async-queue.js"() {
+    "../../node_modules/@math.gl/tasks/dist/worker-utils/lib/async-queue/async-queue.js"() {
       AsyncQueue2 = class {
         constructor() {
           this._values = [];
@@ -17828,7 +18908,7 @@ return true;`);
     }
   });
 
-  // ../../node_modules/@math.gl/core/dist/worker-utils/lib/worker-api/get-worker-url.js
+  // ../../node_modules/@math.gl/tasks/dist/worker-utils/lib/worker-api/get-worker-url.js
   function getWorkerName(worker) {
     const warning = worker.version !== VERSION3 ? ` (worker-utils@${VERSION3})` : "";
     return `${worker.name}@${worker.version}${warning}`;
@@ -17841,7 +18921,7 @@ return true;`);
       if (isBrowser3) {
         url = `modules/${worker.module}/dist/${workerFile}`;
       } else {
-        const workerSourceDirectory = worker.module === "core" && worker.workerNode?.startsWith("worker-utils/") ? "worker-utils/workers" : "workers";
+        const workerSourceDirectory = worker.module === "tasks" && worker.workerNode?.startsWith("worker-utils/") ? "worker-utils/workers" : "workers";
         const workerSourceNode = worker.workerSourceNode || `${workerSourceDirectory}/${worker.id}-worker-node.ts`;
         url = `modules/${worker.module}/src/${workerSourceNode}`;
       }
@@ -17886,7 +18966,7 @@ return true;`);
   }
   var warnedWorkerVersionFallbacks;
   var init_get_worker_url = __esm({
-    "../../node_modules/@math.gl/core/dist/worker-utils/lib/worker-api/get-worker-url.js"() {
+    "../../node_modules/@math.gl/tasks/dist/worker-utils/lib/worker-api/get-worker-url.js"() {
       init_assert3();
       init_globals3();
       init_version2();
@@ -17895,7 +18975,7 @@ return true;`);
     }
   });
 
-  // ../../node_modules/@math.gl/core/dist/worker-utils/lib/worker-api/shared-state.js
+  // ../../node_modules/@math.gl/tasks/dist/worker-utils/lib/worker-api/shared-state.js
   function getWorkerCapabilities() {
     const isolated = typeof globalThis.crossOriginIsolated === "boolean" ? globalThis.crossOriginIsolated : void 0;
     const capabilities = {
@@ -17942,7 +19022,7 @@ return true;`);
   }
   var SharedWorkerState;
   var init_shared_state = __esm({
-    "../../node_modules/@math.gl/core/dist/worker-utils/lib/worker-api/shared-state.js"() {
+    "../../node_modules/@math.gl/tasks/dist/worker-utils/lib/worker-api/shared-state.js"() {
       init_worker_thread();
       init_globals3();
       SharedWorkerState = class {
@@ -17985,7 +19065,7 @@ return true;`);
     }
   });
 
-  // ../../node_modules/@math.gl/core/dist/worker-utils/lib/worker-utils/get-input-byte-length.js
+  // ../../node_modules/@math.gl/tasks/dist/worker-utils/lib/worker-utils/get-input-byte-length.js
   function getInputByteLength(input) {
     const seen = /* @__PURE__ */ new Set();
     let bytes = 0;
@@ -18014,22 +19094,22 @@ return true;`);
     return bytes;
   }
   var init_get_input_byte_length = __esm({
-    "../../node_modules/@math.gl/core/dist/worker-utils/lib/worker-utils/get-input-byte-length.js"() {
+    "../../node_modules/@math.gl/tasks/dist/worker-utils/lib/worker-utils/get-input-byte-length.js"() {
     }
   });
 
-  // ../../node_modules/@math.gl/core/dist/worker-utils/lib/worker-api/validate-output-ownership.js
+  // ../../node_modules/@math.gl/tasks/dist/worker-utils/lib/worker-api/validate-output-ownership.js
   function validateOutputOwnership(ownership) {
     if (ownership !== void 0 && ownership !== "copy" && ownership !== "transfer") {
       throw new Error("Invalid worker output ownership");
     }
   }
   var init_validate_output_ownership = __esm({
-    "../../node_modules/@math.gl/core/dist/worker-utils/lib/worker-api/validate-output-ownership.js"() {
+    "../../node_modules/@math.gl/tasks/dist/worker-utils/lib/worker-api/validate-output-ownership.js"() {
     }
   });
 
-  // ../../node_modules/@math.gl/core/dist/worker-utils/lib/worker-api/process-on-worker.js
+  // ../../node_modules/@math.gl/tasks/dist/worker-utils/lib/worker-api/process-on-worker.js
   async function processOnWorker(worker, data, options = {}, context = {}, jobContext = {}) {
     validateOutputOwnership(options.outputOwnership);
     if (options.inputOwnership !== void 0 && !["copy", "transfer", "share"].includes(options.inputOwnership))
@@ -18323,7 +19403,7 @@ return true;`);
     return inputOptions;
   }
   var init_process_on_worker = __esm({
-    "../../node_modules/@math.gl/core/dist/worker-utils/lib/worker-api/process-on-worker.js"() {
+    "../../node_modules/@math.gl/tasks/dist/worker-utils/lib/worker-api/process-on-worker.js"() {
       init_async_queue();
       init_worker_farm();
       init_get_worker_url();
@@ -18335,10 +19415,10 @@ return true;`);
     }
   });
 
-  // ../../node_modules/@math.gl/core/dist/worker-utils/index.js
+  // ../../node_modules/@math.gl/tasks/dist/worker-utils/index.js
   var import_meta, path, moduleUrl;
   var init_worker_utils = __esm({
-    "../../node_modules/@math.gl/core/dist/worker-utils/index.js"() {
+    "../../node_modules/@math.gl/tasks/dist/worker-utils/index.js"() {
       init_worker_pool();
       init_process_on_worker();
       init_get_transfer_list();
@@ -18348,7 +19428,7 @@ return true;`);
     }
   });
 
-  // ../../node_modules/@math.gl/core/dist/tasks/task-preload.js
+  // ../../node_modules/@math.gl/tasks/dist/tasks/task-preload.js
   function preloadTaskCode(task, signal) {
     if (!task.preload)
       return Promise.resolve();
@@ -18387,13 +19467,162 @@ return true;`);
   }
   var pending, loaded;
   var init_task_preload = __esm({
-    "../../node_modules/@math.gl/core/dist/tasks/task-preload.js"() {
+    "../../node_modules/@math.gl/tasks/dist/tasks/task-preload.js"() {
       pending = /* @__PURE__ */ new WeakMap();
       loaded = /* @__PURE__ */ new WeakSet();
     }
   });
 
-  // ../../node_modules/@math.gl/core/dist/tasks/task-runtime.js
+  // ../../node_modules/@math.gl/tasks/dist/tasks/task-channel.js
+  var TaskRequestError, TaskChannel;
+  var init_task_channel = __esm({
+    "../../node_modules/@math.gl/tasks/dist/tasks/task-channel.js"() {
+      TaskRequestError = class extends Error {
+      };
+      TaskChannel = class {
+        constructor(options) {
+          this.options = options;
+          this.nextId = 1;
+          this.pending = /* @__PURE__ */ new Map();
+          this.incoming = /* @__PURE__ */ new Map();
+        }
+        /** Send a request without serializing other in-flight requests. */
+        request(operation, value, signal, transfer = []) {
+          if (this.failure)
+            return Promise.reject(this.failure.reason);
+          if (signal?.aborted)
+            return Promise.reject(signal.reason);
+          const id = this.nextId++;
+          return new Promise((resolve, reject) => {
+            const abort = () => {
+              const pending2 = this.pending.get(id);
+              if (!pending2)
+                return;
+              this.pending.delete(id);
+              pending2.cleanup();
+              reject(signal?.reason);
+              this.send({ source: "math.gl/tasks", kind: "cancel", id });
+            };
+            this.pending.set(id, {
+              resolve,
+              reject,
+              cleanup: () => signal?.removeEventListener("abort", abort)
+            });
+            signal?.addEventListener("abort", abort, { once: true });
+            this.send({ source: "math.gl/tasks", kind: "request", id, operation, value }, transfer);
+          });
+        }
+        /** Send a one-way notification. */
+        emit(operation, value, transfer = []) {
+          if (this.failure)
+            throw this.failure.reason;
+          this.send({ source: "math.gl/tasks", kind: "event", id: 0, operation, value }, transfer);
+        }
+        /** Dispatch a transport message; unrelated protocols are ignored. */
+        receive(message) {
+          if (this.failure || message?.source !== "math.gl/tasks")
+            return;
+          if (message.kind === "failure") {
+            const reason = new Error(message.error?.message ?? "Task channel failed");
+            this.close(reason);
+            this.options.onFailure?.(reason);
+          } else if (message.kind === "result" || message.kind === "error") {
+            const pending2 = this.pending.get(message.id);
+            if (!pending2)
+              return;
+            this.pending.delete(message.id);
+            pending2.cleanup();
+            if (message.kind === "result")
+              pending2.resolve(message.value);
+            else {
+              const error = new TaskRequestError(message.error?.message ?? "Task request failed");
+              error.name = message.error?.name ?? "Error";
+              pending2.reject(error);
+            }
+          } else if (message.kind === "cancel") {
+            this.incoming.get(message.id)?.abort(new DOMException("Task request cancelled", "AbortError"));
+          } else if (message.kind === "event") {
+            try {
+              this.options.handleEvent?.(message.operation, message.value);
+            } catch (error) {
+              this.fail(error);
+            }
+          } else if (message.kind === "request") {
+            if (this.incoming.has(message.id)) {
+              this.fail(new Error("Duplicate task request identifier"));
+              return;
+            }
+            const controller = new AbortController();
+            this.incoming.set(message.id, controller);
+            void Promise.resolve().then(() => {
+              controller.signal.throwIfAborted();
+              return this.options.handleRequest(message.operation, message.value, controller.signal);
+            }).then((value) => {
+              if (!controller.signal.aborted && !this.failure) {
+                this.send({ source: "math.gl/tasks", kind: "result", id: message.id, value }, this.options.getResultTransferList?.(value, message.value));
+              }
+            }).catch((reason) => {
+              if (!controller.signal.aborted && !this.failure) {
+                this.send({
+                  source: "math.gl/tasks",
+                  kind: "error",
+                  id: message.id,
+                  error: {
+                    name: reason instanceof Error ? reason.name : "Error",
+                    message: reason instanceof Error ? reason.message : String(reason)
+                  }
+                });
+              }
+            }).finally(() => this.incoming.delete(message.id));
+          }
+        }
+        /** Reject all outstanding calls with a common cause and abort incoming callbacks. */
+        close(reason = new Error("Task channel closed")) {
+          if (this.failure)
+            return;
+          this.failure = { reason };
+          for (const pending2 of this.pending.values()) {
+            pending2.cleanup();
+            pending2.reject(reason);
+          }
+          this.pending.clear();
+          for (const controller of this.incoming.values())
+            controller.abort(reason);
+          this.incoming.clear();
+        }
+        send(message, transfer = []) {
+          if (this.failure)
+            return;
+          try {
+            this.options.send(message, transfer);
+          } catch (error) {
+            this.fail(error);
+          }
+        }
+        /** Invalidate the channel and notify the peer when the transport still works. */
+        fail(reason) {
+          if (this.failure)
+            return;
+          this.close(reason);
+          try {
+            this.options.send({
+              source: "math.gl/tasks",
+              kind: "failure",
+              id: 0,
+              error: {
+                name: reason instanceof Error ? reason.name : "Error",
+                message: reason instanceof Error ? reason.message : String(reason)
+              }
+            }, []);
+          } catch {
+          }
+          this.options.onFailure?.(reason);
+        }
+      };
+    }
+  });
+
+  // ../../node_modules/@math.gl/tasks/dist/tasks/task-runtime.js
   function assertPayload(value) {
     if (!value || typeof value !== "object" || Object.getPrototypeOf(value) !== Object.prototype) {
       throw new TypeError("Task payloads must be plain objects with named fields");
@@ -18415,6 +19644,16 @@ return true;`);
     return {
       state,
       signal,
+      requestHost: async (operation, payload, controls) => {
+        signal.throwIfAborted();
+        if (!context.requestHost)
+          throw new Error("No host request handler configured");
+        return context.requestHost(operation, payload, controls);
+      },
+      emitHost: (operation, payload) => {
+        signal.throwIfAborted();
+        context.emitHost?.(operation, payload);
+      },
       throwIfAborted: () => {
         signal.throwIfAborted();
         context.throwIfAborted?.();
@@ -18434,7 +19673,7 @@ return true;`);
   }
   var TaskRuntime;
   var init_task_runtime = __esm({
-    "../../node_modules/@math.gl/core/dist/tasks/task-runtime.js"() {
+    "../../node_modules/@math.gl/tasks/dist/tasks/task-runtime.js"() {
       init_worker_utils();
       init_task_preload();
       TaskRuntime = class {
@@ -18486,7 +19725,7 @@ return true;`);
     }
   });
 
-  // ../../node_modules/@math.gl/core/dist/tasks/task-sync.js
+  // ../../node_modules/@math.gl/tasks/dist/tasks/task-sync.js
   function runTaskSync(task, input, request = {}) {
     if (!isTaskCodeLoaded(task))
       throw new Error("Preload task on the main thread before runTaskSync");
@@ -18504,8 +19743,8 @@ return true;`);
     context.throwIfAborted();
     const options = request.options ?? {};
     if (request.inputOwnership === "transfer") {
-      const metadata2 = new Set(getTransferList(options));
-      if (getTransferList(input).some((buffer) => metadata2.has(buffer)))
+      const metadata3 = new Set(getTransferList(options));
+      if (getTransferList(input).some((buffer) => metadata3.has(buffer)))
         throw new Error("Transferred input aliases reusable options; use inputOwnership: copy");
     }
     const copiedOptions = clonePayload(options);
@@ -18566,14 +19805,151 @@ return true;`);
     return Boolean(value && (typeof value === "object" || typeof value === "function") && typeof value.then === "function");
   }
   var init_task_sync = __esm({
-    "../../node_modules/@math.gl/core/dist/tasks/task-sync.js"() {
+    "../../node_modules/@math.gl/tasks/dist/tasks/task-sync.js"() {
       init_task_preload();
       init_worker_utils();
       init_task_runtime();
     }
   });
 
-  // ../../node_modules/@math.gl/core/dist/tasks/task-runner.js
+  // ../../node_modules/@math.gl/tasks/dist/tasks/task-operation-queue.js
+  var TaskOperationQueue;
+  var init_task_operation_queue = __esm({
+    "../../node_modules/@math.gl/tasks/dist/tasks/task-operation-queue.js"() {
+      TaskOperationQueue = class {
+        constructor(maxConcurrency) {
+          this.maxConcurrency = maxConcurrency;
+          this.pending = [];
+          this.active = 0;
+          this.exclusive = false;
+          this.closed = false;
+          this.idleWaiters = /* @__PURE__ */ new Set();
+          if (!Number.isSafeInteger(maxConcurrency) || maxConcurrency < 1) {
+            throw new RangeError("maxConcurrency must be a positive safe integer");
+          }
+        }
+        /** Queue an operation; aborting before it starts removes it without running it. */
+        run(mode, operation, signal) {
+          if (this.closed)
+            return Promise.reject(new Error("Task operation queue is closed"));
+          if (mode !== "parallel" && mode !== "exclusive")
+            return Promise.reject(new TypeError("Invalid operation mode"));
+          if (signal?.aborted)
+            return Promise.reject(signal.reason);
+          return new Promise((resolve, reject) => {
+            const onAbort = () => {
+              const index = this.pending.indexOf(entry);
+              if (index >= 0) {
+                this.pending.splice(index, 1);
+                entry.cancel(signal?.reason);
+                this.pump();
+              }
+            };
+            const entry = {
+              mode,
+              cancel: (reason) => {
+                signal?.removeEventListener("abort", onAbort);
+                reject(reason);
+              },
+              start: () => {
+                signal?.removeEventListener("abort", onAbort);
+                this.active++;
+                if (mode === "exclusive")
+                  this.exclusive = true;
+                void Promise.resolve().then(() => {
+                  signal?.throwIfAborted();
+                  return operation();
+                }).then(resolve, reject).finally(() => {
+                  this.active--;
+                  if (mode === "exclusive")
+                    this.exclusive = false;
+                  this.pump();
+                });
+              }
+            };
+            this.pending.push(entry);
+            signal?.addEventListener("abort", onAbort, { once: true });
+            if (signal?.aborted)
+              onAbort();
+            else
+              this.pump();
+          });
+        }
+        /** Reject queued calls with one cause while allowing active operations to settle. */
+        cancelPending(reason) {
+          this.closed = true;
+          for (const entry of this.pending.splice(0))
+            entry.cancel(reason);
+          this.pump();
+        }
+        /** Stop accepting new work; accepted operations continue to completion. */
+        close() {
+          this.closed = true;
+          return this.whenIdle();
+        }
+        /** Wait until the queue has no running or waiting operations. */
+        whenIdle() {
+          if (!this.active && !this.pending.length)
+            return Promise.resolve();
+          return new Promise((resolve) => this.idleWaiters.add(resolve));
+        }
+        pump() {
+          while (!this.exclusive && this.pending.length && this.active < this.maxConcurrency) {
+            const entry = this.pending[0];
+            if (entry.mode === "exclusive" && this.active)
+              break;
+            this.pending.shift();
+            entry.start();
+            if (entry.mode === "exclusive")
+              break;
+          }
+          if (!this.active && !this.pending.length) {
+            for (const resolve of this.idleWaiters)
+              resolve();
+            this.idleWaiters.clear();
+          }
+        }
+      };
+    }
+  });
+
+  // ../../node_modules/@math.gl/tasks/dist/tasks/task-worker-channel.js
+  var TaskWorkerChannel;
+  var init_task_worker_channel = __esm({
+    "../../node_modules/@math.gl/tasks/dist/tasks/task-worker-channel.js"() {
+      init_worker_thread();
+      init_task_channel();
+      TaskWorkerChannel = class {
+        constructor(name22, target, options) {
+          this.thread = new WorkerThread({
+            name: name22,
+            url: target.url?.toString(),
+            loadWorker: target.create,
+            workerType: "module"
+          });
+          this.channel = new TaskChannel({
+            ...options,
+            send: (message, transfer) => this.thread.postMessage({ source: "loaders.gl/tasks", type: "task-channel", payload: message }, transfer)
+          });
+          this.thread.onMessage = (message) => {
+            if (message?.type === "task-channel")
+              this.channel.receive(message.payload);
+          };
+          this.thread.onError = (reason) => {
+            this.channel.close(reason);
+            options.onFailure?.(reason);
+          };
+        }
+        /** Settle pending calls and terminate the worker without replacing its state. */
+        async destroy(reason) {
+          this.channel.close(reason);
+          await this.thread.destroy();
+        }
+      };
+    }
+  });
+
+  // ../../node_modules/@math.gl/tasks/dist/tasks/task-runner.js
   async function finish(handle, operation) {
     let result;
     try {
@@ -18645,29 +20021,44 @@ return true;`);
   }
   function assertNoTransferAlias(input, options, ownership) {
     if (ownership === "transfer") {
-      const metadata2 = new Set(getTransferList(options));
-      if (getTransferList(input).some((buffer) => metadata2.has(buffer))) {
+      const metadata3 = new Set(getTransferList(options));
+      if (getTransferList(input).some((buffer) => metadata3.has(buffer))) {
         throw new Error("Transferred input aliases reusable options; use inputOwnership: copy");
       }
     }
   }
   var InitializedTask, TaskRunner;
   var init_task_runner = __esm({
-    "../../node_modules/@math.gl/core/dist/tasks/task-runner.js"() {
+    "../../node_modules/@math.gl/tasks/dist/tasks/task-runner.js"() {
       init_worker_utils();
       init_task_runtime();
       init_task_sync();
+      init_task_operation_queue();
+      init_task_worker_channel();
+      init_task_channel();
       InitializedTask = class {
         /** @internal Use TaskRunner.initializeTask. */
-        constructor(task, release, controls) {
+        constructor(task, release, initializationControls) {
           this.task = task;
           this.release = release;
-          this.tail = Promise.resolve();
+          this.initializationControls = initializationControls;
+          this.nextProgressId = 1;
+          this.progressCallbacks = /* @__PURE__ */ new Map();
+          this.callbackFailures = /* @__PURE__ */ new Map();
           this.closed = false;
+          this.finalized = false;
           this.streams = /* @__PURE__ */ new Set();
           this.invalid = false;
           this.controller = new AbortController();
+          const controls = initializationControls;
           this.runtime = new TaskRuntime(task);
+          const concurrency = controls.operationConcurrency ?? 1;
+          const maximum = task.concurrency?.maxConcurrency ?? 1;
+          if (!Number.isSafeInteger(maximum) || maximum < 1 || !Number.isSafeInteger(concurrency) || concurrency < 1 || concurrency > maximum) {
+            throw new RangeError("Task concurrency must be between 1 and the task maximum");
+          }
+          this.operationQueue = new TaskOperationQueue(concurrency);
+          this.concurrent = concurrency > 1;
           const execution = controls.execution ?? "auto";
           if (!["auto", "main-thread", "worker"].includes(execution))
             throw new TypeError("Invalid execution mode");
@@ -18677,6 +20068,47 @@ return true;`);
             const target = task.worker;
             if (Boolean(target.url) === Boolean(target.create))
               throw new Error("Supply exactly one worker URL or factory");
+            if (this.concurrent || controls.onRequest || controls.onEvent) {
+              this.workerChannel = new TaskWorkerChannel(task.id, target, {
+                handleRequest: async (operation, payload, signal) => {
+                  if (operation === "task:next-input") {
+                    if (!this.channelInputs)
+                      throw new Error("No active task stream");
+                    return this.channelInputs.next();
+                  }
+                  if (!controls.onRequest)
+                    throw new Error("No host request handler configured");
+                  const request = payload;
+                  if (operation !== "task:host-request")
+                    throw new Error("Unknown host request");
+                  return controls.onRequest(request.operation, request.payload, signal);
+                },
+                getResultTransferList: (value, request) => request.outputOwnership === "transfer" ? getTransferList(value) : [],
+                handleEvent: (operation, payload) => {
+                  const { id } = payload;
+                  try {
+                    if (operation === "task:progress") {
+                      const event = payload;
+                      (this.progressCallbacks.get(event.id) ?? this.streamProgress)?.(event.progress);
+                    } else if (operation === "task:host-event") {
+                      const event = payload;
+                      controls.onEvent?.(event.operation, event.payload);
+                    }
+                  } catch (reason) {
+                    if (this.progressCallbacks.has(id) || this.streamProgressId === id) {
+                      if (!this.callbackFailures.has(id))
+                        this.callbackFailures.set(id, { reason });
+                    }
+                  }
+                },
+                onFailure: (reason) => {
+                  this.invalid = true;
+                  this.operationQueue.cancelPending(reason);
+                  this.controller.abort(reason);
+                }
+              });
+              return;
+            }
             this.pool = new WorkerPool({
               name: task.id,
               url: target.url?.toString(),
@@ -18688,7 +20120,7 @@ return true;`);
             this.descriptor = {
               id: task.id,
               name: task.id,
-              module: "core",
+              module: "tasks",
               version: "prototype",
               options: {},
               worker: target.url?.toString() ?? true,
@@ -18708,23 +20140,48 @@ return true;`);
           }
         }
         runTask(input, ...args) {
-          return this.enqueue(async () => {
+          if (this.invalid)
+            return Promise.reject(new Error("Initialized task is invalid; initialize a new instance"));
+          if (this.closed)
+            return Promise.reject(new Error("Initialized task is closed"));
+          const timeout = args[0]?.timeout;
+          if (timeout !== void 0 && (!Number.isSafeInteger(timeout) || timeout < 0 || timeout > 4294967295)) {
+            return Promise.reject(new RangeError("Invalid task timeout"));
+          }
+          const deadline = timeout === void 0 ? void 0 : AbortSignal.timeout(timeout);
+          const signal = deadline && args[0]?.signal ? AbortSignal.any([deadline, args[0].signal]) : deadline ?? args[0]?.signal;
+          const controls = { ...args[0], signal };
+          const mode = this.task.concurrency?.getSchedulingMode?.(input) ?? "exclusive";
+          return this.operationQueue.run(mode, async () => {
+            signal?.throwIfAborted();
             this.checkCapability("atomic");
-            return this.invoke("process", input, args[0]?.options ?? {}, args[0]);
-          });
+            const invalidate = () => {
+              if (this.concurrent) {
+                this.invalid = true;
+                this.operationQueue.cancelPending(signal?.reason);
+                this.controller.abort(signal?.reason);
+              }
+            };
+            signal?.addEventListener("abort", invalidate, { once: true });
+            try {
+              return await this.invoke("process", input, args[0]?.options ?? {}, controls);
+            } finally {
+              signal?.removeEventListener("abort", invalidate);
+            }
+          }, signal);
         }
         /** Independent calls sharing this instance, always serial and in input order. */
-        async *runTasks(inputs, ...args) {
-          yield* this.serialStream(async function* (self3) {
+        runTasks(inputs, ...args) {
+          return this.serialStream(async function* (self3) {
             self3.checkCapability("atomic");
             for await (const input of asAsync(inputs, self3.controls(args[0]).signal)) {
               yield await self3.invoke("process", input, args[0]?.options ?? {}, args[0]);
             }
-          });
+          }, args[0]?.signal);
         }
         /** One processor invocation for the entire input iterable. */
-        async *runTaskInBatches(inputs, ...args) {
-          yield* this.serialStream(async function* (self3) {
+        runTaskInBatches(inputs, ...args) {
+          return this.serialStream(async function* (self3) {
             self3.checkCapability("streaming");
             const controls = self3.controls(args[0]);
             const options = clonePayload(args[0]?.options ?? {});
@@ -18737,7 +20194,31 @@ return true;`);
             }
             let completed = false;
             try {
-              if (self3.pool) {
+              if (self3.workerChannel) {
+                self3.channelInputs = prepared()[Symbol.asyncIterator]();
+                self3.streamProgress = controls.onProgress;
+                try {
+                  await self3.invoke("stream-open", {}, options, controls);
+                  while (true) {
+                    const result = await self3.invoke("stream-next", {}, {}, controls);
+                    if (result.done)
+                      break;
+                    yield result.value;
+                  }
+                } finally {
+                  try {
+                    if (!self3.invalid)
+                      await self3.invoke("stream-close", {}, {}, controls);
+                  } finally {
+                    await self3.channelInputs.return?.();
+                    self3.channelInputs = void 0;
+                    self3.streamProgress = void 0;
+                    if (self3.streamProgressId !== void 0)
+                      self3.callbackFailures.delete(self3.streamProgressId);
+                    self3.streamProgressId = void 0;
+                  }
+                }
+              } else if (self3.pool) {
                 await self3.invoke("stream-options", {}, options, controls);
                 yield* processOnWorkerInBatches(self3.descriptor, prepared(), {
                   ...self3.workerOptions(controls),
@@ -18745,13 +20226,19 @@ return true;`);
                   workerInBatches: true
                 });
               } else {
-                for await (const output of self3.runtime.stream(prepared(), options, localContext(controls))) {
+                for await (const output of self3.runtime.stream(prepared(), options, self3.runtimeContext(controls))) {
                   controls.signal?.throwIfAborted();
                   yield clonePayload(output, controls.outputOwnership ?? "transfer");
                 }
               }
               completed = true;
             } catch (error) {
+              if (self3.workerChannel) {
+                self3.invalid = true;
+                self3.operationQueue.cancelPending(error);
+                self3.controller.abort(error);
+                await self3.workerChannel.destroy(error);
+              }
               if (self3.pool) {
                 self3.invalid = true;
                 await self3.pool.destroy(error);
@@ -18760,8 +20247,23 @@ return true;`);
             } finally {
               if (self3.pool && !completed)
                 self3.invalid = true;
+              if (self3.workerChannel && !completed && !self3.invalid) {
+                const reason = new Error("Worker stream ended before completion");
+                self3.invalid = true;
+                self3.operationQueue.cancelPending(reason);
+                self3.controller.abort(reason);
+                await self3.workerChannel.destroy(reason);
+              }
             }
-          });
+          }, args[0]?.signal);
+        }
+        /** Lifecycle status of this initialized task. */
+        get state() {
+          if (this.invalid)
+            return "invalid";
+          if (this.finalized)
+            return "closed";
+          return this.closed ? "closing" : "ready";
         }
         /** Drain accepted work, invoke destroy, and release execution capacity. */
         close() {
@@ -18769,13 +20271,17 @@ return true;`);
             this.closed = true;
             this.closing = (async () => {
               try {
-                await this.tail;
+                await this.operationQueue.close();
                 if (!this.invalid)
                   await this.invoke("destroy", {}, {});
+                else if (!this.pool && !this.workerChannel)
+                  await this.runtime.destroy();
               } finally {
                 try {
                   await this.pool?.destroy();
+                  await this.workerChannel?.destroy();
                 } finally {
+                  this.finalized = true;
                   this.release();
                 }
               }
@@ -18785,7 +20291,12 @@ return true;`);
         }
         /** Abort work. Local JavaScript must settle before its state can be destroyed. */
         async terminate(reason = new Error("Task terminated")) {
+          this.operationQueue.cancelPending(reason);
           this.controller.abort(reason);
+          if (this.workerChannel) {
+            this.invalid = true;
+            await this.workerChannel.destroy(reason);
+          }
           if (this.pool) {
             this.invalid = true;
             await this.pool.destroy(reason);
@@ -18794,7 +20305,7 @@ return true;`);
           await this.close();
         }
         checkCapability(kind) {
-          if (this.pool ? !this.task.worker?.capabilities[kind] : !(kind === "atomic" ? this.task.process : this.task.processInBatches)) {
+          if (this.pool || this.workerChannel ? !this.task.worker?.capabilities[kind] : !(kind === "atomic" ? this.task.process : this.task.processInBatches)) {
             throw new Error(`Task has no ${kind} processor for this execution route`);
           }
         }
@@ -18825,6 +20336,38 @@ return true;`);
           assertPayload(input);
           assertNoTransferAlias(input, options, prepared.inputOwnership);
           const copiedOptions = clonePayload(options);
+          if (this.workerChannel) {
+            const progressId = this.nextProgressId++;
+            const request = {
+              input: clonePayload(input, prepared.inputOwnership),
+              options: copiedOptions,
+              outputOwnership: prepared.outputOwnership ?? "transfer",
+              progressId
+            };
+            if (operation === "stream-open")
+              this.streamProgressId = progressId;
+            this.progressCallbacks.set(progressId, prepared.onProgress);
+            let callbackFailure;
+            try {
+              const result2 = await this.workerChannel.channel.request(operation, request, prepared.signal, getTransferList(request));
+              callbackFailure = this.callbackFailures.get(progressId) ?? (operation.startsWith("stream-") && this.streamProgressId !== void 0 ? this.callbackFailures.get(this.streamProgressId) : void 0);
+              if (callbackFailure)
+                throw callbackFailure.reason;
+              return result2;
+            } catch (reason) {
+              if (operation === "process" && !prepared.signal?.aborted && (reason instanceof TaskRequestError || callbackFailure))
+                throw reason;
+              this.invalid = true;
+              this.operationQueue.cancelPending(reason);
+              this.controller.abort(reason);
+              await this.workerChannel.destroy(reason);
+              throw reason;
+            } finally {
+              this.progressCallbacks.delete(progressId);
+              if (this.streamProgressId !== progressId)
+                this.callbackFailures.delete(progressId);
+            }
+          }
           if (this.pool) {
             try {
               return await processOnWorker(this.descriptor, { operation, input: clonePayload(input, prepared.inputOwnership), options: copiedOptions }, this.workerOptions({ ...prepared, inputOwnership: "transfer" }));
@@ -18837,7 +20380,7 @@ return true;`);
           if (operation === "destroy")
             return this.runtime.destroy();
           const copied = clonePayload(input, prepared.inputOwnership);
-          const context = localContext(prepared);
+          const context = this.runtimeContext(prepared);
           if (operation === "initialize") {
             const result2 = await this.runtime.initialize(copied, context);
             prepared.signal?.throwIfAborted();
@@ -18847,27 +20390,76 @@ return true;`);
           prepared.signal?.throwIfAborted();
           return clonePayload(result, prepared.outputOwnership ?? "transfer");
         }
+        runtimeContext(prepared) {
+          return {
+            ...localContext(prepared),
+            requestHost: async (operation, payload, controls = {}) => {
+              const signal = prepared.signal ?? this.controller.signal;
+              signal.throwIfAborted();
+              const handler = this.initializationControls.onRequest;
+              if (!handler)
+                throw new Error("No host request handler configured");
+              const result = await handler(operation, clonePayload(payload, controls.inputOwnership), signal);
+              signal.throwIfAborted();
+              return structuredClone(result, {
+                transfer: controls.outputOwnership === "transfer" ? getTransferList(result) : []
+              });
+            },
+            emitHost: (operation, payload) => this.initializationControls.onEvent?.(operation, structuredClone(payload))
+          };
+        }
         enqueue(operation) {
           if (this.closed)
             return Promise.reject(new Error("Initialized task is closed"));
-          const result = this.tail.then(operation);
-          this.tail = result.catch(() => {
+          return this.operationQueue.run("exclusive", operation);
+        }
+        serialStream(operation, signal) {
+          const waiting = new AbortController();
+          const queueSignal = AbortSignal.any([waiting.signal, this.controller.signal, signal].filter((value) => Boolean(value)));
+          let started = false;
+          const iterator = this.acquireStream(operation, queueSignal, () => {
+            started = true;
           });
-          return result;
+          const cancelWaiting = () => {
+            if (!started)
+              waiting.abort(new Error("Stream returned before execution"));
+          };
+          return {
+            [Symbol.asyncIterator]() {
+              return this;
+            },
+            next: () => iterator.next(),
+            return: async () => {
+              cancelWaiting();
+              return iterator.return(void 0);
+            },
+            throw: async (reason) => {
+              cancelWaiting();
+              return iterator.throw(reason);
+            }
+          };
         }
-        async *serialStream(operation) {
+        async *acquireStream(operation, signal, onStart) {
           if (this.closed)
             throw new Error("Initialized task is closed");
-          const before = this.tail;
+          let acquire;
+          const acquired = new Promise((resolve) => {
+            acquire = resolve;
+          });
           let release;
-          this.tail = new Promise((resolve) => {
+          const held = new Promise((resolve) => {
             release = resolve;
           });
-          await before;
-          if (this.controller.signal.aborted) {
+          const lease = this.operationQueue.run("exclusive", async () => {
+            acquire();
+            await held;
+          }, signal);
+          await Promise.race([acquired, lease]);
+          if (signal.aborted) {
             release();
-            throw this.controller.signal.reason;
+            throw signal.reason;
           }
+          onStart();
           const iterator = operation(this)[Symbol.asyncIterator]();
           let stopping;
           const stop = () => {
@@ -19108,20 +20700,17 @@ return true;`);
     }
   });
 
-  // ../../node_modules/@math.gl/core/dist/tasks/index.js
+  // ../../node_modules/@math.gl/tasks/dist/tasks/index.js
   var init_tasks = __esm({
-    "../../node_modules/@math.gl/core/dist/tasks/index.js"() {
+    "../../node_modules/@math.gl/tasks/dist/tasks/index.js"() {
       init_task_runner();
     }
   });
 
-  // ../core/src/worker-utils/lib/worker-api/task-runtime.ts
-  function normalizeTaskProgress(progress) {
-    return { ...progress, phase: progress.phase ?? "process", unit: progress.unit ?? "items" };
-  }
-  var init_task_runtime2 = __esm({
-    "../core/src/worker-utils/lib/worker-api/task-runtime.ts"() {
-      "use strict";
+  // ../../node_modules/@math.gl/tasks/dist/index.js
+  var init_dist2 = __esm({
+    "../../node_modules/@math.gl/tasks/dist/index.js"() {
+      init_tasks();
     }
   });
 
@@ -19189,6 +20778,16 @@ return true;`);
     }
   });
 
+  // ../core/src/worker-utils/lib/worker-api/task-runtime.ts
+  function normalizeTaskProgress(progress) {
+    return { ...progress, phase: progress.phase ?? "process", unit: progress.unit ?? "items" };
+  }
+  var init_task_runtime2 = __esm({
+    "../core/src/worker-utils/lib/worker-api/task-runtime.ts"() {
+      "use strict";
+    }
+  });
+
   // ../core/src/worker-utils/lib/worker-utils/get-transfer-list.ts
   function getTransferList2(object, recursive = true, transfers) {
     const transfersSet = transfers || /* @__PURE__ */ new Set();
@@ -19433,7 +21032,7 @@ return true;`);
   var init_process_on_worker2 = __esm({
     "../core/src/worker-utils/lib/worker-api/process-on-worker.ts"() {
       "use strict";
-      init_tasks();
+      init_dist2();
       init_get_worker_url2();
       init_task_runtime2();
       init_get_transfer_list2();
@@ -19784,9 +21383,9 @@ return true;`);
 
   // ../core/src/loader-utils/lib/iterators/text-iterators.ts
   async function* makeTextDecoderIterator(arrayBufferIterator, options = {}) {
-    const textDecoder = new TextDecoder(void 0, options);
+    const textDecoder2 = new TextDecoder(void 0, options);
     for await (const arrayBuffer of arrayBufferIterator) {
-      yield typeof arrayBuffer === "string" ? arrayBuffer : textDecoder.decode(arrayBuffer, { stream: true });
+      yield typeof arrayBuffer === "string" ? arrayBuffer : textDecoder2.decode(arrayBuffer, { stream: true });
     }
   }
   async function* makeLineIterator(textIterator) {
@@ -21731,6 +23330,35 @@ return true;`);
     out[15] = 1;
     return out;
   }
+  function affineComponents(matrix) {
+    if (matrix.length !== 16 || Array.from(matrix).some((x) => !Number.isFinite(x)) || matrix[3] !== 0 || matrix[7] !== 0 || matrix[11] !== 0 || matrix[15] !== 1) {
+      throw new RangeError("Expected a finite affine matrix");
+    }
+    const scale5 = [
+      Math.hypot(matrix[0], matrix[1], matrix[2]),
+      Math.hypot(matrix[4], matrix[5], matrix[6]),
+      Math.hypot(matrix[8], matrix[9], matrix[10])
+    ];
+    if (scale5.some((x) => x === 0 || !Number.isFinite(x)))
+      throw new RangeError("Singular transform");
+    const rotation = Array.from({ length: 9 }, (_, i) => matrix[Math.floor(i / 3) * 4 + i % 3] / scale5[Math.floor(i / 3)]);
+    for (const [a, b] of [
+      [0, 3],
+      [0, 6],
+      [3, 6]
+    ]) {
+      if (Math.abs(rotation[a] * rotation[b] + rotation[a + 1] * rotation[b + 1] + rotation[a + 2] * rotation[b + 2]) > 1e-7) {
+        throw new RangeError("Sheared transforms do not have a TRS decomposition");
+      }
+    }
+    const determinant3 = rotation[0] * (rotation[4] * rotation[8] - rotation[5] * rotation[7]) - rotation[3] * (rotation[1] * rotation[8] - rotation[2] * rotation[7]) + rotation[6] * (rotation[1] * rotation[5] - rotation[2] * rotation[4]);
+    if (determinant3 < 0) {
+      scale5[0] = -scale5[0];
+      for (let i = 0; i < 3; i++)
+        rotation[i] = -rotation[i];
+    }
+    return { rotation, scale: scale5, translation: [matrix[12], matrix[13], matrix[14]] };
+  }
   var perspective, ortho;
   var init_mat4 = __esm({
     "../../node_modules/@math.gl/core/dist/gl-matrix/mat4.js"() {
@@ -21864,6 +23492,7 @@ return true;`);
   var init_matrix4 = __esm({
     "../../node_modules/@math.gl/core/dist/classes/matrix4.js"() {
       init_matrix();
+      init_mat4();
       init_validators2();
       init_gl_matrix_extras();
       init_mat4();
@@ -22148,27 +23777,15 @@ return true;`);
          * @returns self
          */
         getRotation(result, scaleResult) {
-          result = result || [-0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0];
-          scaleResult = scaleResult || [-0, -0, -0];
-          const scale5 = this.getScale(scaleResult);
-          const inverseScale0 = 1 / scale5[0];
-          const inverseScale1 = 1 / scale5[1];
-          const inverseScale2 = 1 / scale5[2];
-          result[0] = this[0] * inverseScale0;
-          result[1] = this[1] * inverseScale1;
-          result[2] = this[2] * inverseScale2;
-          result[3] = 0;
-          result[4] = this[4] * inverseScale0;
-          result[5] = this[5] * inverseScale1;
-          result[6] = this[6] * inverseScale2;
-          result[7] = 0;
-          result[8] = this[8] * inverseScale0;
-          result[9] = this[9] * inverseScale1;
-          result[10] = this[10] * inverseScale2;
-          result[11] = 0;
-          result[12] = 0;
-          result[13] = 0;
-          result[14] = 0;
+          const { rotation, scale: scale5 } = affineComponents(this);
+          result = result || new Array(16);
+          if (scaleResult)
+            for (let i = 0; i < 3; i++)
+              scaleResult[i] = scale5[i];
+          for (let i = 0; i < 16; i++)
+            result[i] = 0;
+          for (let i = 0; i < 9; i++)
+            result[Math.floor(i / 3) * 4 + i % 3] = rotation[i];
           result[15] = 1;
           return result;
         }
@@ -22179,21 +23796,13 @@ return true;`);
          * @returns self
          */
         getRotationMatrix3(result, scaleResult) {
-          result = result || [-0, -0, -0, -0, -0, -0, -0, -0, -0];
-          scaleResult = scaleResult || [-0, -0, -0];
-          const scale5 = this.getScale(scaleResult);
-          const inverseScale0 = 1 / scale5[0];
-          const inverseScale1 = 1 / scale5[1];
-          const inverseScale2 = 1 / scale5[2];
-          result[0] = this[0] * inverseScale0;
-          result[1] = this[1] * inverseScale1;
-          result[2] = this[2] * inverseScale2;
-          result[3] = this[4] * inverseScale0;
-          result[4] = this[5] * inverseScale1;
-          result[5] = this[6] * inverseScale2;
-          result[6] = this[8] * inverseScale0;
-          result[7] = this[9] * inverseScale1;
-          result[8] = this[10] * inverseScale2;
+          const { rotation, scale: scale5 } = affineComponents(this);
+          result = result || new Array(9);
+          if (scaleResult)
+            for (let i = 0; i < 3; i++)
+              scaleResult[i] = scale5[i];
+          for (let i = 0; i < 9; i++)
+            result[i] = rotation[i];
           return result;
         }
         // Modifiers
@@ -22506,6 +24115,28 @@ return true;`);
     }
     return out;
   }
+  function rotateTowards(out, a, b, step) {
+    if (a.length !== 4 || b.length !== 4 || [...Array.from(a), ...Array.from(b), step].some((x) => !Number.isFinite(x))) {
+      throw new RangeError("Expected finite quaternions and step");
+    }
+    if (a.length !== 4 || step < 0)
+      throw new RangeError("Expected quaternions and a nonnegative step");
+    const aScale = Math.max(...Array.from(a, Math.abs)), bScale = Math.max(...Array.from(b, Math.abs));
+    if (!aScale || !bScale)
+      throw new RangeError("Zero quaternion");
+    const an = Array.from(a, (x) => x / aScale), bn = Array.from(b, (x) => x / bScale);
+    const al = Math.hypot(...an), bl = Math.hypot(...bn);
+    for (let i = 0; i < 4; i++) {
+      an[i] /= al;
+      bn[i] /= bl;
+    }
+    const dot4 = an.reduce((sum, x, i) => sum + x * bn[i], 0);
+    const angle2 = 2 * Math.acos(Math.min(1, Math.abs(dot4)));
+    if (out.length < 4)
+      throw new RangeError("Result buffer is too short");
+    slerp(out, an, bn, angle2 === 0 ? 0 : Math.min(1, step / angle2));
+    return out;
+  }
   var add2, scale4, dot3, lerp2, length3, squaredLength2, normalize3, rotationTo;
   var init_quat = __esm({
     "../../node_modules/@math.gl/core/dist/gl-matrix/quat.js"() {
@@ -22554,6 +24185,7 @@ return true;`);
   var Quaternion;
   var init_quaternion = __esm({
     "../../node_modules/@math.gl/core/dist/classes/quaternion.js"() {
+      init_quat();
       init_math_array();
       init_validators2();
       init_quat();
@@ -22627,6 +24259,9 @@ return true;`);
           return this.check();
         }
         /** Set a quat to the identity quaternion */
+        rotateTowards(target, step) {
+          return rotateTowards(this, this, target, step);
+        }
         identity() {
           identity2(this);
           return this.check();
@@ -22887,7 +24522,7 @@ return true;`);
   });
 
   // ../../node_modules/@math.gl/core/dist/index.js
-  var init_dist = __esm({
+  var init_dist3 = __esm({
     "../../node_modules/@math.gl/core/dist/index.js"() {
       init_vector32();
       init_matrix3();
@@ -22993,6 +24628,435 @@ return true;`);
     }
   });
 
+  // ../core/src/schema-utils/lib/schema/convert-arrow-schema.ts
+  function serializeArrowSchema(arrowSchema) {
+    return {
+      fields: arrowSchema.fields.map((arrowField) => serializeArrowField(arrowField)),
+      metadata: serializeArrowMetadata(arrowSchema.metadata)
+    };
+  }
+  function serializeArrowMetadata(arrowMetadata) {
+    return Object.fromEntries(arrowMetadata);
+  }
+  function deserializeArrowMetadata(metadata3) {
+    return metadata3 ? new Map(Object.entries(metadata3)) : /* @__PURE__ */ new Map();
+  }
+  function serializeArrowField(field) {
+    return {
+      name: field.name,
+      type: serializeArrowType(field.type),
+      nullable: field.nullable,
+      metadata: serializeArrowMetadata(field.metadata)
+    };
+  }
+  function deserializeArrowField(field, options) {
+    return new Field2(
+      field.name,
+      deserializeArrowType(field.type, options),
+      field.nullable,
+      deserializeArrowMetadata(field.metadata)
+    );
+  }
+  function serializeArrowType(arrowType) {
+    if (isArrowViewType(arrowType, "BinaryView")) {
+      return "binary-view";
+    }
+    if (isArrowViewType(arrowType, "Utf8View")) {
+      return "utf8-view";
+    }
+    if (isOptionalArrowType(arrowType, "LargeList")) {
+      const largeListType = arrowType;
+      return {
+        type: "large-list",
+        children: [serializeArrowField(largeListType.valueField)]
+      };
+    }
+    switch (arrowType.constructor) {
+      case Null2:
+        return "null";
+      case Binary2:
+        return "binary";
+      case FixedSizeBinary2:
+        return {
+          type: "fixed-size-binary",
+          byteWidth: arrowType.byteWidth
+        };
+      case Bool2:
+        return "bool";
+      case Int_:
+        const intType = arrowType;
+        return `${intType.isSigned ? "" : "u"}int${intType.bitWidth}`;
+      case Int8:
+        return "int8";
+      case Int16:
+        return "int16";
+      case Int32:
+        return "int32";
+      case Int64:
+        return "int64";
+      case Uint8:
+        return "uint8";
+      case Uint16:
+        return "uint16";
+      case Uint32:
+        return "uint32";
+      case Uint64:
+        return "uint64";
+      case Float:
+        const precision = arrowType.precision;
+        switch (precision) {
+          case Precision.HALF:
+            return "float16";
+          case Precision.SINGLE:
+            return "float32";
+          case Precision.DOUBLE:
+            return "float64";
+          default:
+            return "float16";
+        }
+      case Float16:
+        return "float16";
+      case Float32:
+        return "float32";
+      case Float64:
+        return "float64";
+      case Utf82:
+        return "utf8";
+      case Decimal2:
+        const decimal = arrowType;
+        return {
+          type: "decimal",
+          bitWidth: decimal.bitWidth,
+          precision: decimal.precision,
+          scale: decimal.scale
+        };
+      case Date_:
+        const dateUnit = arrowType.unit;
+        return dateUnit === DateUnit.DAY ? "date-day" : "date-millisecond";
+      case DateDay:
+        return "date-day";
+      case DateMillisecond:
+        return "date-millisecond";
+      case Time_:
+        const timeUnit = arrowType.unit;
+        switch (timeUnit) {
+          case TimeUnit.SECOND:
+            return "time-second";
+          case TimeUnit.MILLISECOND:
+            return "time-millisecond";
+          case TimeUnit.MICROSECOND:
+            return "time-microsecond";
+          case TimeUnit.NANOSECOND:
+            return "time-nanosecond";
+          default:
+            return "time-second";
+        }
+      case TimeMillisecond:
+        return "time-millisecond";
+      case TimeSecond:
+        return "time-second";
+      case TimeMicrosecond:
+        return "time-microsecond";
+      case TimeNanosecond:
+        return "time-nanosecond";
+      case Timestamp_:
+        const timeStampUnit = arrowType.unit;
+        switch (timeStampUnit) {
+          case TimeUnit.SECOND:
+            return "timestamp-second";
+          case TimeUnit.MILLISECOND:
+            return "timestamp-millisecond";
+          case TimeUnit.MICROSECOND:
+            return "timestamp-microsecond";
+          case TimeUnit.NANOSECOND:
+            return "timestamp-nanosecond";
+          default:
+            return "timestamp-second";
+        }
+      case TimestampSecond:
+        return "timestamp-second";
+      case TimestampMillisecond:
+        return "timestamp-millisecond";
+      case TimestampMicrosecond:
+        return "timestamp-microsecond";
+      case TimestampNanosecond:
+        return "timestamp-nanosecond";
+      case Interval_:
+        const intervalUnit = arrowType.unit;
+        switch (intervalUnit) {
+          case IntervalUnit.DAY_TIME:
+            return "interval-daytime";
+          case IntervalUnit.YEAR_MONTH:
+            return "interval-yearmonth";
+          default:
+            return "interval-daytime";
+        }
+      case IntervalDayTime:
+        return "interval-daytime";
+      case IntervalYearMonth:
+        return "interval-yearmonth";
+      case Map_:
+        const mapType = arrowType;
+        return {
+          type: "map",
+          keysSorted: mapType.keysSorted,
+          children: mapType.children.map((arrowField) => serializeArrowField(arrowField))
+        };
+      case List2:
+        const listType = arrowType;
+        const listField = listType.valueField;
+        return {
+          type: "list",
+          children: [serializeArrowField(listField)]
+        };
+      case FixedSizeList2:
+        const fixedSizeList = arrowType;
+        return {
+          type: "fixed-size-list",
+          listSize: fixedSizeList.listSize,
+          children: [serializeArrowField(fixedSizeList.children[0])]
+        };
+      case Struct:
+        const structType = arrowType;
+        return {
+          type: "struct",
+          children: structType.children.map((arrowField) => serializeArrowField(arrowField))
+        };
+      case SparseUnion:
+      case DenseUnion:
+        const unionType = arrowType;
+        return {
+          type: unionType instanceof DenseUnion ? "dense-union" : "sparse-union",
+          typeIds: unionType.typeIds,
+          children: unionType.children.map((arrowField) => serializeArrowField(arrowField)),
+          typeIdToChildIndex: { ...unionType.typeIdToChildIndex }
+        };
+      case Dictionary:
+        const dictionaryType = arrowType;
+        return {
+          type: "dictionary",
+          id: dictionaryType.id,
+          indices: serializeArrowDictionaryKeyType(dictionaryType.indices),
+          dictionary: serializeArrowType(dictionaryType.dictionary),
+          isOrdered: dictionaryType.isOrdered
+        };
+      default:
+        throw new Error(`arrow type not supported: ${arrowType.constructor.name}`);
+    }
+  }
+  function deserializeArrowType(dataType, options) {
+    if (typeof dataType === "object") {
+      switch (dataType.type) {
+        case "decimal":
+          return new Decimal2(dataType.scale, dataType.precision, dataType.bitWidth);
+        case "map": {
+          const children = dataType.children.map(
+            (arrowField) => deserializeArrowField(arrowField, options)
+          );
+          return new Map_(children[0], dataType.keysSorted);
+        }
+        case "list": {
+          const field = deserializeArrowField(dataType.children[0], options);
+          return new List2(field);
+        }
+        case "large-list": {
+          const field = deserializeArrowField(dataType.children[0], options);
+          const LargeList3 = getOptionalArrowConstructor("LargeList");
+          if (!LargeList3) {
+            throw new Error(
+              "LargeList requires an Apache Arrow runtime that exports the LargeList constructor"
+            );
+          }
+          return new LargeList3(field);
+        }
+        case "fixed-size-list": {
+          const child = deserializeArrowField(dataType.children[0], options);
+          return new FixedSizeList2(dataType.listSize, child);
+        }
+        case "fixed-size-binary":
+          return new FixedSizeBinary2(dataType.byteWidth);
+        case "struct": {
+          const children = dataType.children.map(
+            (arrowField) => deserializeArrowField(arrowField, options)
+          );
+          return new Struct(children);
+        }
+        case "sparse-union":
+        case "dense-union": {
+          const children = dataType.children.map(
+            (arrowField) => deserializeArrowField(arrowField, options)
+          );
+          return dataType.type === "dense-union" ? new DenseUnion(dataType.typeIds, children) : new SparseUnion(dataType.typeIds, children);
+        }
+        case "dictionary": {
+          return new Dictionary(
+            deserializeArrowType(dataType.dictionary, options),
+            deserializeArrowDictionaryKeyType(dataType.indices),
+            dataType.id,
+            dataType.isOrdered
+          );
+        }
+        default:
+          throw new Error("array type not supported");
+      }
+    }
+    switch (dataType) {
+      case "null":
+        return new Null2();
+      case "binary":
+        return makeVariableWidthArrowType("BinaryView", new Binary2(), options);
+      case "binary-view":
+        return makeRequiredArrowViewType("BinaryView");
+      case "bool":
+        return new Bool2();
+      case "int8":
+        return new Int8();
+      case "int16":
+        return new Int16();
+      case "int32":
+        return new Int32();
+      case "int64":
+        return new Int64();
+      case "uint8":
+        return new Uint8();
+      case "uint16":
+        return new Uint16();
+      case "uint32":
+        return new Uint32();
+      case "uint64":
+        return new Uint64();
+      case "float16":
+        return new Float16();
+      case "float32":
+        return new Float32();
+      case "float64":
+        return new Float64();
+      case "utf8":
+        return makeVariableWidthArrowType("Utf8View", new Utf82(), options);
+      case "utf8-view":
+        return makeRequiredArrowViewType("Utf8View");
+      case "date-day":
+        return new DateDay();
+      case "date-millisecond":
+        return new DateMillisecond();
+      case "time-second":
+        return new TimeSecond();
+      case "time-millisecond":
+        return new TimeMillisecond();
+      case "time-microsecond":
+        return new TimeMicrosecond();
+      case "time-nanosecond":
+        return new TimeNanosecond();
+      case "timestamp-second":
+        return new TimestampSecond();
+      case "timestamp-millisecond":
+        return new TimestampMillisecond();
+      case "timestamp-microsecond":
+        return new TimestampMicrosecond();
+      case "timestamp-nanosecond":
+        return new TimestampNanosecond();
+      case "interval-daytime":
+        return new IntervalDayTime();
+      case "interval-yearmonth":
+        return new IntervalYearMonth();
+      default:
+        throw new Error("array type not supported");
+    }
+  }
+  function getOptionalArrowConstructor(typeName) {
+    return Arrow_dom_exports[typeName];
+  }
+  function isArrowViewType(arrowType, viewTypeName) {
+    const constructor = getOptionalArrowConstructor(viewTypeName);
+    if (constructor && arrowType instanceof constructor) {
+      return true;
+    }
+    const guards = DataType;
+    const guard = viewTypeName === "BinaryView" ? guards.isBinaryView : guards.isUtf8View;
+    return Boolean(guard?.(arrowType));
+  }
+  function isOptionalArrowType(arrowType, typeName) {
+    const constructor = getOptionalArrowConstructor(typeName);
+    return Boolean(constructor && arrowType instanceof constructor);
+  }
+  function makeVariableWidthArrowType(viewTypeName, fallbackType, options) {
+    const viewTypeMode = options?.viewTypes || "never";
+    if (viewTypeMode === "never") {
+      return fallbackType;
+    }
+    const constructor = getOptionalArrowConstructor(viewTypeName);
+    if (constructor) {
+      return new constructor();
+    }
+    if (viewTypeMode === "require") {
+      throw new Error(
+        `${viewTypeName} requires apache-arrow 21.2.0 or later; the installed runtime does not support it`
+      );
+    }
+    return fallbackType;
+  }
+  function makeRequiredArrowViewType(viewTypeName) {
+    const constructor = getOptionalArrowConstructor(viewTypeName);
+    if (!constructor) {
+      throw new Error(
+        `${viewTypeName} requires apache-arrow 21.2.0 or later; the installed runtime does not support it`
+      );
+    }
+    return new constructor();
+  }
+  function serializeArrowDictionaryKeyType(arrowType) {
+    if (arrowType instanceof Int_) {
+      const prefix = arrowType.isSigned ? "int" : "uint";
+      const keyType = `${prefix}${arrowType.bitWidth}`;
+      if (isSchemaDictionaryKeyType(keyType)) {
+        return keyType;
+      }
+    }
+    switch (arrowType.constructor) {
+      case Int8:
+        return "int8";
+      case Int16:
+        return "int16";
+      case Int32:
+        return "int32";
+      case Uint8:
+        return "uint8";
+      case Uint16:
+        return "uint16";
+      case Uint32:
+        return "uint32";
+      default:
+        throw new Error(`arrow dictionary index type not supported: ${arrowType.constructor.name}`);
+    }
+  }
+  function isSchemaDictionaryKeyType(keyType) {
+    return ["int8", "int16", "int32", "uint8", "uint16", "uint32"].includes(keyType);
+  }
+  function deserializeArrowDictionaryKeyType(keyType) {
+    switch (keyType) {
+      case "int8":
+        return new Int8();
+      case "int16":
+        return new Int16();
+      case "int32":
+        return new Int32();
+      case "uint8":
+        return new Uint8();
+      case "uint16":
+        return new Uint16();
+      case "uint32":
+        return new Uint32();
+      default:
+        throw new Error(`schema dictionary index type not supported: ${keyType}`);
+    }
+  }
+  var init_convert_arrow_schema = __esm({
+    "../core/src/schema-utils/lib/schema/convert-arrow-schema.ts"() {
+      "use strict";
+      init_Arrow_dom();
+    }
+  });
+
   // ../core/src/schema-utils/lib/mesh/mesh-utils.ts
   function getMeshBoundingBox(attributes) {
     const positionAttribute = attributes?.POSITION;
@@ -23094,7 +25158,7 @@ return true;`);
   var init_float162 = __esm({
     "../core/src/schema/float16.ts"() {
       "use strict";
-      init_dist();
+      init_dist3();
     }
   });
 
@@ -23273,22 +25337,22 @@ return true;`);
       if (!suppliedField?.metadata) {
         return canonicalField;
       }
-      const metadata2 = new Map(canonicalField.metadata);
+      const metadata3 = new Map(canonicalField.metadata);
       for (const [key, value] of Object.entries(suppliedField.metadata)) {
-        metadata2.set(key, value);
+        metadata3.set(key, value);
       }
       return new Field2(
         canonicalField.name,
         canonicalField.type,
         canonicalField.nullable,
-        metadata2
+        metadata3
       );
     }
     const field = schema?.fields.find((schemaField) => schemaField.name === attributeName);
     if (componentType === "float16") {
-      const metadata2 = new Map(Object.entries(field?.metadata || {}));
-      metadata2.set("componentType", "float16");
-      return new Field2(attributeName, column.type, false, metadata2);
+      const metadata3 = new Map(Object.entries(field?.metadata || {}));
+      metadata3.set("componentType", "float16");
+      return new Field2(attributeName, column.type, false, metadata3);
     }
     if (field && field.type.toString() !== column.type.toString()) {
       const deserializedField = deserializeArrowField(field);
@@ -23336,17 +25400,17 @@ return true;`);
     return new Vector([indicesData]);
   }
   function getMeshArrowMetadata(options) {
-    const metadata2 = { ...options.schema?.metadata };
+    const metadata3 = { ...options.schema?.metadata };
     if (options.topology) {
-      metadata2.topology ||= options.topology;
+      metadata3.topology ||= options.topology;
     }
     if (Number.isFinite(options.mode)) {
-      metadata2.mode ||= String(options.mode);
+      metadata3.mode ||= String(options.mode);
     }
     if (options.boundingBox) {
-      metadata2.boundingBox ||= JSON.stringify(options.boundingBox);
+      metadata3.boundingBox ||= JSON.stringify(options.boundingBox);
     }
-    return deserializeArrowMetadata(metadata2);
+    return deserializeArrowMetadata(metadata3);
   }
   var MESH_ARROW_ATTRIBUTE_ORDER;
   var init_convert_mesh_to_table = __esm({
@@ -23386,15 +25450,15 @@ return true;`);
       const attributeData = arrowTable.getChild(name22);
       const size = getFixedSizeListSize(attributeData);
       const typedArray = getAttributeTypedArray(attributeData, size);
-      const metadata2 = getMeshAttributeMetadata(field.metadata);
-      const value = metadata2.componentType === "float16" ? restoreFloat16Array(typedArray) : typedArray;
+      const metadata3 = getMeshAttributeMetadata(field.metadata);
+      const value = metadata3.componentType === "float16" ? restoreFloat16Array(typedArray) : typedArray;
       const shared = columns.find(
         (column) => column.data.length === attributeData.data.length && attributes[column.name].value.constructor === value.constructor && column.data.every((chunk, index) => shareArrowStorage(chunk, attributeData.data[index]))
       );
       attributes[name22] = {
         value: shared ? attributes[shared.name].value : value,
         size,
-        ...metadata2
+        ...metadata3
       };
       if (!shared) columns.push({ name: name22, data: attributeData.data });
     }
@@ -23431,23 +25495,23 @@ return true;`);
     }
     return null;
   }
-  function getMeshAttributeMetadata(metadata2 = {}) {
+  function getMeshAttributeMetadata(metadata3 = {}) {
     const result = {};
-    if (metadata2.byteOffset !== void 0) {
-      result.byteOffset = Number(metadata2.byteOffset);
+    if (metadata3.byteOffset !== void 0) {
+      result.byteOffset = Number(metadata3.byteOffset);
     }
-    if (metadata2.byteStride !== void 0) {
-      result.byteStride = Number(metadata2.byteStride);
+    if (metadata3.byteStride !== void 0) {
+      result.byteStride = Number(metadata3.byteStride);
     }
-    if (metadata2.normalized !== void 0) {
-      result.normalized = metadata2.normalized === "true";
+    if (metadata3.normalized !== void 0) {
+      result.normalized = metadata3.normalized === "true";
     }
-    if (metadata2.componentType === "float16") {
+    if (metadata3.componentType === "float16") {
       result.componentType = "float16";
     }
-    if (metadata2["loaders.gl.transform"]) {
+    if (metadata3["loaders.gl.transform"]) {
       try {
-        const transform = JSON.parse(metadata2["loaders.gl.transform"]);
+        const transform = JSON.parse(metadata3["loaders.gl.transform"]);
         if (isMeshAttributeTransform(transform)) {
           result.transform = transform;
         }
@@ -23534,17 +25598,29 @@ return true;`);
   });
 
   // ../core/src/schema-utils/lib/mesh/deduce-mesh-schema.ts
+  function deduceMeshSchema(attributes, metadata3 = {}) {
+    const fields = deduceMeshFields(attributes);
+    return { fields, metadata: metadata3 };
+  }
   function deduceMeshField(name22, attribute, optionalMetadata) {
     const type = attribute.componentType || getDataTypeFromTypedArray(attribute.value);
-    const metadata2 = optionalMetadata ? optionalMetadata : makeMeshAttributeMetadata(attribute);
+    const metadata3 = optionalMetadata ? optionalMetadata : makeMeshAttributeMetadata(attribute);
     const dataType = attribute.size === 1 ? type : { type: "fixed-size-list", listSize: attribute.size, children: [{ name: "value", type }] };
     return {
       name: name22,
       type: dataType,
       nullable: false,
-      metadata: metadata2
+      metadata: metadata3
     };
   }
+  function deduceMeshFields(attributes) {
+    const fields = [];
+    for (const attributeName in attributes) {
+      const attribute = attributes[attributeName];
+      fields.push(deduceMeshField(attributeName, attribute));
+    }
+    return fields;
+  }
   function makeMeshAttributeMetadata(attribute) {
     const result = {};
     if ("byteOffset" in attribute) {
@@ -23584,11 +25660,11 @@ return true;`);
   });
 
   // src/obj/lib/get-obj-schema.ts
-  function getOBJSchema(attributes, metadata2 = {}) {
+  function getOBJSchema(attributes, metadata3 = {}) {
     const stringMetadata = {};
-    for (const key in metadata2) {
+    for (const key in metadata3) {
       if (key !== "value") {
-        stringMetadata[key] = JSON.stringify(metadata2[key]);
+        stringMetadata[key] = JSON.stringify(metadata3[key]);
       }
     }
     const fields = [];
@@ -23600,10 +25676,10 @@ return true;`);
     return { fields, metadata: stringMetadata };
   }
   function getFieldFromAttribute(name22, attribute) {
-    const metadata2 = {};
+    const metadata3 = {};
     for (const key in attribute) {
       if (key !== "value") {
-        metadata2[key] = JSON.stringify(attribute[key]);
+        metadata3[key] = JSON.stringify(attribute[key]);
       }
     }
     let { type } = getDataTypeFromArray(attribute.value);
@@ -23611,7 +25687,7 @@ return true;`);
     if (!isSingleValue) {
       type = { type: "fixed-size-list", listSize: attribute.size, children: [{ name: "values", type }] };
     }
-    return { name: name22, type, nullable: false, metadata: metadata2 };
+    return { name: name22, type, nullable: false, metadata: metadata3 };
   }
   var init_get_obj_schema = __esm({
     "src/obj/lib/get-obj-schema.ts"() {
@@ -24165,7 +26241,7 @@ return true;`);
     "src/obj/obj-loader.ts"() {
       "use strict";
       init_loader_utils();
-      init_arrow_transport();
+      init_arrow_worker_transport();
       init_schema_utils();
       init_get_obj_schema();
       init_parse_obj();
@@ -24224,7 +26300,7 @@ return true;`);
     "src/obj/obj-loader-types.ts"() {
       "use strict";
       init_obj_format();
-      init_arrow_transport();
+      init_arrow_worker_transport();
       VERSION4 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
       OBJLoader = {
         ...OBJFormat,
@@ -24666,8 +26742,8 @@ return true;`);
   }
   function getBlobOrSVGDataUrl(arrayBuffer, url) {
     if (isSVG(url)) {
-      const textDecoder = new TextDecoder();
-      let xmlText = textDecoder.decode(arrayBuffer);
+      const textDecoder2 = new TextDecoder();
+      let xmlText = textDecoder2.decode(arrayBuffer);
       try {
         if (typeof unescape === "function" && typeof encodeURIComponent === "function") {
           xmlText = unescape(encodeURIComponent(xmlText));
@@ -26127,8 +28203,8 @@ return true;`);
   }
   function parseJSONChunk(glb, dataView, byteOffset, chunkLength2, chunkIndex) {
     const jsonChunk = new Uint8Array(dataView.buffer, byteOffset, chunkLength2);
-    const textDecoder = new TextDecoder("utf8");
-    const jsonText = textDecoder.decode(jsonChunk);
+    const textDecoder2 = new TextDecoder("utf8");
+    const jsonText = textDecoder2.decode(jsonChunk);
     glb.json = JSON.parse(jsonText);
     glb.jsonChunkIndex = chunkIndex;
     return padToFourBytes(chunkLength2);
@@ -26913,8 +28989,8 @@ return true;`);
          * @param mimeType
          */
         addImage(imageData, mimeTypeOpt) {
-          const metadata2 = getBinaryImageMetadata(imageData);
-          const mimeType = mimeTypeOpt || metadata2?.mimeType;
+          const metadata3 = getBinaryImageMetadata(imageData);
+          const mimeType = mimeTypeOpt || metadata3?.mimeType;
           const bufferViewIndex = this.addBufferView(imageData);
           const glTFImage = {
             bufferView: bufferViewIndex,
@@ -27773,8 +29849,8 @@ return true;`);
         }
         /** Return the loaded buffer companion for a raw buffer definition. */
         getLoadedBuffer(buffer) {
-          const metadata2 = this.getMetadata(buffer);
-          return this.gltf.buffers[metadata2.index];
+          const metadata3 = this.getMetadata(buffer);
+          return this.gltf.buffers[metadata3.index];
         }
         /** Return the loaded byte range for a raw buffer-view definition. */
         getLoadedBufferView(bufferView) {
@@ -28321,7 +30397,7 @@ return true;`);
     return attributeValueArray;
   }
   function getPropertyDataString(numberOfElements, valuesDataBytes, arrayOffsets, stringOffsets, fixedArrayCount) {
-    const textDecoder = new TextDecoder("utf8");
+    const textDecoder2 = new TextDecoder("utf8");
     if (arrayOffsets) {
       if (!stringOffsets) {
         throw new Error("stringOffsets is required for variable-length string arrays");
@@ -28335,7 +30411,7 @@ return true;`);
           const startByte = stringOffsets[stringIndex];
           const endByte = stringOffsets[stringIndex + 1];
           const stringData = valuesDataBytes.subarray(startByte, endByte);
-          strings.push(textDecoder.decode(stringData));
+          strings.push(textDecoder2.decode(stringData));
         }
         result.push(strings);
       }
@@ -28348,7 +30424,7 @@ return true;`);
         const startByte = Number(stringOffsets[index]);
         const endByte = Number(stringOffsets[index + 1]);
         if (startByte >= 0 && endByte >= startByte && endByte <= valuesDataBytes.length) {
-          stringsArray.push(textDecoder.decode(valuesDataBytes.subarray(startByte, endByte)));
+          stringsArray.push(textDecoder2.decode(valuesDataBytes.subarray(startByte, endByte)));
         }
       }
       return fixedArrayCount ? Array.from(
@@ -29238,19 +31314,26 @@ return true;`);
       for (const [primitiveIndex, primitive] of mesh.primitives.entries()) {
         const extension = primitive.extensions?.[name4];
         if (!extension) continue;
+        const descriptor = descriptors.find(
+          (item) => item.meshIndex === meshIndex && item.primitiveIndex === primitiveIndex
+        );
+        const legacyColorSpace = options?.gltf?.legacyGaussianSplatColorSpace;
+        const normalizedExtension = legacyColorSpace && extension.extensions?.[SPZ_COMPRESSION_EXTENSION_NAME] ? {
+          ...extension,
+          kernel: extension.kernel ?? "ellipse",
+          colorSpace: extension.colorSpace ?? legacyColorSpace
+        } : extension;
+        if (descriptor) descriptor.extension = normalizedExtension;
         validateGaussianSplatPrimitive(
           gltfData.json,
           primitive,
-          extension,
+          normalizedExtension,
           meshIndex,
           primitiveIndex,
           iterator
         );
         const compression = extension.extensions?.[SPZ_COMPRESSION_EXTENSION_NAME];
         if (compression) {
-          const descriptor = descriptors.find(
-            (item) => item.meshIndex === meshIndex && item.primitiveIndex === primitiveIndex
-          );
           if (descriptor) {
             const decoder2 = options?.gltf?.splatDecoder;
             const bufferView = gltfData.json.bufferViews?.[compression.bufferView];
@@ -30807,7 +32890,7 @@ return true;`);
 
   // src/draco/lib/utils/get-draco-schema.ts
   function getDracoSchema(attributes, loaderData, indices) {
-    const metadata2 = makeMetadata(loaderData.metadata);
+    const metadata3 = makeMetadata(loaderData.metadata);
     const fields = [];
     const namedLoaderDataAttributes = transformAttributesLoaderData(loaderData.attributes);
     for (const attributeName in attributes) {
@@ -30823,7 +32906,7 @@ return true;`);
       const indicesField = getArrowFieldFromAttribute("indices", indices);
       fields.push(indicesField);
     }
-    return { fields, metadata: metadata2 };
+    return { fields, metadata: metadata3 };
   }
   function transformAttributesLoaderData(loaderData) {
     const result = {};
@@ -30841,11 +32924,11 @@ return true;`);
     const field = deduceMeshField(attributeName, attribute, metadataMap);
     return field;
   }
-  function makeMetadata(metadata2) {
-    Object.entries(metadata2);
+  function makeMetadata(metadata3) {
+    Object.entries(metadata3);
     const serializedMetadata = {};
-    for (const key in metadata2) {
-      serializedMetadata[`${key}.string`] = JSON.stringify(metadata2[key]);
+    for (const key in metadata3) {
+      serializedMetadata[`${key}.string`] = JSON.stringify(metadata3[key]);
     }
     return serializedMetadata;
   }
@@ -31062,14 +33145,14 @@ return true;`);
          * @returns
          */
         _getDracoLoaderData(dracoGeometry, geometry_type, options) {
-          const metadata2 = this._getTopLevelMetadata(dracoGeometry);
+          const metadata3 = this._getTopLevelMetadata(dracoGeometry);
           const attributes = this._getDracoAttributes(dracoGeometry, options);
           return {
             geometry_type,
             num_attributes: dracoGeometry.num_attributes(),
             num_points: dracoGeometry.num_points(),
             num_faces: dracoGeometry instanceof this.draco.Mesh ? dracoGeometry.num_faces() : 0,
-            metadata: metadata2,
+            metadata: metadata3,
             attributes
           };
         }
@@ -31083,7 +33166,7 @@ return true;`);
           const dracoAttributes = {};
           for (let attributeId = 0; attributeId < dracoGeometry.num_attributes(); attributeId++) {
             const dracoAttribute = this.decoder.GetAttribute(dracoGeometry, attributeId);
-            const metadata2 = this._getAttributeMetadata(dracoGeometry, attributeId);
+            const metadata3 = this._getAttributeMetadata(dracoGeometry, attributeId);
             dracoAttributes[dracoAttribute.unique_id()] = {
               unique_id: dracoAttribute.unique_id(),
               attribute_type: dracoAttribute.attribute_type(),
@@ -31093,7 +33176,7 @@ return true;`);
               byte_stride: dracoAttribute.byte_stride(),
               normalized: dracoAttribute.normalized(),
               attribute_index: attributeId,
-              metadata: metadata2
+              metadata: metadata3
             };
             const quantization = this._getQuantizationTransform(dracoAttribute, options);
             if (quantization) {
@@ -31604,7 +33687,7 @@ return true;`);
   var init_draco_loader_types = __esm({
     "src/draco/draco-loader-types.ts"() {
       "use strict";
-      init_arrow_transport();
+      init_arrow_worker_transport();
       init_version5();
       init_draco_format();
       init_draco_loader_options();
@@ -32038,7 +34121,7 @@ return true;`);
   var init_KHR_texture_transform = __esm({
     "src/gltf/lib/extensions/KHR_texture_transform.ts"() {
       "use strict";
-      init_dist();
+      init_dist3();
       init_gltf_utils();
       init_gltf_constants();
       init_gltf_iterator();
@@ -32176,10 +34259,10 @@ return true;`);
   }
   function resolveTechniques(techniquesExtension, iterator) {
     const { programs = [], shaders = [], techniques = [] } = techniquesExtension;
-    const textDecoder = new TextDecoder();
+    const textDecoder2 = new TextDecoder();
     shaders.forEach((shader) => {
       if (Number.isFinite(shader.bufferView)) {
-        shader.code = textDecoder.decode(
+        shader.code = textDecoder2.decode(
           getTypedArrayForBufferView(iterator.data, iterator.gltf.buffers, shader.bufferView)
         );
       } else {
@@ -34090,7 +36173,7 @@ return true;`);
   var init_convert_gltf_v1_matrix_nodes = __esm({
     "src/gltf/lib/api/convert-gltf-v1-matrix-nodes.ts"() {
       "use strict";
-      init_dist();
+      init_dist3();
     }
   });
 
@@ -34805,8 +36888,8 @@ return true;`);
       gltf.baseUri = options.core?.baseUrl;
     }
     if (data instanceof ArrayBuffer && !isGLB(data, byteOffset, options.glb)) {
-      const textDecoder = new TextDecoder();
-      data = textDecoder.decode(data);
+      const textDecoder2 = new TextDecoder();
+      data = textDecoder2.decode(data);
     }
     if (typeof data === "string") {
       gltf.json = parseJSON(data);
@@ -35791,9 +37874,9 @@ return true;`);
          * @param dracoGeometry - WASM Draco Object
          * @param metadata
          */
-        _addGeometryMetadata(dracoGeometry, metadata2) {
+        _addGeometryMetadata(dracoGeometry, metadata3) {
           const dracoMetadata = new this.draco.Metadata();
-          this._populateDracoMetadata(dracoMetadata, metadata2);
+          this._populateDracoMetadata(dracoMetadata, metadata3);
           this.dracoMeshBuilder.AddMetadata(dracoGeometry, dracoMetadata);
         }
         /**
@@ -35802,9 +37885,9 @@ return true;`);
          * @param uniqueAttributeId
          * @param metadata
          */
-        _addAttributeMetadata(dracoGeometry, uniqueAttributeId, metadata2) {
+        _addAttributeMetadata(dracoGeometry, uniqueAttributeId, metadata3) {
           const dracoAttributeMetadata = new this.draco.Metadata();
-          this._populateDracoMetadata(dracoAttributeMetadata, metadata2);
+          this._populateDracoMetadata(dracoAttributeMetadata, metadata3);
           this.dracoMeshBuilder.SetMetadataForAttribute(
             dracoGeometry,
             uniqueAttributeId,
@@ -35816,8 +37899,8 @@ return true;`);
          * @param dracoMetadata - WASM Draco Object
          * @param metadata
          */
-        _populateDracoMetadata(dracoMetadata, metadata2) {
-          for (const [key, value] of getEntries(metadata2)) {
+        _populateDracoMetadata(dracoMetadata, metadata3) {
+          for (const [key, value] of getEntries(metadata3)) {
             switch (typeof value) {
               case "number":
                 if (Math.trunc(value) === value) {
@@ -37778,6 +39861,129 @@ Actual: ${this.attribValue}`
     }
   });
 
+  // src/stl/parse-stl.ts
+  function parseSTL(data) {
+    const view = new DataView(data);
+    const binary = data.byteLength >= 84 && 84 + view.getUint32(80, true) * 50 === data.byteLength;
+    let positions;
+    let normals;
+    let header;
+    if (binary) {
+      const triangleCount = view.getUint32(80, true);
+      positions = new Float32Array(triangleCount * 9);
+      normals = new Float32Array(triangleCount * 9);
+      header = new TextDecoder().decode(data.slice(0, 80));
+      for (let triangle = 0; triangle < triangleCount; triangle++) {
+        const offset = 84 + triangle * 50;
+        for (let component = 0; component < 9; component++) {
+          positions[triangle * 9 + component] = view.getFloat32(offset + 12 + component * 4, true);
+          normals[triangle * 9 + component] = view.getFloat32(offset + component % 3 * 4, true);
+        }
+      }
+    } else {
+      const lines = new TextDecoder().decode(data).trim().split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+      const vertices = [];
+      const normalValues = [];
+      header = lines[0] || "";
+      let lineIndex = 0;
+      while (lineIndex < lines.length) {
+        if (!/^solid(?:\s|$)/i.test(lines[lineIndex++]))
+          throw new Error("STL: expected solid header or exact binary length");
+        while (lineIndex < lines.length && !/^endsolid(?:\s|$)/i.test(lines[lineIndex])) {
+          const normal = parseVector(lines[lineIndex++], "facet normal");
+          if (!/^outer\s+loop$/i.test(lines[lineIndex++] || ""))
+            throw new Error("STL: expected outer loop");
+          for (let vertex = 0; vertex < 3; vertex++) {
+            vertices.push(...parseVector(lines[lineIndex++], "vertex"));
+            normalValues.push(...normal);
+          }
+          if (!/^endloop$/i.test(lines[lineIndex++] || "") || !/^endfacet$/i.test(lines[lineIndex++] || ""))
+            throw new Error("STL: incomplete facet");
+        }
+        if (lineIndex >= lines.length) throw new Error("STL: missing endsolid");
+        lineIndex++;
+      }
+      if (!lines.length) throw new Error("STL: empty input");
+      positions = new Float32Array(vertices);
+      normals = new Float32Array(normalValues);
+    }
+    if (!positions.every(Number.isFinite) || !normals.every(Number.isFinite))
+      throw new Error("STL: non-finite coordinates");
+    const attributes = { POSITION: { value: positions, size: 3 }, NORMAL: { value: normals, size: 3 } };
+    return {
+      topology: "triangle-list",
+      mode: 4,
+      attributes,
+      schema: deduceMeshSchema(attributes),
+      header: {
+        vertexCount: positions.length / 3,
+        boundingBox: getMeshBoundingBox(attributes) ?? void 0
+      },
+      loaderData: { header, format: binary ? "binary" : "ascii" }
+    };
+  }
+  function parseVector(line, prefix) {
+    const tokens = line?.split(/\s+/) || [];
+    const prefixTokens = prefix.split(" ");
+    const components = tokens.slice(prefixTokens.length);
+    if (prefixTokens.some((token, index) => tokens[index]?.toLowerCase() !== token) || components.length !== 3 || components.some((value) => !/^[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:e[+-]?\d+)?$/i.test(value))) {
+      throw new Error(`STL: invalid ${prefix} record`);
+    }
+    return components.map(Number);
+  }
+  var init_parse_stl = __esm({
+    "src/stl/parse-stl.ts"() {
+      "use strict";
+      init_schema_utils();
+    }
+  });
+
+  // src/stl-loader.ts
+  var stl_loader_exports = {};
+  __export(stl_loader_exports, {
+    STLLoaderWithParser: () => STLLoaderWithParser
+  });
+  var _preload2, metadata2, STLLoaderWithParser;
+  var init_stl_loader = __esm({
+    "src/stl-loader.ts"() {
+      "use strict";
+      init_stl_loader_types();
+      init_parse_stl();
+      ({ preload: _preload2, ...metadata2 } = STLLoader);
+      STLLoaderWithParser = {
+        ...metadata2,
+        parse: async (data) => parseSTL(data),
+        parseSync: parseSTL
+      };
+    }
+  });
+
+  // src/stl-loader-types.ts
+  async function preload10() {
+    const { STLLoaderWithParser: STLLoaderWithParser2 } = await Promise.resolve().then(() => (init_stl_loader(), stl_loader_exports));
+    return STLLoaderWithParser2;
+  }
+  var VERSION10, STLLoader;
+  var init_stl_loader_types = __esm({
+    "src/stl-loader-types.ts"() {
+      "use strict";
+      VERSION10 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+      STLLoader = {
+        name: "STL",
+        id: "stl",
+        module: "scene",
+        version: VERSION10,
+        extensions: ["stl"],
+        mimeTypes: ["model/stl"],
+        binary: true,
+        dataType: null,
+        batchType: null,
+        options: {},
+        preload: preload10
+      };
+    }
+  });
+
   // bundle.ts
   var bundle_exports = {};
   __export(bundle_exports, {
@@ -37805,6 +40011,7 @@ Actual: ${this.attribValue}`
     OBJWorkerLoader: () => OBJWorkerLoader,
     OBJWriter: () => OBJWriter,
     RequestScheduler: () => import_core4.RequestScheduler,
+    STLLoader: () => STLLoader,
     USDLoader: () => USDLoader,
     _BrowserFileSystem: () => import_core4._BrowserFileSystem,
     _fetchProgress: () => import_core4._fetchProgress,
@@ -38388,6 +40595,7 @@ Actual: ${this.attribValue}`
   init_draco_format();
   init_draco_libraries();
   init_materialx_loader_types();
+  init_stl_loader_types();
   return __toCommonJS(bundle_exports);
 })();
       return __exports__;