minidraco 0.1.1 → 0.3.0

package/dist/three.js

@@ -10,284 +10,158 @@ import {
   SRGBColorSpace
 } from "three";
 
-// src/decoder/core/Macros.ts
-function bitstreamVersion(major, minor) {
-  return (major & 255) << 8 | minor & 255;
+// src/decoder/core/DracoTypes.ts
+var DataType = {
+  INVALID: 0,
+  INT8: 1,
+  UINT8: 2,
+  INT16: 3,
+  UINT16: 4,
+  INT32: 5,
+  UINT32: 6,
+  INT64: 7,
+  UINT64: 8,
+  FLOAT32: 9,
+  FLOAT64: 10,
+  BOOL: 11,
+  TYPES_COUNT: 12
+};
+function dataTypeLength(dt) {
+  switch (dt) {
+    case DataType.INT8:
+    case DataType.UINT8:
+      return 1;
+    case DataType.INT16:
+    case DataType.UINT16:
+      return 2;
+    case DataType.INT32:
+    case DataType.UINT32:
+      return 4;
+    case DataType.INT64:
+    case DataType.UINT64:
+      return 8;
+    case DataType.FLOAT32:
+      return 4;
+    case DataType.FLOAT64:
+      return 8;
+    case DataType.BOOL:
+      return 1;
+    default:
+      return -1;
+  }
 }
 
-// src/decoder/core/BitUtils.ts
-function convertSymbolsToSignedInts(input, count, output) {
-  for (let i = 0; i < count; i++) {
-    const val = input[i];
-    output[i] = val >>> 1 ^ -(val & 1);
+// src/decoder/attributes/GeometryAttribute.ts
+var Type = {
+  INVALID: -1,
+  POSITION: 0,
+  NORMAL: 1,
+  COLOR: 2,
+  TEX_COORD: 3,
+  GENERIC: 4,
+  NAMED_ATTRIBUTES_COUNT: 5
+};
+var GeometryAttribute = class {
+  _buffer;
+  _numComponents;
+  _dataType;
+  _normalized;
+  _byteStride;
+  _byteOffset;
+  _attributeType;
+  _uniqueId;
+  constructor() {
+    this._buffer = null;
+    this._numComponents = 1;
+    this._dataType = DataType.FLOAT32;
+    this._normalized = false;
+    this._byteStride = 0;
+    this._byteOffset = 0;
+    this._attributeType = Type.INVALID;
+    this._uniqueId = 0;
   }
-}
-function convertSymbolToSignedInt(val) {
-  const isPositive = (val & 1) === 0;
-  val >>>= 1;
-  if (isPositive) {
-    return val;
+  init(attributeType, buffer, numComponents, dataType, normalized, byteStride, byteOffset) {
+    this._buffer = buffer;
+    this._numComponents = numComponents;
+    this._dataType = dataType;
+    this._normalized = normalized;
+    this._byteStride = byteStride;
+    this._byteOffset = byteOffset;
+    this._attributeType = attributeType;
   }
-  return -val - 1;
-}
-
-// src/decoder/core/VarintDecoding.ts
-function decodeVarintUnsigned(buffer, maxBytes) {
-  let result = 0;
-  for (let i = 0; i < maxBytes; i++) {
-    const byte = buffer.decodeUint8();
-    if (byte === void 0) return void 0;
-    if (byte & 128) {
-      const bytes = [byte & 127];
-      let done = false;
-      for (let j = i + 1; j < maxBytes; j++) {
-        const next = buffer.decodeUint8();
-        if (next === void 0) return void 0;
-        if (next & 128) {
-          bytes.push(next & 127);
-        } else {
-          bytes.push(next);
-          done = true;
-          break;
-        }
-      }
-      if (!done) return void 0;
-      result = bytes[bytes.length - 1];
-      for (let k = bytes.length - 2; k >= 0; k--) {
-        result = result * 128 + bytes[k];
-      }
-      return result;
+  // Returns a Uint8Array view of the buffer starting at the attribute entry.
+  getAddress(attIndex) {
+    const bytePos = this._byteOffset + this._byteStride * attIndex;
+    return this._buffer.data.subarray(bytePos);
+  }
+  copyFrom(srcAtt) {
+    this._numComponents = srcAtt._numComponents;
+    this._dataType = srcAtt._dataType;
+    this._normalized = srcAtt._normalized;
+    this._byteStride = srcAtt._byteStride;
+    this._byteOffset = srcAtt._byteOffset;
+    this._attributeType = srcAtt._attributeType;
+    this._uniqueId = srcAtt._uniqueId;
+    if (srcAtt._buffer === null) {
+      this._buffer = null;
     } else {
-      return byte;
+      if (this._buffer === null) {
+        return false;
+      }
+      this._buffer.update(srcAtt._buffer.data, srcAtt._buffer.dataSize);
     }
+    return true;
   }
-  return void 0;
-}
-function decodeVarint(buffer, signed = false) {
-  const maxBytes = 10;
-  const value = decodeVarintUnsigned(buffer, maxBytes);
-  if (value === void 0) return void 0;
-  if (signed) {
-    return convertSymbolToSignedInt(value);
+  resetBuffer(buffer, byteStride, byteOffset) {
+    this._buffer = buffer;
+    this._byteStride = byteStride;
+    this._byteOffset = byteOffset;
   }
-  return value;
-}
-
-// src/decoder/core/DecoderBuffer.ts
-var BitDecoder = class {
-  _bitBuffer;
-  _bitOffset;
-  _byteLength;
-  constructor() {
-    this._bitBuffer = null;
-    this._bitOffset = 0;
-    this._byteLength = 0;
+  get attributeType() {
+    return this._attributeType;
   }
-  reset(uint8Array, byteLength) {
-    this._bitBuffer = uint8Array;
-    this._byteLength = byteLength;
-    this._bitOffset = 0;
+  get dataType() {
+    return this._dataType;
   }
-  bitsDecoded() {
-    return this._bitOffset;
+  get numComponents() {
+    return this._numComponents;
   }
-  getBits(nbits) {
-    if (nbits > 32) return void 0;
-    const buf = this._bitBuffer;
-    let off = this._bitOffset;
-    const byteOffset = off >> 3;
-    const bitShift = off & 7;
-    if (byteOffset + 4 < this._byteLength) {
-      const val = (buf[byteOffset] | buf[byteOffset + 1] << 8 | buf[byteOffset + 2] << 16 | buf[byteOffset + 3] << 24) >>> 0;
-      let result;
-      if (nbits > 32 - bitShift) {
-        const val2 = buf[byteOffset + 4];
-        const low = val >>> bitShift;
-        const high = val2 << 32 - bitShift;
-        result = (low | high) >>> 0;
-      } else {
-        result = val >>> bitShift;
-      }
-      this._bitOffset = off + nbits;
-      return nbits === 32 ? result : result & (1 << nbits) - 1;
-    }
-    let value = 0;
-    let bitsRead = 0;
-    let currOff = off;
-    while (bitsRead < nbits) {
-      const bOff = currOff >> 3;
-      if (bOff >= this._byteLength) break;
-      const bShift = currOff & 7;
-      const bitsAvail = 8 - bShift;
-      const bitsNeeded = nbits - bitsRead;
-      const bitsToRead = bitsAvail < bitsNeeded ? bitsAvail : bitsNeeded;
-      const mask = (1 << bitsToRead) - 1;
-      value |= (buf[bOff] >> bShift & mask) << bitsRead;
-      bitsRead += bitsToRead;
-      currOff += bitsToRead;
-    }
-    this._bitOffset = currOff;
-    return value;
+  get buffer() {
+    return this._buffer;
+  }
+  get byteStride() {
+    return this._byteStride;
+  }
+  get byteOffset() {
+    return this._byteOffset;
+  }
+  get uniqueId() {
+    return this._uniqueId;
+  }
+  set uniqueId(id) {
+    this._uniqueId = id;
   }
 };
-var DecoderBuffer = class {
-  _data;
-  _dataView;
-  _dataSize;
-  _pos;
-  _bitDecoder;
-  _bitMode;
-  _bitstreamVersion;
+
+// src/decoder/point_cloud/PointCloud.ts
+var NAMED_ATTRIBUTES_COUNT = 8;
+var PointCloud = class {
+  num_points_;
+  attributes_;
+  named_attribute_index_;
   constructor() {
-    this._data = null;
-    this._dataView = null;
-    this._dataSize = 0;
-    this._pos = 0;
-    this._bitDecoder = new BitDecoder();
-    this._bitMode = false;
-    this._bitstreamVersion = 0;
-  }
-  init(data, dataSize, version) {
-    if (data instanceof ArrayBuffer) {
-      this._data = new Uint8Array(data);
-    } else if (data instanceof Uint8Array) {
-      this._data = data;
-    } else {
-      this._data = new Uint8Array(data);
+    this.num_points_ = 0;
+    this.attributes_ = [];
+    this.named_attribute_index_ = [];
+    for (let i = 0; i < NAMED_ATTRIBUTES_COUNT; ++i) {
+      this.named_attribute_index_.push([]);
     }
-    this._dataView = new DataView(this._data.buffer, this._data.byteOffset, this._data.byteLength);
-    this._dataSize = dataSize !== void 0 ? dataSize : this._data.length;
-    this._pos = 0;
-    if (version !== void 0) {
-      this._bitstreamVersion = version;
+  }
+  numNamedAttributes(type) {
+    if (type < 0 || type >= NAMED_ATTRIBUTES_COUNT) {
+      return 0;
     }
-  }
-  // Typed little-endian reads.
-  decodeUint8() {
-    if (this._pos + 1 > this._dataSize) return void 0;
-    const val = this._data[this._pos];
-    this._pos += 1;
-    return val;
-  }
-  decodeInt8() {
-    if (this._pos + 1 > this._dataSize) return void 0;
-    const val = this._dataView.getInt8(this._pos);
-    this._pos += 1;
-    return val;
-  }
-  decodeUint16() {
-    if (this._pos + 2 > this._dataSize) return void 0;
-    const val = this._dataView.getUint16(this._pos, true);
-    this._pos += 2;
-    return val;
-  }
-  decodeUint32() {
-    if (this._pos + 4 > this._dataSize) return void 0;
-    const val = this._dataView.getUint32(this._pos, true);
-    this._pos += 4;
-    return val;
-  }
-  decodeInt32() {
-    if (this._pos + 4 > this._dataSize) return void 0;
-    const val = this._dataView.getInt32(this._pos, true);
-    this._pos += 4;
-    return val;
-  }
-  decodeFloat32() {
-    if (this._pos + 4 > this._dataSize) return void 0;
-    const val = this._dataView.getFloat32(this._pos, true);
-    this._pos += 4;
-    return val;
-  }
-  decodeUint64() {
-    if (this._pos + 8 > this._dataSize) return void 0;
-    const lo = this._dataView.getUint32(this._pos, true);
-    const hi = this._dataView.getUint32(this._pos + 4, true);
-    this._pos += 8;
-    return hi * 4294967296 + lo;
-  }
-  decodeBytes(size) {
-    if (this._pos + size > this._dataSize) return void 0;
-    const result = this._data.slice(this._pos, this._pos + size);
-    this._pos += size;
-    return result;
-  }
-  startBitDecoding(decodeSize) {
-    let outSize = 0;
-    if (decodeSize) {
-      if (this._bitstreamVersion < bitstreamVersion(2, 2)) {
-        outSize = this.decodeUint64();
-        if (outSize === void 0) return void 0;
-      } else {
-        outSize = decodeVarint(this, false);
-        if (outSize === void 0) return void 0;
-      }
-    }
-    this._bitMode = true;
-    this._bitDecoder.reset(this._data.subarray(this._pos), this._dataSize - this._pos);
-    return outSize;
-  }
-  endBitDecoding() {
-    this._bitMode = false;
-    const bitsDecoded = this._bitDecoder.bitsDecoded();
-    const bytesDecoded = Math.ceil(bitsDecoded / 8);
-    this._pos += bytesDecoded;
-  }
-  decodeLeastSignificantBits32(nbits) {
-    if (!this._bitMode) return void 0;
-    return this._bitDecoder.getBits(nbits);
-  }
-  decodeVarintUint32() {
-    return decodeVarint(this, false);
-  }
-  decodeVarintUint64() {
-    return decodeVarint(this, false);
-  }
-  advance(bytes) {
-    this._pos += bytes;
-  }
-  get bitstreamVersion() {
-    return this._bitstreamVersion;
-  }
-  set bitstreamVersion(v) {
-    this._bitstreamVersion = v;
-  }
-  get data() {
-    return this._data;
-  }
-  get dataHead() {
-    return this._data.subarray(this._pos);
-  }
-  get remainingSize() {
-    return this._dataSize - this._pos;
-  }
-  get decodedSize() {
-    return this._pos;
-  }
-  get bitDecoderActive() {
-    return this._bitMode;
-  }
-};
-
-// src/decoder/point_cloud/PointCloud.ts
-var NAMED_ATTRIBUTES_COUNT = 8;
-var PointCloud = class {
-  num_points_;
-  attributes_;
-  named_attribute_index_;
-  constructor() {
-    this.num_points_ = 0;
-    this.attributes_ = [];
-    this.named_attribute_index_ = [];
-    for (let i = 0; i < NAMED_ATTRIBUTES_COUNT; ++i) {
-      this.named_attribute_index_.push([]);
-    }
-  }
-  numNamedAttributes(type) {
-    if (type < 0 || type >= NAMED_ATTRIBUTES_COUNT) {
-      return 0;
-    }
-    return this.named_attribute_index_[type].length;
+    return this.named_attribute_index_[type].length;
   }
   getNamedAttributeId(type, i) {
     if (i === void 0) i = 0;
@@ -368,25 +242,17 @@ var Mesh = class extends PointCloud {
     this.numFaces_ = 0;
     this.attribute_data_ = [];
   }
-  _ensureFaceCapacity(numFaces) {
-    if (this.faces_.length >= numFaces * 3) {
-      return;
-    }
-    const grown = new Int32Array(numFaces * 3);
-    grown.set(this.faces_);
-    this.faces_ = grown;
-  }
-  addFace(face) {
-    const f = this.numFaces_;
-    this._ensureFaceCapacity(f + 1);
-    const o = f * 3;
-    this.faces_[o] = face[0];
-    this.faces_[o + 1] = face[1];
-    this.faces_[o + 2] = face[2];
-    this.numFaces_ = f + 1;
-  }
+  // Sizes faces_ to hold numFaces faces. Called once per decode, before any
+  // face index is written (edgebreaker: _assignPointsToCorners; sequential:
+  // decodeConnectivity), so the buffer is allocated exactly here — the
+  // decoders fill faces_ directly rather than appending face-by-face.
   setNumFaces(numFaces) {
-    this._ensureFaceCapacity(numFaces);
+    const needed = numFaces * 3;
+    if (this.faces_.length < needed) {
+      const grown = new Int32Array(needed);
+      grown.set(this.faces_);
+      this.faces_ = grown;
+    }
     this.numFaces_ = numFaces;
   }
   numFaces() {
@@ -405,1248 +271,1401 @@ var Mesh = class extends PointCloud {
   }
 };
 
-// src/decoder/compression/config/CompressionShared.ts
-var kDracoPointCloudBitstreamVersionMajor = 2;
-var kDracoPointCloudBitstreamVersionMinor = 3;
-var kDracoMeshBitstreamVersionMajor = 2;
-var kDracoMeshBitstreamVersionMinor = 2;
-function DRACO_BITSTREAM_VERSION(major, minor) {
-  return major << 8 | minor;
-}
-var EncodedGeometryType = {
-  INVALID_GEOMETRY_TYPE: -1,
-  POINT_CLOUD: 0,
-  TRIANGULAR_MESH: 1,
-  NUM_ENCODED_GEOMETRY_TYPES: 2
-};
-var MeshEncoderMethod = {
-  MESH_SEQUENTIAL_ENCODING: 0,
-  MESH_EDGEBREAKER_ENCODING: 1
-};
-var SequentialAttributeEncoderType = {
-  SEQUENTIAL_ATTRIBUTE_ENCODER_GENERIC: 0,
-  SEQUENTIAL_ATTRIBUTE_ENCODER_INTEGER: 1,
-  SEQUENTIAL_ATTRIBUTE_ENCODER_QUANTIZATION: 2,
-  SEQUENTIAL_ATTRIBUTE_ENCODER_NORMALS: 3
-};
-var PredictionSchemeMethod = {
-  PREDICTION_NONE: -2,
-  PREDICTION_UNDEFINED: -1,
-  PREDICTION_DIFFERENCE: 0,
-  MESH_PREDICTION_PARALLELOGRAM: 1,
-  MESH_PREDICTION_MULTI_PARALLELOGRAM: 2,
-  MESH_PREDICTION_TEX_COORDS_DEPRECATED: 3,
-  MESH_PREDICTION_CONSTRAINED_MULTI_PARALLELOGRAM: 4,
-  MESH_PREDICTION_TEX_COORDS_PORTABLE: 5,
-  MESH_PREDICTION_GEOMETRIC_NORMAL: 6,
-  NUM_PREDICTION_SCHEMES: 7
-};
-var PredictionSchemeTransformType = {
-  PREDICTION_TRANSFORM_NONE: -1,
-  PREDICTION_TRANSFORM_DELTA: 0,
-  PREDICTION_TRANSFORM_WRAP: 1,
-  PREDICTION_TRANSFORM_NORMAL_OCTAHEDRON: 2,
-  PREDICTION_TRANSFORM_NORMAL_OCTAHEDRON_CANONICALIZED: 3,
-  NUM_PREDICTION_SCHEME_TRANSFORM_TYPES: 4
-};
-var MeshTraversalMethod = {
-  MESH_TRAVERSAL_DEPTH_FIRST: 0,
-  MESH_TRAVERSAL_PREDICTION_DEGREE: 1,
-  NUM_TRAVERSAL_METHODS: 2
-};
-var MeshEdgebreakerConnectivityEncodingMethod = {
-  MESH_EDGEBREAKER_STANDARD_ENCODING: 0,
-  MESH_EDGEBREAKER_PREDICTIVE_ENCODING: 1,
-  // Deprecated.
-  MESH_EDGEBREAKER_VALENCE_ENCODING: 2
-};
-var DracoHeader = class {
-  dracoString;
-  versionMajor;
-  versionMinor;
-  encoderType;
-  encoderMethod;
-  flags;
-  constructor() {
-    this.dracoString = new Int8Array(5);
-    this.versionMajor = 0;
-    this.versionMinor = 0;
-    this.encoderType = 0;
-    this.encoderMethod = 0;
-    this.flags = 0;
-  }
-};
-var NormalPredictionMode = {
-  ONE_TRIANGLE: 0,
-  // To be deprecated.
-  TRIANGLE_AREA: 1
-};
-var SymbolCodingMethod = {
-  SYMBOL_CODING_TAGGED: 0,
-  SYMBOL_CODING_RAW: 1,
-  NUM_SYMBOL_CODING_METHODS: 2
-};
-var METADATA_FLAG_MASK = 32768;
-
-// src/decoder/compression/config/DracoOptions.ts
-var DracoOptions = class {
-  _globalOptions;
-  _attributeOptions;
+// src/decoder/core/DataBuffer.ts
+var DataBuffer = class {
+  _data;
   constructor() {
-    this._globalOptions = /* @__PURE__ */ new Map();
-    this._attributeOptions = /* @__PURE__ */ new Map();
+    this._data = new Uint8Array(0);
   }
-  getGlobalBool(name, defaultVal) {
-    if (this._globalOptions.has(name)) {
-      return !!this._globalOptions.get(name);
+  update(data, size, offset = 0) {
+    if (data === null || data === void 0) {
+      if (size + offset < 0) return false;
+      this._resize(size + offset);
+    } else {
+      if (size < 0) return false;
+      if (size + offset > this._data.length) {
+        this._resize(size + offset);
+      }
+      const view = data;
+      const src = new Uint8Array(view.buffer || data, view.byteOffset || 0, size);
+      this._data.set(src, offset);
     }
-    return defaultVal;
+    return true;
   }
-  findAttributeOptions(attKey) {
-    if (this._attributeOptions.has(attKey)) {
-      return this._attributeOptions.get(attKey);
-    }
-    return null;
+  resize(newSize) {
+    this._resize(newSize);
   }
-  getAttributeBool(attKey, name, defaultVal) {
-    const attOpts = this.findAttributeOptions(attKey);
-    if (attOpts !== null && attOpts.has(name)) {
-      return !!attOpts.get(name);
+  write(bytePos, inArray, dataSize) {
+    if (inArray instanceof Uint8Array) {
+      this._data.set(inArray.length === dataSize ? inArray : inArray.subarray(0, dataSize), bytePos);
+      return;
     }
-    return this.getGlobalBool(name, defaultVal);
+    const view = inArray;
+    const src = new Uint8Array(view.buffer || inArray, view.byteOffset || 0, dataSize);
+    this._data.set(src, bytePos);
   }
-};
-
-// src/decoder/compression/config/DecoderOptions.ts
-var DecoderOptions = class extends DracoOptions {
-  constructor() {
-    super();
+  get data() {
+    return this._data;
   }
-};
-
-// src/decoder/core/Status.ts
-var StatusCode = {
-  OK: 0,
-  DRACO_ERROR: -1,
-  IO_ERROR: -2,
-  INVALID_PARAMETER: -3,
-  UNSUPPORTED_VERSION: -4,
-  UNKNOWN_VERSION: -5,
-  UNSUPPORTED_FEATURE: -6
-};
-var Status = class {
-  code;
-  errorMsg;
-  constructor(code = StatusCode.OK, errorMsg = "") {
-    this.code = code;
-    this.errorMsg = errorMsg;
+  get dataSize() {
+    return this._data.length;
   }
-  ok() {
-    return this.code === StatusCode.OK;
+  _resize(newSize) {
+    if (newSize === this._data.length) return;
+    const newData = new Uint8Array(newSize);
+    newData.set(this._data.subarray(0, Math.min(this._data.length, newSize)));
+    this._data = newData;
   }
 };
-function okStatus() {
-  return new Status(StatusCode.OK);
-}
 
-// src/decoder/metadata/MetadataDecoder.ts
-var kMaxSubmetadataLevel = 1e3;
-var MetadataDecoder = class {
-  buffer_;
-  constructor() {
-    this.buffer_ = null;
+// src/decoder/attributes/GeometryIndices.ts
+var kInvalidAttributeValueIndex = 4294967295 >>> 0;
+
+// src/decoder/attributes/PointAttribute.ts
+var PointAttribute = class extends GeometryAttribute {
+  _identityMapping;
+  _numUniqueEntries;
+  _indicesMap;
+  _attributeBuffer;
+  _attributeTransformData;
+  // Lazily-created cached views over the attribute buffer.
+  _cachedFloat32View;
+  _cachedFloat32Buffer;
+  _cachedInt32View;
+  _cachedInt32Buffer;
+  _cachedUint32View;
+  _cachedUint32Buffer;
+  _cachedUint16View;
+  _cachedUint16Buffer;
+  _cachedInt16View;
+  _cachedInt16Buffer;
+  _cachedUint8View;
+  _cachedUint8Buffer;
+  _cachedInt8View;
+  _cachedInt8Buffer;
+  _cachedFloat64View;
+  _cachedFloat64Buffer;
+  _cachedDataView;
+  _cachedDVBuffer;
+  constructor(geometryAttribute) {
+    super();
+    this._identityMapping = false;
+    this._numUniqueEntries = 0;
+    this._indicesMap = [];
+    this._attributeBuffer = null;
+    this._attributeTransformData = null;
+    if (geometryAttribute instanceof GeometryAttribute) {
+      this._buffer = geometryAttribute._buffer;
+      this._numComponents = geometryAttribute._numComponents;
+      this._dataType = geometryAttribute._dataType;
+      this._normalized = geometryAttribute._normalized;
+      this._byteStride = geometryAttribute._byteStride;
+      this._byteOffset = geometryAttribute._byteOffset;
+      this._attributeType = geometryAttribute._attributeType;
+      this._uniqueId = geometryAttribute._uniqueId;
+    }
   }
-  // Skips per-attribute metadata followed by the geometry-level metadata.
-  skipGeometryMetadata(inBuffer) {
-    this.buffer_ = inBuffer;
-    const numAttMetadata = decodeVarint(this.buffer_);
-    if (numAttMetadata === void 0) {
-      return false;
+  // Intentionally shadows GeometryAttribute.init with a different signature (matches draco.js / C++ source).
+  // @ts-expect-error -- signature intentionally differs from the base class, as in the source.
+  init(attributeType, numComponents, dataType, normalized, numAttributeValues) {
+    this._attributeBuffer = new DataBuffer();
+    const byteStride = dataTypeLength(dataType) * numComponents;
+    super.init(attributeType, this._attributeBuffer, numComponents, dataType, normalized, byteStride, 0);
+    this.reset(numAttributeValues);
+    this.setIdentityMapping();
+  }
+  reset(numAttributeValues) {
+    if (this._attributeBuffer === null) {
+      this._attributeBuffer = new DataBuffer();
     }
-    for (let i = 0; i < numAttMetadata; ++i) {
-      if (decodeVarint(this.buffer_) === void 0) {
-        return false;
-      }
-      if (!this._skipMetadata(0)) {
-        return false;
-      }
+    const entrySize = dataTypeLength(this.dataType) * this.numComponents;
+    this._attributeBuffer.update(null, numAttributeValues * entrySize);
+    this.resetBuffer(this._attributeBuffer, entrySize, 0);
+    this._numUniqueEntries = numAttributeValues;
+    return true;
+  }
+  get size() {
+    return this._numUniqueEntries;
+  }
+  mappedIndex(pointIndex) {
+    if (this._identityMapping) {
+      return pointIndex;
     }
-    return this._skipMetadata(0);
+    return this._indicesMap[pointIndex];
   }
-  // Discards one metadata block (key-value entries plus nested sub-metadata).
-  // Sub-blocks read depth-first in stream order, matching the C++ stack traversal.
-  _skipMetadata(level) {
-    if (level > kMaxSubmetadataLevel) {
-      return false;
+  get isMappingIdentity() {
+    return this._identityMapping;
+  }
+  get indicesMapSize() {
+    if (this._identityMapping) {
+      return 0;
     }
-    const numEntries = decodeVarint(this.buffer_);
-    if (numEntries === void 0) {
-      return false;
+    return this._indicesMap.length;
+  }
+  // Direct access to the explicit point->value index map (Uint32Array after
+  // setExplicitMapping). Lets hot mapping loops write entries without a
+  // per-entry setPointMapEntry() dispatch.
+  get indicesMap() {
+    return this._indicesMap;
+  }
+  // Implicit mapping: point index equals attribute entry index.
+  setIdentityMapping() {
+    this._identityMapping = true;
+    this._indicesMap = [];
+  }
+  setExplicitMapping(numPoints) {
+    this._identityMapping = false;
+    this._indicesMap = new Uint32Array(numPoints);
+    this._indicesMap.fill(kInvalidAttributeValueIndex);
+  }
+  // Like setExplicitMapping but skips the invalid-index fill. Only for callers
+  // that provably write every entry right away (the fill was ~4% of decode
+  // time on primitive-heavy files). The array still starts zeroed by the
+  // engine, so a buggy caller reads valid-looking zeros — hence opt-in.
+  setExplicitMappingUnfilled(numPoints) {
+    this._identityMapping = false;
+    this._indicesMap = new Uint32Array(numPoints);
+  }
+  setAttributeTransformData(transformData) {
+    this._attributeTransformData = transformData;
+  }
+  // Mirrors C++ PointAttribute::ConvertValue<T>().
+  convertValue(attIndex, outVal) {
+    const bytePos = this._byteOffset + this._byteStride * attIndex;
+    const bufData = this._buffer.data;
+    const dt = this._dataType;
+    const nc = this._numComponents;
+    if (dt === DataType.FLOAT32) {
+      if (this._cachedFloat32View === void 0 || this._cachedFloat32Buffer !== bufData.buffer) {
+        this._cachedFloat32Buffer = bufData.buffer;
+        this._cachedFloat32View = new Float32Array(bufData.buffer);
+      }
+      const baseIndex = bufData.byteOffset + bytePos >> 2;
+      for (let i = 0; i < nc; ++i) {
+        outVal[i] = this._cachedFloat32View[baseIndex + i];
+      }
+      return;
     }
-    for (let i = 0; i < numEntries; ++i) {
-      if (!this._skipEntry()) {
-        return false;
+    if (dt === DataType.INT32) {
+      if (this._cachedInt32View === void 0 || this._cachedInt32Buffer !== bufData.buffer) {
+        this._cachedInt32Buffer = bufData.buffer;
+        this._cachedInt32View = new Int32Array(bufData.buffer);
+      }
+      const baseIndex = bufData.byteOffset + bytePos >> 2;
+      for (let i = 0; i < nc; ++i) {
+        outVal[i] = this._cachedInt32View[baseIndex + i];
       }
+      return;
     }
-    const numSubMetadata = decodeVarint(this.buffer_);
-    if (numSubMetadata === void 0) {
-      return false;
+    if (dt === DataType.UINT32) {
+      if (this._cachedUint32View === void 0 || this._cachedUint32Buffer !== bufData.buffer) {
+        this._cachedUint32Buffer = bufData.buffer;
+        this._cachedUint32View = new Uint32Array(bufData.buffer);
+      }
+      const baseIndex = bufData.byteOffset + bytePos >> 2;
+      for (let i = 0; i < nc; ++i) {
+        outVal[i] = this._cachedUint32View[baseIndex + i];
+      }
+      return;
     }
-    if (numSubMetadata > this.buffer_.remainingSize) {
-      return false;
+    if (this._cachedDataView === void 0 || this._cachedDVBuffer !== bufData.buffer) {
+      this._cachedDVBuffer = bufData.buffer;
+      this._cachedDataView = new DataView(bufData.buffer, bufData.byteOffset, bufData.byteLength);
     }
-    for (let i = 0; i < numSubMetadata; ++i) {
-      if (!this._skipName()) {
-        return false;
-      }
-      if (!this._skipMetadata(level + 1)) {
-        return false;
+    const dv = this._cachedDataView;
+    for (let i = 0; i < nc; ++i) {
+      switch (dt) {
+        case DataType.INT8:
+          outVal[i] = dv.getInt8(bytePos + i);
+          break;
+        case DataType.UINT8:
+          outVal[i] = dv.getUint8(bytePos + i);
+          break;
+        case DataType.INT16:
+          outVal[i] = dv.getInt16(bytePos + i * 2, true);
+          break;
+        case DataType.UINT16:
+          outVal[i] = dv.getUint16(bytePos + i * 2, true);
+          break;
+        case DataType.INT32:
+          outVal[i] = dv.getInt32(bytePos + i * 4, true);
+          break;
+        case DataType.UINT32:
+          outVal[i] = dv.getUint32(bytePos + i * 4, true);
+          break;
+        case DataType.FLOAT64:
+          outVal[i] = dv.getFloat64(bytePos + i * 8, true);
+          break;
+        default:
+          outVal[i] = 0;
+          break;
       }
     }
-    return true;
   }
-  // Skips a key-value entry: name then a length-prefixed value.
-  _skipEntry() {
-    if (!this._skipName()) {
-      return false;
+  // Flat-array extraction of all values into one output typed array (avoids the
+  // per-point temp-array copy via cached typed-array views over the buffer).
+  extractTo(OutputTypedArray, numPoints) {
+    const numComponents = this._numComponents;
+    const array = new OutputTypedArray(numPoints * numComponents);
+    if (this._buffer == null || this._buffer.data == null || numPoints === 0) {
+      return array;
     }
-    const dataSize = decodeVarint(this.buffer_);
-    if (dataSize === void 0 || dataSize === 0) {
-      return false;
+    const bufData = this._buffer.data;
+    const dt = this._dataType;
+    const isIdentity = this._identityMapping;
+    const indicesMap = this._indicesMap;
+    const byteStride = this._byteStride;
+    const byteOffset = this._byteOffset;
+    let srcView = null;
+    let shift = 0;
+    if (dt === DataType.FLOAT32) {
+      if (this._cachedFloat32View === void 0 || this._cachedFloat32Buffer !== bufData.buffer) {
+        this._cachedFloat32Buffer = bufData.buffer;
+        this._cachedFloat32View = new Float32Array(bufData.buffer);
+      }
+      srcView = this._cachedFloat32View;
+      shift = 2;
+    } else if (dt === DataType.INT32) {
+      if (this._cachedInt32View === void 0 || this._cachedInt32Buffer !== bufData.buffer) {
+        this._cachedInt32Buffer = bufData.buffer;
+        this._cachedInt32View = new Int32Array(bufData.buffer);
+      }
+      srcView = this._cachedInt32View;
+      shift = 2;
+    } else if (dt === DataType.UINT32) {
+      if (this._cachedUint32View === void 0 || this._cachedUint32Buffer !== bufData.buffer) {
+        this._cachedUint32Buffer = bufData.buffer;
+        this._cachedUint32View = new Uint32Array(bufData.buffer);
+      }
+      srcView = this._cachedUint32View;
+      shift = 2;
+    } else if (dt === DataType.UINT16) {
+      if (this._cachedUint16View === void 0 || this._cachedUint16Buffer !== bufData.buffer) {
+        this._cachedUint16Buffer = bufData.buffer;
+        this._cachedUint16View = new Uint16Array(bufData.buffer);
+      }
+      srcView = this._cachedUint16View;
+      shift = 1;
+    } else if (dt === DataType.INT16) {
+      if (this._cachedInt16View === void 0 || this._cachedInt16Buffer !== bufData.buffer) {
+        this._cachedInt16Buffer = bufData.buffer;
+        this._cachedInt16View = new Int16Array(bufData.buffer);
+      }
+      srcView = this._cachedInt16View;
+      shift = 1;
+    } else if (dt === DataType.UINT8) {
+      if (this._cachedUint8View === void 0 || this._cachedUint8Buffer !== bufData.buffer) {
+        this._cachedUint8Buffer = bufData.buffer;
+        this._cachedUint8View = new Uint8Array(bufData.buffer);
+      }
+      srcView = this._cachedUint8View;
+      shift = 0;
+    } else if (dt === DataType.INT8) {
+      if (this._cachedInt8View === void 0 || this._cachedInt8Buffer !== bufData.buffer) {
+        this._cachedInt8Buffer = bufData.buffer;
+        this._cachedInt8View = new Int8Array(bufData.buffer);
+      }
+      srcView = this._cachedInt8View;
+      shift = 0;
+    } else if (dt === DataType.FLOAT64) {
+      if (this._cachedFloat64View === void 0 || this._cachedFloat64Buffer !== bufData.buffer) {
+        this._cachedFloat64Buffer = bufData.buffer;
+        this._cachedFloat64View = new Float64Array(bufData.buffer);
+      }
+      srcView = this._cachedFloat64View;
+      shift = 3;
     }
-    if (dataSize > this.buffer_.remainingSize) {
-      return false;
+    if (srcView !== null) {
+      const srcStart = bufData.byteOffset + byteOffset >> shift;
+      const strideElements = byteStride >> shift;
+      if (isIdentity && strideElements === numComponents) {
+        const srcEnd = srcStart + numPoints * numComponents;
+        if (srcView.constructor === OutputTypedArray) {
+          array.set(srcView.subarray(srcStart, srcEnd));
+          return array;
+        }
+      }
+      if (isIdentity) {
+        let dst = 0;
+        for (let i = 0; i < numPoints; i++) {
+          const srcOffset = srcStart + i * strideElements;
+          for (let j = 0; j < numComponents; j++) {
+            array[dst + j] = srcView[srcOffset + j];
+          }
+          dst += numComponents;
+        }
+      } else if (numComponents === 3) {
+        let dst = 0;
+        for (let i = 0; i < numPoints; i++) {
+          const srcOffset = srcStart + indicesMap[i] * strideElements;
+          array[dst] = srcView[srcOffset];
+          array[dst + 1] = srcView[srcOffset + 1];
+          array[dst + 2] = srcView[srcOffset + 2];
+          dst += 3;
+        }
+      } else if (numComponents === 2) {
+        let dst = 0;
+        for (let i = 0; i < numPoints; i++) {
+          const srcOffset = srcStart + indicesMap[i] * strideElements;
+          array[dst] = srcView[srcOffset];
+          array[dst + 1] = srcView[srcOffset + 1];
+          dst += 2;
+        }
+      } else if (numComponents === 4) {
+        let dst = 0;
+        for (let i = 0; i < numPoints; i++) {
+          const srcOffset = srcStart + indicesMap[i] * strideElements;
+          array[dst] = srcView[srcOffset];
+          array[dst + 1] = srcView[srcOffset + 1];
+          array[dst + 2] = srcView[srcOffset + 2];
+          array[dst + 3] = srcView[srcOffset + 3];
+          dst += 4;
+        }
+      } else if (numComponents === 1) {
+        let dst = 0;
+        for (let i = 0; i < numPoints; i++) {
+          array[dst++] = srcView[srcStart + indicesMap[i] * strideElements];
+        }
+      } else {
+        let dst = 0;
+        for (let i = 0; i < numPoints; i++) {
+          const srcOffset = srcStart + indicesMap[i] * strideElements;
+          for (let j = 0; j < numComponents; j++) {
+            array[dst + j] = srcView[srcOffset + j];
+          }
+          dst += numComponents;
+        }
+      }
+      return array;
+    }
+    const temp = new Array(numComponents);
+    for (let i = 0; i < numPoints; i++) {
+      const attIndex = isIdentity ? i : indicesMap[i];
+      this.convertValue(attIndex, temp);
+      const dstOffset = i * numComponents;
+      for (let j = 0; j < numComponents; j++) {
+        array[dstOffset + j] = temp[j];
+      }
     }
-    return this.buffer_.decodeBytes(dataSize) !== void 0;
+    return array;
   }
-  // Skips a name (uint8 length prefix followed by that many bytes).
-  _skipName() {
-    const nameLen = this.buffer_.decodeUint8();
-    if (nameLen === void 0) {
-      return false;
+  // Intentionally returns void while the base class returns boolean (matches the source's shape).
+  // @ts-expect-error -- return type intentionally differs from the base class, as in the source.
+  copyFrom(srcAtt) {
+    if (this.buffer === null) {
+      this._attributeBuffer = new DataBuffer();
+      this.resetBuffer(this._attributeBuffer, 0, 0);
     }
-    if (nameLen === 0) {
-      return true;
+    if (!super.copyFrom(srcAtt)) {
+      return;
+    }
+    this._identityMapping = srcAtt._identityMapping;
+    this._numUniqueEntries = srcAtt._numUniqueEntries;
+    this._indicesMap = srcAtt._indicesMap.slice();
+    if (srcAtt._attributeTransformData) {
+      this._attributeTransformData = srcAtt._attributeTransformData;
+    } else {
+      this._attributeTransformData = null;
     }
-    return this.buffer_.decodeBytes(nameLen) !== void 0;
   }
 };
 
-// src/decoder/compression/point_cloud/PointCloudDecoder.ts
-var PointCloudDecoder = class _PointCloudDecoder {
-  _pointCloud;
-  _buffer;
-  _versionMajor;
-  _versionMinor;
-  _options;
-  _attributesDecoders;
-  _attributeToDecoderMap;
-  constructor() {
-    this._pointCloud = null;
-    this._buffer = null;
-    this._versionMajor = 0;
-    this._versionMinor = 0;
-    this._options = null;
-    this._attributesDecoders = [];
-    this._attributeToDecoderMap = [];
+// src/decoder/core/Macros.ts
+function bitstreamVersion(major, minor) {
+  return (major & 255) << 8 | minor & 255;
+}
+
+// src/decoder/core/BitUtils.ts
+function convertSymbolsToSignedInts(input, count, output) {
+  for (let i = 0; i < count; i++) {
+    const val = input[i];
+    output[i] = val >>> 1 ^ -(val & 1);
   }
-  getGeometryType() {
-    return EncodedGeometryType.POINT_CLOUD;
+}
+function convertSymbolToSignedInt(val) {
+  const isPositive = (val & 1) === 0;
+  val >>>= 1;
+  if (isPositive) {
+    return val;
   }
-  // Returns a Status; on success outHeader is populated.
-  static decodeHeader(buffer, outHeader) {
-    const kIoErrorMsg = "Failed to parse Draco header.";
-    const bytes = buffer.decodeBytes(5);
-    if (bytes === void 0) {
-      return new Status(StatusCode.IO_ERROR, kIoErrorMsg);
-    }
-    for (let i = 0; i < 5; i++) {
-      outHeader.dracoString[i] = bytes[i];
-    }
-    const magic = String.fromCharCode(bytes[0], bytes[1], bytes[2], bytes[3], bytes[4]);
-    if (magic !== "DRACO") {
-      return new Status(StatusCode.DRACO_ERROR, "Not a Draco file.");
-    }
-    const versionMajor = buffer.decodeUint8();
-    if (versionMajor === void 0) {
-      return new Status(StatusCode.IO_ERROR, kIoErrorMsg);
-    }
-    outHeader.versionMajor = versionMajor;
-    const versionMinor = buffer.decodeUint8();
-    if (versionMinor === void 0) {
-      return new Status(StatusCode.IO_ERROR, kIoErrorMsg);
-    }
-    outHeader.versionMinor = versionMinor;
-    const encoderType = buffer.decodeUint8();
-    if (encoderType === void 0) {
-      return new Status(StatusCode.IO_ERROR, kIoErrorMsg);
-    }
-    outHeader.encoderType = encoderType;
-    const encoderMethod = buffer.decodeUint8();
-    if (encoderMethod === void 0) {
-      return new Status(StatusCode.IO_ERROR, kIoErrorMsg);
+  return -val - 1;
+}
+
+// src/decoder/core/VarintDecoding.ts
+function decodeVarintUnsigned(buffer, maxBytes) {
+  let result = 0;
+  let multiplier = 1;
+  for (let i = 0; i < maxBytes; i++) {
+    const byte = buffer.decodeUint8();
+    if (byte === void 0) return void 0;
+    if (byte & 128) {
+      result += (byte & 127) * multiplier;
+      multiplier *= 128;
+    } else {
+      return result + byte * multiplier;
     }
-    outHeader.encoderMethod = encoderMethod;
-    const flags = buffer.decodeUint16();
-    if (flags === void 0) {
-      return new Status(StatusCode.IO_ERROR, kIoErrorMsg);
-    }
-    outHeader.flags = flags;
-    return okStatus();
   }
-  // Main entry point for point cloud decoding.
-  decode(options, inBuffer, outPointCloud) {
-    this._options = options;
-    this._buffer = inBuffer;
-    this._pointCloud = outPointCloud;
-    const header = new DracoHeader();
-    const headerStatus = _PointCloudDecoder.decodeHeader(this._buffer, header);
-    if (!headerStatus.ok()) {
-      return headerStatus;
-    }
-    if (header.encoderType !== this.getGeometryType()) {
-      return new Status(StatusCode.DRACO_ERROR, "Using incompatible decoder for the input geometry.");
-    }
-    this._versionMajor = header.versionMajor;
-    this._versionMinor = header.versionMinor;
-    const maxSupportedMajorVersion = header.encoderType === EncodedGeometryType.POINT_CLOUD ? kDracoPointCloudBitstreamVersionMajor : kDracoMeshBitstreamVersionMajor;
-    const maxSupportedMinorVersion = header.encoderType === EncodedGeometryType.POINT_CLOUD ? kDracoPointCloudBitstreamVersionMinor : kDracoMeshBitstreamVersionMinor;
-    if (this._versionMajor < 1 || this._versionMajor > maxSupportedMajorVersion) {
-      return new Status(StatusCode.UNKNOWN_VERSION, "Unknown major version.");
-    }
-    if (this._versionMajor === maxSupportedMajorVersion && this._versionMinor > maxSupportedMinorVersion) {
-      return new Status(StatusCode.UNKNOWN_VERSION, "Unknown minor version.");
-    }
-    this._buffer.bitstreamVersion = DRACO_BITSTREAM_VERSION(this._versionMajor, this._versionMinor);
-    if (header.encoderType === EncodedGeometryType.TRIANGULAR_MESH && this._buffer.bitstreamVersion < DRACO_BITSTREAM_VERSION(2, 2)) {
-      return new Status(
-        StatusCode.UNKNOWN_VERSION,
-        "Unsupported bitstream version (only Draco 2.2 meshes are supported)."
-      );
-    }
-    if (header.flags & METADATA_FLAG_MASK) {
-      const metadataStatus = this._decodeMetadata();
-      if (!metadataStatus.ok()) {
-        return metadataStatus;
+  return void 0;
+}
+function decodeVarint(buffer, signed = false) {
+  const maxBytes = 10;
+  const value = decodeVarintUnsigned(buffer, maxBytes);
+  if (value === void 0) return void 0;
+  if (signed) {
+    return convertSymbolToSignedInt(value);
+  }
+  return value;
+}
+
+// src/decoder/core/DecoderBuffer.ts
+var BitDecoder = class {
+  _bitBuffer;
+  _bitOffset;
+  _byteLength;
+  constructor() {
+    this._bitBuffer = null;
+    this._bitOffset = 0;
+    this._byteLength = 0;
+  }
+  reset(uint8Array, byteLength) {
+    this._bitBuffer = uint8Array;
+    this._byteLength = byteLength;
+    this._bitOffset = 0;
+  }
+  bitsDecoded() {
+    return this._bitOffset;
+  }
+  getBits(nbits) {
+    if (nbits > 32) return void 0;
+    const buf = this._bitBuffer;
+    let off = this._bitOffset;
+    const byteOffset = off >> 3;
+    const bitShift = off & 7;
+    if (byteOffset + 4 < this._byteLength) {
+      const val = (buf[byteOffset] | buf[byteOffset + 1] << 8 | buf[byteOffset + 2] << 16 | buf[byteOffset + 3] << 24) >>> 0;
+      let result;
+      if (nbits > 32 - bitShift) {
+        const val2 = buf[byteOffset + 4];
+        const low = val >>> bitShift;
+        const high = val2 << 32 - bitShift;
+        result = (low | high) >>> 0;
+      } else {
+        result = val >>> bitShift;
       }
+      this._bitOffset = off + nbits;
+      return nbits === 32 ? result : result & (1 << nbits) - 1;
     }
-    if (!this.initializeDecoder()) {
-      return new Status(StatusCode.DRACO_ERROR, "Failed to initialize the decoder.");
-    }
-    if (!this.decodeGeometryData()) {
-      return new Status(StatusCode.DRACO_ERROR, "Failed to decode geometry data.");
-    }
-    if (!this.decodePointAttributes()) {
-      return new Status(StatusCode.DRACO_ERROR, "Failed to decode point attributes.");
+    let value = 0;
+    let bitsRead = 0;
+    let currOff = off;
+    while (bitsRead < nbits) {
+      const bOff = currOff >> 3;
+      if (bOff >= this._byteLength) return void 0;
+      const bShift = currOff & 7;
+      const bitsAvail = 8 - bShift;
+      const bitsNeeded = nbits - bitsRead;
+      const bitsToRead = bitsAvail < bitsNeeded ? bitsAvail : bitsNeeded;
+      const mask = (1 << bitsToRead) - 1;
+      value |= (buf[bOff] >> bShift & mask) << bitsRead;
+      bitsRead += bitsToRead;
+      currOff += bitsToRead;
     }
-    return okStatus();
+    this._bitOffset = currOff;
+    return value;
   }
-  bitstreamVersion() {
-    return DRACO_BITSTREAM_VERSION(this._versionMajor, this._versionMinor);
+};
+var DecoderBuffer = class {
+  _data;
+  _dataView;
+  _dataSize;
+  _pos;
+  _bitDecoder;
+  _bitMode;
+  _bitstreamVersion;
+  constructor() {
+    this._data = null;
+    this._dataView = null;
+    this._dataSize = 0;
+    this._pos = 0;
+    this._bitDecoder = new BitDecoder();
+    this._bitMode = false;
+    this._bitstreamVersion = 0;
   }
-  setAttributesDecoder(attDecoderId, decoder) {
-    if (attDecoderId < 0) {
-      return false;
+  init(data, dataSize, version) {
+    if (data instanceof ArrayBuffer) {
+      this._data = new Uint8Array(data);
+    } else if (data instanceof Uint8Array) {
+      this._data = data;
+    } else {
+      this._data = new Uint8Array(data);
     }
-    while (this._attributesDecoders.length <= attDecoderId) {
-      this._attributesDecoders.push(null);
+    this._dataView = new DataView(this._data.buffer, this._data.byteOffset, this._data.byteLength);
+    this._dataSize = dataSize !== void 0 ? dataSize : this._data.length;
+    this._pos = 0;
+    if (version !== void 0) {
+      this._bitstreamVersion = version;
     }
-    this._attributesDecoders[attDecoderId] = decoder;
-    return true;
   }
-  getPortableAttribute(parentAttId) {
-    if (parentAttId < 0 || parentAttId >= this._pointCloud.numAttributes()) {
-      return null;
-    }
-    const parentAttDecoderId = this._attributeToDecoderMap[parentAttId];
-    return this._attributesDecoders[parentAttDecoderId].getPortableAttribute(parentAttId);
+  // Typed little-endian reads.
+  decodeUint8() {
+    if (this._pos + 1 > this._dataSize) return void 0;
+    const val = this._data[this._pos];
+    this._pos += 1;
+    return val;
   }
-  attributesDecoder(decId) {
-    return this._attributesDecoders[decId];
+  decodeInt8() {
+    if (this._pos + 1 > this._dataSize) return void 0;
+    const val = this._dataView.getInt8(this._pos);
+    this._pos += 1;
+    return val;
   }
-  numAttributesDecoders() {
-    return this._attributesDecoders.length;
+  decodeUint16() {
+    if (this._pos + 2 > this._dataSize) return void 0;
+    const val = this._dataView.getUint16(this._pos, true);
+    this._pos += 2;
+    return val;
   }
-  pointCloud() {
-    return this._pointCloud;
+  decodeUint32() {
+    if (this._pos + 4 > this._dataSize) return void 0;
+    const val = this._dataView.getUint32(this._pos, true);
+    this._pos += 4;
+    return val;
   }
-  buffer() {
-    return this._buffer;
+  decodeInt32() {
+    if (this._pos + 4 > this._dataSize) return void 0;
+    const val = this._dataView.getInt32(this._pos, true);
+    this._pos += 4;
+    return val;
   }
-  options() {
-    return this._options;
+  decodeFloat32() {
+    if (this._pos + 4 > this._dataSize) return void 0;
+    const val = this._dataView.getFloat32(this._pos, true);
+    this._pos += 4;
+    return val;
   }
-  // -- Protected virtual methods (override in subclasses) --
-  initializeDecoder() {
-    return true;
+  decodeUint64() {
+    if (this._pos + 8 > this._dataSize) return void 0;
+    const lo = this._dataView.getUint32(this._pos, true);
+    const hi = this._dataView.getUint32(this._pos + 4, true);
+    this._pos += 8;
+    return hi * 4294967296 + lo;
   }
-  // Must be implemented by derived classes.
-  createAttributesDecoder(_attDecoderId) {
-    return false;
+  decodeBytes(size) {
+    if (this._pos + size > this._dataSize) return void 0;
+    const result = this._data.slice(this._pos, this._pos + size);
+    this._pos += size;
+    return result;
   }
-  decodeGeometryData() {
-    return true;
+  // Zero-copy variant of decodeBytes: a view into the stream, only valid until
+  // the caller's next chance to mutate the buffer — copy out before keeping it.
+  decodeBytesView(size) {
+    if (this._pos + size > this._dataSize) return void 0;
+    const result = this._data.subarray(this._pos, this._pos + size);
+    this._pos += size;
+    return result;
   }
-  decodePointAttributes() {
-    const numAttributesDecoders = this._buffer.decodeUint8();
-    if (numAttributesDecoders === void 0) {
-      return false;
-    }
-    for (let i = 0; i < numAttributesDecoders; ++i) {
-      if (!this.createAttributesDecoder(i)) {
-        return false;
-      }
-    }
-    for (let i = 0; i < this._attributesDecoders.length; ++i) {
-      if (!this._attributesDecoders[i].init(this, this._pointCloud)) {
-        return false;
-      }
-    }
-    for (let i = 0; i < numAttributesDecoders; ++i) {
-      if (!this._attributesDecoders[i].decodeAttributesDecoderData(this._buffer)) {
-        return false;
-      }
-    }
-    for (let i = 0; i < numAttributesDecoders; ++i) {
-      const numAttributes = this._attributesDecoders[i].getNumAttributes();
-      for (let j = 0; j < numAttributes; ++j) {
-        const attId = this._attributesDecoders[i].getAttributeId(j);
-        while (this._attributeToDecoderMap.length <= attId) {
-          this._attributeToDecoderMap.push(0);
-        }
-        this._attributeToDecoderMap[attId] = i;
+  startBitDecoding(decodeSize) {
+    let outSize = 0;
+    if (decodeSize) {
+      if (this._bitstreamVersion < bitstreamVersion(2, 2)) {
+        outSize = this.decodeUint64();
+        if (outSize === void 0) return void 0;
+      } else {
+        outSize = decodeVarint(this, false);
+        if (outSize === void 0) return void 0;
       }
     }
-    if (!this.decodeAllAttributes()) {
-      return false;
-    }
-    if (!this.onAttributesDecoded()) {
-      return false;
-    }
-    return true;
+    this._bitMode = true;
+    this._bitDecoder.reset(this._data.subarray(this._pos), this._dataSize - this._pos);
+    return outSize;
   }
-  decodeAllAttributes() {
-    for (let i = 0; i < this._attributesDecoders.length; i++) {
-      if (!this._attributesDecoders[i].decodeAttributes(this._buffer)) {
-        return false;
-      }
-    }
-    return true;
+  endBitDecoding() {
+    this._bitMode = false;
+    const bitsDecoded = this._bitDecoder.bitsDecoded();
+    const bytesDecoded = Math.ceil(bitsDecoded / 8);
+    this._pos += bytesDecoded;
   }
-  onAttributesDecoded() {
-    return true;
+  decodeLeastSignificantBits32(nbits) {
+    if (!this._bitMode) return void 0;
+    return this._bitDecoder.getBits(nbits);
   }
-  _decodeMetadata() {
-    const metadataDecoder = new MetadataDecoder();
-    if (!metadataDecoder.skipGeometryMetadata(this._buffer)) {
-      return new Status(StatusCode.DRACO_ERROR, "Failed to decode metadata.");
-    }
-    return okStatus();
+  decodeVarintUint32() {
+    return decodeVarint(this, false);
   }
-};
-
-// src/decoder/compression/mesh/MeshDecoder.ts
-var MeshDecoder = class extends PointCloudDecoder {
-  _mesh;
-  constructor() {
-    super();
-    this._mesh = null;
+  decodeVarintUint64() {
+    return decodeVarint(this, false);
   }
-  getGeometryType() {
-    return EncodedGeometryType.TRIANGULAR_MESH;
+  advance(bytes) {
+    this._pos += bytes;
   }
-  decodeMesh(options, inBuffer, outMesh) {
-    this._mesh = outMesh;
-    return this.decode(options, inBuffer, outMesh);
+  get bitstreamVersion() {
+    return this._bitstreamVersion;
   }
-  getCornerTable() {
-    return null;
+  set bitstreamVersion(v) {
+    this._bitstreamVersion = v;
   }
-  getAttributeCornerTable(_attId) {
-    return null;
+  get data() {
+    return this._data;
   }
-  getAttributeEncodingData(_attId) {
-    return null;
+  get dataHead() {
+    return this._data.subarray(this._pos);
   }
-  mesh() {
-    return this._mesh;
+  get remainingSize() {
+    return this._dataSize - this._pos;
   }
-  decodeGeometryData() {
-    if (this._mesh === null) {
-      return false;
-    }
-    if (!this.decodeConnectivity()) {
-      return false;
-    }
-    return super.decodeGeometryData();
+  get decodedSize() {
+    return this._pos;
   }
-  // Overridden by derived classes.
-  decodeConnectivity() {
-    return false;
+  get bitDecoderActive() {
+    return this._bitMode;
   }
 };
 
-// src/decoder/mesh/MeshAttributeCornerTable.ts
-var kInvalidCornerIndex = -1;
-var kInvalidVertexIndex = -1;
-var MeshAttributeCornerTable = class {
-  is_edge_on_seam_;
-  is_vertex_on_seam_;
-  no_interior_seams_;
-  corner_to_vertex_map_;
-  vertex_to_left_most_corner_map_;
-  vertex_to_attribute_entry_id_map_;
-  corner_table_;
-  // Lazily built; see oppositeCornerArray.
-  _effectiveOpposite;
-  // Every corner passed to addSeamEdge (may contain duplicates); lets
-  // oppositeCornerArray patch seams without scanning every corner's flag.
-  _seamCorners;
+// src/decoder/core/ScratchArena.ts
+var freeInt32 = [];
+var freeUint8 = [];
+var borrowedInt32 = [];
+var borrowedUint8 = [];
+var acquire = (free, borrowed, size) => {
+  for (let i = free.length - 1; i >= 0; --i) {
+    const buffer = free[i];
+    if (buffer.length >= size) {
+      free[i] = free[free.length - 1];
+      free.pop();
+      borrowed.push(buffer);
+      return buffer;
+    }
+  }
+  return null;
+};
+var scratchInt32 = (size) => {
+  const pooled = acquire(freeInt32, borrowedInt32, size);
+  if (pooled !== null) return pooled.subarray(0, size);
+  const fresh = new Int32Array(size);
+  borrowedInt32.push(fresh);
+  return fresh;
+};
+var scratchUint8Zeroed = (size) => {
+  const pooled = acquire(freeUint8, borrowedUint8, size);
+  if (pooled !== null) {
+    const view = pooled.subarray(0, size);
+    view.fill(0);
+    return view;
+  }
+  const fresh = new Uint8Array(size);
+  borrowedUint8.push(fresh);
+  return fresh;
+};
+var releaseScratch = () => {
+  for (const buffer of borrowedInt32) freeInt32.push(buffer);
+  for (const buffer of borrowedUint8) freeUint8.push(buffer);
+  borrowedInt32.length = 0;
+  borrowedUint8.length = 0;
+};
+
+// src/decoder/compression/config/CompressionShared.ts
+var kDracoPointCloudBitstreamVersionMajor = 2;
+var kDracoPointCloudBitstreamVersionMinor = 3;
+var kDracoMeshBitstreamVersionMajor = 2;
+var kDracoMeshBitstreamVersionMinor = 2;
+function DRACO_BITSTREAM_VERSION(major, minor) {
+  return major << 8 | minor;
+}
+var EncodedGeometryType = {
+  INVALID_GEOMETRY_TYPE: -1,
+  POINT_CLOUD: 0,
+  TRIANGULAR_MESH: 1,
+  NUM_ENCODED_GEOMETRY_TYPES: 2
+};
+var MeshEncoderMethod = {
+  MESH_SEQUENTIAL_ENCODING: 0,
+  MESH_EDGEBREAKER_ENCODING: 1
+};
+var SequentialAttributeEncoderType = {
+  SEQUENTIAL_ATTRIBUTE_ENCODER_GENERIC: 0,
+  SEQUENTIAL_ATTRIBUTE_ENCODER_INTEGER: 1,
+  SEQUENTIAL_ATTRIBUTE_ENCODER_QUANTIZATION: 2,
+  SEQUENTIAL_ATTRIBUTE_ENCODER_NORMALS: 3
+};
+var PredictionSchemeMethod = {
+  PREDICTION_NONE: -2,
+  PREDICTION_UNDEFINED: -1,
+  PREDICTION_DIFFERENCE: 0,
+  MESH_PREDICTION_PARALLELOGRAM: 1,
+  MESH_PREDICTION_MULTI_PARALLELOGRAM: 2,
+  MESH_PREDICTION_TEX_COORDS_DEPRECATED: 3,
+  MESH_PREDICTION_CONSTRAINED_MULTI_PARALLELOGRAM: 4,
+  MESH_PREDICTION_TEX_COORDS_PORTABLE: 5,
+  MESH_PREDICTION_GEOMETRIC_NORMAL: 6,
+  NUM_PREDICTION_SCHEMES: 7
+};
+var PredictionSchemeTransformType = {
+  PREDICTION_TRANSFORM_NONE: -1,
+  PREDICTION_TRANSFORM_DELTA: 0,
+  PREDICTION_TRANSFORM_WRAP: 1,
+  PREDICTION_TRANSFORM_NORMAL_OCTAHEDRON: 2,
+  PREDICTION_TRANSFORM_NORMAL_OCTAHEDRON_CANONICALIZED: 3,
+  NUM_PREDICTION_SCHEME_TRANSFORM_TYPES: 4
+};
+var MeshTraversalMethod = {
+  MESH_TRAVERSAL_DEPTH_FIRST: 0,
+  MESH_TRAVERSAL_PREDICTION_DEGREE: 1,
+  NUM_TRAVERSAL_METHODS: 2
+};
+var MeshEdgebreakerConnectivityEncodingMethod = {
+  MESH_EDGEBREAKER_STANDARD_ENCODING: 0,
+  MESH_EDGEBREAKER_PREDICTIVE_ENCODING: 1,
+  // Deprecated.
+  MESH_EDGEBREAKER_VALENCE_ENCODING: 2
+};
+var DracoHeader = class {
+  dracoString;
+  versionMajor;
+  versionMinor;
+  encoderType;
+  encoderMethod;
+  flags;
   constructor() {
-    this.is_edge_on_seam_ = [];
-    this.is_vertex_on_seam_ = [];
-    this.no_interior_seams_ = true;
-    this.corner_to_vertex_map_ = [];
-    this.vertex_to_left_most_corner_map_ = [];
-    this.vertex_to_attribute_entry_id_map_ = [];
-    this.corner_table_ = null;
-    this._effectiveOpposite = null;
-    this._seamCorners = [];
+    this.dracoString = new Int8Array(5);
+    this.versionMajor = 0;
+    this.versionMinor = 0;
+    this.encoderType = 0;
+    this.encoderMethod = 0;
+    this.flags = 0;
   }
-  initEmpty(table) {
-    if (table === null) {
-      return false;
+};
+var NormalPredictionMode = {
+  ONE_TRIANGLE: 0,
+  // To be deprecated.
+  TRIANGLE_AREA: 1
+};
+var SymbolCodingMethod = {
+  SYMBOL_CODING_TAGGED: 0,
+  SYMBOL_CODING_RAW: 1,
+  NUM_SYMBOL_CODING_METHODS: 2
+};
+var METADATA_FLAG_MASK = 32768;
+
+// src/decoder/compression/config/DracoOptions.ts
+var DracoOptions = class {
+  _globalOptions;
+  _attributeOptions;
+  constructor() {
+    this._globalOptions = /* @__PURE__ */ new Map();
+    this._attributeOptions = /* @__PURE__ */ new Map();
+  }
+  getGlobalBool(name, defaultVal) {
+    if (this._globalOptions.has(name)) {
+      return !!this._globalOptions.get(name);
     }
-    this.is_edge_on_seam_ = new Uint8Array(table.numCorners());
-    this.is_vertex_on_seam_ = new Uint8Array(table.numVertices());
-    this.corner_to_vertex_map_ = new Int32Array(table.numCorners()).fill(kInvalidVertexIndex);
-    this.vertex_to_attribute_entry_id_map_ = [];
-    this.vertex_to_left_most_corner_map_ = [];
-    this._effectiveOpposite = null;
-    this._seamCorners = [];
-    this.corner_table_ = table;
-    this.no_interior_seams_ = true;
-    return true;
+    return defaultVal;
   }
-  addSeamEdge(c) {
-    const cornerToVertex = this.corner_table_.cornerToVertexArray();
-    const oppositeCorners = this.corner_table_.oppositeCornerArray();
-    const isEdge = this.is_edge_on_seam_;
-    const isVert = this.is_vertex_on_seam_;
-    isEdge[c] = 1;
-    this._seamCorners.push(c);
-    let rem = c - (c / 3 | 0) * 3;
-    isVert[cornerToVertex[rem === 2 ? c - 2 : c + 1]] = 1;
-    isVert[cornerToVertex[rem === 0 ? c + 2 : c - 1]] = 1;
-    const oppCorner = oppositeCorners[c];
-    if (oppCorner !== kInvalidCornerIndex) {
-      this.no_interior_seams_ = false;
-      isEdge[oppCorner] = 1;
-      this._seamCorners.push(oppCorner);
-      rem = oppCorner - (oppCorner / 3 | 0) * 3;
-      isVert[cornerToVertex[rem === 2 ? oppCorner - 2 : oppCorner + 1]] = 1;
-      isVert[cornerToVertex[rem === 0 ? oppCorner + 2 : oppCorner - 1]] = 1;
+  findAttributeOptions(attKey) {
+    if (this._attributeOptions.has(attKey)) {
+      return this._attributeOptions.get(attKey);
     }
+    return null;
   }
-  recomputeVertices(_cornerTable, _vertexIds) {
-    return this._recomputeVerticesInternal();
+  getAttributeBool(attKey, name, defaultVal) {
+    const attOpts = this.findAttributeOptions(attKey);
+    if (attOpts !== null && attOpts.has(name)) {
+      return !!attOpts.get(name);
+    }
+    return this.getGlobalBool(name, defaultVal);
   }
-  // Only the C++ RecomputeVertices(nullptr, nullptr) path: the decoder always
-  // rebuilds the attribute-vertex maps from connectivity alone.
-  _recomputeVerticesInternal() {
-    const ct = this.corner_table_;
-    const numCorners = ct.numCorners();
-    const numBaseVertices = ct.numVertices();
-    const leftMostMap = new Int32Array(numCorners);
-    const cornerToVertex = this.corner_to_vertex_map_;
-    const isVertexOnSeam = this.is_vertex_on_seam_;
-    const isEdgeOnSeam = this.is_edge_on_seam_;
-    const seamOpp = this.oppositeCornerArray();
-    const baseOpp = ct.oppositeCornerArray();
-    const vertexLeftmost = ct.vertexLeftmostCornerArray();
-    let numNewVertices = 0;
-    for (let v = 0; v < numBaseVertices; ++v) {
-      const c = vertexLeftmost[v];
-      if (c === kInvalidCornerIndex) continue;
-      if (!isVertexOnSeam[v]) {
-        const firstVertId = numNewVertices++;
-        leftMostMap[firstVertId] = c;
-        cornerToVertex[c] = firstVertId;
-        let pv = c % 3 === 0 ? c + 2 : c - 1;
-        let bopp = baseOpp[pv];
-        let actC = bopp < 0 ? kInvalidCornerIndex : bopp % 3 === 0 ? bopp + 2 : bopp - 1;
-        while (actC !== kInvalidCornerIndex && actC !== c) {
-          cornerToVertex[actC] = firstVertId;
-          pv = actC % 3 === 0 ? actC + 2 : actC - 1;
-          bopp = baseOpp[pv];
-          actC = bopp < 0 ? kInvalidCornerIndex : bopp % 3 === 0 ? bopp + 2 : bopp - 1;
-        }
-      } else {
-        let firstVertId = numNewVertices++;
-        let firstC = c;
-        let actC;
-        let nx = firstC % 3 === 2 ? firstC - 2 : firstC + 1;
-        let opp = seamOpp[nx];
-        actC = opp < 0 ? kInvalidCornerIndex : opp % 3 === 2 ? opp - 2 : opp + 1;
-        while (actC !== kInvalidCornerIndex) {
-          firstC = actC;
-          nx = firstC % 3 === 2 ? firstC - 2 : firstC + 1;
-          opp = seamOpp[nx];
-          actC = opp < 0 ? kInvalidCornerIndex : opp % 3 === 2 ? opp - 2 : opp + 1;
-          if (actC === c) return false;
-        }
-        cornerToVertex[firstC] = firstVertId;
-        leftMostMap[firstVertId] = firstC;
-        let pv = firstC % 3 === 0 ? firstC + 2 : firstC - 1;
-        let bopp = baseOpp[pv];
-        actC = bopp < 0 ? kInvalidCornerIndex : bopp % 3 === 0 ? bopp + 2 : bopp - 1;
-        while (actC !== kInvalidCornerIndex && actC !== firstC) {
-          const nAct = actC % 3 === 2 ? actC - 2 : actC + 1;
-          if (isEdgeOnSeam[nAct]) {
-            firstVertId = numNewVertices++;
-            leftMostMap[firstVertId] = actC;
-          }
-          cornerToVertex[actC] = firstVertId;
-          pv = actC % 3 === 0 ? actC + 2 : actC - 1;
-          bopp = baseOpp[pv];
-          actC = bopp < 0 ? kInvalidCornerIndex : bopp % 3 === 0 ? bopp + 2 : bopp - 1;
-        }
-      }
-    }
-    this.vertex_to_attribute_entry_id_map_ = new Int32Array(numNewVertices);
-    this.vertex_to_left_most_corner_map_ = leftMostMap.subarray(0, numNewVertices);
-    return true;
-  }
-  isCornerOppositeToSeamEdge(corner) {
-    return this.is_edge_on_seam_[corner];
-  }
-  opposite(corner) {
-    if (corner === kInvalidCornerIndex || this.isCornerOppositeToSeamEdge(corner)) {
-      return kInvalidCornerIndex;
-    }
-    return this.corner_table_.opposite(corner);
-  }
-  next(corner) {
-    return this.corner_table_.next(corner);
-  }
-  previous(corner) {
-    return this.corner_table_.previous(corner);
-  }
-  swingRight(corner) {
-    return this.previous(this.opposite(this.previous(corner)));
-  }
-  swingLeft(corner) {
-    return this.next(this.opposite(this.next(corner)));
-  }
-  numVertices() {
-    return this.vertex_to_attribute_entry_id_map_.length;
-  }
-  numFaces() {
-    return this.corner_table_.numFaces();
-  }
-  numCorners() {
-    return this.corner_table_.numCorners();
-  }
-  vertex(corner) {
-    return this.confidentVertex(corner);
-  }
-  confidentVertex(corner) {
-    return this.corner_to_vertex_map_[corner];
-  }
-  leftMostCorner(v) {
-    return this.vertex_to_left_most_corner_map_[v];
+};
+
+// src/decoder/compression/config/DecoderOptions.ts
+var DecoderOptions = class extends DracoOptions {
+  constructor() {
+    super();
   }
-  face(corner) {
-    return this.corner_table_.face(corner);
+};
+
+// src/decoder/core/Status.ts
+var StatusCode = {
+  OK: 0,
+  DRACO_ERROR: -1,
+  IO_ERROR: -2,
+  INVALID_PARAMETER: -3,
+  UNSUPPORTED_VERSION: -4,
+  UNKNOWN_VERSION: -5,
+  UNSUPPORTED_FEATURE: -6
+};
+var Status = class {
+  code;
+  errorMsg;
+  constructor(code = StatusCode.OK, errorMsg = "") {
+    this.code = code;
+    this.errorMsg = errorMsg;
   }
-  firstCorner(faceIndex) {
-    return this.corner_table_.firstCorner(faceIndex);
+  ok() {
+    return this.code === StatusCode.OK;
   }
-  allCorners(faceIndex) {
-    return this.corner_table_.allCorners(faceIndex);
+};
+function okStatus() {
+  return new Status(StatusCode.OK);
+}
+
+// src/decoder/metadata/MetadataDecoder.ts
+var kMaxSubmetadataLevel = 1e3;
+var MetadataDecoder = class {
+  buffer_;
+  constructor() {
+    this.buffer_ = null;
   }
-  // --- Flat-array accessors: let DepthFirstTraverser avoid per-corner dispatch. ---
-  cornerToVertexArray() {
-    return this.corner_to_vertex_map_;
+  // Skips per-attribute metadata followed by the geometry-level metadata.
+  skipGeometryMetadata(inBuffer) {
+    this.buffer_ = inBuffer;
+    const numAttMetadata = decodeVarint(this.buffer_);
+    if (numAttMetadata === void 0) {
+      return false;
+    }
+    for (let i = 0; i < numAttMetadata; ++i) {
+      if (decodeVarint(this.buffer_) === void 0) {
+        return false;
+      }
+      if (!this._skipMetadata(0)) {
+        return false;
+      }
+    }
+    return this._skipMetadata(0);
   }
-  // Seam-aware opposite corners (seam edges -> -1), matching opposite(). Cached on
-  // first use; seams and connectivity are finalized before traversal, so it's stable.
-  oppositeCornerArray() {
-    if (this._effectiveOpposite === null) {
-      const nc = this.corner_table_.numCorners();
-      const base = this.corner_table_.oppositeCornerArray();
-      const seamCorners = this._seamCorners;
-      if (seamCorners.length === 0) {
-        this._effectiveOpposite = base;
-      } else {
-        const eff = base.slice(0, nc);
-        for (let i = 0, l = seamCorners.length; i < l; ++i) {
-          eff[seamCorners[i]] = kInvalidCornerIndex;
-        }
-        this._effectiveOpposite = eff;
+  // Discards one metadata block (key-value entries plus nested sub-metadata).
+  // Sub-blocks read depth-first in stream order, matching the C++ stack traversal.
+  _skipMetadata(level) {
+    if (level > kMaxSubmetadataLevel) {
+      return false;
+    }
+    const numEntries = decodeVarint(this.buffer_);
+    if (numEntries === void 0) {
+      return false;
+    }
+    for (let i = 0; i < numEntries; ++i) {
+      if (!this._skipEntry()) {
+        return false;
       }
     }
-    return this._effectiveOpposite;
+    const numSubMetadata = decodeVarint(this.buffer_);
+    if (numSubMetadata === void 0) {
+      return false;
+    }
+    if (numSubMetadata > this.buffer_.remainingSize) {
+      return false;
+    }
+    for (let i = 0; i < numSubMetadata; ++i) {
+      if (!this._skipName()) {
+        return false;
+      }
+      if (!this._skipMetadata(level + 1)) {
+        return false;
+      }
+    }
+    return true;
   }
-  vertexLeftmostCornerArray() {
-    return this.vertex_to_left_most_corner_map_;
+  // Skips a key-value entry: name then a length-prefixed value.
+  _skipEntry() {
+    if (!this._skipName()) {
+      return false;
+    }
+    const dataSize = decodeVarint(this.buffer_);
+    if (dataSize === void 0 || dataSize === 0) {
+      return false;
+    }
+    return this._skipBytes(dataSize);
   }
-  // Per-base-vertex seam flag (Uint8Array); exposed so hot dedup loops inline the lookup.
-  vertexOnSeamArray() {
-    return this.is_vertex_on_seam_;
+  // Skips a name (uint8 length prefix followed by that many bytes).
+  _skipName() {
+    const nameLen = this.buffer_.decodeUint8();
+    if (nameLen === void 0) {
+      return false;
+    }
+    if (nameLen === 0) {
+      return true;
+    }
+    return this._skipBytes(nameLen);
   }
-  hasSameSeams(other) {
-    if (other === null || other === void 0) return false;
-    const seamA = this.is_edge_on_seam_;
-    const seamB = other.is_edge_on_seam_;
-    if (seamA.length !== seamB.length) return false;
-    for (let i = 0, l = seamA.length; i < l; ++i) {
-      if (seamA[i] !== seamB[i]) return false;
+  _skipBytes(size) {
+    if (size > this.buffer_.remainingSize) {
+      return false;
     }
+    this.buffer_.advance(size);
     return true;
   }
-  adoptVertexRecompute(other) {
-    this.corner_to_vertex_map_ = other.corner_to_vertex_map_;
-    this.vertex_to_attribute_entry_id_map_ = other.vertex_to_attribute_entry_id_map_;
-    this.vertex_to_left_most_corner_map_ = other.vertex_to_left_most_corner_map_;
-    this.no_interior_seams_ = other.no_interior_seams_;
-    this._effectiveOpposite = other._effectiveOpposite;
-    this._seamCorners = other._seamCorners;
-  }
-  isDegenerated(faceIndex) {
-    return this.corner_table_.isDegenerated(faceIndex);
-  }
 };
 
-// src/decoder/core/DracoTypes.ts
-var DataType = {
-  INVALID: 0,
-  INT8: 1,
-  UINT8: 2,
-  INT16: 3,
-  UINT16: 4,
-  INT32: 5,
-  UINT32: 6,
-  INT64: 7,
-  UINT64: 8,
-  FLOAT32: 9,
-  FLOAT64: 10,
-  BOOL: 11,
-  TYPES_COUNT: 12
-};
-function dataTypeLength(dt) {
-  switch (dt) {
-    case DataType.INT8:
-    case DataType.UINT8:
-      return 1;
-    case DataType.INT16:
-    case DataType.UINT16:
-      return 2;
-    case DataType.INT32:
-    case DataType.UINT32:
-      return 4;
-    case DataType.INT64:
-    case DataType.UINT64:
-      return 8;
-    case DataType.FLOAT32:
-      return 4;
-    case DataType.FLOAT64:
-      return 8;
-    case DataType.BOOL:
-      return 1;
-    default:
-      return -1;
-  }
-}
-
-// src/decoder/attributes/GeometryAttribute.ts
-var Type = {
-  INVALID: -1,
-  POSITION: 0,
-  NORMAL: 1,
-  COLOR: 2,
-  TEX_COORD: 3,
-  GENERIC: 4,
-  NAMED_ATTRIBUTES_COUNT: 5
-};
-var GeometryAttribute = class {
+// src/decoder/compression/point_cloud/PointCloudDecoder.ts
+var PointCloudDecoder = class _PointCloudDecoder {
+  _pointCloud;
   _buffer;
-  _numComponents;
-  _dataType;
-  _normalized;
-  _byteStride;
-  _byteOffset;
-  _attributeType;
-  _uniqueId;
+  _versionMajor;
+  _versionMinor;
+  _options;
+  _attributesDecoders;
+  _attributeToDecoderMap;
   constructor() {
+    this._pointCloud = null;
     this._buffer = null;
-    this._numComponents = 1;
-    this._dataType = DataType.FLOAT32;
-    this._normalized = false;
-    this._byteStride = 0;
-    this._byteOffset = 0;
-    this._attributeType = Type.INVALID;
-    this._uniqueId = 0;
+    this._versionMajor = 0;
+    this._versionMinor = 0;
+    this._options = null;
+    this._attributesDecoders = [];
+    this._attributeToDecoderMap = [];
   }
-  init(attributeType, buffer, numComponents, dataType, normalized, byteStride, byteOffset) {
-    this._buffer = buffer;
-    this._numComponents = numComponents;
-    this._dataType = dataType;
-    this._normalized = normalized;
-    this._byteStride = byteStride;
-    this._byteOffset = byteOffset;
-    this._attributeType = attributeType;
+  getGeometryType() {
+    return EncodedGeometryType.POINT_CLOUD;
   }
-  // Returns a Uint8Array view of the buffer starting at the attribute entry.
-  getAddress(attIndex) {
-    const bytePos = this._byteOffset + this._byteStride * attIndex;
-    return this._buffer.data.subarray(bytePos);
+  // Returns a Status; on success outHeader is populated.
+  static decodeHeader(buffer, outHeader) {
+    const kIoErrorMsg = "Failed to parse Draco header.";
+    const bytes = buffer.decodeBytes(5);
+    if (bytes === void 0) {
+      return new Status(StatusCode.IO_ERROR, kIoErrorMsg);
+    }
+    for (let i = 0; i < 5; i++) {
+      outHeader.dracoString[i] = bytes[i];
+    }
+    const magic = String.fromCharCode(bytes[0], bytes[1], bytes[2], bytes[3], bytes[4]);
+    if (magic !== "DRACO") {
+      return new Status(StatusCode.DRACO_ERROR, "Not a Draco file.");
+    }
+    const versionMajor = buffer.decodeUint8();
+    if (versionMajor === void 0) {
+      return new Status(StatusCode.IO_ERROR, kIoErrorMsg);
+    }
+    outHeader.versionMajor = versionMajor;
+    const versionMinor = buffer.decodeUint8();
+    if (versionMinor === void 0) {
+      return new Status(StatusCode.IO_ERROR, kIoErrorMsg);
+    }
+    outHeader.versionMinor = versionMinor;
+    const encoderType = buffer.decodeUint8();
+    if (encoderType === void 0) {
+      return new Status(StatusCode.IO_ERROR, kIoErrorMsg);
+    }
+    outHeader.encoderType = encoderType;
+    const encoderMethod = buffer.decodeUint8();
+    if (encoderMethod === void 0) {
+      return new Status(StatusCode.IO_ERROR, kIoErrorMsg);
+    }
+    outHeader.encoderMethod = encoderMethod;
+    const flags = buffer.decodeUint16();
+    if (flags === void 0) {
+      return new Status(StatusCode.IO_ERROR, kIoErrorMsg);
+    }
+    outHeader.flags = flags;
+    return okStatus();
   }
-  copyFrom(srcAtt) {
-    this._numComponents = srcAtt._numComponents;
-    this._dataType = srcAtt._dataType;
-    this._normalized = srcAtt._normalized;
-    this._byteStride = srcAtt._byteStride;
-    this._byteOffset = srcAtt._byteOffset;
-    this._attributeType = srcAtt._attributeType;
-    this._uniqueId = srcAtt._uniqueId;
-    if (srcAtt._buffer === null) {
-      this._buffer = null;
-    } else {
-      if (this._buffer === null) {
-        return false;
+  // Main entry point for point cloud decoding.
+  decode(options, inBuffer, outPointCloud) {
+    this._options = options;
+    this._buffer = inBuffer;
+    this._pointCloud = outPointCloud;
+    const header = new DracoHeader();
+    const headerStatus = _PointCloudDecoder.decodeHeader(this._buffer, header);
+    if (!headerStatus.ok()) {
+      return headerStatus;
+    }
+    if (header.encoderType !== this.getGeometryType()) {
+      return new Status(StatusCode.DRACO_ERROR, "Using incompatible decoder for the input geometry.");
+    }
+    this._versionMajor = header.versionMajor;
+    this._versionMinor = header.versionMinor;
+    const maxSupportedMajorVersion = header.encoderType === EncodedGeometryType.POINT_CLOUD ? kDracoPointCloudBitstreamVersionMajor : kDracoMeshBitstreamVersionMajor;
+    const maxSupportedMinorVersion = header.encoderType === EncodedGeometryType.POINT_CLOUD ? kDracoPointCloudBitstreamVersionMinor : kDracoMeshBitstreamVersionMinor;
+    if (this._versionMajor < 1 || this._versionMajor > maxSupportedMajorVersion) {
+      return new Status(StatusCode.UNKNOWN_VERSION, "Unknown major version.");
+    }
+    if (this._versionMajor === maxSupportedMajorVersion && this._versionMinor > maxSupportedMinorVersion) {
+      return new Status(StatusCode.UNKNOWN_VERSION, "Unknown minor version.");
+    }
+    this._buffer.bitstreamVersion = DRACO_BITSTREAM_VERSION(this._versionMajor, this._versionMinor);
+    if (header.encoderType === EncodedGeometryType.TRIANGULAR_MESH && this._buffer.bitstreamVersion < DRACO_BITSTREAM_VERSION(2, 2)) {
+      return new Status(
+        StatusCode.UNKNOWN_VERSION,
+        "Unsupported bitstream version (only Draco 2.2 meshes are supported)."
+      );
+    }
+    if (header.flags & METADATA_FLAG_MASK) {
+      const metadataStatus = this._decodeMetadata();
+      if (!metadataStatus.ok()) {
+        return metadataStatus;
       }
-      this._buffer.update(srcAtt._buffer.data, srcAtt._buffer.dataSize);
     }
+    if (!this.initializeDecoder()) {
+      return new Status(StatusCode.DRACO_ERROR, "Failed to initialize the decoder.");
+    }
+    if (!this.decodeGeometryData()) {
+      return new Status(StatusCode.DRACO_ERROR, "Failed to decode geometry data.");
+    }
+    if (!this.decodePointAttributes()) {
+      return new Status(StatusCode.DRACO_ERROR, "Failed to decode point attributes.");
+    }
+    return okStatus();
+  }
+  bitstreamVersion() {
+    return DRACO_BITSTREAM_VERSION(this._versionMajor, this._versionMinor);
+  }
+  setAttributesDecoder(attDecoderId, decoder) {
+    if (attDecoderId < 0) {
+      return false;
+    }
+    while (this._attributesDecoders.length <= attDecoderId) {
+      this._attributesDecoders.push(null);
+    }
+    this._attributesDecoders[attDecoderId] = decoder;
     return true;
   }
-  resetBuffer(buffer, byteStride, byteOffset) {
-    this._buffer = buffer;
-    this._byteStride = byteStride;
-    this._byteOffset = byteOffset;
+  getPortableAttribute(parentAttId) {
+    if (parentAttId < 0 || parentAttId >= this._pointCloud.numAttributes()) {
+      return null;
+    }
+    const parentAttDecoderId = this._attributeToDecoderMap[parentAttId];
+    return this._attributesDecoders[parentAttDecoderId].getPortableAttribute(parentAttId);
   }
-  get attributeType() {
-    return this._attributeType;
+  attributesDecoder(decId) {
+    return this._attributesDecoders[decId];
   }
-  get dataType() {
-    return this._dataType;
+  numAttributesDecoders() {
+    return this._attributesDecoders.length;
   }
-  get numComponents() {
-    return this._numComponents;
+  pointCloud() {
+    return this._pointCloud;
   }
-  get buffer() {
+  buffer() {
     return this._buffer;
   }
-  get byteStride() {
-    return this._byteStride;
-  }
-  get byteOffset() {
-    return this._byteOffset;
+  options() {
+    return this._options;
   }
-  get uniqueId() {
-    return this._uniqueId;
+  // -- Protected virtual methods (override in subclasses) --
+  initializeDecoder() {
+    return true;
   }
-  set uniqueId(id) {
-    this._uniqueId = id;
+  // Must be implemented by derived classes.
+  createAttributesDecoder(_attDecoderId) {
+    return false;
   }
-};
-
-// src/decoder/core/DataBuffer.ts
-var DataBuffer = class {
-  _data;
-  constructor() {
-    this._data = new Uint8Array(0);
+  decodeGeometryData() {
+    return true;
   }
-  update(data, size, offset = 0) {
-    if (data === null || data === void 0) {
-      if (size + offset < 0) return false;
-      this._resize(size + offset);
-    } else {
-      if (size < 0) return false;
-      if (size + offset > this._data.length) {
-        this._resize(size + offset);
+  decodePointAttributes() {
+    const numAttributesDecoders = this._buffer.decodeUint8();
+    if (numAttributesDecoders === void 0) {
+      return false;
+    }
+    for (let i = 0; i < numAttributesDecoders; ++i) {
+      if (!this.createAttributesDecoder(i)) {
+        return false;
       }
-      const view = data;
-      const src = new Uint8Array(view.buffer || data, view.byteOffset || 0, size);
-      this._data.set(src, offset);
     }
-    return true;
-  }
-  resize(newSize) {
-    this._resize(newSize);
-  }
-  write(bytePos, inArray, dataSize) {
-    if (inArray instanceof Uint8Array) {
-      this._data.set(inArray.length === dataSize ? inArray : inArray.subarray(0, dataSize), bytePos);
-      return;
+    for (let i = 0; i < this._attributesDecoders.length; ++i) {
+      if (!this._attributesDecoders[i].init(this, this._pointCloud)) {
+        return false;
+      }
     }
-    const view = inArray;
-    const src = new Uint8Array(view.buffer || inArray, view.byteOffset || 0, dataSize);
-    this._data.set(src, bytePos);
-  }
-  get data() {
-    return this._data;
-  }
-  get dataSize() {
-    return this._data.length;
-  }
-  _resize(newSize) {
-    if (newSize === this._data.length) return;
-    const newData = new Uint8Array(newSize);
-    newData.set(this._data.subarray(0, Math.min(this._data.length, newSize)));
-    this._data = newData;
-  }
-};
-
-// src/decoder/attributes/GeometryIndices.ts
-var kInvalidAttributeValueIndex = 4294967295 >>> 0;
-
-// src/decoder/attributes/PointAttribute.ts
-var PointAttribute = class extends GeometryAttribute {
-  _identityMapping;
-  _numUniqueEntries;
-  _indicesMap;
-  _attributeBuffer;
-  _attributeTransformData;
-  // Lazily-created cached views over the attribute buffer.
-  _cachedFloat32View;
-  _cachedFloat32Buffer;
-  _cachedInt32View;
-  _cachedInt32Buffer;
-  _cachedUint32View;
-  _cachedUint32Buffer;
-  _cachedUint16View;
-  _cachedUint16Buffer;
-  _cachedInt16View;
-  _cachedInt16Buffer;
-  _cachedUint8View;
-  _cachedUint8Buffer;
-  _cachedInt8View;
-  _cachedInt8Buffer;
-  _cachedFloat64View;
-  _cachedFloat64Buffer;
-  _cachedDataView;
-  _cachedDVBuffer;
-  constructor(geometryAttribute) {
-    super();
-    this._identityMapping = false;
-    this._numUniqueEntries = 0;
-    this._indicesMap = [];
-    this._attributeBuffer = null;
-    this._attributeTransformData = null;
-    if (geometryAttribute instanceof GeometryAttribute) {
-      this._buffer = geometryAttribute._buffer;
-      this._numComponents = geometryAttribute._numComponents;
-      this._dataType = geometryAttribute._dataType;
-      this._normalized = geometryAttribute._normalized;
-      this._byteStride = geometryAttribute._byteStride;
-      this._byteOffset = geometryAttribute._byteOffset;
-      this._attributeType = geometryAttribute._attributeType;
-      this._uniqueId = geometryAttribute._uniqueId;
+    for (let i = 0; i < numAttributesDecoders; ++i) {
+      if (!this._attributesDecoders[i].decodeAttributesDecoderData(this._buffer)) {
+        return false;
+      }
     }
+    for (let i = 0; i < numAttributesDecoders; ++i) {
+      const numAttributes = this._attributesDecoders[i].getNumAttributes();
+      for (let j = 0; j < numAttributes; ++j) {
+        const attId = this._attributesDecoders[i].getAttributeId(j);
+        while (this._attributeToDecoderMap.length <= attId) {
+          this._attributeToDecoderMap.push(0);
+        }
+        this._attributeToDecoderMap[attId] = i;
+      }
+    }
+    if (!this.decodeAllAttributes()) {
+      return false;
+    }
+    if (!this.onAttributesDecoded()) {
+      return false;
+    }
+    return true;
   }
-  // Intentionally shadows GeometryAttribute.init with a different signature (matches draco.js / C++ source).
-  // @ts-expect-error -- signature intentionally differs from the base class, as in the source.
-  init(attributeType, numComponents, dataType, normalized, numAttributeValues) {
-    this._attributeBuffer = new DataBuffer();
-    const byteStride = dataTypeLength(dataType) * numComponents;
-    super.init(attributeType, this._attributeBuffer, numComponents, dataType, normalized, byteStride, 0);
-    this.reset(numAttributeValues);
-    this.setIdentityMapping();
-  }
-  reset(numAttributeValues) {
-    if (this._attributeBuffer === null) {
-      this._attributeBuffer = new DataBuffer();
+  decodeAllAttributes() {
+    for (let i = 0; i < this._attributesDecoders.length; i++) {
+      if (!this._attributesDecoders[i].decodeAttributes(this._buffer)) {
+        return false;
+      }
     }
-    const entrySize = dataTypeLength(this.dataType) * this.numComponents;
-    this._attributeBuffer.update(null, numAttributeValues * entrySize);
-    this.resetBuffer(this._attributeBuffer, entrySize, 0);
-    this._numUniqueEntries = numAttributeValues;
     return true;
   }
-  get size() {
-    return this._numUniqueEntries;
+  onAttributesDecoded() {
+    return true;
   }
-  mappedIndex(pointIndex) {
-    if (this._identityMapping) {
-      return pointIndex;
+  _decodeMetadata() {
+    const metadataDecoder = new MetadataDecoder();
+    if (!metadataDecoder.skipGeometryMetadata(this._buffer)) {
+      return new Status(StatusCode.DRACO_ERROR, "Failed to decode metadata.");
     }
-    return this._indicesMap[pointIndex];
+    return okStatus();
   }
-  get isMappingIdentity() {
-    return this._identityMapping;
+};
+
+// src/decoder/compression/mesh/MeshDecoder.ts
+var MeshDecoder = class extends PointCloudDecoder {
+  _mesh;
+  constructor() {
+    super();
+    this._mesh = null;
   }
-  get indicesMapSize() {
-    if (this._identityMapping) {
-      return 0;
-    }
-    return this._indicesMap.length;
+  getGeometryType() {
+    return EncodedGeometryType.TRIANGULAR_MESH;
   }
-  // Direct access to the explicit point->value index map (Uint32Array after
-  // setExplicitMapping). Lets hot mapping loops write entries without a
-  // per-entry setPointMapEntry() dispatch.
-  get indicesMap() {
-    return this._indicesMap;
+  decodeMesh(options, inBuffer, outMesh) {
+    this._mesh = outMesh;
+    return this.decode(options, inBuffer, outMesh);
   }
-  // Implicit mapping: point index equals attribute entry index.
-  setIdentityMapping() {
-    this._identityMapping = true;
-    this._indicesMap = [];
+  getCornerTable() {
+    return null;
   }
-  setExplicitMapping(numPoints) {
-    this._identityMapping = false;
-    this._indicesMap = new Uint32Array(numPoints);
-    this._indicesMap.fill(kInvalidAttributeValueIndex);
+  getAttributeCornerTable(_attId) {
+    return null;
   }
-  // Like setExplicitMapping but skips the invalid-index fill. Only for callers
-  // that provably write every entry right away (the fill was ~4% of decode
-  // time on primitive-heavy files). The array still starts zeroed by the
-  // engine, so a buggy caller reads valid-looking zeros — hence opt-in.
-  setExplicitMappingUnfilled(numPoints) {
-    this._identityMapping = false;
-    this._indicesMap = new Uint32Array(numPoints);
+  getAttributeEncodingData(_attId) {
+    return null;
   }
-  setAttributeTransformData(transformData) {
-    this._attributeTransformData = transformData;
+  mesh() {
+    return this._mesh;
   }
-  // Mirrors C++ PointAttribute::ConvertValue<T>().
-  convertValue(attIndex, outVal) {
-    const bytePos = this._byteOffset + this._byteStride * attIndex;
-    const bufData = this._buffer.data;
-    const dt = this._dataType;
-    const nc = this._numComponents;
-    if (dt === DataType.FLOAT32) {
-      if (this._cachedFloat32View === void 0 || this._cachedFloat32Buffer !== bufData.buffer) {
-        this._cachedFloat32Buffer = bufData.buffer;
-        this._cachedFloat32View = new Float32Array(bufData.buffer);
-      }
-      const baseIndex = bufData.byteOffset + bytePos >> 2;
-      for (let i = 0; i < nc; ++i) {
-        outVal[i] = this._cachedFloat32View[baseIndex + i];
-      }
-      return;
-    }
-    if (dt === DataType.INT32) {
-      if (this._cachedInt32View === void 0 || this._cachedInt32Buffer !== bufData.buffer) {
-        this._cachedInt32Buffer = bufData.buffer;
-        this._cachedInt32View = new Int32Array(bufData.buffer);
-      }
-      const baseIndex = bufData.byteOffset + bytePos >> 2;
-      for (let i = 0; i < nc; ++i) {
-        outVal[i] = this._cachedInt32View[baseIndex + i];
-      }
-      return;
-    }
-    if (dt === DataType.UINT32) {
-      if (this._cachedUint32View === void 0 || this._cachedUint32Buffer !== bufData.buffer) {
-        this._cachedUint32Buffer = bufData.buffer;
-        this._cachedUint32View = new Uint32Array(bufData.buffer);
-      }
-      const baseIndex = bufData.byteOffset + bytePos >> 2;
-      for (let i = 0; i < nc; ++i) {
-        outVal[i] = this._cachedUint32View[baseIndex + i];
-      }
-      return;
-    }
-    if (this._cachedDataView === void 0 || this._cachedDVBuffer !== bufData.buffer) {
-      this._cachedDVBuffer = bufData.buffer;
-      this._cachedDataView = new DataView(bufData.buffer, bufData.byteOffset, bufData.byteLength);
+  decodeGeometryData() {
+    if (this._mesh === null) {
+      return false;
     }
-    const dv = this._cachedDataView;
-    for (let i = 0; i < nc; ++i) {
-      switch (dt) {
-        case DataType.INT8:
-          outVal[i] = dv.getInt8(bytePos + i);
-          break;
-        case DataType.UINT8:
-          outVal[i] = dv.getUint8(bytePos + i);
-          break;
-        case DataType.INT16:
-          outVal[i] = dv.getInt16(bytePos + i * 2, true);
-          break;
-        case DataType.UINT16:
-          outVal[i] = dv.getUint16(bytePos + i * 2, true);
-          break;
-        case DataType.INT32:
-          outVal[i] = dv.getInt32(bytePos + i * 4, true);
-          break;
-        case DataType.UINT32:
-          outVal[i] = dv.getUint32(bytePos + i * 4, true);
-          break;
-        case DataType.FLOAT64:
-          outVal[i] = dv.getFloat64(bytePos + i * 8, true);
-          break;
-        default:
-          outVal[i] = 0;
-          break;
-      }
+    if (!this.decodeConnectivity()) {
+      return false;
     }
+    return super.decodeGeometryData();
   }
-  // Flat-array extraction of all values into one output typed array (avoids the
-  // per-point temp-array copy via cached typed-array views over the buffer).
-  extractTo(OutputTypedArray, numPoints) {
-    const numComponents = this._numComponents;
-    const array = new OutputTypedArray(numPoints * numComponents);
-    if (this._buffer == null || this._buffer.data == null || numPoints === 0) {
-      return array;
+  // Overridden by derived classes.
+  decodeConnectivity() {
+    return false;
+  }
+};
+
+// src/decoder/mesh/MeshAttributeCornerTable.ts
+var kInvalidCornerIndex = -1;
+var kInvalidVertexIndex = -1;
+var MeshAttributeCornerTable = class {
+  is_edge_on_seam_;
+  is_vertex_on_seam_;
+  no_interior_seams_;
+  corner_to_vertex_map_;
+  vertex_to_left_most_corner_map_;
+  vertex_to_attribute_entry_id_map_;
+  corner_table_;
+  // Lazily built; see oppositeCornerArray.
+  _effectiveOpposite;
+  // Every corner passed to addSeamEdge (may contain duplicates); lets
+  // oppositeCornerArray patch seams without scanning every corner's flag.
+  _seamCorners;
+  constructor() {
+    this.is_edge_on_seam_ = [];
+    this.is_vertex_on_seam_ = [];
+    this.no_interior_seams_ = true;
+    this.corner_to_vertex_map_ = [];
+    this.vertex_to_left_most_corner_map_ = [];
+    this.vertex_to_attribute_entry_id_map_ = [];
+    this.corner_table_ = null;
+    this._effectiveOpposite = null;
+    this._seamCorners = [];
+  }
+  initEmpty(table) {
+    if (table === null) {
+      return false;
     }
-    const bufData = this._buffer.data;
-    const dt = this._dataType;
-    const isIdentity = this._identityMapping;
-    const indicesMap = this._indicesMap;
-    const byteStride = this._byteStride;
-    const byteOffset = this._byteOffset;
-    let srcView = null;
-    let shift = 0;
-    if (dt === DataType.FLOAT32) {
-      if (this._cachedFloat32View === void 0 || this._cachedFloat32Buffer !== bufData.buffer) {
-        this._cachedFloat32Buffer = bufData.buffer;
-        this._cachedFloat32View = new Float32Array(bufData.buffer);
-      }
-      srcView = this._cachedFloat32View;
-      shift = 2;
-    } else if (dt === DataType.INT32) {
-      if (this._cachedInt32View === void 0 || this._cachedInt32Buffer !== bufData.buffer) {
-        this._cachedInt32Buffer = bufData.buffer;
-        this._cachedInt32View = new Int32Array(bufData.buffer);
-      }
-      srcView = this._cachedInt32View;
-      shift = 2;
-    } else if (dt === DataType.UINT32) {
-      if (this._cachedUint32View === void 0 || this._cachedUint32Buffer !== bufData.buffer) {
-        this._cachedUint32Buffer = bufData.buffer;
-        this._cachedUint32View = new Uint32Array(bufData.buffer);
-      }
-      srcView = this._cachedUint32View;
-      shift = 2;
-    } else if (dt === DataType.UINT16) {
-      if (this._cachedUint16View === void 0 || this._cachedUint16Buffer !== bufData.buffer) {
-        this._cachedUint16Buffer = bufData.buffer;
-        this._cachedUint16View = new Uint16Array(bufData.buffer);
-      }
-      srcView = this._cachedUint16View;
-      shift = 1;
-    } else if (dt === DataType.INT16) {
-      if (this._cachedInt16View === void 0 || this._cachedInt16Buffer !== bufData.buffer) {
-        this._cachedInt16Buffer = bufData.buffer;
-        this._cachedInt16View = new Int16Array(bufData.buffer);
-      }
-      srcView = this._cachedInt16View;
-      shift = 1;
-    } else if (dt === DataType.UINT8) {
-      if (this._cachedUint8View === void 0 || this._cachedUint8Buffer !== bufData.buffer) {
-        this._cachedUint8Buffer = bufData.buffer;
-        this._cachedUint8View = new Uint8Array(bufData.buffer);
-      }
-      srcView = this._cachedUint8View;
-      shift = 0;
-    } else if (dt === DataType.INT8) {
-      if (this._cachedInt8View === void 0 || this._cachedInt8Buffer !== bufData.buffer) {
-        this._cachedInt8Buffer = bufData.buffer;
-        this._cachedInt8View = new Int8Array(bufData.buffer);
-      }
-      srcView = this._cachedInt8View;
-      shift = 0;
-    } else if (dt === DataType.FLOAT64) {
-      if (this._cachedFloat64View === void 0 || this._cachedFloat64Buffer !== bufData.buffer) {
-        this._cachedFloat64Buffer = bufData.buffer;
-        this._cachedFloat64View = new Float64Array(bufData.buffer);
-      }
-      srcView = this._cachedFloat64View;
-      shift = 3;
+    this.is_edge_on_seam_ = new Uint8Array(table.numCorners());
+    this.is_vertex_on_seam_ = new Uint8Array(table.numVertices());
+    this.corner_to_vertex_map_ = new Int32Array(table.numCorners()).fill(kInvalidVertexIndex);
+    this.vertex_to_attribute_entry_id_map_ = [];
+    this.vertex_to_left_most_corner_map_ = [];
+    this._effectiveOpposite = null;
+    this._seamCorners = [];
+    this.corner_table_ = table;
+    this.no_interior_seams_ = true;
+    return true;
+  }
+  addSeamEdge(c) {
+    const cornerToVertex = this.corner_table_.cornerToVertexArray();
+    const oppositeCorners = this.corner_table_.oppositeCornerArray();
+    const isEdge = this.is_edge_on_seam_;
+    const isVert = this.is_vertex_on_seam_;
+    isEdge[c] = 1;
+    this._seamCorners.push(c);
+    let rem = c - (c / 3 | 0) * 3;
+    isVert[cornerToVertex[rem === 2 ? c - 2 : c + 1]] = 1;
+    isVert[cornerToVertex[rem === 0 ? c + 2 : c - 1]] = 1;
+    const oppCorner = oppositeCorners[c];
+    if (oppCorner !== kInvalidCornerIndex) {
+      this.no_interior_seams_ = false;
+      isEdge[oppCorner] = 1;
+      this._seamCorners.push(oppCorner);
+      rem = oppCorner - (oppCorner / 3 | 0) * 3;
+      isVert[cornerToVertex[rem === 2 ? oppCorner - 2 : oppCorner + 1]] = 1;
+      isVert[cornerToVertex[rem === 0 ? oppCorner + 2 : oppCorner - 1]] = 1;
     }
-    if (srcView !== null) {
-      const srcStart = bufData.byteOffset + byteOffset >> shift;
-      const strideElements = byteStride >> shift;
-      if (isIdentity && strideElements === numComponents) {
-        const srcEnd = srcStart + numPoints * numComponents;
-        if (srcView.constructor === OutputTypedArray) {
-          array.set(srcView.subarray(srcStart, srcEnd));
-          return array;
-        }
-      }
-      if (isIdentity) {
-        let dst = 0;
-        for (let i = 0; i < numPoints; i++) {
-          const srcOffset = srcStart + i * strideElements;
-          for (let j = 0; j < numComponents; j++) {
-            array[dst + j] = srcView[srcOffset + j];
-          }
-          dst += numComponents;
-        }
-      } else if (numComponents === 3) {
-        let dst = 0;
-        for (let i = 0; i < numPoints; i++) {
-          const srcOffset = srcStart + indicesMap[i] * strideElements;
-          array[dst] = srcView[srcOffset];
-          array[dst + 1] = srcView[srcOffset + 1];
-          array[dst + 2] = srcView[srcOffset + 2];
-          dst += 3;
-        }
-      } else if (numComponents === 2) {
-        let dst = 0;
-        for (let i = 0; i < numPoints; i++) {
-          const srcOffset = srcStart + indicesMap[i] * strideElements;
-          array[dst] = srcView[srcOffset];
-          array[dst + 1] = srcView[srcOffset + 1];
-          dst += 2;
-        }
-      } else if (numComponents === 4) {
-        let dst = 0;
-        for (let i = 0; i < numPoints; i++) {
-          const srcOffset = srcStart + indicesMap[i] * strideElements;
-          array[dst] = srcView[srcOffset];
-          array[dst + 1] = srcView[srcOffset + 1];
-          array[dst + 2] = srcView[srcOffset + 2];
-          array[dst + 3] = srcView[srcOffset + 3];
-          dst += 4;
+  }
+  recomputeVertices(_cornerTable, _vertexIds) {
+    return this._recomputeVerticesInternal();
+  }
+  // Only the C++ RecomputeVertices(nullptr, nullptr) path: the decoder always
+  // rebuilds the attribute-vertex maps from connectivity alone.
+  _recomputeVerticesInternal() {
+    const ct = this.corner_table_;
+    const numCorners = ct.numCorners();
+    const numBaseVertices = ct.numVertices();
+    const leftMostMap = new Int32Array(numCorners);
+    const cornerToVertex = this.corner_to_vertex_map_;
+    const isVertexOnSeam = this.is_vertex_on_seam_;
+    const isEdgeOnSeam = this.is_edge_on_seam_;
+    const seamOpp = this.oppositeCornerArray();
+    const baseOpp = ct.oppositeCornerArray();
+    const vertexLeftmost = ct.vertexLeftmostCornerArray();
+    let numNewVertices = 0;
+    for (let v = 0; v < numBaseVertices; ++v) {
+      const c = vertexLeftmost[v];
+      if (c === kInvalidCornerIndex) continue;
+      if (!isVertexOnSeam[v]) {
+        const firstVertId = numNewVertices++;
+        leftMostMap[firstVertId] = c;
+        cornerToVertex[c] = firstVertId;
+        let pv = c % 3 === 0 ? c + 2 : c - 1;
+        let bopp = baseOpp[pv];
+        let actC = bopp < 0 ? kInvalidCornerIndex : bopp % 3 === 0 ? bopp + 2 : bopp - 1;
+        while (actC !== kInvalidCornerIndex && actC !== c) {
+          cornerToVertex[actC] = firstVertId;
+          pv = actC % 3 === 0 ? actC + 2 : actC - 1;
+          bopp = baseOpp[pv];
+          actC = bopp < 0 ? kInvalidCornerIndex : bopp % 3 === 0 ? bopp + 2 : bopp - 1;
         }
-      } else if (numComponents === 1) {
-        let dst = 0;
-        for (let i = 0; i < numPoints; i++) {
-          array[dst++] = srcView[srcStart + indicesMap[i] * strideElements];
+      } else {
+        let firstVertId = numNewVertices++;
+        let firstC = c;
+        let actC;
+        let nx = firstC % 3 === 2 ? firstC - 2 : firstC + 1;
+        let opp = seamOpp[nx];
+        actC = opp < 0 ? kInvalidCornerIndex : opp % 3 === 2 ? opp - 2 : opp + 1;
+        while (actC !== kInvalidCornerIndex) {
+          firstC = actC;
+          nx = firstC % 3 === 2 ? firstC - 2 : firstC + 1;
+          opp = seamOpp[nx];
+          actC = opp < 0 ? kInvalidCornerIndex : opp % 3 === 2 ? opp - 2 : opp + 1;
+          if (actC === c) return false;
         }
-      } else {
-        let dst = 0;
-        for (let i = 0; i < numPoints; i++) {
-          const srcOffset = srcStart + indicesMap[i] * strideElements;
-          for (let j = 0; j < numComponents; j++) {
-            array[dst + j] = srcView[srcOffset + j];
+        cornerToVertex[firstC] = firstVertId;
+        leftMostMap[firstVertId] = firstC;
+        let pv = firstC % 3 === 0 ? firstC + 2 : firstC - 1;
+        let bopp = baseOpp[pv];
+        actC = bopp < 0 ? kInvalidCornerIndex : bopp % 3 === 0 ? bopp + 2 : bopp - 1;
+        while (actC !== kInvalidCornerIndex && actC !== firstC) {
+          const nAct = actC % 3 === 2 ? actC - 2 : actC + 1;
+          if (isEdgeOnSeam[nAct]) {
+            firstVertId = numNewVertices++;
+            leftMostMap[firstVertId] = actC;
           }
-          dst += numComponents;
+          cornerToVertex[actC] = firstVertId;
+          pv = actC % 3 === 0 ? actC + 2 : actC - 1;
+          bopp = baseOpp[pv];
+          actC = bopp < 0 ? kInvalidCornerIndex : bopp % 3 === 0 ? bopp + 2 : bopp - 1;
         }
       }
-      return array;
-    }
-    const temp = new Array(numComponents);
-    for (let i = 0; i < numPoints; i++) {
-      const attIndex = isIdentity ? i : indicesMap[i];
-      this.convertValue(attIndex, temp);
-      const dstOffset = i * numComponents;
-      for (let j = 0; j < numComponents; j++) {
-        array[dstOffset + j] = temp[j];
-      }
     }
-    return array;
+    this.vertex_to_attribute_entry_id_map_ = new Int32Array(numNewVertices);
+    this.vertex_to_left_most_corner_map_ = leftMostMap.subarray(0, numNewVertices);
+    return true;
   }
-  // Intentionally returns void while the base class returns boolean (matches the source's shape).
-  // @ts-expect-error -- return type intentionally differs from the base class, as in the source.
-  copyFrom(srcAtt) {
-    if (this.buffer === null) {
-      this._attributeBuffer = new DataBuffer();
-      this.resetBuffer(this._attributeBuffer, 0, 0);
+  isCornerOppositeToSeamEdge(corner) {
+    return this.is_edge_on_seam_[corner];
+  }
+  opposite(corner) {
+    if (corner === kInvalidCornerIndex || this.isCornerOppositeToSeamEdge(corner)) {
+      return kInvalidCornerIndex;
     }
-    if (!super.copyFrom(srcAtt)) {
-      return;
+    return this.corner_table_.opposite(corner);
+  }
+  next(corner) {
+    return this.corner_table_.next(corner);
+  }
+  previous(corner) {
+    return this.corner_table_.previous(corner);
+  }
+  swingRight(corner) {
+    return this.previous(this.opposite(this.previous(corner)));
+  }
+  swingLeft(corner) {
+    return this.next(this.opposite(this.next(corner)));
+  }
+  numVertices() {
+    return this.vertex_to_attribute_entry_id_map_.length;
+  }
+  numFaces() {
+    return this.corner_table_.numFaces();
+  }
+  numCorners() {
+    return this.corner_table_.numCorners();
+  }
+  vertex(corner) {
+    return this.confidentVertex(corner);
+  }
+  confidentVertex(corner) {
+    return this.corner_to_vertex_map_[corner];
+  }
+  leftMostCorner(v) {
+    return this.vertex_to_left_most_corner_map_[v];
+  }
+  // --- Flat-array accessors: let DepthFirstTraverser avoid per-corner dispatch. ---
+  cornerToVertexArray() {
+    return this.corner_to_vertex_map_;
+  }
+  // Seam-aware opposite corners (seam edges -> -1), matching opposite(). Cached on
+  // first use; seams and connectivity are finalized before traversal, so it's stable.
+  oppositeCornerArray() {
+    if (this._effectiveOpposite === null) {
+      const nc = this.corner_table_.numCorners();
+      const base = this.corner_table_.oppositeCornerArray();
+      const seamCorners = this._seamCorners;
+      if (seamCorners.length === 0) {
+        this._effectiveOpposite = base;
+      } else {
+        const eff = scratchInt32(nc);
+        eff.set(base.length === nc ? base : base.subarray(0, nc));
+        for (let i = 0, l = seamCorners.length; i < l; ++i) {
+          eff[seamCorners[i]] = kInvalidCornerIndex;
+        }
+        this._effectiveOpposite = eff;
+      }
     }
-    this._identityMapping = srcAtt._identityMapping;
-    this._numUniqueEntries = srcAtt._numUniqueEntries;
-    this._indicesMap = srcAtt._indicesMap.slice();
-    if (srcAtt._attributeTransformData) {
-      this._attributeTransformData = srcAtt._attributeTransformData;
-    } else {
-      this._attributeTransformData = null;
+    return this._effectiveOpposite;
+  }
+  vertexLeftmostCornerArray() {
+    return this.vertex_to_left_most_corner_map_;
+  }
+  // Per-base-vertex seam flag (Uint8Array); exposed so hot dedup loops inline the lookup.
+  vertexOnSeamArray() {
+    return this.is_vertex_on_seam_;
+  }
+  hasSameSeams(other) {
+    if (other === null || other === void 0) return false;
+    const seamA = this.is_edge_on_seam_;
+    const seamB = other.is_edge_on_seam_;
+    if (seamA.length !== seamB.length) return false;
+    for (let i = 0, l = seamA.length; i < l; ++i) {
+      if (seamA[i] !== seamB[i]) return false;
     }
+    return true;
+  }
+  adoptVertexRecompute(other) {
+    this.corner_to_vertex_map_ = other.corner_to_vertex_map_;
+    this.vertex_to_attribute_entry_id_map_ = other.vertex_to_attribute_entry_id_map_;
+    this.vertex_to_left_most_corner_map_ = other.vertex_to_left_most_corner_map_;
+    this.no_interior_seams_ = other.no_interior_seams_;
+    this._effectiveOpposite = other._effectiveOpposite;
+    this._seamCorners = other._seamCorners;
   }
 };
 
@@ -1863,15 +1882,12 @@ var SequentialAttributeDecoder = class {
   decodeValues(pointIds, buffer) {
     const numValues = pointIds.length;
     const entrySize = this._attribute.byteStride;
-    let outBytePos = 0;
-    for (let i = 0; i < numValues; i++) {
-      const valueData = buffer.decodeBytes(entrySize);
-      if (valueData === void 0) {
-        return false;
-      }
-      this._attribute.buffer.write(outBytePos, valueData, entrySize);
-      outBytePos += entrySize;
+    const totalSize = numValues * entrySize;
+    const valueData = buffer.decodeBytesView(totalSize);
+    if (valueData === void 0) {
+      return false;
     }
+    this._attribute.buffer.write(0, valueData, totalSize);
     return true;
   }
   setPortableAttribute(att) {
@@ -2009,6 +2025,9 @@ var RAnsDecoder = class {
       this.bufOffset = offset - 3;
       this.state = memGetLe24(buf, offset - 3) & 4194303;
     } else if (x === 3) {
+      if (offset - base < 4) {
+        return 1;
+      }
       this.bufOffset = offset - 4;
       this.state = memGetLe32(buf, offset - 4) & 1073741823;
     } else {
@@ -2053,12 +2072,69 @@ var RAnsDecoder = class {
   }
   // Batch ransRead() into out[0..count): all fields hoisted to locals, state
   // written back once. Removes per-symbol property reads and call indirection.
+  // lutTable's element type varies per decoder (Uint8/16/32 by symbol count),
+  // which would make the hot lutTable[rem] access site polymorphic — dispatch
+  // once here so each loop body stays monomorphic on its concrete type. The
+  // three bodies are intentionally identical copies.
   decodeSymbols(out, count) {
+    const lutTable = this.lutTable;
+    if (lutTable instanceof Uint8Array) {
+      this._decodeSymbolsU8(out, count, lutTable);
+    } else if (lutTable instanceof Uint16Array) {
+      this._decodeSymbolsU16(out, count, lutTable);
+    } else {
+      this._decodeSymbolsU32(out, count, lutTable);
+    }
+  }
+  _decodeSymbolsU8(out, count, lutTable) {
+    const buf = this.buf;
+    const lRansBase = this.lRansBase;
+    const ransPrecisionBits = this.ransPrecisionBits;
+    const ransPrecisionMask = this.ransPrecisionMask;
+    const probTable = this.probTable;
+    const cumProbTable = this.cumProbTable;
+    let state = this.state;
+    let bufOffset = this.bufOffset;
+    const bufStart = this.bufStart;
+    for (let i = 0; i < count; ++i) {
+      while (state < lRansBase && bufOffset > bufStart) {
+        state = state << 8 | buf[--bufOffset];
+      }
+      const rem = state & ransPrecisionMask;
+      const symbol = lutTable[rem];
+      out[i] = symbol;
+      state = (state >>> ransPrecisionBits) * probTable[symbol] + rem - cumProbTable[symbol];
+    }
+    this.state = state;
+    this.bufOffset = bufOffset;
+  }
+  _decodeSymbolsU16(out, count, lutTable) {
+    const buf = this.buf;
+    const lRansBase = this.lRansBase;
+    const ransPrecisionBits = this.ransPrecisionBits;
+    const ransPrecisionMask = this.ransPrecisionMask;
+    const probTable = this.probTable;
+    const cumProbTable = this.cumProbTable;
+    let state = this.state;
+    let bufOffset = this.bufOffset;
+    const bufStart = this.bufStart;
+    for (let i = 0; i < count; ++i) {
+      while (state < lRansBase && bufOffset > bufStart) {
+        state = state << 8 | buf[--bufOffset];
+      }
+      const rem = state & ransPrecisionMask;
+      const symbol = lutTable[rem];
+      out[i] = symbol;
+      state = (state >>> ransPrecisionBits) * probTable[symbol] + rem - cumProbTable[symbol];
+    }
+    this.state = state;
+    this.bufOffset = bufOffset;
+  }
+  _decodeSymbolsU32(out, count, lutTable) {
     const buf = this.buf;
     const lRansBase = this.lRansBase;
     const ransPrecisionBits = this.ransPrecisionBits;
     const ransPrecisionMask = this.ransPrecisionMask;
-    const lutTable = this.lutTable;
     const probTable = this.probTable;
     const cumProbTable = this.cumProbTable;
     let state = this.state;
@@ -2119,16 +2195,12 @@ function computeRAnsPrecisionFromUniqueSymbolsBitLength(symbolsBitLength) {
   return unclamped;
 }
 var RAnsSymbolDecoder = class {
-  uniqueSymbolsBitLength_;
   ransPrecisionBits_;
-  ransPrecision_;
   probabilityTable_;
   numSymbols_;
   ans_;
   constructor(uniqueSymbolsBitLength) {
-    this.uniqueSymbolsBitLength_ = uniqueSymbolsBitLength;
     this.ransPrecisionBits_ = computeRAnsPrecisionFromUniqueSymbolsBitLength(uniqueSymbolsBitLength);
-    this.ransPrecision_ = 1 << this.ransPrecisionBits_;
     this.probabilityTable_ = null;
     this.numSymbols_ = 0;
     this.ans_ = new RAnsDecoder(this.ransPrecisionBits_);
@@ -3540,8 +3612,7 @@ var MeshPredictionSchemeTexCoordsPortablePredictor = class {
         }
         const xUV0 = nUV0 * pnNorm2Squared + cnDotPn * pnUV0;
         const xUV1 = nUV1 * pnNorm2Squared + cnDotPn * pnUV1;
-        const pnAbsMax = Math.max(Math.abs(pn0), Math.abs(pn1), Math.abs(pn2));
-        if (pnAbsMax > 0 && Math.abs(cnDotPn) > INT64_MAX / pnAbsMax) {
+        if (pnAbsMaxG > 0 && cnDotPnAbs > INT64_MAX / pnAbsMaxG) {
           return false;
         }
         const xPos0 = next0 + Math.trunc(cnDotPn * pn0 / pnNorm2Squared);
@@ -3909,7 +3980,7 @@ var SequentialIntegerAttributeDecoder = class extends SequentialAttributeDecoder
         if (portableAttributeData.byteLength < 4 * numValues) {
           return false;
         }
-        const bytes = buffer.decodeBytes(4 * numValues);
+        const bytes = buffer.decodeBytesView(4 * numValues);
         if (bytes === void 0) return false;
         const srcView = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
         for (let i = 0; i < numValues; i++) {
@@ -3919,12 +3990,13 @@ var SequentialIntegerAttributeDecoder = class extends SequentialAttributeDecoder
         if (buffer.remainingSize < numBytes * numValues) {
           return false;
         }
+        const bytes = buffer.decodeBytesView(numBytes * numValues);
+        if (bytes === void 0) return false;
         for (let i = 0; i < numValues; i++) {
-          const valueBytes = buffer.decodeBytes(numBytes);
-          if (valueBytes === void 0) return false;
           let val = 0;
+          const valueOffset = i * numBytes;
           for (let b = 0; b < numBytes; b++) {
-            val |= valueBytes[b] << b * 8;
+            val |= bytes[valueOffset + b] << b * 8;
           }
           portableAttributeData[i] = val;
         }
@@ -4586,15 +4658,6 @@ var AttributeQuantizationTransform = class _AttributeQuantizationTransform exten
     }
     return true;
   }
-  get quantizationBits() {
-    return this._quantizationBits;
-  }
-  get range() {
-    return this._range;
-  }
-  minValue(axis) {
-    return this._minValues[axis];
-  }
   static _isQuantizationValid(quantizationBits) {
     return quantizationBits >= 1 && quantizationBits <= 30;
   }
@@ -4673,7 +4736,7 @@ var SequentialAttributeDecodersController = class extends AttributesDecoder {
     if (!this._sequencer) {
       return false;
     }
-    if (!this._sequencer.generateSequence(this._pointIds)) {
+    if (!this._sequencer.generateSequence()) {
       return false;
     }
     this._pointIds = this._sequencer.getOutputPointIds();
@@ -4797,19 +4860,29 @@ var DepthFirstTraverser = class {
   init(cornerTable, observer) {
     this._cornerTable = cornerTable;
     this._observer = observer;
-    this._isFaceVisited = new Uint8Array(cornerTable.numFaces());
-    this._isVertexVisited = new Uint8Array(cornerTable.numVertices());
+    this._isFaceVisited = null;
+    this._isVertexVisited = null;
     this._numVisitedFaces = 0;
     this._cornerToVertex = cornerTable.cornerToVertexArray();
     this._oppositeCorners = cornerTable.oppositeCornerArray();
     this._vertexLeftmost = cornerTable.vertexLeftmostCornerArray();
     this._numCorners = cornerTable.numCorners();
-    this._cornerTraversalStack = new Int32Array(this._numCorners);
   }
   cornerTable() {
     return this._cornerTable;
   }
+  // Scratch buffers are set up here rather than in init() so a shared-traversal
+  // -cache hit — where generateSequence returns before any traversal — skips
+  // this entirely, including the visited-flag zero-fill (worth ~0.5% on the
+  // 488-primitive manablade-static bundle, which shares attribute corner tables across
+  // primitives). Uint8Array (0/1) instead of Array(bool): these flags are read
+  // and written on every corner of the hottest decode loop (traverseFromCorner).
+  // Decode-scoped scratch: released in bulk at the end of the decode.
   onTraversalStart() {
+    const cornerTable = this._cornerTable;
+    this._isFaceVisited = scratchUint8Zeroed(cornerTable.numFaces());
+    this._isVertexVisited = scratchUint8Zeroed(cornerTable.numVertices());
+    this._cornerTraversalStack = scratchInt32(this._numCorners);
   }
   onTraversalEnd() {
   }
@@ -4825,6 +4898,14 @@ var DepthFirstTraverser = class {
     const vertexLeftmost = this._vertexLeftmost;
     const stack = this._cornerTraversalStack;
     let numVisitedFaces = this._numVisitedFaces;
+    const sequencer = observer._sequencer;
+    const encodingData = observer._encodingData;
+    const obsFaces = observer._faces;
+    const encodedToCornerMap = observer._encodedToCornerMap;
+    const vertexToEncodedMap = observer._vertexToEncodedMap;
+    const outPointIds = sequencer._outPointIds;
+    let numOutPoints = sequencer._numOutPoints;
+    let numValues = encodingData.numValues;
     let stackSize = 0;
     stack[stackSize++] = cornerId;
     const nextCorner = cornerId % 3 === 2 ? cornerId - 2 : cornerId + 1;
@@ -4836,11 +4917,15 @@ var DepthFirstTraverser = class {
     }
     if (!isVertexVisited[nextVert]) {
       isVertexVisited[nextVert] = 1;
-      observer.onNewVertexVisited(nextVert, nextCorner);
+      outPointIds[numOutPoints++] = obsFaces[nextCorner];
+      encodedToCornerMap[numValues] = nextCorner;
+      vertexToEncodedMap[nextVert] = numValues++;
     }
     if (!isVertexVisited[prevVert]) {
       isVertexVisited[prevVert] = 1;
-      observer.onNewVertexVisited(prevVert, prevCorner);
+      outPointIds[numOutPoints++] = obsFaces[prevCorner];
+      encodedToCornerMap[numValues] = prevCorner;
+      vertexToEncodedMap[prevVert] = numValues++;
     }
     while (stackSize > 0) {
       cornerId = stack[stackSize - 1];
@@ -4854,6 +4939,8 @@ var DepthFirstTraverser = class {
         numVisitedFaces++;
         const vertId = cornerToVertex[cornerId];
         if (vertId === kInvalidVertexIndex2) {
+          sequencer._numOutPoints = numOutPoints;
+          encodingData.numValues = numValues;
           return false;
         }
         if (!isVertexVisited[vertId]) {
@@ -4864,7 +4951,9 @@ var DepthFirstTraverser = class {
             onBoundary = oppositeCorners[nextLc] < 0;
           }
           isVertexVisited[vertId] = 1;
-          observer.onNewVertexVisited(vertId, cornerId);
+          outPointIds[numOutPoints++] = obsFaces[cornerId];
+          encodedToCornerMap[numValues] = cornerId;
+          vertexToEncodedMap[vertId] = numValues++;
           if (!onBoundary) {
             const nextCornerId2 = cornerId % 3 === 2 ? cornerId - 2 : cornerId + 1;
             cornerId = oppositeCorners[nextCornerId2];
@@ -4901,6 +4990,8 @@ var DepthFirstTraverser = class {
       }
     }
     this._numVisitedFaces = numVisitedFaces;
+    sequencer._numOutPoints = numOutPoints;
+    encodingData.numValues = numValues;
     return true;
   }
 };
@@ -5113,7 +5204,7 @@ var MeshTraversalSequencer = class {
   setTraverser(traverser) {
     this._traverser = traverser;
   }
-  generateSequence(_outPointIds) {
+  generateSequence() {
     const cornerTable = this._traverser.cornerTable();
     const methodId = this._traverser._traversalMethodId;
     const cacheKey = cornerTable.cornerToVertexArray();
@@ -5451,7 +5542,7 @@ var MeshEdgebreakerDecoderImpl = class {
     return true;
   }
   _decodeConnectivity(numSymbols) {
-    const activeCornerStack = new Int32Array(numSymbols + this._topologySplitData.length + 16);
+    const activeCornerStack = scratchInt32(numSymbols + this._topologySplitData.length + 16);
     let activeCornerStackSize = 0;
     const topologySplitActiveCorners = /* @__PURE__ */ new Map();
     const invalidVertices = [];
@@ -6052,7 +6143,8 @@ var CornerTable = class {
     const newVertex = this._numVertices;
     this._numVertices++;
     if (newVertex >= this._vertexCorners.length) {
-      const newArr = new Int32Array(this._vertexCorners.length + 64);
+      const newCapacity = Math.max(newVertex + 1, this._vertexCorners.length * 2, 64);
+      const newArr = new Int32Array(newCapacity);
       newArr.fill(-1);
       newArr.set(this._vertexCorners);
       this._vertexCorners = newArr;
@@ -6315,7 +6407,7 @@ var MeshEdgebreakerTraversalValenceDecoder = class extends MeshEdgebreakerTraver
     this._activeContext = -1;
     this._minValence = 2;
     this._maxValence = 7;
-    this._vertexValences = [];
+    this._vertexValences = new Int32Array(0);
     this._contextSymbols = [];
     this._contextCounters = [];
   }
@@ -6339,7 +6431,7 @@ var MeshEdgebreakerTraversalValenceDecoder = class extends MeshEdgebreakerTraver
     if (this._numVertices < 0) {
       return false;
     }
-    this._vertexValences = new Array(this._numVertices).fill(0);
+    this._vertexValences = new Int32Array(this._numVertices);
     const numUniqueValences = this._maxValence - this._minValence + 1;
     this._contextSymbols = new Array(numUniqueValences);
     this._contextCounters = new Array(numUniqueValences);
@@ -6381,34 +6473,37 @@ var MeshEdgebreakerTraversalValenceDecoder = class extends MeshEdgebreakerTraver
     return this._lastSymbol;
   }
   newActiveCornerReached(corner) {
-    const ct = this._cornerTable;
-    const next = ct.next(corner);
-    const prev = ct.previous(corner);
+    const cornerToVertex = this._cornerTable._cornerToVertex;
+    const valences = this._vertexValences;
+    const next = corner % 3 === 2 ? corner - 2 : corner + 1;
+    const prev = corner % 3 === 0 ? corner + 2 : corner - 1;
+    const vertNext = cornerToVertex[next];
+    const vertPrev = cornerToVertex[prev];
     switch (this._lastSymbol) {
       case TOPOLOGY_C:
       case TOPOLOGY_S:
-        this._vertexValences[ct.vertex(next)] += 1;
-        this._vertexValences[ct.vertex(prev)] += 1;
+        valences[vertNext] += 1;
+        valences[vertPrev] += 1;
         break;
       case TOPOLOGY_R:
-        this._vertexValences[ct.vertex(corner)] += 1;
-        this._vertexValences[ct.vertex(next)] += 1;
-        this._vertexValences[ct.vertex(prev)] += 2;
+        valences[cornerToVertex[corner]] += 1;
+        valences[vertNext] += 1;
+        valences[vertPrev] += 2;
         break;
       case TOPOLOGY_L:
-        this._vertexValences[ct.vertex(corner)] += 1;
-        this._vertexValences[ct.vertex(next)] += 2;
-        this._vertexValences[ct.vertex(prev)] += 1;
+        valences[cornerToVertex[corner]] += 1;
+        valences[vertNext] += 2;
+        valences[vertPrev] += 1;
         break;
       case TOPOLOGY_E:
-        this._vertexValences[ct.vertex(corner)] += 2;
-        this._vertexValences[ct.vertex(next)] += 2;
-        this._vertexValences[ct.vertex(prev)] += 2;
+        valences[cornerToVertex[corner]] += 2;
+        valences[vertNext] += 2;
+        valences[vertPrev] += 2;
         break;
       default:
         break;
     }
-    const activeValence = this._vertexValences[ct.vertex(next)];
+    const activeValence = valences[vertNext];
     let clampedValence;
     if (activeValence < this._minValence) {
       clampedValence = this._minValence;
@@ -6527,45 +6622,30 @@ var MeshSequentialDecoder = class extends MeshDecoder {
         return false;
       }
     } else {
+      const mesh = this.mesh();
+      mesh.setNumFaces(numFaces);
+      const faces = mesh.faces_;
+      const numIndices = numFaces * 3;
+      const buffer = this.buffer();
       if (numPoints < 256) {
-        for (let i = 0; i < numFaces; ++i) {
-          const face = [0, 0, 0];
-          for (let j = 0; j < 3; ++j) {
-            const val = this.buffer().decodeUint8();
-            if (val === void 0) return false;
-            face[j] = val;
-          }
-          this.mesh().addFace(face);
-        }
+        const src = buffer.decodeBytesView(numIndices);
+        if (src === void 0) return false;
+        for (let i = 0; i < numIndices; ++i) faces[i] = src[i];
       } else if (numPoints < 1 << 16) {
-        for (let i = 0; i < numFaces; ++i) {
-          const face = [0, 0, 0];
-          for (let j = 0; j < 3; ++j) {
-            const val = this.buffer().decodeUint16();
-            if (val === void 0) return false;
-            face[j] = val;
-          }
-          this.mesh().addFace(face);
-        }
+        const src = buffer.decodeBytesView(numIndices * 2);
+        if (src === void 0) return false;
+        for (let i = 0; i < numIndices; ++i) faces[i] = src[i * 2] | src[i * 2 + 1] << 8;
       } else if (numPoints < 1 << 21) {
-        for (let i = 0; i < numFaces; ++i) {
-          const face = [0, 0, 0];
-          for (let j = 0; j < 3; ++j) {
-            const val = decodeVarint(this.buffer());
-            if (val === void 0) return false;
-            face[j] = val;
-          }
-          this.mesh().addFace(face);
+        for (let i = 0; i < numIndices; ++i) {
+          const val = decodeVarint(buffer);
+          if (val === void 0) return false;
+          faces[i] = val;
         }
       } else {
-        for (let i = 0; i < numFaces; ++i) {
-          const face = [0, 0, 0];
-          for (let j = 0; j < 3; ++j) {
-            const val = this.buffer().decodeUint32();
-            if (val === void 0) return false;
-            face[j] = val;
-          }
-          this.mesh().addFace(face);
+        const src = buffer.decodeBytesView(numIndices * 4);
+        if (src === void 0) return false;
+        for (let i = 0; i < numIndices; ++i) {
+          faces[i] = src[i * 4] | src[i * 4 + 1] << 8 | src[i * 4 + 2] << 16 | src[i * 4 + 3] << 24;
         }
       }
     }
@@ -6579,32 +6659,31 @@ var MeshSequentialDecoder = class extends MeshDecoder {
     );
   }
   _decodeAndDecompressIndices(numFaces) {
-    const indicesBuffer = new Uint32Array(numFaces * 3);
-    if (!decodeSymbols(numFaces * 3, 1, this.buffer(), indicesBuffer)) {
+    const numIndices = numFaces * 3;
+    const indicesBuffer = new Uint32Array(numIndices);
+    if (!decodeSymbols(numIndices, 1, this.buffer(), indicesBuffer)) {
       return false;
     }
+    const mesh = this.mesh();
+    mesh.setNumFaces(numFaces);
+    const faces = mesh.faces_;
     let lastIndexValue = 0;
-    let vertexIndex = 0;
-    for (let i = 0; i < numFaces; ++i) {
-      const face = [0, 0, 0];
-      for (let j = 0; j < 3; ++j) {
-        const encodedVal = indicesBuffer[vertexIndex++];
-        let indexDiff = encodedVal >>> 1;
-        if (encodedVal & 1) {
-          if (indexDiff > lastIndexValue) {
-            return false;
-          }
-          indexDiff = -indexDiff;
-        } else {
-          if (indexDiff > 2147483647 - lastIndexValue) {
-            return false;
-          }
+    for (let i = 0; i < numIndices; ++i) {
+      const encodedVal = indicesBuffer[i];
+      let indexDiff = encodedVal >>> 1;
+      if (encodedVal & 1) {
+        if (indexDiff > lastIndexValue) {
+          return false;
+        }
+        indexDiff = -indexDiff;
+      } else {
+        if (indexDiff > 2147483647 - lastIndexValue) {
+          return false;
         }
-        const indexValue = indexDiff + lastIndexValue | 0;
-        face[j] = indexValue;
-        lastIndexValue = indexValue;
       }
-      this.mesh().addFace(face);
+      const indexValue = indexDiff + lastIndexValue | 0;
+      faces[i] = indexValue;
+      lastIndexValue = indexValue;
     }
     return true;
   }
@@ -6662,9 +6741,15 @@ var Decoder = class {
     if (result.header.encoderType !== EncodedGeometryType.TRIANGULAR_MESH) {
       return { ok: false, message: "Input is not a mesh." };
     }
-    const decoder = createMeshDecoder(result.header.encoderMethod);
-    const status = decoder.decodeMesh(this.options_, inBuffer, outGeometry);
-    return { ok: status.ok(), message: status.errorMsg };
+    try {
+      const decoder = createMeshDecoder(result.header.encoderMethod);
+      const status = decoder.decodeMesh(this.options_, inBuffer, outGeometry);
+      return { ok: status.ok(), message: status.errorMsg };
+    } catch (error) {
+      return { ok: false, message: error instanceof Error ? error.message : String(error) };
+    } finally {
+      releaseScratch();
+    }
   }
   options() {
     return this.options_;
@@ -6675,18 +6760,17 @@ var Decoder = class {
 var decodeDracoMesh = (data) => {
   const buffer = new DecoderBuffer();
   buffer.init(data, data.length);
-  if (Decoder.getEncodedGeometryType(buffer) !== EncodedGeometryType.TRIANGULAR_MESH) {
-    throw new Error("minidraco: Input is not a Draco triangular mesh.");
-  }
   const decoder = new Decoder();
   const result = decoder.decodeMeshFromBuffer(buffer);
   if (!result.ok || result.mesh === null) {
-    throw new Error(`minidraco: ${result.message}`);
+    const message = result.message === "Input is not a mesh." ? "Input is not a Draco triangular mesh." : result.message;
+    throw new Error(`minidraco: ${message}`);
   }
   return result.mesh;
 };
 
 // src/three/index.ts
+var isLoadingManager = (value) => typeof value?.itemStart === "function";
 var _taskCache = /* @__PURE__ */ new WeakMap();
 var _attributeTypeMap = {
   POSITION: Type.POSITION,
@@ -6704,13 +6788,24 @@ var _typedArrayMap = {
   Uint16Array,
   Uint32Array
 };
-var MiniDRACOLoader = class extends Loader {
+var MinidracoLoader = class extends Loader {
   defaultAttributeIDs;
   defaultAttributeTypes;
   workerLimit;
+  // Opt-in (0 = disabled): buffers at or below this size decode on the main
+  // thread instead of paying the ~0.5 ms worker message roundtrip.
+  // Worth enabling (e.g. 4096) when the main thread is otherwise idle during
+  // loads — in a full GLTFLoader parse the main thread is already busy
+  // building geometries, and measurements show the pool wins there even for
+  // tiny primitives.
+  mainThreadByteThreshold;
   _workers;
   _taskId;
   _tasks;
+  // Tasks queued during the current microtask; flushed as one batched message
+  // per worker (a 488-primitive scene costs 4 postMessages, not 488).
+  _batch;
+  _batchScheduled;
   // Set when spawning a worker fails (bundler without module-worker support,
   // file:// pages, …): decoding transparently falls back to the main thread.
   _workersBroken;
@@ -6718,8 +6813,10 @@ var MiniDRACOLoader = class extends Loader {
   // Same-origin blob bootstrap used when the worker asset lives on a CDN
   // origin (created lazily, revoked on dispose).
   _workerBlobUrl;
-  constructor(manager) {
-    super(manager);
+  // Accepts either a LoadingManager (three-compatible form) or an options bag.
+  constructor(managerOrOptions) {
+    const options = isLoadingManager(managerOrOptions) ? { manager: managerOrOptions } : managerOrOptions ?? {};
+    super(options.manager);
     this.defaultAttributeIDs = {
       position: "POSITION",
       normal: "NORMAL",
@@ -6732,10 +6829,13 @@ var MiniDRACOLoader = class extends Loader {
       color: "Float32Array",
       uv: "Float32Array"
     };
-    this.workerLimit = 4;
+    this.workerLimit = options.workers === false ? 0 : options.workerLimit ?? 4;
+    this.mainThreadByteThreshold = options.mainThreadByteThreshold ?? 0;
     this._workers = [];
     this._taskId = 0;
     this._tasks = /* @__PURE__ */ new Map();
+    this._batch = [];
+    this._batchScheduled = false;
     this._workersBroken = false;
     this._workerUrl = null;
     this._workerBlobUrl = null;
@@ -6748,8 +6848,12 @@ var MiniDRACOLoader = class extends Loader {
     this._workerUrl = url;
     return this;
   }
-  // Kept for API compatibility with THREE.DRACOLoader — minidraco has no
-  // external decoder files to configure.
+  // No-ops kept for API compatibility with THREE.DRACOLoader — minidraco has
+  // no external decoder files to configure. The params are `unknown` (not
+  // `string`/`object`) so the signatures stay assignable to THREE.DRACOLoader
+  // across three versions, whose setDecoderPath has grown to accept a
+  // `string | DecoderPaths` — letting `new MinidracoLoader()` be passed to
+  // GLTFLoader.setDRACOLoader() with no cast.
   setDecoderPath(_path) {
     return this;
   }
@@ -6760,13 +6864,30 @@ var MiniDRACOLoader = class extends Loader {
     this.workerLimit = limit;
     return this;
   }
+  // Toggle the worker pool on/off. false decodes synchronously on the main
+  // thread; true enables the pool, keeping the current size or falling back to
+  // the default 4 if it was disabled. For a specific pool size use
+  // setWorkerLimit(n).
+  setWorkers(enabled) {
+    this.workerLimit = enabled ? this.workerLimit || 4 : 0;
+    return this;
+  }
   preload() {
-    if (this._workersAvailable()) this._getWorker();
+    if (this._workersAvailable()) {
+      while (this._workers.length < this.workerLimit && this._getWorker() !== null) {
+      }
+    }
     return this;
   }
   dispose() {
     for (const entry of this._workers) entry.worker.terminate();
     this._workers = [];
+    const disposedError = new Error("MinidracoLoader: disposed while decoding");
+    disposedError.isDecodeError = true;
+    for (const task of this._batch) task.reject(disposedError);
+    this._batch = [];
+    this._batchScheduled = false;
+    for (const [, task] of this._tasks) task.reject(disposedError);
     this._tasks.clear();
     if (this._workerBlobUrl !== null) {
       URL.revokeObjectURL(this._workerBlobUrl);
@@ -6809,10 +6930,6 @@ var MiniDRACOLoader = class extends Loader {
       const cachedTask = _taskCache.get(buffer);
       if (cachedTask.key === taskKey) {
         return cachedTask.promise;
-      } else if (buffer.byteLength === 0) {
-        throw new Error(
-          "MiniDRACOLoader: Unable to re-decode a buffer with different settings. Buffer has already been transferred."
-        );
       }
     }
     const geometryPending = this._runTask(buffer, taskConfig);
@@ -6821,12 +6938,16 @@ var MiniDRACOLoader = class extends Loader {
   }
   async _runTask(buffer, taskConfig) {
     if (this._workersAvailable()) {
-      try {
-        const raw = await this._decodeInWorker(buffer, taskConfig);
-        return this._buildGeometryFromRaw(raw, taskConfig);
-      } catch (error) {
-        if (error?.isDecodeError) throw error;
-        this._workersBroken = true;
+      if (buffer.byteLength > this.mainThreadByteThreshold) {
+        try {
+          const raw = await this._decodeInWorker(buffer, taskConfig);
+          return this._buildGeometryFromRaw(raw, taskConfig);
+        } catch (error) {
+          if (error?.isDecodeError) throw error;
+          this._workersBroken = true;
+        }
+      } else {
+        await Promise.resolve();
       }
     }
     return this._decodeBuffer(buffer, taskConfig);
@@ -6855,17 +6976,18 @@ var MiniDRACOLoader = class extends Loader {
       }
       const entry = { worker, pending: 0 };
       worker.onmessage = (event) => {
-        const { id, ok, indices, attributes, error } = event.data;
-        const task = this._tasks.get(id);
-        if (!task) return;
-        this._tasks.delete(id);
-        task.entry.pending--;
-        if (ok) {
-          task.resolve({ indices, attributes });
-        } else {
-          const decodeError = new Error(error);
-          decodeError.isDecodeError = true;
-          task.reject(decodeError);
+        for (const { id, ok, indices, attributes, error } of event.data.results) {
+          const task = this._tasks.get(id);
+          if (!task) continue;
+          this._tasks.delete(id);
+          task.entry.pending--;
+          if (ok) {
+            task.resolve({ indices, attributes });
+          } else {
+            const decodeError = new Error(error);
+            decodeError.isDecodeError = true;
+            task.reject(decodeError);
+          }
         }
       };
       worker.onerror = (event) => {
@@ -6873,7 +6995,7 @@ var MiniDRACOLoader = class extends Loader {
         for (const [id, task] of this._tasks) {
           if (task.entry.worker === worker) {
             this._tasks.delete(id);
-            task.reject(new Error(`MiniDRACOLoader worker failed: ${event.message ?? "unknown error"}`));
+            task.reject(new Error(`MinidracoLoader worker failed: ${event.message ?? "unknown error"}`));
           }
         }
       };
@@ -6885,22 +7007,56 @@ var MiniDRACOLoader = class extends Loader {
     return best;
   }
   _decodeInWorker(buffer, taskConfig) {
-    const entry = this._getWorker();
-    if (entry === null) {
-      return Promise.reject(new Error("MiniDRACOLoader: worker unavailable"));
-    }
     const id = this._taskId++;
     return new Promise((resolve, reject) => {
-      this._tasks.set(id, { resolve, reject, entry });
-      entry.pending++;
+      this._batch.push({ id, buffer, taskConfig, resolve, reject });
+      if (!this._batchScheduled) {
+        this._batchScheduled = true;
+        queueMicrotask(() => this._flushBatch());
+      }
+    });
+  }
+  _flushBatch() {
+    this._batchScheduled = false;
+    const batch = this._batch;
+    if (batch.length === 0) return;
+    this._batch = [];
+    while (this._workers.length < Math.min(this.workerLimit, batch.length) && this._getWorker() !== null) {
+    }
+    if (this._workersBroken || this._workers.length === 0) {
+      const error = new Error("MinidracoLoader: worker unavailable");
+      for (const task of batch) task.reject(error);
+      return;
+    }
+    batch.sort((a, b) => b.buffer.byteLength - a.buffer.byteLength);
+    let totalBytes = 0;
+    for (const task of batch) totalBytes += task.buffer.byteLength;
+    const averageBytes = totalBytes / batch.length;
+    const buckets = this._workers.map((entry) => ({
+      entry,
+      tasks: [],
+      bytes: entry.pending * averageBytes
+    }));
+    for (const task of batch) {
+      let best = buckets[0];
+      for (const bucket of buckets) if (bucket.bytes < best.bytes) best = bucket;
+      best.tasks.push(task);
+      best.bytes += task.buffer.byteLength;
+    }
+    for (const { entry, tasks } of buckets) {
+      if (tasks.length === 0) continue;
+      entry.pending += tasks.length;
+      for (const task of tasks) this._tasks.set(task.id, { resolve: task.resolve, reject: task.reject, entry });
       entry.worker.postMessage({
-        id,
-        buffer,
-        attributeIDs: taskConfig.attributeIDs,
-        attributeTypes: taskConfig.attributeTypes,
-        useUniqueIDs: taskConfig.useUniqueIDs
+        tasks: tasks.map((task) => ({
+          id: task.id,
+          buffer: task.buffer,
+          attributeIDs: task.taskConfig.attributeIDs,
+          attributeTypes: task.taskConfig.attributeTypes,
+          useUniqueIDs: task.taskConfig.useUniqueIDs
+        }))
       });
-    });
+    }
   }
   _buildGeometryFromRaw(raw, taskConfig) {
     const geometry = new BufferGeometry();
@@ -6964,6 +7120,6 @@ var MiniDRACOLoader = class extends Loader {
   }
 };
 export {
-  MiniDRACOLoader as DRACOLoader,
-  MiniDRACOLoader
+  MinidracoLoader as DRACOLoader,
+  MinidracoLoader
 };