minidraco 0.1.0 → 0.2.0

package/dist/index.js

@@ -200,6 +200,14 @@ var DecoderBuffer = class {
     this._pos += size;
     return result;
   }
+  // 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;
+  }
   startBitDecoding(decodeSize) {
     let outSize = 0;
     if (decodeSize) {
@@ -257,6 +265,48 @@ var DecoderBuffer = class {
   }
 };
 
+// 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/point_cloud/PointCloud.ts
 var NAMED_ATTRIBUTES_COUNT = 8;
 var PointCloud = class {
@@ -356,25 +406,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() {
@@ -1044,15 +1086,6 @@ var MeshAttributeCornerTable = class {
   leftMostCorner(v) {
     return this.vertex_to_left_most_corner_map_[v];
   }
-  face(corner) {
-    return this.corner_table_.face(corner);
-  }
-  firstCorner(faceIndex) {
-    return this.corner_table_.firstCorner(faceIndex);
-  }
-  allCorners(faceIndex) {
-    return this.corner_table_.allCorners(faceIndex);
-  }
   // --- Flat-array accessors: let DepthFirstTraverser avoid per-corner dispatch. ---
   cornerToVertexArray() {
     return this.corner_to_vertex_map_;
@@ -1067,7 +1100,8 @@ var MeshAttributeCornerTable = class {
       if (seamCorners.length === 0) {
         this._effectiveOpposite = base;
       } else {
-        const eff = base.slice(0, nc);
+        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;
         }
@@ -1101,9 +1135,6 @@ var MeshAttributeCornerTable = class {
     this._effectiveOpposite = other._effectiveOpposite;
     this._seamCorners = other._seamCorners;
   }
-  isDegenerated(faceIndex) {
-    return this.corner_table_.isDegenerated(faceIndex);
-  }
 };
 
 // src/decoder/core/DracoTypes.ts
@@ -1851,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) {
@@ -1997,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 {
@@ -2041,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;
@@ -2107,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_);
@@ -3528,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);
@@ -4574,15 +4657,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;
   }
@@ -4661,7 +4735,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();
@@ -4785,19 +4859,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() {
   }
@@ -4813,6 +4897,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;
@@ -4824,11 +4916,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];
@@ -4842,6 +4938,8 @@ var DepthFirstTraverser = class {
         numVisitedFaces++;
         const vertId = cornerToVertex[cornerId];
         if (vertId === kInvalidVertexIndex2) {
+          sequencer._numOutPoints = numOutPoints;
+          encodingData.numValues = numValues;
           return false;
         }
         if (!isVertexVisited[vertId]) {
@@ -4852,7 +4950,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];
@@ -4889,6 +4989,8 @@ var DepthFirstTraverser = class {
       }
     }
     this._numVisitedFaces = numVisitedFaces;
+    sequencer._numOutPoints = numOutPoints;
+    encodingData.numValues = numValues;
     return true;
   }
 };
@@ -5101,7 +5203,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();
@@ -5439,7 +5541,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 = [];
@@ -6303,7 +6405,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 = [];
   }
@@ -6327,7 +6429,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);
@@ -6369,34 +6471,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;
@@ -6515,45 +6620,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;
         }
       }
     }
@@ -6567,32 +6657,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;
   }
@@ -6650,9 +6739,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_;

package/dist/three.d.ts

@@ -113,8 +113,6 @@ declare class Mesh extends PointCloud {
         elementType: number;
     }[];
     constructor();
-    _ensureFaceCapacity(numFaces: number): void;
-    addFace(face: ArrayLike<number>): void;
     setNumFaces(numFaces: number): void;
     numFaces(): number;
     face(faceId: number): number[];
@@ -123,6 +121,12 @@ declare class Mesh extends PointCloud {
 
 type AttributeIDs = Record<string, number | string>;
 type AttributeTypes = Record<string, string>;
+interface MiniDRACOLoaderOptions {
+    manager?: LoadingManager;
+    workers?: boolean;
+    workerLimit?: number;
+    syncByteThreshold?: number;
+}
 interface TaskConfig {
     attributeIDs: AttributeIDs;
     attributeTypes: AttributeTypes;
@@ -142,10 +146,18 @@ interface WorkerEntry {
     worker: Worker;
     pending: number;
 }
+interface QueuedTask {
+    id: number;
+    buffer: ArrayBuffer;
+    taskConfig: TaskConfig;
+    resolve: (raw: RawGeometry) => void;
+    reject: (error: unknown) => void;
+}
 declare class MiniDRACOLoader extends Loader<BufferGeometry> {
     defaultAttributeIDs: AttributeIDs;
     defaultAttributeTypes: AttributeTypes;
     workerLimit: number;
+    syncByteThreshold: number;
     _workers: WorkerEntry[];
     _taskId: number;
     _tasks: Map<number, {
@@ -153,11 +165,17 @@ declare class MiniDRACOLoader extends Loader<BufferGeometry> {
         reject: (error: unknown) => void;
         entry: WorkerEntry;
     }>;
+    _batch: QueuedTask[];
+    _batchScheduled: boolean;
     _workersBroken: boolean;
-    constructor(manager?: LoadingManager);
-    setDecoderPath(_path?: string): this;
-    setDecoderConfig(_config?: object): this;
+    _workerUrl: string | URL | null;
+    _workerBlobUrl: string | null;
+    constructor(managerOrOptions?: LoadingManager | MiniDRACOLoaderOptions);
+    setWorkerUrl(url: string | URL | null): this;
+    setDecoderPath(_path?: unknown): this;
+    setDecoderConfig(_config?: unknown): this;
     setWorkerLimit(limit: number): this;
+    setWorkers(enabled: boolean): this;
     preload(): this;
     dispose(): this;
     load(url: string, onLoad: (geometry: BufferGeometry) => void, onProgress?: (event: ProgressEvent) => void, onError?: (err: unknown) => void): void;
@@ -166,12 +184,13 @@ declare class MiniDRACOLoader extends Loader<BufferGeometry> {
     decodeGeometry(buffer: ArrayBuffer, taskConfig: TaskConfig): Promise<BufferGeometry>;
     _runTask(buffer: ArrayBuffer, taskConfig: TaskConfig): Promise<BufferGeometry>;
     _workersAvailable(): boolean;
-    _getWorker(): WorkerEntry;
+    _getWorker(): WorkerEntry | null;
     _decodeInWorker(buffer: ArrayBuffer, taskConfig: TaskConfig): Promise<RawGeometry>;
+    _flushBatch(): void;
     _buildGeometryFromRaw(raw: RawGeometry, taskConfig: TaskConfig): BufferGeometry;
     _decodeBuffer(buffer: ArrayBuffer, taskConfig: TaskConfig): BufferGeometry;
     _buildGeometry(dracoGeometry: Mesh, taskConfig: TaskConfig): BufferGeometry;
     _assignVertexColorSpace(attribute: BufferAttribute, inputColorSpace: string): void;
 }
 
-export { type AttributeIDs, type AttributeTypes, MiniDRACOLoader as DRACOLoader, MiniDRACOLoader };
+export { type AttributeIDs, type AttributeTypes, MiniDRACOLoader as DRACOLoader, MiniDRACOLoader, type MiniDRACOLoaderOptions };