minidraco 0.1.0 → 0.2.0

package/dist/three.js

@@ -212,6 +212,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) {
@@ -269,6 +277,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 {
@@ -368,25 +418,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() {
@@ -1056,15 +1098,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_;
@@ -1079,7 +1112,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;
         }
@@ -1113,9 +1147,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
@@ -1863,15 +1894,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 +2037,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 +2084,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 +2207,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 +3624,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);
@@ -4586,15 +4669,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 +4747,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 +4871,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 +4909,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 +4928,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 +4950,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 +4962,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 +5001,8 @@ var DepthFirstTraverser = class {
       }
     }
     this._numVisitedFaces = numVisitedFaces;
+    sequencer._numOutPoints = numOutPoints;
+    encodingData.numValues = numValues;
     return true;
   }
 };
@@ -5113,7 +5215,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 +5553,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 = [];
@@ -6315,7 +6417,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 +6441,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 +6483,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 +6632,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 +6669,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 +6751,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_;
@@ -6687,6 +6782,7 @@ var decodeDracoMesh = (data) => {
 };
 
 // src/three/index.ts
+var isLoadingManager = (value) => typeof value?.itemStart === "function";
 var _taskCache = /* @__PURE__ */ new WeakMap();
 var _attributeTypeMap = {
   POSITION: Type.POSITION,
@@ -6708,14 +6804,31 @@ var MiniDRACOLoader = class extends Loader {
   defaultAttributeIDs;
   defaultAttributeTypes;
   workerLimit;
+  // Opt-in (0 = disabled): buffers at or below this size decode synchronously
+  // 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.
+  syncByteThreshold;
   _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;
-  constructor(manager) {
-    super(manager);
+  _workerUrl;
+  // Same-origin blob bootstrap used when the worker asset lives on a CDN
+  // origin (created lazily, revoked on dispose).
+  _workerBlobUrl;
+  // 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",
@@ -6728,14 +6841,31 @@ var MiniDRACOLoader = class extends Loader {
       color: "Float32Array",
       uv: "Float32Array"
     };
-    this.workerLimit = 4;
+    this.workerLimit = options.workers === false ? 0 : options.workerLimit ?? 4;
+    this.syncByteThreshold = options.syncByteThreshold ?? 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;
+  }
+  // Overrides where the decode worker is loaded from. Normally unnecessary:
+  // the worker resolves through `new URL('./worker.js', import.meta.url)`
+  // (bundlers emit it as a hashed asset), and CDN origins are handled by the
+  // blob bootstrap in _getWorker.
+  setWorkerUrl(url) {
+    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;
   }
@@ -6746,14 +6876,35 @@ 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);
+      this._workerBlobUrl = null;
+    }
     return this;
   }
   load(url, onLoad, onProgress, onError) {
@@ -6791,10 +6942,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);
@@ -6803,12 +6950,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.syncByteThreshold) {
+        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);
@@ -6817,21 +6968,38 @@ var MiniDRACOLoader = class extends Loader {
     return this.workerLimit > 0 && typeof Worker !== "undefined" && !this._workersBroken;
   }
   _getWorker() {
+    if (this._workersBroken) return null;
     if (this._workers.length < this.workerLimit) {
-      const worker = new Worker(new URL("./worker.js", import.meta.url), { type: "module" });
+      const workerUrl = this._workerUrl ?? new URL("./worker.js", import.meta.url);
+      let worker;
+      try {
+        worker = new Worker(workerUrl, { type: "module" });
+      } catch {
+        try {
+          if (this._workerBlobUrl === null) {
+            const bootstrap = `import ${JSON.stringify(String(workerUrl))};`;
+            this._workerBlobUrl = URL.createObjectURL(new Blob([bootstrap], { type: "text/javascript" }));
+          }
+          worker = new Worker(this._workerBlobUrl, { type: "module" });
+        } catch {
+          this._workersBroken = true;
+          return null;
+        }
+      }
       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) => {
@@ -6851,19 +7019,56 @@ var MiniDRACOLoader = class extends Loader {
     return best;
   }
   _decodeInWorker(buffer, taskConfig) {
-    const entry = this._getWorker();
     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();