minidraco 0.3.0 → 0.5.0

package/dist/three.js

@@ -271,6 +271,90 @@ var Mesh = class extends PointCloud {
   }
 };
 
+// src/decoder/core/ScratchArena.ts
+var MAX_CLASS = 28;
+var freeInt32 = [];
+var freeUint32 = [];
+var freeUint8 = [];
+for (let i = 0; i <= MAX_CLASS; ++i) {
+  freeInt32.push([]);
+  freeUint32.push([]);
+  freeUint8.push([]);
+}
+var borrowedInt32 = [];
+var borrowedUint32 = [];
+var borrowedUint8 = [];
+var sizeClass = (size) => size <= 1 ? 0 : 32 - Math.clz32(size - 1);
+var takeInt32 = (size) => {
+  const k = sizeClass(size);
+  if (k > MAX_CLASS) return new Int32Array(size);
+  const bucket = freeInt32[k];
+  let pooled = bucket.length > 0 ? bucket.pop() : new Int32Array(size);
+  if (pooled.length < size) pooled = new Int32Array(1 << k);
+  borrowedInt32.push(pooled);
+  return pooled.length === size ? pooled : pooled.subarray(0, size);
+};
+var takeUint32 = (size) => {
+  const k = sizeClass(size);
+  if (k > MAX_CLASS) return new Uint32Array(size);
+  const bucket = freeUint32[k];
+  let pooled = bucket.length > 0 ? bucket.pop() : new Uint32Array(size);
+  if (pooled.length < size) pooled = new Uint32Array(1 << k);
+  borrowedUint32.push(pooled);
+  return pooled.length === size ? pooled : pooled.subarray(0, size);
+};
+var byteCapacity = (size) => size < 8 ? 8 : size + 7 & ~7;
+var takeUint8 = (size) => {
+  const capacity = byteCapacity(size);
+  const k = sizeClass(capacity);
+  if (k > MAX_CLASS) return new Uint8Array(capacity);
+  const bucket = freeUint8[k];
+  let pooled = bucket.length > 0 ? bucket.pop() : new Uint8Array(capacity);
+  if (pooled.length < size) pooled = new Uint8Array(1 << k);
+  borrowedUint8.push(pooled);
+  return pooled.length === size ? pooled : pooled.subarray(0, size);
+};
+var scratchInt32 = (size) => takeInt32(size);
+var scratchInt32Filled = (size, value) => {
+  const view = takeInt32(size);
+  view.fill(value);
+  return view;
+};
+var scratchUint32 = (size) => takeUint32(size);
+var scratchUint32Zeroed = (size) => {
+  const view = takeUint32(size);
+  view.fill(0);
+  return view;
+};
+var scratchUint8 = (size) => takeUint8(size);
+var scratchUint8Zeroed = (size) => {
+  const view = takeUint8(size);
+  view.fill(0);
+  return view;
+};
+var scratchUint8Filled = (size, value) => {
+  const view = takeUint8(size);
+  view.fill(value);
+  return view;
+};
+var releaseScratch = () => {
+  for (let i = 0; i < borrowedInt32.length; ++i) {
+    const buffer = borrowedInt32[i];
+    freeInt32[sizeClass(buffer.length)].push(buffer);
+  }
+  for (let i = 0; i < borrowedUint32.length; ++i) {
+    const buffer = borrowedUint32[i];
+    freeUint32[sizeClass(buffer.length)].push(buffer);
+  }
+  for (let i = 0; i < borrowedUint8.length; ++i) {
+    const buffer = borrowedUint8[i];
+    freeUint8[sizeClass(buffer.length)].push(buffer);
+  }
+  borrowedInt32.length = 0;
+  borrowedUint32.length = 0;
+  borrowedUint8.length = 0;
+};
+
 // src/decoder/core/DataBuffer.ts
 var DataBuffer = class {
   _data;
@@ -295,6 +379,15 @@ var DataBuffer = class {
   resize(newSize) {
     this._resize(newSize);
   }
+  // Replaces the contents with a decode-scoped scratch buffer of exactly
+  // `size` bytes; the previous contents are dropped and the new ones are
+  // arbitrary, so every byte must be written before it is read. Only for
+  // buffers that never outlive the decode (see ScratchArena) — the portable
+  // attributes the integer decoders build and discard per attribute are the
+  // one caller, and their per-primitive allocation showed up in profiles.
+  adoptScratch(size) {
+    this._data = scratchUint8(size);
+  }
   write(bytePos, inArray, dataSize) {
     if (inArray instanceof Uint8Array) {
       this._data.set(inArray.length === dataSize ? inArray : inArray.subarray(0, dataSize), bytePos);
@@ -384,6 +477,19 @@ var PointAttribute = class extends GeometryAttribute {
     this._numUniqueEntries = numAttributeValues;
     return true;
   }
+  // Like reset(), but backs the attribute with decode-scoped scratch memory.
+  // Only valid for attributes that never escape the decode and whose every
+  // byte is written before it is read (see DataBuffer.adoptScratch).
+  resetScratch(numAttributeValues) {
+    if (this._attributeBuffer === null) {
+      this._attributeBuffer = new DataBuffer();
+    }
+    const entrySize = dataTypeLength(this.dataType) * this.numComponents;
+    this._attributeBuffer.adoptScratch(numAttributeValues * entrySize);
+    this.resetBuffer(this._attributeBuffer, entrySize, 0);
+    this._numUniqueEntries = numAttributeValues;
+    return true;
+  }
   get size() {
     return this._numUniqueEntries;
   }
@@ -426,6 +532,20 @@ var PointAttribute = class extends GeometryAttribute {
     this._identityMapping = false;
     this._indicesMap = new Uint32Array(numPoints);
   }
+  // Adopts an already-computed map, shared with other attributes of the same
+  // mesh. The map must be treated as read-only from here on (reads go through
+  // mappedIndex/extractTo; copyFrom slices).
+  setExplicitMappingShared(map) {
+    this._identityMapping = false;
+    this._indicesMap = map;
+  }
+  // Like setExplicitMappingUnfilled, but from decode-scoped scratch. Only for
+  // attributes that never escape the decode (see ScratchArena) -- the portable
+  // attributes the sequential decoders build and discard.
+  setExplicitMappingScratch(numPoints) {
+    this._identityMapping = false;
+    this._indicesMap = scratchUint32(numPoints);
+  }
   setAttributeTransformData(transformData) {
     this._attributeTransformData = transformData;
   }
@@ -921,48 +1041,6 @@ 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/compression/config/CompressionShared.ts
 var kDracoPointCloudBitstreamVersionMajor = 2;
 var kDracoPointCloudBitstreamVersionMinor = 3;
@@ -1194,82 +1272,705 @@ var MetadataDecoder = class {
   }
 };
 
-// src/decoder/compression/point_cloud/PointCloudDecoder.ts
-var PointCloudDecoder = class _PointCloudDecoder {
-  _pointCloud;
-  _buffer;
-  _versionMajor;
-  _versionMinor;
-  _options;
-  _attributesDecoders;
-  _attributeToDecoderMap;
+// src/decoder/compression/entropy/ANSCoding.ts
+var ANS_P8_PRECISION = 256;
+var ANS_L_BASE = 4096;
+var ANS_IO_BASE = 256;
+var COARSE_STREAM_FACTOR = 8;
+var COARSE_BUCKET_BITS = 8;
+function memGetLe16(buf, offset) {
+  return buf[offset] | buf[offset + 1] << 8;
+}
+function memGetLe24(buf, offset) {
+  return buf[offset] | buf[offset + 1] << 8 | buf[offset + 2] << 16;
+}
+function memGetLe32(buf, offset) {
+  return buf[offset] | buf[offset + 1] << 8 | buf[offset + 2] << 16 | buf[offset + 3] << 24 >>> 0;
+}
+var AnsDecoder = class {
+  buf;
+  bufOffset;
+  // First valid byte of this decoder's slice within buf: init is passed
+  // absolute offsets into the source buffer to avoid a subarray allocation.
+  bufStart;
+  state;
   constructor() {
-    this._pointCloud = null;
-    this._buffer = null;
-    this._versionMajor = 0;
-    this._versionMinor = 0;
-    this._options = null;
-    this._attributesDecoders = [];
-    this._attributeToDecoderMap = [];
+    this.buf = null;
+    this.bufOffset = 0;
+    this.bufStart = 0;
+    this.state = 0;
   }
-  getGeometryType() {
-    return EncodedGeometryType.POINT_CLOUD;
+};
+function ansReadInit(ans, buf, offset, base = 0) {
+  if (offset - base < 1) {
+    return 1;
   }
-  // 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);
+  ans.buf = buf;
+  ans.bufStart = base;
+  const x = buf[offset - 1] >> 6;
+  if (x === 0) {
+    ans.bufOffset = offset - 1;
+    ans.state = buf[offset - 1] & 63;
+  } else if (x === 1) {
+    if (offset - base < 2) {
+      return 1;
     }
-    for (let i = 0; i < 5; i++) {
-      outHeader.dracoString[i] = bytes[i];
+    ans.bufOffset = offset - 2;
+    ans.state = memGetLe16(buf, offset - 2) & 16383;
+  } else if (x === 2) {
+    if (offset - base < 3) {
+      return 1;
     }
-    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.");
+    ans.bufOffset = offset - 3;
+    ans.state = memGetLe24(buf, offset - 3) & 4194303;
+  } else {
+    return 1;
+  }
+  ans.state += ANS_L_BASE;
+  if (ans.state >= ANS_L_BASE * ANS_IO_BASE) {
+    return 1;
+  }
+  return 0;
+}
+function ansReadEnd(ans) {
+  return ans.state === ANS_L_BASE;
+}
+var tablePool = [];
+var acquirePooled = (Ctor, size) => {
+  for (let i = tablePool.length - 1; i >= 0; --i) {
+    const buf = tablePool[i];
+    if (buf.constructor === Ctor && buf.length >= size) {
+      tablePool[i] = tablePool[tablePool.length - 1];
+      tablePool.pop();
+      return buf;
     }
-    const versionMajor = buffer.decodeUint8();
-    if (versionMajor === void 0) {
-      return new Status(StatusCode.IO_ERROR, kIoErrorMsg);
+  }
+  return new Ctor(size);
+};
+var RAnsDecoder = class {
+  ransPrecisionBits;
+  ransPrecision;
+  ransPrecisionMask;
+  lRansBase;
+  lutTable;
+  probTable;
+  cumProbTable;
+  // Short-stream mode (see ransBuildLookUpTable): no full-precision lut; a
+  // 256-entry bucket table narrows each lookup to a symbol range that a short
+  // cumProb scan finishes. cumProbTable then carries one extra trailing entry
+  // (== ransPrecision) so the scan needs no bounds check.
+  coarse;
+  bucketShift;
+  bucketTable;
+  buf;
+  bufOffset;
+  // First valid byte of this decoder's slice within buf (absolute offsets,
+  // see AnsDecoder.bufStart).
+  bufStart;
+  state;
+  constructor(ransPrecisionBits) {
+    this.ransPrecisionBits = ransPrecisionBits;
+    this.ransPrecision = 1 << ransPrecisionBits;
+    this.ransPrecisionMask = this.ransPrecision - 1;
+    this.lRansBase = this.ransPrecision * 4;
+    this.lutTable = null;
+    this.probTable = null;
+    this.cumProbTable = null;
+    this.coarse = false;
+    this.bucketShift = 0;
+    this.bucketTable = null;
+    this.buf = null;
+    this.bufOffset = 0;
+    this.bufStart = 0;
+    this.state = 0;
+  }
+  // offset is the absolute end of the encoded bytes within buf and base the
+  // absolute start (offset - base = encoded length). Passing the source
+  // buffer with absolute offsets avoids a subarray allocation per init.
+  // Returns 0 on success, non-zero on error.
+  readInit(buf, offset, base = 0) {
+    if (offset - base < 1) {
+      return 1;
     }
-    outHeader.versionMajor = versionMajor;
-    const versionMinor = buffer.decodeUint8();
-    if (versionMinor === void 0) {
-      return new Status(StatusCode.IO_ERROR, kIoErrorMsg);
+    this.buf = buf;
+    this.bufStart = base;
+    const x = buf[offset - 1] >> 6;
+    if (x === 0) {
+      this.bufOffset = offset - 1;
+      this.state = buf[offset - 1] & 63;
+    } else if (x === 1) {
+      if (offset - base < 2) {
+        return 1;
+      }
+      this.bufOffset = offset - 2;
+      this.state = memGetLe16(buf, offset - 2) & 16383;
+    } else if (x === 2) {
+      if (offset - base < 3) {
+        return 1;
+      }
+      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 {
+      return 1;
     }
-    outHeader.versionMinor = versionMinor;
-    const encoderType = buffer.decodeUint8();
-    if (encoderType === void 0) {
-      return new Status(StatusCode.IO_ERROR, kIoErrorMsg);
+    this.state += this.lRansBase;
+    if (this.state >= this.lRansBase * ANS_IO_BASE) {
+      return 1;
     }
-    outHeader.encoderType = encoderType;
-    const encoderMethod = buffer.decodeUint8();
-    if (encoderMethod === void 0) {
-      return new Status(StatusCode.IO_ERROR, kIoErrorMsg);
+    return 0;
+  }
+  readEnd() {
+    if (this.lutTable !== null) {
+      tablePool.push(this.lutTable);
+      this.lutTable = null;
     }
-    outHeader.encoderMethod = encoderMethod;
-    const flags = buffer.decodeUint16();
-    if (flags === void 0) {
-      return new Status(StatusCode.IO_ERROR, kIoErrorMsg);
+    if (this.probTable !== null) {
+      tablePool.push(this.probTable);
+      this.probTable = null;
     }
-    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 (this.cumProbTable !== null) {
+      tablePool.push(this.cumProbTable);
+      this.cumProbTable = null;
     }
-    if (header.encoderType !== this.getGeometryType()) {
-      return new Status(StatusCode.DRACO_ERROR, "Using incompatible decoder for the input geometry.");
+    if (this.bucketTable !== null) {
+      tablePool.push(this.bucketTable);
+      this.bucketTable = null;
     }
-    this._versionMajor = header.versionMajor;
+    return this.state === this.lRansBase;
+  }
+  ransRead() {
+    const buf = this.buf;
+    const lRansBase = this.lRansBase;
+    let state = this.state;
+    let bufOffset = this.bufOffset;
+    const bufStart = this.bufStart;
+    while (state < lRansBase && bufOffset > bufStart) {
+      state = state << 8 | buf[--bufOffset];
+    }
+    const quo = state >>> this.ransPrecisionBits;
+    const rem = state & this.ransPrecisionMask;
+    let symbol;
+    if (this.coarse) {
+      const cumProbTable = this.cumProbTable;
+      symbol = this.bucketTable[rem >> this.bucketShift];
+      while (cumProbTable[symbol + 1] <= rem) symbol++;
+    } else {
+      symbol = this.lutTable[rem];
+    }
+    this.state = quo * this.probTable[symbol] + rem - this.cumProbTable[symbol];
+    this.bufOffset = bufOffset;
+    return symbol;
+  }
+  // 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) {
+    if (this.coarse) {
+      this._decodeSymbolsCoarse(out, count);
+      return;
+    }
+    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;
+  }
+  // Short-stream loop: bucket table + cumProb scan instead of the full lut.
+  // Same state arithmetic as the lut loops, so the output is identical.
+  _decodeSymbolsCoarse(out, count) {
+    const buf = this.buf;
+    const lRansBase = this.lRansBase;
+    const ransPrecisionBits = this.ransPrecisionBits;
+    const ransPrecisionMask = this.ransPrecisionMask;
+    const probTable = this.probTable;
+    const cumProbTable = this.cumProbTable;
+    const bucketTable = this.bucketTable;
+    const bucketShift = this.bucketShift;
+    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;
+      let symbol = bucketTable[rem >> bucketShift];
+      while (cumProbTable[symbol + 1] <= rem) symbol++;
+      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 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;
+  }
+  // Builds the decoding tables. Returns false on bad input data.
+  //
+  // expectedCount is how many symbols the caller will decode from this stream.
+  // The full lut has ransPrecision (>= 4096) entries, and a primitive-heavy
+  // file builds thousands of them to decode a few dozen symbols each -- on such
+  // files the table builds cost more than the decodes. Short streams therefore
+  // get a coarse 256-entry bucket table (symbol at the start of each
+  // precision/256-wide bucket) and finish each lookup with a scan of the
+  // cumulative probabilities; long streams keep the exact lut, whose per-symbol
+  // cost is lower.
+  ransBuildLookUpTable(tokenProbs, numSymbols, expectedCount = 2147483647) {
+    const ransPrecision = this.ransPrecision;
+    const coarse = numSymbols <= 65535 && expectedCount * COARSE_STREAM_FACTOR < ransPrecision;
+    this.coarse = coarse;
+    const probTable = acquirePooled(Uint32Array, numSymbols);
+    const cumProbTable = acquirePooled(Uint32Array, numSymbols + 1);
+    this.probTable = probTable;
+    this.cumProbTable = cumProbTable;
+    let cumProb = 0;
+    if (coarse) {
+      this.lutTable = null;
+      for (let i = 0; i < numSymbols; ++i) {
+        const prob = tokenProbs[i];
+        probTable[i] = prob;
+        cumProbTable[i] = cumProb;
+        cumProb += prob;
+        if (cumProb > ransPrecision) {
+          return false;
+        }
+      }
+      if (cumProb !== ransPrecision) {
+        return false;
+      }
+      cumProbTable[numSymbols] = ransPrecision;
+      const bucketShift = this.ransPrecisionBits - COARSE_BUCKET_BITS;
+      const bucketTable = acquirePooled(Uint16Array, 1 << COARSE_BUCKET_BITS);
+      this.bucketShift = bucketShift;
+      this.bucketTable = bucketTable;
+      let symbol = 0;
+      for (let b = 0; b < 1 << COARSE_BUCKET_BITS; ++b) {
+        const rem = b << bucketShift;
+        while (cumProbTable[symbol + 1] <= rem) symbol++;
+        bucketTable[b] = symbol;
+      }
+      return true;
+    }
+    const LutArray = numSymbols <= 256 ? Uint8Array : numSymbols <= 65536 ? Uint16Array : Uint32Array;
+    const lutTable = acquirePooled(LutArray, ransPrecision);
+    this.lutTable = lutTable;
+    let actProb = 0;
+    for (let i = 0; i < numSymbols; ++i) {
+      const prob = tokenProbs[i];
+      probTable[i] = prob;
+      cumProbTable[i] = cumProb;
+      cumProb += prob;
+      if (cumProb > ransPrecision) {
+        return false;
+      }
+      if (prob < 32) {
+        for (let j = actProb; j < cumProb; ++j) {
+          lutTable[j] = i;
+        }
+      } else {
+        lutTable.fill(i, actProb, cumProb);
+      }
+      actProb = cumProb;
+    }
+    if (cumProb !== ransPrecision) {
+      return false;
+    }
+    cumProbTable[numSymbols] = ransPrecision;
+    return true;
+  }
+};
+function ransDecodeSymbolsPairU8(a, outA, countA, b, outB, countB) {
+  const lutA = a.lutTable;
+  const lutB = b.lutTable;
+  const bufA = a.buf;
+  const bufB = b.buf;
+  const probA = a.probTable;
+  const probB = b.probTable;
+  const cumA = a.cumProbTable;
+  const cumB = b.cumProbTable;
+  const lBaseA = a.lRansBase;
+  const lBaseB = b.lRansBase;
+  const bitsA = a.ransPrecisionBits;
+  const bitsB = b.ransPrecisionBits;
+  const maskA = a.ransPrecisionMask;
+  const maskB = b.ransPrecisionMask;
+  const startA = a.bufStart;
+  const startB = b.bufStart;
+  let stateA = a.state;
+  let stateB = b.state;
+  let offA = a.bufOffset;
+  let offB = b.bufOffset;
+  const shared = countA < countB ? countA : countB;
+  for (let i = 0; i < shared; ++i) {
+    while (stateA < lBaseA && offA > startA) {
+      stateA = stateA << 8 | bufA[--offA];
+    }
+    while (stateB < lBaseB && offB > startB) {
+      stateB = stateB << 8 | bufB[--offB];
+    }
+    const remA = stateA & maskA;
+    const remB = stateB & maskB;
+    const symA = lutA[remA];
+    const symB = lutB[remB];
+    outA[i] = symA;
+    outB[i] = symB;
+    stateA = (stateA >>> bitsA) * probA[symA] + remA - cumA[symA];
+    stateB = (stateB >>> bitsB) * probB[symB] + remB - cumB[symB];
+  }
+  a.state = stateA;
+  a.bufOffset = offA;
+  b.state = stateB;
+  b.bufOffset = offB;
+  if (shared < countA) {
+    a.decodeSymbols(outA.subarray(shared), countA - shared);
+  }
+  if (shared < countB) {
+    b.decodeSymbols(outB.subarray(shared), countB - shared);
+  }
+}
+function ransDecodeSymbolsPair(a, outA, countA, b, outB, countB) {
+  const lutA = a.lutTable;
+  const lutB = b.lutTable;
+  if (lutA instanceof Uint8Array && lutB instanceof Uint8Array) {
+    ransDecodeSymbolsPairU8(a, outA, countA, b, outB, countB);
+  } else if (lutA instanceof Uint16Array && lutB instanceof Uint16Array) {
+    ransDecodeSymbolsPairU16(a, outA, countA, b, outB, countB);
+  } else if (lutA instanceof Uint8Array && lutB instanceof Uint16Array) {
+    ransDecodeSymbolsPairU8U16(a, outA, countA, b, outB, countB);
+  } else if (lutA instanceof Uint16Array && lutB instanceof Uint8Array) {
+    ransDecodeSymbolsPairU8U16(b, outB, countB, a, outA, countA);
+  } else {
+    a.decodeSymbols(outA, countA);
+    b.decodeSymbols(outB, countB);
+  }
+}
+function ransDecodeSymbolsPairU16(a, outA, countA, b, outB, countB) {
+  const lutA = a.lutTable;
+  const lutB = b.lutTable;
+  const bufA = a.buf;
+  const bufB = b.buf;
+  const probA = a.probTable;
+  const probB = b.probTable;
+  const cumA = a.cumProbTable;
+  const cumB = b.cumProbTable;
+  const lBaseA = a.lRansBase;
+  const lBaseB = b.lRansBase;
+  const bitsA = a.ransPrecisionBits;
+  const bitsB = b.ransPrecisionBits;
+  const maskA = a.ransPrecisionMask;
+  const maskB = b.ransPrecisionMask;
+  const startA = a.bufStart;
+  const startB = b.bufStart;
+  let stateA = a.state;
+  let stateB = b.state;
+  let offA = a.bufOffset;
+  let offB = b.bufOffset;
+  const shared = countA < countB ? countA : countB;
+  for (let i = 0; i < shared; ++i) {
+    while (stateA < lBaseA && offA > startA) {
+      stateA = stateA << 8 | bufA[--offA];
+    }
+    while (stateB < lBaseB && offB > startB) {
+      stateB = stateB << 8 | bufB[--offB];
+    }
+    const remA = stateA & maskA;
+    const remB = stateB & maskB;
+    const symA = lutA[remA];
+    const symB = lutB[remB];
+    outA[i] = symA;
+    outB[i] = symB;
+    stateA = (stateA >>> bitsA) * probA[symA] + remA - cumA[symA];
+    stateB = (stateB >>> bitsB) * probB[symB] + remB - cumB[symB];
+  }
+  a.state = stateA;
+  a.bufOffset = offA;
+  b.state = stateB;
+  b.bufOffset = offB;
+  if (shared < countA) {
+    a.decodeSymbols(outA.subarray(shared), countA - shared);
+  }
+  if (shared < countB) {
+    b.decodeSymbols(outB.subarray(shared), countB - shared);
+  }
+}
+function ransDecodeSymbolsPairU8U16(a, outA, countA, b, outB, countB) {
+  const lutA = a.lutTable;
+  const lutB = b.lutTable;
+  const bufA = a.buf;
+  const bufB = b.buf;
+  const probA = a.probTable;
+  const probB = b.probTable;
+  const cumA = a.cumProbTable;
+  const cumB = b.cumProbTable;
+  const lBaseA = a.lRansBase;
+  const lBaseB = b.lRansBase;
+  const bitsA = a.ransPrecisionBits;
+  const bitsB = b.ransPrecisionBits;
+  const maskA = a.ransPrecisionMask;
+  const maskB = b.ransPrecisionMask;
+  const startA = a.bufStart;
+  const startB = b.bufStart;
+  let stateA = a.state;
+  let stateB = b.state;
+  let offA = a.bufOffset;
+  let offB = b.bufOffset;
+  const shared = countA < countB ? countA : countB;
+  for (let i = 0; i < shared; ++i) {
+    while (stateA < lBaseA && offA > startA) {
+      stateA = stateA << 8 | bufA[--offA];
+    }
+    while (stateB < lBaseB && offB > startB) {
+      stateB = stateB << 8 | bufB[--offB];
+    }
+    const remA = stateA & maskA;
+    const remB = stateB & maskB;
+    const symA = lutA[remA];
+    const symB = lutB[remB];
+    outA[i] = symA;
+    outB[i] = symB;
+    stateA = (stateA >>> bitsA) * probA[symA] + remA - cumA[symA];
+    stateB = (stateB >>> bitsB) * probB[symB] + remB - cumB[symB];
+  }
+  a.state = stateA;
+  a.bufOffset = offA;
+  b.state = stateB;
+  b.bufOffset = offB;
+  if (shared < countA) {
+    a.decodeSymbols(outA.subarray(shared), countA - shared);
+  }
+  if (shared < countB) {
+    b.decodeSymbols(outB.subarray(shared), countB - shared);
+  }
+}
+function ransDecodeSymbolsTrioU8(a, outA, countA, b, outB, countB, c, outC, countC) {
+  const lutA = a.lutTable;
+  const lutB = b.lutTable;
+  const lutC = c.lutTable;
+  const bufA = a.buf;
+  const bufB = b.buf;
+  const bufC = c.buf;
+  const probA = a.probTable;
+  const probB = b.probTable;
+  const probC = c.probTable;
+  const cumA = a.cumProbTable;
+  const cumB = b.cumProbTable;
+  const cumC = c.cumProbTable;
+  const lBaseA = a.lRansBase;
+  const lBaseB = b.lRansBase;
+  const lBaseC = c.lRansBase;
+  const bitsA = a.ransPrecisionBits;
+  const bitsB = b.ransPrecisionBits;
+  const bitsC = c.ransPrecisionBits;
+  const maskA = a.ransPrecisionMask;
+  const maskB = b.ransPrecisionMask;
+  const maskC = c.ransPrecisionMask;
+  const startA = a.bufStart;
+  const startB = b.bufStart;
+  const startC = c.bufStart;
+  let stateA = a.state;
+  let stateB = b.state;
+  let stateC = c.state;
+  let offA = a.bufOffset;
+  let offB = b.bufOffset;
+  let offC = c.bufOffset;
+  let shared = countA < countB ? countA : countB;
+  if (countC < shared) shared = countC;
+  for (let i = 0; i < shared; ++i) {
+    while (stateA < lBaseA && offA > startA) {
+      stateA = stateA << 8 | bufA[--offA];
+    }
+    while (stateB < lBaseB && offB > startB) {
+      stateB = stateB << 8 | bufB[--offB];
+    }
+    while (stateC < lBaseC && offC > startC) {
+      stateC = stateC << 8 | bufC[--offC];
+    }
+    const remA = stateA & maskA;
+    const remB = stateB & maskB;
+    const remC = stateC & maskC;
+    const symA = lutA[remA];
+    const symB = lutB[remB];
+    const symC = lutC[remC];
+    outA[i] = symA;
+    outB[i] = symB;
+    outC[i] = symC;
+    stateA = (stateA >>> bitsA) * probA[symA] + remA - cumA[symA];
+    stateB = (stateB >>> bitsB) * probB[symB] + remB - cumB[symB];
+    stateC = (stateC >>> bitsC) * probC[symC] + remC - cumC[symC];
+  }
+  a.state = stateA;
+  a.bufOffset = offA;
+  b.state = stateB;
+  b.bufOffset = offB;
+  c.state = stateC;
+  c.bufOffset = offC;
+  const restA = countA - shared;
+  const restB = countB - shared;
+  const restC = countC - shared;
+  const tails = [];
+  if (restA > 0) tails.push([a, outA.subarray(shared), restA]);
+  if (restB > 0) tails.push([b, outB.subarray(shared), restB]);
+  if (restC > 0) tails.push([c, outC.subarray(shared), restC]);
+  if (tails.length === 2) {
+    ransDecodeSymbolsPairU8(tails[0][0], tails[0][1], tails[0][2], tails[1][0], tails[1][1], tails[1][2]);
+  } else {
+    for (const [decoder, out, count] of tails) {
+      decoder.decodeSymbols(out, count);
+    }
+  }
+}
+
+// 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 = [];
+  }
+  getGeometryType() {
+    return EncodedGeometryType.POINT_CLOUD;
+  }
+  // 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();
+  }
+  // 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;
@@ -1388,17 +2089,40 @@ var PointCloudDecoder = class _PointCloudDecoder {
     return true;
   }
   decodeAllAttributes() {
-    for (let i = 0; i < this._attributesDecoders.length; i++) {
-      if (!this._attributesDecoders[i].decodeAttributes(this._buffer)) {
+    const decoders = this._attributesDecoders;
+    for (let i2 = 0; i2 < decoders.length; i2++) {
+      if (!decoders[i2].decodeAttributesParse(this._buffer)) {
         return false;
       }
     }
-    return true;
-  }
-  onAttributesDecoded() {
-    return true;
-  }
-  _decodeMetadata() {
+    const pending = [];
+    for (let i2 = 0; i2 < decoders.length; i2++) {
+      decoders[i2].collectPendingSymbolStreams(pending);
+    }
+    const paired = pending.filter((stream) => !stream.ans.coarse);
+    let i = 0;
+    for (; i + 1 < paired.length; i += 2) {
+      const a = paired[i];
+      const b = paired[i + 1];
+      ransDecodeSymbolsPair(a.ans, a.out, a.count, b.ans, b.out, b.count);
+    }
+    if (i < paired.length) {
+      paired[i].ans.decodeSymbols(paired[i].out, paired[i].count);
+    }
+    for (const stream of pending) {
+      if (stream.ans.coarse) stream.ans.decodeSymbols(stream.out, stream.count);
+    }
+    for (let k = 0; k < decoders.length; k++) {
+      if (!decoders[k].decodeAttributesFinish()) {
+        return false;
+      }
+    }
+    return true;
+  }
+  onAttributesDecoded() {
+    return true;
+  }
+  _decodeMetadata() {
     const metadataDecoder = new MetadataDecoder();
     if (!metadataDecoder.skipGeometryMetadata(this._buffer)) {
       return new Status(StatusCode.DRACO_ERROR, "Failed to decode metadata.");
@@ -1457,46 +2181,62 @@ var MeshAttributeCornerTable = class {
   no_interior_seams_;
   corner_to_vertex_map_;
   vertex_to_left_most_corner_map_;
-  vertex_to_attribute_entry_id_map_;
+  // Attribute-vertex count. C++ keeps a vertex -> attribute-entry map here, but
+  // the decoder only ever reads its size, so track the count directly instead
+  // of allocating an Int32Array per attribute corner table.
+  num_attribute_vertices_;
   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.
+  // Preallocated to its exact upper bound (2 per seam edge) by the caller via
+  // reserveSeamEdges -- a plain array grown by push() was measurable on
+  // seam-heavy files.
   _seamCorners;
+  _numSeamCorners;
   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.num_attribute_vertices_ = 0;
     this.corner_table_ = null;
     this._effectiveOpposite = null;
     this._seamCorners = [];
+    this._numSeamCorners = 0;
   }
   initEmpty(table) {
     if (table === null) {
       return false;
     }
-    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.is_edge_on_seam_ = scratchUint8Zeroed(table.numCorners());
+    this.is_vertex_on_seam_ = scratchUint8Zeroed(table.numVertices());
+    this.corner_to_vertex_map_ = scratchInt32Filled(table.numCorners(), kInvalidVertexIndex);
+    this.num_attribute_vertices_ = 0;
     this.vertex_to_left_most_corner_map_ = [];
     this._effectiveOpposite = null;
     this._seamCorners = [];
+    this._numSeamCorners = 0;
     this.corner_table_ = table;
     this.no_interior_seams_ = true;
     return true;
   }
+  // Sizes the seam-corner list for numSeamEdges upcoming addSeamEdge calls
+  // (each adds at most two corners). Decode-scoped scratch.
+  reserveSeamEdges(numSeamEdges) {
+    this._seamCorners = scratchInt32(numSeamEdges * 2);
+    this._numSeamCorners = 0;
+  }
   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_;
+    const seamCorners = this._seamCorners;
     isEdge[c] = 1;
-    this._seamCorners.push(c);
+    seamCorners[this._numSeamCorners++] = 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;
@@ -1504,7 +2244,7 @@ var MeshAttributeCornerTable = class {
     if (oppCorner !== kInvalidCornerIndex) {
       this.no_interior_seams_ = false;
       isEdge[oppCorner] = 1;
-      this._seamCorners.push(oppCorner);
+      seamCorners[this._numSeamCorners++] = 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;
@@ -1519,12 +2259,12 @@ var MeshAttributeCornerTable = class {
     const ct = this.corner_table_;
     const numCorners = ct.numCorners();
     const numBaseVertices = ct.numVertices();
-    const leftMostMap = new Int32Array(numCorners);
+    const leftMostMap = scratchInt32(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 swingRight = ct.swingRightArray();
     const vertexLeftmost = ct.vertexLeftmostCornerArray();
     let numNewVertices = 0;
     for (let v = 0; v < numBaseVertices; ++v) {
@@ -1534,14 +2274,10 @@ var MeshAttributeCornerTable = class {
         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;
+        let actC = swingRight[c];
         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;
+          actC = swingRight[actC];
         }
       } else {
         let firstVertId = numNewVertices++;
@@ -1559,9 +2295,7 @@ var MeshAttributeCornerTable = class {
         }
         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;
+        actC = swingRight[firstC];
         while (actC !== kInvalidCornerIndex && actC !== firstC) {
           const nAct = actC % 3 === 2 ? actC - 2 : actC + 1;
           if (isEdgeOnSeam[nAct]) {
@@ -1569,13 +2303,11 @@ var MeshAttributeCornerTable = class {
             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;
+          actC = swingRight[actC];
         }
       }
     }
-    this.vertex_to_attribute_entry_id_map_ = new Int32Array(numNewVertices);
+    this.num_attribute_vertices_ = numNewVertices;
     this.vertex_to_left_most_corner_map_ = leftMostMap.subarray(0, numNewVertices);
     return true;
   }
@@ -1601,7 +2333,7 @@ var MeshAttributeCornerTable = class {
     return this.next(this.opposite(this.next(corner)));
   }
   numVertices() {
-    return this.vertex_to_attribute_entry_id_map_.length;
+    return this.num_attribute_vertices_;
   }
   numFaces() {
     return this.corner_table_.numFaces();
@@ -1629,12 +2361,13 @@ var MeshAttributeCornerTable = class {
       const nc = this.corner_table_.numCorners();
       const base = this.corner_table_.oppositeCornerArray();
       const seamCorners = this._seamCorners;
-      if (seamCorners.length === 0) {
+      const numSeamCorners = this._numSeamCorners;
+      if (numSeamCorners === 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) {
+        for (let i = 0; i < numSeamCorners; ++i) {
           eff[seamCorners[i]] = kInvalidCornerIndex;
         }
         this._effectiveOpposite = eff;
@@ -1649,23 +2382,20 @@ var MeshAttributeCornerTable = class {
   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) {
+  // Takes over another table's state wholesale. Only valid when both tables
+  // were built from the same corner table and the same seam edges, in which
+  // case every one of these is identical and read-only from here on.
+  adoptFrom(other) {
+    this.corner_table_ = other.corner_table_;
+    this.is_edge_on_seam_ = other.is_edge_on_seam_;
+    this.is_vertex_on_seam_ = other.is_vertex_on_seam_;
     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.num_attribute_vertices_ = other.num_attribute_vertices_;
     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;
+    this._numSeamCorners = other._numSeamCorners;
   }
 };
 
@@ -1679,6 +2409,21 @@ var AttributesDecoderInterface = class {
   decodeAttributesDecoderData(_buffer) {
     return false;
   }
+  // --- Optional two-phase decode across attributes decoders ---
+  // PointCloudDecoder parses every decoder first (all buffer reads are
+  // size-driven, so parsing runs ahead of the deferred rANS symbol decodes),
+  // then decodes the collected streams two at a time, then finishes each
+  // decoder in order (so parent attributes complete before dependents).
+  // Defaults keep the original single-phase behavior for decoders that do not
+  // split.
+  decodeAttributesParse(buffer) {
+    return this.decodeAttributes(buffer);
+  }
+  collectPendingSymbolStreams(_out) {
+  }
+  decodeAttributesFinish() {
+    return true;
+  }
   decodeAttributes(_buffer) {
     return false;
   }
@@ -1825,6 +2570,22 @@ var SequentialAttributeDecoder = class {
     this._attributeId = attributeId;
     return true;
   }
+  // --- Optional two-phase decode ---
+  // The controller calls Parse for every attribute first (headers, schemes,
+  // prediction data -- all size-driven cursor movement), collects the pending
+  // rANS symbol streams, decodes them in pairs (see ransDecodeSymbolsPair),
+  // then calls Finish per attribute in order. Decoders without a deferrable
+  // stream simply do the whole decode in Parse. Defaults preserve the
+  // original single-phase behavior.
+  decodePortableAttributeParse(pointIds, buffer) {
+    return this.decodePortableAttribute(pointIds, buffer);
+  }
+  pendingSymbolStream() {
+    return null;
+  }
+  decodePortableAttributeFinish() {
+    return true;
+  }
   decodePortableAttribute(pointIds, buffer) {
     if (this._attribute.numComponents <= 0) {
       return false;
@@ -1845,7 +2606,7 @@ var SequentialAttributeDecoder = class {
   getPortableAttribute() {
     if (!this._attribute.isMappingIdentity && this._portableAttribute && this._portableAttribute.isMappingIdentity) {
       const size = this._attribute.indicesMapSize;
-      this._portableAttribute.setExplicitMappingUnfilled(size);
+      this._portableAttribute.setExplicitMappingScratch(size);
       const src = this._attribute.indicesMap;
       const dst = this._portableAttribute.indicesMap;
       if (src.length === size) {
@@ -1890,300 +2651,11 @@ var SequentialAttributeDecoder = class {
     this._attribute.buffer.write(0, valueData, totalSize);
     return true;
   }
-  setPortableAttribute(att) {
-    this._portableAttribute = att;
-  }
-  get portableAttribute() {
-    return this._portableAttribute;
-  }
-};
-
-// src/decoder/compression/entropy/ANSCoding.ts
-var ANS_P8_PRECISION = 256;
-var ANS_L_BASE = 4096;
-var ANS_IO_BASE = 256;
-function memGetLe16(buf, offset) {
-  return buf[offset] | buf[offset + 1] << 8;
-}
-function memGetLe24(buf, offset) {
-  return buf[offset] | buf[offset + 1] << 8 | buf[offset + 2] << 16;
-}
-function memGetLe32(buf, offset) {
-  return buf[offset] | buf[offset + 1] << 8 | buf[offset + 2] << 16 | buf[offset + 3] << 24 >>> 0;
-}
-var AnsDecoder = class {
-  buf;
-  bufOffset;
-  // First valid byte of this decoder's slice within buf: init is passed
-  // absolute offsets into the source buffer to avoid a subarray allocation.
-  bufStart;
-  state;
-  constructor() {
-    this.buf = null;
-    this.bufOffset = 0;
-    this.bufStart = 0;
-    this.state = 0;
-  }
-};
-function ansReadInit(ans, buf, offset, base = 0) {
-  if (offset - base < 1) {
-    return 1;
-  }
-  ans.buf = buf;
-  ans.bufStart = base;
-  const x = buf[offset - 1] >> 6;
-  if (x === 0) {
-    ans.bufOffset = offset - 1;
-    ans.state = buf[offset - 1] & 63;
-  } else if (x === 1) {
-    if (offset - base < 2) {
-      return 1;
-    }
-    ans.bufOffset = offset - 2;
-    ans.state = memGetLe16(buf, offset - 2) & 16383;
-  } else if (x === 2) {
-    if (offset - base < 3) {
-      return 1;
-    }
-    ans.bufOffset = offset - 3;
-    ans.state = memGetLe24(buf, offset - 3) & 4194303;
-  } else {
-    return 1;
-  }
-  ans.state += ANS_L_BASE;
-  if (ans.state >= ANS_L_BASE * ANS_IO_BASE) {
-    return 1;
-  }
-  return 0;
-}
-function ansReadEnd(ans) {
-  return ans.state === ANS_L_BASE;
-}
-var tablePool = [];
-var acquirePooled = (Ctor, size) => {
-  for (let i = tablePool.length - 1; i >= 0; --i) {
-    const buf = tablePool[i];
-    if (buf.constructor === Ctor && buf.length >= size) {
-      tablePool[i] = tablePool[tablePool.length - 1];
-      tablePool.pop();
-      return buf;
-    }
-  }
-  return new Ctor(size);
-};
-var RAnsDecoder = class {
-  ransPrecisionBits;
-  ransPrecision;
-  ransPrecisionMask;
-  lRansBase;
-  lutTable;
-  probTable;
-  cumProbTable;
-  buf;
-  bufOffset;
-  // First valid byte of this decoder's slice within buf (absolute offsets,
-  // see AnsDecoder.bufStart).
-  bufStart;
-  state;
-  constructor(ransPrecisionBits) {
-    this.ransPrecisionBits = ransPrecisionBits;
-    this.ransPrecision = 1 << ransPrecisionBits;
-    this.ransPrecisionMask = this.ransPrecision - 1;
-    this.lRansBase = this.ransPrecision * 4;
-    this.lutTable = null;
-    this.probTable = null;
-    this.cumProbTable = null;
-    this.buf = null;
-    this.bufOffset = 0;
-    this.bufStart = 0;
-    this.state = 0;
-  }
-  // offset is the absolute end of the encoded bytes within buf and base the
-  // absolute start (offset - base = encoded length). Passing the source
-  // buffer with absolute offsets avoids a subarray allocation per init.
-  // Returns 0 on success, non-zero on error.
-  readInit(buf, offset, base = 0) {
-    if (offset - base < 1) {
-      return 1;
-    }
-    this.buf = buf;
-    this.bufStart = base;
-    const x = buf[offset - 1] >> 6;
-    if (x === 0) {
-      this.bufOffset = offset - 1;
-      this.state = buf[offset - 1] & 63;
-    } else if (x === 1) {
-      if (offset - base < 2) {
-        return 1;
-      }
-      this.bufOffset = offset - 2;
-      this.state = memGetLe16(buf, offset - 2) & 16383;
-    } else if (x === 2) {
-      if (offset - base < 3) {
-        return 1;
-      }
-      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 {
-      return 1;
-    }
-    this.state += this.lRansBase;
-    if (this.state >= this.lRansBase * ANS_IO_BASE) {
-      return 1;
-    }
-    return 0;
-  }
-  readEnd() {
-    if (this.lutTable !== null) {
-      tablePool.push(this.lutTable);
-      this.lutTable = null;
-    }
-    if (this.probTable !== null) {
-      tablePool.push(this.probTable);
-      this.probTable = null;
-    }
-    if (this.cumProbTable !== null) {
-      tablePool.push(this.cumProbTable);
-      this.cumProbTable = null;
-    }
-    return this.state === this.lRansBase;
-  }
-  ransRead() {
-    const buf = this.buf;
-    const lRansBase = this.lRansBase;
-    let state = this.state;
-    let bufOffset = this.bufOffset;
-    const bufStart = this.bufStart;
-    while (state < lRansBase && bufOffset > bufStart) {
-      state = state << 8 | buf[--bufOffset];
-    }
-    const quo = state >>> this.ransPrecisionBits;
-    const rem = state & this.ransPrecisionMask;
-    const symbol = this.lutTable[rem];
-    this.state = quo * this.probTable[symbol] + rem - this.cumProbTable[symbol];
-    this.bufOffset = bufOffset;
-    return symbol;
-  }
-  // 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 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;
-  }
-  // Builds the ransPrecision-entry lookup table. Returns false on bad input data.
-  ransBuildLookUpTable(tokenProbs, numSymbols) {
-    const LutArray = numSymbols <= 256 ? Uint8Array : numSymbols <= 65536 ? Uint16Array : Uint32Array;
-    const lutTable = acquirePooled(LutArray, this.ransPrecision);
-    const probTable = acquirePooled(Uint32Array, numSymbols);
-    const cumProbTable = acquirePooled(Uint32Array, numSymbols);
-    this.lutTable = lutTable;
-    this.probTable = probTable;
-    this.cumProbTable = cumProbTable;
-    let cumProb = 0;
-    let actProb = 0;
-    for (let i = 0; i < numSymbols; ++i) {
-      const prob = tokenProbs[i];
-      probTable[i] = prob;
-      cumProbTable[i] = cumProb;
-      cumProb += prob;
-      if (cumProb > this.ransPrecision) {
-        return false;
-      }
-      if (prob < 32) {
-        for (let j = actProb; j < cumProb; ++j) {
-          lutTable[j] = i;
-        }
-      } else {
-        lutTable.fill(i, actProb, cumProb);
-      }
-      actProb = cumProb;
-    }
-    if (cumProb !== this.ransPrecision) {
-      return false;
-    }
-    return true;
+  setPortableAttribute(att) {
+    this._portableAttribute = att;
+  }
+  get portableAttribute() {
+    return this._portableAttribute;
   }
 };
 
@@ -2208,8 +2680,10 @@ var RAnsSymbolDecoder = class {
   get numSymbols() {
     return this.numSymbols_;
   }
-  // Initialize the decoder and decode the probability table.
-  create(buffer) {
+  // Initialize the decoder and decode the probability table. expectedCount is
+  // the number of symbols the caller will decode (lets short streams skip the
+  // full lookup table; see RAnsDecoder.ransBuildLookUpTable).
+  create(buffer, expectedCount = 2147483647) {
     if (buffer.bitstreamVersion === 0) {
       return false;
     }
@@ -2220,7 +2694,7 @@ var RAnsSymbolDecoder = class {
       return false;
     }
     const numSymbols = this.numSymbols_;
-    const probabilityTable = new Uint32Array(numSymbols);
+    const probabilityTable = scratchUint32Zeroed(numSymbols);
     this.probabilityTable_ = probabilityTable;
     if (numSymbols === 0) {
       return true;
@@ -2250,7 +2724,7 @@ var RAnsSymbolDecoder = class {
       }
     }
     buffer.advance(pos - startPos);
-    if (!this.ans_.ransBuildLookUpTable(this.probabilityTable_, this.numSymbols_)) {
+    if (!this.ans_.ransBuildLookUpTable(this.probabilityTable_, this.numSymbols_, expectedCount)) {
       return false;
     }
     return true;
@@ -2292,7 +2766,7 @@ function decodeSymbols(numValues, numComponents, srcBuffer, outValues) {
 }
 function decodeTaggedSymbols(numValues, numComponents, srcBuffer, outValues) {
   const tagDecoder = new RAnsSymbolDecoder(5);
-  if (!tagDecoder.create(srcBuffer)) {
+  if (!tagDecoder.create(srcBuffer, Math.ceil(numValues / numComponents))) {
     return false;
   }
   if (!tagDecoder.startDecoding(srcBuffer)) {
@@ -2301,27 +2775,76 @@ function decodeTaggedSymbols(numValues, numComponents, srcBuffer, outValues) {
   if (numValues > 0 && tagDecoder.numSymbols === 0) {
     return false;
   }
+  const tagAns = tagDecoder.ans_;
   srcBuffer.startBitDecoding(false);
   const bd = srcBuffer._bitDecoder;
-  const tagAns = tagDecoder.ans_;
+  const buf = bd._bitBuffer;
+  const byteLength = bd._byteLength;
+  let bitOffset = bd._bitOffset;
   let valueId = 0;
   for (let i = 0; i < numValues; i += numComponents) {
     const bitLength = tagAns.ransRead();
-    for (let j = 0; j < numComponents; ++j) {
-      const val = bd.getBits(bitLength);
-      if (val === void 0) {
-        return false;
+    if (bitLength < 32) {
+      const mask = (1 << bitLength) - 1;
+      let j = 0;
+      for (; j < numComponents; ++j) {
+        const byteOffset = bitOffset >> 3;
+        if (byteOffset + 4 >= byteLength) break;
+        const bitShift = bitOffset & 7;
+        let value = (buf[byteOffset] | buf[byteOffset + 1] << 8 | buf[byteOffset + 2] << 16 | buf[byteOffset + 3] << 24) >>> bitShift;
+        if (bitLength > 32 - bitShift) {
+          value = (value | buf[byteOffset + 4] << 32 - bitShift) >>> 0;
+        }
+        bitOffset += bitLength;
+        outValues[valueId++] = value & mask;
+      }
+      if (j === numComponents) continue;
+      bd._bitOffset = bitOffset;
+      for (; j < numComponents; ++j) {
+        const val = bd.getBits(bitLength);
+        if (val === void 0) {
+          return false;
+        }
+        outValues[valueId++] = val;
+      }
+      bitOffset = bd._bitOffset;
+    } else {
+      bd._bitOffset = bitOffset;
+      for (let j = 0; j < numComponents; ++j) {
+        const val = bd.getBits(bitLength);
+        if (val === void 0) {
+          return false;
+        }
+        outValues[valueId++] = val;
       }
-      outValues[valueId++] = val;
+      bitOffset = bd._bitOffset;
     }
   }
+  bd._bitOffset = bitOffset;
   tagDecoder.endDecoding();
   srcBuffer.endBitDecoding();
   return true;
 }
+function parseRawSymbolStream(numValues, srcBuffer) {
+  const maxBitLength = srcBuffer.decodeUint8();
+  if (maxBitLength === void 0 || maxBitLength < 1 || maxBitLength > 18) {
+    return null;
+  }
+  const decoder = new RAnsSymbolDecoder(maxBitLength);
+  if (!decoder.create(srcBuffer, numValues)) {
+    return null;
+  }
+  if (numValues > 0 && decoder.numSymbols === 0) {
+    return null;
+  }
+  if (!decoder.startDecoding(srcBuffer)) {
+    return null;
+  }
+  return decoder;
+}
 function decodeRawSymbolsInternal(uniqueSymbolsBitLength, numValues, srcBuffer, outValues) {
   const decoder = new RAnsSymbolDecoder(uniqueSymbolsBitLength);
-  if (!decoder.create(srcBuffer)) {
+  if (!decoder.create(srcBuffer, numValues)) {
     return false;
   }
   if (numValues > 0 && decoder.numSymbols === 0) {
@@ -2421,6 +2944,16 @@ var PredictionSchemeDecoderInterface = class {
   decodePredictionData(_buffer) {
     return true;
   }
+  /**
+   * Like computeOriginalValues, but inCorr still holds unsigned zigzag-coded
+   * corrections; the implementation unpacks each one inline, replacing the
+   * standalone convertSymbolsToSignedInts pass. Returns undefined when the
+   * scheme/transform combination cannot fuse (the caller then falls back to
+   * the two-pass path). Base implementation: never fusable.
+   */
+  computeOriginalValuesZigzag(_inCorr, _outData, _size, _numComponents, _entryToPointIdMap) {
+    return void 0;
+  }
   /** Reverts the prediction applied during encoding, writing original values to outData. */
   computeOriginalValues(_inCorr, _outData, _size, _numComponents, _entryToPointIdMap) {
     return false;
@@ -2756,7 +3289,7 @@ var OctahedronToolBox = class {
 // src/decoder/compression/attributes/prediction_schemes/MeshPredictionSchemeGeometricNormalPredictorArea.ts
 var UPPER_BOUND = 1 << 29;
 function buildInt32PositionCache(att, map, numEntries, tempPos) {
-  const cache = new Int32Array(numEntries * 3);
+  const cache = scratchInt32(numEntries * 3);
   const bufData = att.buffer && att.buffer.data;
   if (att.dataType === DataType.INT32 && att.numComponents === 3 && bufData) {
     const src = new Int32Array(bufData.buffer);
@@ -2837,7 +3370,7 @@ var MeshPredictionSchemeGeometricNormalPredictorArea = class {
     const cornerToVertex = this._cornerToVertex;
     const vertexToDataMap = this._meshData.vertexToDataMap;
     const nc = cornerToVertex.length;
-    const c2o = new Int32Array(nc);
+    const c2o = scratchInt32(nc);
     for (let c = 0; c < nc; ++c) {
       const v = cornerToVertex[c];
       c2o[c] = v < 0 ? -1 : vertexToDataMap[v] * 3;
@@ -3088,10 +3621,21 @@ var MeshPredictionSchemeParallelogramDecoder = class extends MeshPredictionSchem
   isInitialized() {
     return this._meshData.isInitialized();
   }
+  // Zigzag-fused variant: decodes corrections that are still in their unsigned
+  // zigzag form, unpacking each one inline. Only offered for the wrap
+  // transform (whose corrections are the only zigzag-coded ones this scheme
+  // sees); callers fall back to the standalone conversion pass otherwise.
+  computeOriginalValuesZigzag(inCorr, outData, _size, numComponents, _entryToPointIdMap) {
+    this._transform.init(numComponents);
+    if (!this._transform.getType || this._transform.getType() !== PredictionSchemeTransformType.PREDICTION_TRANSFORM_WRAP) {
+      return void 0;
+    }
+    return this._computeOriginalValuesWrap(inCorr, outData, numComponents, true);
+  }
   computeOriginalValues(inCorr, outData, size, numComponents, entryToPointIdMap) {
     this._transform.init(numComponents);
     if (this._transform.getType && this._transform.getType() === PredictionSchemeTransformType.PREDICTION_TRANSFORM_WRAP) {
-      return this._computeOriginalValuesWrap(inCorr, outData, numComponents);
+      return this._computeOriginalValuesWrap(inCorr, outData, numComponents, false);
     }
     const table = this._meshData.cornerTable;
     const vertexToDataMap = this._meshData.vertexToDataMap;
@@ -3132,12 +3676,18 @@ var MeshPredictionSchemeParallelogramDecoder = class extends MeshPredictionSchem
     }
     return true;
   }
-  _computeOriginalValuesWrap(inCorr, outData, numComponents) {
+  // The wrap transform's corrections are zigzag-coded; with `zigzag` set the
+  // decode folds the (val >>> 1) ^ -(val & 1) unpacking into each correction
+  // read, replacing the standalone convertSymbolsToSignedInts pass over the
+  // whole array (see computeOriginalValuesZigzag). Every correction is read
+  // exactly once before its slot is overwritten, so the in-place aliasing of
+  // inCorr and outData is preserved.
+  _computeOriginalValuesWrap(inCorr, outData, numComponents, zigzag) {
     if (numComponents === 2) {
-      return this._computeOriginalValuesWrap2(inCorr, outData);
+      return this._computeOriginalValuesWrap2(inCorr, outData, zigzag);
     }
     if (numComponents === 3) {
-      return this._computeOriginalValuesWrap3(inCorr, outData);
+      return this._computeOriginalValuesWrap3(inCorr, outData, zigzag);
     }
     const table = this._meshData.cornerTable;
     const vertexToDataMap = this._meshData.vertexToDataMap;
@@ -3155,7 +3705,8 @@ var MeshPredictionSchemeParallelogramDecoder = class extends MeshPredictionSchem
       } else if (pred < minValue) {
         pred = minValue;
       }
-      let orig = pred + inCorr[c] | 0;
+      const raw = inCorr[c];
+      let orig = pred + (zigzag ? raw >>> 1 ^ -(raw & 1) : raw) | 0;
       if (orig > maxValue) {
         orig -= maxDif;
       } else if (orig < minValue) {
@@ -3194,7 +3745,8 @@ var MeshPredictionSchemeParallelogramDecoder = class extends MeshPredictionSchem
           } else if (pred < minValue) {
             pred = minValue;
           }
-          let orig = pred + inCorr[dstOffset + c] | 0;
+          const raw = inCorr[dstOffset + c];
+          let orig = pred + (zigzag ? raw >>> 1 ^ -(raw & 1) : raw) | 0;
           if (orig > maxValue) {
             orig -= maxDif;
           } else if (orig < minValue) {
@@ -3211,7 +3763,8 @@ var MeshPredictionSchemeParallelogramDecoder = class extends MeshPredictionSchem
           } else if (pred < minValue) {
             pred = minValue;
           }
-          let orig = pred + inCorr[dstOffset + c] | 0;
+          const raw = inCorr[dstOffset + c];
+          let orig = pred + (zigzag ? raw >>> 1 ^ -(raw & 1) : raw) | 0;
           if (orig > maxValue) {
             orig -= maxDif;
           } else if (orig < minValue) {
@@ -3223,7 +3776,7 @@ var MeshPredictionSchemeParallelogramDecoder = class extends MeshPredictionSchem
     }
     return true;
   }
-  _computeOriginalValuesWrap2(inCorr, outData) {
+  _computeOriginalValuesWrap2(inCorr, outData, zigzag) {
     const table = this._meshData.cornerTable;
     const vertexToDataMap = this._meshData.vertexToDataMap;
     const oppositeCorners = table.oppositeCornerArray();
@@ -3245,8 +3798,10 @@ var MeshPredictionSchemeParallelogramDecoder = class extends MeshPredictionSchem
     } else if (pred1 < minValue) {
       pred1 = minValue;
     }
-    let orig0 = pred0 + inCorr[0] | 0;
-    let orig1 = pred1 + inCorr[1] | 0;
+    const raw0 = inCorr[0];
+    const raw1 = inCorr[1];
+    let orig0 = pred0 + (zigzag ? raw0 >>> 1 ^ -(raw0 & 1) : raw0) | 0;
+    let orig1 = pred1 + (zigzag ? raw1 >>> 1 ^ -(raw1 & 1) : raw1) | 0;
     if (orig0 > maxValue) {
       orig0 -= maxDif;
     } else if (orig0 < minValue) {
@@ -3300,8 +3855,10 @@ var MeshPredictionSchemeParallelogramDecoder = class extends MeshPredictionSchem
       } else if (pred1 < minValue) {
         pred1 = minValue;
       }
-      orig0 = pred0 + inCorr[dstOffset] | 0;
-      orig1 = pred1 + inCorr[dstOffset + 1] | 0;
+      const rawA = inCorr[dstOffset];
+      const rawB = inCorr[dstOffset + 1];
+      orig0 = pred0 + (zigzag ? rawA >>> 1 ^ -(rawA & 1) : rawA) | 0;
+      orig1 = pred1 + (zigzag ? rawB >>> 1 ^ -(rawB & 1) : rawB) | 0;
       if (orig0 > maxValue) {
         orig0 -= maxDif;
       } else if (orig0 < minValue) {
@@ -3317,7 +3874,7 @@ var MeshPredictionSchemeParallelogramDecoder = class extends MeshPredictionSchem
     }
     return true;
   }
-  _computeOriginalValuesWrap3(inCorr, outData) {
+  _computeOriginalValuesWrap3(inCorr, outData, zigzag) {
     const table = this._meshData.cornerTable;
     const vertexToDataMap = this._meshData.vertexToDataMap;
     const oppositeCorners = table.oppositeCornerArray();
@@ -3345,9 +3902,12 @@ var MeshPredictionSchemeParallelogramDecoder = class extends MeshPredictionSchem
     } else if (pred2 < minValue) {
       pred2 = minValue;
     }
-    let orig0 = pred0 + inCorr[0] | 0;
-    let orig1 = pred1 + inCorr[1] | 0;
-    let orig2 = pred2 + inCorr[2] | 0;
+    const raw0 = inCorr[0];
+    const raw1 = inCorr[1];
+    const raw2 = inCorr[2];
+    let orig0 = pred0 + (zigzag ? raw0 >>> 1 ^ -(raw0 & 1) : raw0) | 0;
+    let orig1 = pred1 + (zigzag ? raw1 >>> 1 ^ -(raw1 & 1) : raw1) | 0;
+    let orig2 = pred2 + (zigzag ? raw2 >>> 1 ^ -(raw2 & 1) : raw2) | 0;
     if (orig0 > maxValue) {
       orig0 -= maxDif;
     } else if (orig0 < minValue) {
@@ -3414,9 +3974,12 @@ var MeshPredictionSchemeParallelogramDecoder = class extends MeshPredictionSchem
       } else if (pred2 < minValue) {
         pred2 = minValue;
       }
-      orig0 = pred0 + inCorr[dstOffset] | 0;
-      orig1 = pred1 + inCorr[dstOffset + 1] | 0;
-      orig2 = pred2 + inCorr[dstOffset + 2] | 0;
+      const rawA = inCorr[dstOffset];
+      const rawB = inCorr[dstOffset + 1];
+      const rawC = inCorr[dstOffset + 2];
+      orig0 = pred0 + (zigzag ? rawA >>> 1 ^ -(rawA & 1) : rawA) | 0;
+      orig1 = pred1 + (zigzag ? rawB >>> 1 ^ -(rawB & 1) : rawB) | 0;
+      orig2 = pred2 + (zigzag ? rawC >>> 1 ^ -(rawC & 1) : rawC) | 0;
       if (orig0 > maxValue) {
         orig0 -= maxDif;
       } else if (orig0 < minValue) {
@@ -3783,11 +4346,16 @@ var PredictionSchemeDeltaDecoder = class extends PredictionSchemeDecoder {
     return true;
   }
   computeOriginalValues(inCorr, outData, size, numComponents, entryToPointIdMap) {
-    this._transform.init(numComponents);
+    const transform = this._transform;
+    transform.init(numComponents);
+    if (transform.computeOriginalValuesDelta) {
+      transform.computeOriginalValuesDelta(inCorr, outData, size, numComponents);
+      return true;
+    }
     const zeroVals = new Int32Array(numComponents);
-    this._transform.computeOriginalValue(zeroVals, 0, inCorr, 0, outData, 0);
+    transform.computeOriginalValue(zeroVals, 0, inCorr, 0, outData, 0);
     for (let i = numComponents; i < size; i += numComponents) {
-      this._transform.computeOriginalValue(outData, i - numComponents, inCorr, i, outData, i);
+      transform.computeOriginalValue(outData, i - numComponents, inCorr, i, outData, i);
     }
     return true;
   }
@@ -3923,14 +4491,49 @@ var PredictionSchemeWrapDecodingTransform = class {
 // src/decoder/compression/attributes/SequentialIntegerAttributeDecoder.ts
 var SequentialIntegerAttributeDecoder = class extends SequentialAttributeDecoder {
   _predictionScheme;
+  // Two-phase decode state (see SequentialAttributeDecoder): the parse phase
+  // stashes the primed raw-symbol stream here so the controller can batch and
+  // pair several attributes' decodes; the finish phase consumes it.
+  _pendingSymbolDecoder;
+  _pendingNumValues;
+  _finishPointIds;
   constructor() {
     super();
     this._predictionScheme = null;
+    this._pendingSymbolDecoder = null;
+    this._pendingNumValues = 0;
+    this._finishPointIds = null;
   }
-  transformAttributeToOriginalFormat(pointIds) {
-    return this._storeValues(pointIds.length);
+  // --- Two-phase decode (parse headers / batch symbol decode / finish) ---
+  decodePortableAttributeParse(pointIds, buffer) {
+    if (this.attribute.numComponents <= 0) {
+      return false;
+    }
+    if (!this.attribute.reset(pointIds.length)) {
+      return false;
+    }
+    this._finishPointIds = pointIds;
+    return this._decodeValuesParse(pointIds, buffer);
   }
-  decodeValues(pointIds, buffer) {
+  pendingSymbolStream() {
+    if (this._pendingSymbolDecoder === null) {
+      return null;
+    }
+    const portableAttributeData = this.getPortableAttributeData();
+    return {
+      ans: this._pendingSymbolDecoder.ans_,
+      out: new Uint32Array(portableAttributeData.buffer, portableAttributeData.byteOffset, this._pendingNumValues),
+      count: this._pendingNumValues
+    };
+  }
+  decodePortableAttributeFinish() {
+    if (this._pendingSymbolDecoder !== null) {
+      this._pendingSymbolDecoder.endDecoding();
+      this._pendingSymbolDecoder = null;
+    }
+    return this._finishIntegerValues(this._finishPointIds);
+  }
+  _decodeValuesParse(pointIds, buffer) {
     const predictionSchemeMethod = buffer.decodeInt8();
     if (predictionSchemeMethod === void 0) return false;
     if (predictionSchemeMethod < PredictionSchemeMethod.PREDICTION_NONE || predictionSchemeMethod >= PredictionSchemeMethod.NUM_PREDICTION_SCHEMES) {
@@ -3949,12 +4552,6 @@ var SequentialIntegerAttributeDecoder = class extends SequentialAttributeDecoder
         return false;
       }
     }
-    if (!this.decodeIntegerValues(pointIds, buffer)) {
-      return false;
-    }
-    return true;
-  }
-  decodeIntegerValues(pointIds, buffer) {
     const numComponents = this.getNumValueComponents();
     if (numComponents <= 0) {
       return false;
@@ -3969,9 +4566,23 @@ var SequentialIntegerAttributeDecoder = class extends SequentialAttributeDecoder
     const compressed = buffer.decodeUint8();
     if (compressed === void 0) return false;
     if (compressed > 0) {
-      const outUint32 = new Uint32Array(portableAttributeData.buffer, portableAttributeData.byteOffset, numValues);
-      if (!decodeSymbols(numValues, numComponents, buffer, outUint32)) {
-        return false;
+      if (numValues > 0) {
+        const scheme = buffer.decodeUint8();
+        if (scheme === SymbolCodingMethod.SYMBOL_CODING_RAW) {
+          const decoder = parseRawSymbolStream(numValues, buffer);
+          if (decoder === null) {
+            return false;
+          }
+          this._pendingSymbolDecoder = decoder;
+          this._pendingNumValues = numValues;
+        } else if (scheme === SymbolCodingMethod.SYMBOL_CODING_TAGGED) {
+          const outUint32 = new Uint32Array(portableAttributeData.buffer, portableAttributeData.byteOffset, numValues);
+          if (!decodeTaggedSymbols(numValues, numComponents, buffer, outUint32)) {
+            return false;
+          }
+        } else {
+          return false;
+        }
       }
     } else {
       const numBytes = buffer.decodeUint8();
@@ -4002,15 +4613,40 @@ var SequentialIntegerAttributeDecoder = class extends SequentialAttributeDecoder
         }
       }
     }
-    if (numValues > 0 && (this._predictionScheme === null || !this._predictionScheme.areCorrectionsPositive())) {
-      const asUint32 = new Uint32Array(portableAttributeData.buffer, portableAttributeData.byteOffset, numValues);
-      convertSymbolsToSignedInts(asUint32, numValues, portableAttributeData);
-    }
     if (this._predictionScheme) {
       if (!this._predictionScheme.decodePredictionData(buffer)) {
         return false;
       }
+    }
+    return true;
+  }
+  // The post-symbol tail of the decode: zigzag unpacking and prediction.
+  _finishIntegerValues(pointIds) {
+    const numComponents = this.getNumValueComponents();
+    const numValues = pointIds.length * numComponents;
+    const portableAttributeData = this.getPortableAttributeData();
+    if (portableAttributeData === null) {
+      return false;
+    }
+    const needsZigzag = numValues > 0 && (this._predictionScheme === null || !this._predictionScheme.areCorrectionsPositive());
+    if (this._predictionScheme) {
       if (numValues > 0) {
+        if (needsZigzag) {
+          const fused = this._predictionScheme.computeOriginalValuesZigzag(
+            portableAttributeData,
+            portableAttributeData,
+            numValues,
+            numComponents,
+            pointIds
+          );
+          if (fused !== void 0) {
+            return fused;
+          }
+        }
+        if (needsZigzag) {
+          const asUint32 = new Uint32Array(portableAttributeData.buffer, portableAttributeData.byteOffset, numValues);
+          convertSymbolsToSignedInts(asUint32, numValues, portableAttributeData);
+        }
         if (!this._predictionScheme.computeOriginalValues(
           portableAttributeData,
           portableAttributeData,
@@ -4021,9 +4657,34 @@ var SequentialIntegerAttributeDecoder = class extends SequentialAttributeDecoder
           return false;
         }
       }
+    } else if (needsZigzag) {
+      const asUint32 = new Uint32Array(portableAttributeData.buffer, portableAttributeData.byteOffset, numValues);
+      convertSymbolsToSignedInts(asUint32, numValues, portableAttributeData);
     }
     return true;
   }
+  transformAttributeToOriginalFormat(pointIds) {
+    return this._storeValues(pointIds.length);
+  }
+  // Single-phase entry (base-class decodePortableAttribute path): parse,
+  // decode any deferred symbol stream immediately, finish.
+  decodeValues(pointIds, buffer) {
+    this._finishPointIds = pointIds;
+    if (!this._decodeValuesParse(pointIds, buffer)) {
+      return false;
+    }
+    const pending = this._pendingSymbolDecoder;
+    if (pending !== null) {
+      const portableAttributeData = this.getPortableAttributeData();
+      const outUint32 = new Uint32Array(
+        portableAttributeData.buffer,
+        portableAttributeData.byteOffset,
+        this._pendingNumValues
+      );
+      pending.ans_.decodeSymbols(outUint32, this._pendingNumValues);
+    }
+    return this.decodePortableAttributeFinish();
+  }
   // Prediction scheme for decoding integer values; subclasses override for others.
   createIntPredictionScheme(method, transformType) {
     if (transformType !== PredictionSchemeTransformType.PREDICTION_TRANSFORM_WRAP) {
@@ -4086,7 +4747,7 @@ var SequentialIntegerAttributeDecoder = class extends SequentialAttributeDecoder
     );
     const portAtt = new PointAttribute(ga);
     portAtt.setIdentityMapping();
-    portAtt.reset(numEntries);
+    portAtt.resetScratch(numEntries);
     portAtt.uniqueId = this.attribute.uniqueId;
     this.setPortableAttribute(portAtt);
   }
@@ -4112,12 +4773,22 @@ var AttributeTransformType = {
 };
 
 // src/decoder/attributes/AttributeTransformData.ts
+var INITIAL_CAPACITY = 32;
 var AttributeTransformData = class {
   _transformType;
-  _buffer;
+  // Parameter bytes, little-endian, appended in transform-defined order.
+  // Capacity grows geometrically and the DataView is cached alongside it: the
+  // previous DataBuffer-backed version reallocated the buffer and built a
+  // fresh DataView on *every* appended value, which on primitive-heavy files
+  // cost more than the dequantization it describes.
+  _bytes;
+  _view;
+  _size;
   constructor() {
     this._transformType = AttributeTransformType.INVALID;
-    this._buffer = new DataBuffer();
+    this._bytes = new Uint8Array(INITIAL_CAPACITY);
+    this._view = new DataView(this._bytes.buffer);
+    this._size = 0;
   }
   get transformType() {
     return this._transformType;
@@ -4125,13 +4796,29 @@ var AttributeTransformData = class {
   set transformType(type) {
     this._transformType = type;
   }
+  // Number of parameter bytes written so far (the next append offset).
+  get dataSize() {
+    return this._size;
+  }
+  get data() {
+    return this._bytes.subarray(0, this._size);
+  }
+  _reserve(sizeNeeded) {
+    if (sizeNeeded <= this._bytes.length) return;
+    let capacity = this._bytes.length * 2;
+    if (capacity < sizeNeeded) capacity = sizeNeeded;
+    const grown = new Uint8Array(capacity);
+    grown.set(this._bytes);
+    this._bytes = grown;
+    this._view = new DataView(grown.buffer);
+  }
   setParameterValue(byteOffset, value, type) {
     const sizeNeeded = byteOffset + this._typeSize(type);
-    if (sizeNeeded > this._buffer.dataSize) {
-      this._buffer.resize(sizeNeeded);
+    this._reserve(sizeNeeded);
+    if (sizeNeeded > this._size) {
+      this._size = sizeNeeded;
     }
-    const data = this._buffer.data;
-    const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+    const view = this._view;
     switch (type) {
       case "int32":
         view.setInt32(byteOffset, value, true);
@@ -4163,7 +4850,7 @@ var AttributeTransformData = class {
     }
   }
   appendParameterValue(value, type) {
-    this.setParameterValue(this._buffer.dataSize, value, type);
+    this.setParameterValue(this._size, value, type);
   }
   _typeSize(type) {
     switch (type) {
@@ -4209,7 +4896,6 @@ var AttributeTransform = class {
 // src/decoder/attributes/AttributeOctahedronTransform.ts
 var AttributeOctahedronTransform = class extends AttributeTransform {
   _quantizationBits;
-  _tmpVec;
   constructor() {
     super();
     this._quantizationBits = -1;
@@ -4241,15 +4927,30 @@ var AttributeOctahedronTransform = class extends AttributeTransform {
     const srcI32 = new Int32Array(srcAddr.buffer, srcAddr.byteOffset, numPoints * 2);
     const dstAddr = targetAttribute.getAddress(0);
     const dstF32 = new Float32Array(dstAddr.buffer, dstAddr.byteOffset, numPoints * 3);
-    const outVec = this._tmpVec || (this._tmpVec = new Float32Array(3));
+    const fround = Math.fround;
+    const scale = toolBox._dequantizationScale;
     let si = 0;
     let di = 0;
     for (let i = 0; i < numPoints; i++) {
-      toolBox.quantizedOctahedralCoordsToUnitVector(srcI32[si], srcI32[si + 1], outVec);
+      let y = fround(fround(fround(srcI32[si]) * scale) - 1);
+      let z = fround(fround(fround(srcI32[si + 1]) * scale) - 1);
       si += 2;
-      dstF32[di] = outVec[0];
-      dstF32[di + 1] = outVec[1];
-      dstF32[di + 2] = outVec[2];
+      const x = fround(fround(1 - Math.abs(y)) - Math.abs(z));
+      let xOffset = -x;
+      if (xOffset < 0) xOffset = 0;
+      y = fround(y + (y < 0 ? xOffset : -xOffset));
+      z = fround(z + (z < 0 ? xOffset : -xOffset));
+      const normSquared = fround(fround(fround(x * x) + fround(y * y)) + fround(z * z));
+      if (normSquared < 1e-6) {
+        dstF32[di] = 0;
+        dstF32[di + 1] = 0;
+        dstF32[di + 2] = 0;
+      } else {
+        const d = fround(1 / fround(Math.sqrt(normSquared)));
+        dstF32[di] = fround(x * d);
+        dstF32[di + 1] = fround(y * d);
+        dstF32[di + 2] = fround(z * d);
+      }
       di += 3;
     }
     return true;
@@ -4419,6 +5120,140 @@ var PredictionSchemeNormalOctahedronCanonicalizedDecodingTransform = class exten
     outOrigVals[outOffset] = origS + center;
     outOrigVals[outOffset + 1] = origT + center;
   }
+  // Fused delta loop for PredictionSchemeDeltaDecoder: the whole
+  // value[i] = original(value[i-1], corr[i]) chain in one call, with the
+  // toolbox fields hoisted to locals and the previous output carried in
+  // locals. This is the hot path for PREDICTION_DIFFERENCE normals (one call
+  // per value through the interface was ~8% of decode time on the bundles).
+  // The arithmetic is computeOriginalValue above verbatim -- keep them in
+  // sync; only the plumbing differs.
+  computeOriginalValuesDelta(inCorr, outData, size, numComponents) {
+    const toolBox = this._octahedronToolBox;
+    const center = toolBox._centerValue;
+    const maxQuantizedValue = toolBox._maxQuantizedValue;
+    let prevS = 0;
+    let prevT = 0;
+    for (let i = 0; i < size; i += numComponents) {
+      const corrS = inCorr[i];
+      const corrT = inCorr[i + 1];
+      let predS = prevS - center;
+      let predT = prevT - center;
+      const predIsInDiamond = Math.abs(predS) + Math.abs(predT) <= center;
+      if (!predIsInDiamond) {
+        let signS = 0;
+        let signT = 0;
+        if (predS >= 0 && predT >= 0) {
+          signS = 1;
+          signT = 1;
+        } else if (predS <= 0 && predT <= 0) {
+          signS = -1;
+          signT = -1;
+        } else {
+          signS = predS > 0 ? 1 : -1;
+          signT = predT > 0 ? 1 : -1;
+        }
+        const cornerPointS = signS * center;
+        const cornerPointT = signT * center;
+        let us = predS * 2 - cornerPointS | 0;
+        let ut = predT * 2 - cornerPointT | 0;
+        if (signS * signT >= 0) {
+          const temp = us;
+          us = -ut;
+          ut = -temp;
+        } else {
+          const temp = us;
+          us = ut;
+          ut = temp;
+        }
+        predS = (us + cornerPointS) / 2 | 0;
+        predT = (ut + cornerPointT) / 2 | 0;
+      }
+      const predIsInBottomLeft = predS === 0 && predT === 0 || predS < 0 && predT <= 0;
+      let rotationCount = 0;
+      if (predS === 0) {
+        if (predT > 0) rotationCount = 3;
+        else if (predT < 0) rotationCount = 1;
+      } else if (predS > 0) {
+        if (predT >= 0) rotationCount = 2;
+        else rotationCount = 1;
+      } else {
+        if (predT > 0) rotationCount = 3;
+      }
+      if (!predIsInBottomLeft) {
+        const s = predS, t = predT;
+        switch (rotationCount) {
+          case 1:
+            predS = t;
+            predT = -s | 0;
+            break;
+          case 2:
+            predS = -s | 0;
+            predT = -t | 0;
+            break;
+          case 3:
+            predS = -t | 0;
+            predT = s;
+            break;
+        }
+      }
+      let origS = predS + corrS | 0;
+      if (origS > center) origS -= maxQuantizedValue;
+      else if (origS < -center) origS += maxQuantizedValue;
+      let origT = predT + corrT | 0;
+      if (origT > center) origT -= maxQuantizedValue;
+      else if (origT < -center) origT += maxQuantizedValue;
+      if (!predIsInBottomLeft) {
+        const s = origS, t = origT;
+        switch (4 - rotationCount & 3) {
+          case 1:
+            origS = t;
+            origT = -s | 0;
+            break;
+          case 2:
+            origS = -s | 0;
+            origT = -t | 0;
+            break;
+          case 3:
+            origS = -t | 0;
+            origT = s;
+            break;
+        }
+      }
+      if (!predIsInDiamond) {
+        let signS = 0;
+        let signT = 0;
+        if (origS >= 0 && origT >= 0) {
+          signS = 1;
+          signT = 1;
+        } else if (origS <= 0 && origT <= 0) {
+          signS = -1;
+          signT = -1;
+        } else {
+          signS = origS > 0 ? 1 : -1;
+          signT = origT > 0 ? 1 : -1;
+        }
+        const cornerPointS = signS * center;
+        const cornerPointT = signT * center;
+        let us = origS * 2 - cornerPointS | 0;
+        let ut = origT * 2 - cornerPointT | 0;
+        if (signS * signT >= 0) {
+          const temp = us;
+          us = -ut;
+          ut = -temp;
+        } else {
+          const temp = us;
+          us = ut;
+          ut = temp;
+        }
+        origS = (us + cornerPointS) / 2 | 0;
+        origT = (ut + cornerPointT) / 2 | 0;
+      }
+      prevS = origS + center | 0;
+      prevT = origT + center | 0;
+      outData[i] = prevS;
+      outData[i + 1] = prevT;
+    }
+  }
 };
 
 // src/decoder/compression/attributes/prediction_schemes/PredictionSchemeNormalOctahedronDecodingTransform.ts
@@ -4733,6 +5568,12 @@ var SequentialAttributeDecodersController = class extends AttributesDecoder {
     return true;
   }
   decodeAttributes(buffer) {
+    if (!this._prepareSequence()) {
+      return false;
+    }
+    return super.decodeAttributes(buffer);
+  }
+  _prepareSequence() {
     if (!this._sequencer) {
       return false;
     }
@@ -4747,7 +5588,44 @@ var SequentialAttributeDecodersController = class extends AttributesDecoder {
         return false;
       }
     }
-    return super.decodeAttributes(buffer);
+    return true;
+  }
+  // Two-phase decode (see AttributesDecoder): parse everything that reads the
+  // buffer -- sequence, portable headers (deferring raw rANS symbol decodes),
+  // and the transform parameters -- so the deferred streams of ALL attributes
+  // decoders can then be paired, and finish (zigzag, prediction, inverse
+  // transform) runs per decoder in the original order afterwards. None of the
+  // finish work reads the buffer, and dependents only read parent portable
+  // VALUES in finish, so ordering and output stay identical.
+  decodeAttributesParse(buffer) {
+    if (!this._prepareSequence()) {
+      return false;
+    }
+    const numAttributes = this.getNumAttributes();
+    for (let i = 0; i < numAttributes; i++) {
+      if (!this._sequentialDecoders[i].decodePortableAttributeParse(this._pointIds, buffer)) {
+        return false;
+      }
+    }
+    return this.decodeDataNeededByPortableTransforms(buffer);
+  }
+  collectPendingSymbolStreams(out) {
+    const numAttributes = this.getNumAttributes();
+    for (let i = 0; i < numAttributes; i++) {
+      const pending = this._sequentialDecoders[i].pendingSymbolStream();
+      if (pending !== null) {
+        out.push(pending);
+      }
+    }
+  }
+  decodeAttributesFinish() {
+    const numAttributes = this.getNumAttributes();
+    for (let i = 0; i < numAttributes; i++) {
+      if (!this._sequentialDecoders[i].decodePortableAttributeFinish()) {
+        return false;
+      }
+    }
+    return this.transformAttributesToOriginalFormat();
   }
   getPortableAttribute(pointAttributeId) {
     const locId = this.getLocalIdForPointAttribute(pointAttributeId);
@@ -4874,14 +5752,13 @@ var DepthFirstTraverser = class {
   // 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
+  // ~500-primitive manablade 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() {
@@ -4891,7 +5768,6 @@ var DepthFirstTraverser = class {
       return true;
     }
     const isFaceVisited = this._isFaceVisited;
-    const isVertexVisited = this._isVertexVisited;
     const observer = this._observer;
     const cornerToVertex = this._cornerToVertex;
     const oppositeCorners = this._oppositeCorners;
@@ -4915,14 +5791,12 @@ var DepthFirstTraverser = class {
     if (nextVert === kInvalidVertexIndex2 || prevVert === kInvalidVertexIndex2) {
       return false;
     }
-    if (!isVertexVisited[nextVert]) {
-      isVertexVisited[nextVert] = 1;
+    if (vertexToEncodedMap[nextVert] < 0) {
       outPointIds[numOutPoints++] = obsFaces[nextCorner];
       encodedToCornerMap[numValues] = nextCorner;
       vertexToEncodedMap[nextVert] = numValues++;
     }
-    if (!isVertexVisited[prevVert]) {
-      isVertexVisited[prevVert] = 1;
+    if (vertexToEncodedMap[prevVert] < 0) {
       outPointIds[numOutPoints++] = obsFaces[prevCorner];
       encodedToCornerMap[numValues] = prevCorner;
       vertexToEncodedMap[prevVert] = numValues++;
@@ -4943,27 +5817,26 @@ var DepthFirstTraverser = class {
           encodingData.numValues = numValues;
           return false;
         }
-        if (!isVertexVisited[vertId]) {
+        const faceBase = faceId * 3;
+        const nextCornerId = cornerId === faceBase + 2 ? faceBase : cornerId + 1;
+        if (vertexToEncodedMap[vertId] < 0) {
           const lc = vertexLeftmost[vertId];
           let onBoundary = true;
-          if (lc !== void 0 && lc >= 0) {
+          if (lc >= 0) {
             const nextLc = lc % 3 === 2 ? lc - 2 : lc + 1;
             onBoundary = oppositeCorners[nextLc] < 0;
           }
-          isVertexVisited[vertId] = 1;
           outPointIds[numOutPoints++] = obsFaces[cornerId];
           encodedToCornerMap[numValues] = cornerId;
           vertexToEncodedMap[vertId] = numValues++;
           if (!onBoundary) {
-            const nextCornerId2 = cornerId % 3 === 2 ? cornerId - 2 : cornerId + 1;
-            cornerId = oppositeCorners[nextCornerId2];
+            cornerId = oppositeCorners[nextCornerId];
             faceId = cornerId / 3 | 0;
             continue;
           }
         }
-        const nextCornerId = cornerId % 3 === 2 ? cornerId - 2 : cornerId + 1;
         const rightCornerId = oppositeCorners[nextCornerId];
-        const prevCornerId = cornerId % 3 === 0 ? cornerId + 2 : cornerId - 1;
+        const prevCornerId = cornerId === faceBase ? faceBase + 2 : cornerId - 1;
         const leftCornerId = oppositeCorners[prevCornerId];
         const rightFaceId = rightCornerId === kInvalidCornerIndex4 ? kInvalidFaceIndex : rightCornerId / 3 | 0;
         const leftFaceId = leftCornerId === kInvalidCornerIndex4 ? kInvalidFaceIndex : leftCornerId / 3 | 0;
@@ -5193,6 +6066,9 @@ var MeshTraversalSequencer = class {
   _outPointIds;
   _numOutPoints;
   _traversalCache;
+  // The cache entry the last generateSequence resolved to (hit or store);
+  // carries the shared indicesMap.
+  _cacheEntry;
   constructor(mesh, encodingData, traversalCache = null) {
     this._mesh = mesh;
     this._encodingData = encodingData;
@@ -5200,6 +6076,7 @@ var MeshTraversalSequencer = class {
     this._outPointIds = new Int32Array(0);
     this._numOutPoints = 0;
     this._traversalCache = traversalCache;
+    this._cacheEntry = null;
   }
   setTraverser(traverser) {
     this._traverser = traverser;
@@ -5214,6 +6091,7 @@ var MeshTraversalSequencer = class {
       if (cached !== void 0) {
         this._outPointIds = cached.pointIds;
         this._encodingData.adoptTraversalResult(cached.vertexMap, cached.cornerMap, cached.numValues);
+        this._cacheEntry = cached;
         return true;
       }
     }
@@ -5229,12 +6107,15 @@ var MeshTraversalSequencer = class {
         byMethod = /* @__PURE__ */ new Map();
         this._traversalCache.set(cacheKey, byMethod);
       }
-      byMethod.set(methodId, {
+      const entry = {
         pointIds: this._outPointIds,
         vertexMap: this._encodingData.vertexToEncodedAttributeValueIndexMap,
         cornerMap: this._encodingData.encodedAttributeValueIndexToCornerMap,
-        numValues: this._encodingData.numValues
-      });
+        numValues: this._encodingData.numValues,
+        indicesMap: null
+      };
+      byMethod.set(methodId, entry);
+      this._cacheEntry = entry;
     }
     return true;
   }
@@ -5245,6 +6126,11 @@ var MeshTraversalSequencer = class {
     this._outPointIds[this._numOutPoints++] = pointId;
   }
   updatePointToAttributeIndexMapping(attribute) {
+    const entry = this._cacheEntry;
+    if (entry !== null && entry.indicesMap !== null) {
+      attribute.setExplicitMappingShared(entry.indicesMap);
+      return true;
+    }
     const cornerTable = this._traverser.cornerTable();
     const numFaces = this._mesh.numFaces();
     const numPoints = this._mesh.numPoints();
@@ -5266,11 +6152,14 @@ var MeshTraversalSequencer = class {
       }
       indicesMap[pointId] = attEntryId;
     }
+    if (entry !== null) {
+      entry.indicesMap = attribute.indicesMap;
+    }
     return true;
   }
   _generateSequenceInternal() {
     this._numOutPoints = 0;
-    this._outPointIds = new Int32Array(this._mesh.numPoints());
+    this._outPointIds = scratchInt32(this._mesh.numPoints());
     this._traverser.onTraversalStart();
     const numFaces = this._traverser.cornerTable().numFaces();
     for (let i = 0; i < numFaces && this._traverser._numVisitedFaces < numFaces; ++i) {
@@ -5461,14 +6350,14 @@ var MeshEdgebreakerDecoderImpl = class {
     this._attributeData = [];
     for (let i = 0; i < numAttributeData; ++i) {
       const ad = new AttributeData();
-      ad.attributeSeamCorners = new Int32Array(numFaces * 3);
+      ad.attributeSeamCorners = scratchInt32(numFaces * 3);
       ad.numSeamCorners = 0;
       this._attributeData.push(ad);
     }
     if (!this._cornerTable.reset(numFaces, this._numEncodedVertices + numEncodedSplitSymbols)) {
       return false;
     }
-    this._isVertHole = new Uint8Array(this._numEncodedVertices + numEncodedSplitSymbols).fill(1);
+    this._isVertHole = scratchUint8Filled(this._numEncodedVertices + numEncodedSplitSymbols, 1);
     if (this._decodeHoleAndTopologySplitEvents(this._decoder.buffer()) === -1) {
       return false;
     }
@@ -5493,20 +6382,37 @@ var MeshEdgebreakerDecoderImpl = class {
     }
     this._traversalDecoder.done();
     let previousConnectivityData = null;
+    let previousSeamCorners = null;
+    let previousSeamCount = 0;
     for (let i = 0; i < this._attributeData.length; ++i) {
       const connectivityData = this._attributeData[i].connectivityData;
-      connectivityData.initEmpty(this._cornerTable);
       const seamCorners = this._attributeData[i].attributeSeamCorners;
       const seamCount = this._attributeData[i].numSeamCorners;
-      for (let s = 0; s < seamCount; ++s) {
-        connectivityData.addSeamEdge(seamCorners[s]);
+      let sameAsPrevious = previousConnectivityData !== null && seamCount === previousSeamCount;
+      if (sameAsPrevious) {
+        const previous = previousSeamCorners;
+        for (let s = 0; s < seamCount; ++s) {
+          if (seamCorners[s] !== previous[s]) {
+            sameAsPrevious = false;
+            break;
+          }
+        }
       }
-      if (connectivityData.hasSameSeams(previousConnectivityData)) {
-        connectivityData.adoptVertexRecompute(previousConnectivityData);
-      } else if (!connectivityData.recomputeVertices(null, null)) {
-        return false;
+      if (sameAsPrevious) {
+        connectivityData.adoptFrom(previousConnectivityData);
+      } else {
+        connectivityData.initEmpty(this._cornerTable);
+        connectivityData.reserveSeamEdges(seamCount);
+        for (let s = 0; s < seamCount; ++s) {
+          connectivityData.addSeamEdge(seamCorners[s]);
+        }
+        if (!connectivityData.recomputeVertices(null, null)) {
+          return false;
+        }
       }
       previousConnectivityData = connectivityData;
+      previousSeamCorners = seamCorners;
+      previousSeamCount = seamCount;
     }
     this._posEncodingData.init(this._cornerTable.numVertices());
     for (let i = 0; i < this._attributeData.length; ++i) {
@@ -5545,39 +6451,27 @@ var MeshEdgebreakerDecoderImpl = class {
     const activeCornerStack = scratchInt32(numSymbols + this._topologySplitData.length + 16);
     let activeCornerStackSize = 0;
     const topologySplitActiveCorners = /* @__PURE__ */ new Map();
+    const splitResult = { faceEdge: 0, encoderSplitSymbolId: 0 };
     const invalidVertices = [];
     const removeInvalidVertices = this._attributeData.length === 0;
     let maxNumVertices = this._isVertHole.length;
     let numFacesDecoded = 0;
     const cornerToVertex = this._cornerTable._cornerToVertex;
     const oppositeCorners = this._cornerTable._oppositeCorners;
-    const numCorners = this._cornerTable.numCorners();
-    const next = (c) => c < 0 ? -1 : c % 3 === 2 ? c - 2 : c + 1;
-    const prev = (c) => c < 0 ? -1 : c % 3 === 0 ? c + 2 : c - 1;
-    const vertex = (c) => c < 0 || c >= numCorners ? -1 : cornerToVertex[c];
-    const opposite = (c) => c < 0 || c >= numCorners ? -1 : oppositeCorners[c];
-    const leftMostCorner = (v) => v < 0 || v >= this._cornerTable._vertexCorners.length ? -1 : this._cornerTable._vertexCorners[v];
-    const swingLeft = (c) => {
-      const n = next(c);
-      const o = opposite(n);
-      return o < 0 ? -1 : next(o);
-    };
-    const swingRight = (c) => {
-      const p = prev(c);
-      const o = opposite(p);
-      return o < 0 ? -1 : prev(o);
-    };
     const vc = this._cornerTable;
+    let vertexCorners = vc._vertexCorners;
+    const isVertHole = this._isVertHole;
+    const traversalDecoder = this._traversalDecoder;
     for (let symbolId = 0; symbolId < numSymbols; ++symbolId) {
       const faceIndex = numFacesDecoded++;
       let checkTopologySplit = false;
-      const symbol = this._traversalDecoder.decodeSymbol();
+      const symbol = traversalDecoder.decodeSymbol();
       if (symbol === TOPOLOGY_C) {
         if (activeCornerStackSize === 0) return -1;
         const cornerA = activeCornerStack[activeCornerStackSize - 1];
         const nA = cornerA % 3 === 2 ? cornerA - 2 : cornerA + 1;
         const vertexX = cornerToVertex[nA];
-        const lmcX = vc._vertexCorners[vertexX];
+        const lmcX = vertexCorners[vertexX];
         const cornerB = lmcX % 3 === 2 ? lmcX - 2 : lmcX + 1;
         if (cornerA === cornerB) return -1;
         if (oppositeCorners[cornerA] !== kInvalidCornerIndex6 || oppositeCorners[cornerB] !== kInvalidCornerIndex6) {
@@ -5596,8 +6490,8 @@ var MeshEdgebreakerDecoderImpl = class {
         cornerToVertex[corner] = vertexX;
         cornerToVertex[corner + 1] = vertBNext;
         cornerToVertex[corner + 2] = vertAPrev;
-        vc._vertexCorners[vertAPrev] = corner + 2;
-        this._isVertHole[vertexX] = 0;
+        vertexCorners[vertAPrev] = corner + 2;
+        isVertHole[vertexX] = 0;
         activeCornerStack[activeCornerStackSize - 1] = corner;
       } else if (symbol === TOPOLOGY_R || symbol === TOPOLOGY_L) {
         if (activeCornerStackSize === 0) return -1;
@@ -5618,14 +6512,20 @@ var MeshEdgebreakerDecoderImpl = class {
         }
         oppositeCorners[oppCorner] = cornerA;
         oppositeCorners[cornerA] = oppCorner;
-        const newVertIndex = this._cornerTable.addNewVertex();
-        if (this._cornerTable.numVertices() > maxNumVertices) return -1;
+        let newVertIndex;
+        if (vc._numVertices < vertexCorners.length) {
+          newVertIndex = vc._numVertices++;
+        } else {
+          newVertIndex = vc.addNewVertex();
+          vertexCorners = vc._vertexCorners;
+        }
+        if (vc._numVertices > maxNumVertices) return -1;
         cornerToVertex[oppCorner] = newVertIndex;
-        vc._vertexCorners[newVertIndex] = oppCorner;
+        vertexCorners[newVertIndex] = oppCorner;
         const pA = cornerA % 3 === 0 ? cornerA + 2 : cornerA - 1;
         const vertexR = cornerToVertex[pA];
         cornerToVertex[cornerR] = vertexR;
-        vc._vertexCorners[vertexR] = cornerR;
+        vertexCorners[vertexR] = cornerR;
         const nA = cornerA % 3 === 2 ? cornerA - 2 : cornerA + 1;
         cornerToVertex[cornerL] = cornerToVertex[nA];
         activeCornerStack[activeCornerStackSize - 1] = corner;
@@ -5657,11 +6557,11 @@ var MeshEdgebreakerDecoderImpl = class {
         const pB = cornerB % 3 === 0 ? cornerB + 2 : cornerB - 1;
         const vertBPrev = cornerToVertex[pB];
         cornerToVertex[corner + 2] = vertBPrev;
-        vc._vertexCorners[vertBPrev] = corner + 2;
+        vertexCorners[vertBPrev] = corner + 2;
         let cornerN = cornerB % 3 === 2 ? cornerB - 2 : cornerB + 1;
         const vertexN = cornerToVertex[cornerN];
-        this._traversalDecoder.mergeVertices(vertexP, vertexN);
-        vc._vertexCorners[vertexP] = vc._vertexCorners[vertexN];
+        traversalDecoder.mergeVertices(vertexP, vertexN);
+        vertexCorners[vertexP] = vertexCorners[vertexN];
         const firstCorner = cornerN;
         while (cornerN !== kInvalidCornerIndex6) {
           cornerToVertex[cornerN] = vertexP;
@@ -5672,32 +6572,38 @@ var MeshEdgebreakerDecoderImpl = class {
             return -1;
           }
         }
-        vc._vertexCorners[vertexN] = -1;
+        vertexCorners[vertexN] = -1;
         if (removeInvalidVertices) {
           invalidVertices.push(vertexN);
         }
         activeCornerStack[activeCornerStackSize - 1] = corner;
       } else if (symbol === TOPOLOGY_E) {
         const corner = 3 * faceIndex;
-        const firstVertIndex = this._cornerTable.addNewVertex();
-        this._cornerTable.addNewVertex();
-        this._cornerTable.addNewVertex();
-        if (this._cornerTable.numVertices() > maxNumVertices) return -1;
+        let firstVertIndex;
+        if (vc._numVertices + 3 <= vertexCorners.length) {
+          firstVertIndex = vc._numVertices;
+          vc._numVertices += 3;
+        } else {
+          firstVertIndex = vc.addNewVertex();
+          vc.addNewVertex();
+          vc.addNewVertex();
+          vertexCorners = vc._vertexCorners;
+        }
+        if (vc._numVertices > maxNumVertices) return -1;
         cornerToVertex[corner] = firstVertIndex;
         cornerToVertex[corner + 1] = firstVertIndex + 1;
         cornerToVertex[corner + 2] = firstVertIndex + 2;
-        vc._vertexCorners[firstVertIndex] = corner;
-        vc._vertexCorners[firstVertIndex + 1] = corner + 1;
-        vc._vertexCorners[firstVertIndex + 2] = corner + 2;
+        vertexCorners[firstVertIndex] = corner;
+        vertexCorners[firstVertIndex + 1] = corner + 1;
+        vertexCorners[firstVertIndex + 2] = corner + 2;
         activeCornerStack[activeCornerStackSize++] = corner;
         checkTopologySplit = true;
       } else {
         return -1;
       }
-      this._traversalDecoder.newActiveCornerReached(activeCornerStack[activeCornerStackSize - 1]);
-      if (checkTopologySplit) {
+      traversalDecoder.newActiveCornerReached(activeCornerStack[activeCornerStackSize - 1]);
+      if (checkTopologySplit && this._topologySplitData.length > 0) {
         const encoderSymbolId = numSymbols - symbolId - 1;
-        const splitResult = { faceEdge: 0, encoderSplitSymbolId: 0 };
         while (this._isTopologySplit(encoderSymbolId, splitResult)) {
           if (splitResult.encoderSplitSymbolId < 0) return -1;
           const actTopCorner = activeCornerStack[activeCornerStackSize - 1];
@@ -5712,15 +6618,39 @@ var MeshEdgebreakerDecoderImpl = class {
         }
       }
     }
-    if (this._cornerTable.numVertices() > maxNumVertices) {
+    if (vc._numVertices > maxNumVertices) {
+      return -1;
+    }
+    numFacesDecoded = this._decodeStartFaces(activeCornerStack, activeCornerStackSize, numFacesDecoded);
+    if (numFacesDecoded === -1) {
+      return -1;
+    }
+    if (numFacesDecoded !== this._cornerTable.numFaces()) {
       return -1;
     }
+    return this._removeInvalidVertices(invalidVertices);
+  }
+  // Connects the remaining active-stack corners to newly decoded start faces.
+  // Returns the updated decoded-face count, or -1 on malformed input.
+  _decodeStartFaces(activeCornerStack, activeCornerStackSize, numFacesDecoded) {
+    const ct = this._cornerTable;
+    const cornerToVertex = ct._cornerToVertex;
+    const oppositeCorners = ct._oppositeCorners;
+    const vertexCorners = ct._vertexCorners;
+    const isVertHole = this._isVertHole;
+    const traversalDecoder = this._traversalDecoder;
+    const numCorners = ct.numCorners();
+    const numFaces = ct.numFaces();
+    const next = (c) => c < 0 ? -1 : c % 3 === 2 ? c - 2 : c + 1;
+    const vertex = (c) => c < 0 || c >= numCorners ? -1 : cornerToVertex[c];
+    const opposite = (c) => c < 0 || c >= numCorners ? -1 : oppositeCorners[c];
+    const leftMostCorner = (v) => v < 0 || v >= vertexCorners.length ? -1 : vertexCorners[v];
     while (activeCornerStackSize > 0) {
       const corner = activeCornerStack[activeCornerStackSize - 1];
       activeCornerStackSize--;
-      const interiorFace = this._traversalDecoder.decodeStartFaceConfiguration();
+      const interiorFace = traversalDecoder.decodeStartFaceConfiguration();
       if (interiorFace) {
-        if (numFacesDecoded >= this._cornerTable.numFaces()) {
+        if (numFacesDecoded >= numFaces) {
           return -1;
         }
         const cornerA = corner;
@@ -5746,9 +6676,9 @@ var MeshEdgebreakerDecoderImpl = class {
         cornerToVertex[newCorner] = vertX;
         cornerToVertex[newCorner + 1] = vertP;
         cornerToVertex[newCorner + 2] = vertN;
-        this._isVertHole[vertX] = 0;
-        this._isVertHole[vertP] = 0;
-        this._isVertHole[vertN] = 0;
+        isVertHole[vertX] = 0;
+        isVertHole[vertP] = 0;
+        isVertHole[vertN] = 0;
         this._initFaceConfigurations.push(true);
         this._initCorners.push(newCorner);
       } else {
@@ -5756,10 +6686,34 @@ var MeshEdgebreakerDecoderImpl = class {
         this._initCorners.push(corner);
       }
     }
-    if (numFacesDecoded !== this._cornerTable.numFaces()) {
-      return -1;
-    }
-    let numVertices = this._cornerTable.numVertices();
+    return numFacesDecoded;
+  }
+  // Removes invalid (isolated) vertices by swapping them with the last valid
+  // vertex in the table, matching C++ mesh_edgebreaker_decoder_impl.cc (the
+  // forward iteration order matters). Returns the final vertex count, or -1.
+  _removeInvalidVertices(invalidVertices) {
+    const ct = this._cornerTable;
+    const cornerToVertex = ct._cornerToVertex;
+    const oppositeCorners = ct._oppositeCorners;
+    const vertexCorners = ct._vertexCorners;
+    const isVertHole = this._isVertHole;
+    const numCorners = ct.numCorners();
+    const next = (c) => c < 0 ? -1 : c % 3 === 2 ? c - 2 : c + 1;
+    const prev = (c) => c < 0 ? -1 : c % 3 === 0 ? c + 2 : c - 1;
+    const vertex = (c) => c < 0 || c >= numCorners ? -1 : cornerToVertex[c];
+    const opposite = (c) => c < 0 || c >= numCorners ? -1 : oppositeCorners[c];
+    const leftMostCorner = (v) => v < 0 || v >= vertexCorners.length ? -1 : vertexCorners[v];
+    const swingLeft = (c) => {
+      const n = next(c);
+      const o = opposite(n);
+      return o < 0 ? -1 : next(o);
+    };
+    const swingRight = (c) => {
+      const p = prev(c);
+      const o = opposite(p);
+      return o < 0 ? -1 : prev(o);
+    };
+    let numVertices = ct.numVertices();
     for (let ivIdx = 0; ivIdx < invalidVertices.length; ++ivIdx) {
       const invalidVert = invalidVertices[ivIdx];
       let srcVert = numVertices - 1;
@@ -5789,10 +6743,10 @@ var MeshEdgebreakerDecoderImpl = class {
           cid = swingRight(cid);
         }
       }
-      this._cornerTable._vertexCorners[invalidVert] = leftMostCorner(srcVert);
-      this._cornerTable._vertexCorners[srcVert] = -1;
-      this._isVertHole[invalidVert] = this._isVertHole[srcVert];
-      this._isVertHole[srcVert] = 0;
+      vertexCorners[invalidVert] = leftMostCorner(srcVert);
+      vertexCorners[srcVert] = -1;
+      isVertHole[invalidVert] = isVertHole[srcVert];
+      isVertHole[srcVert] = 0;
       numVertices--;
     }
     return numVertices;
@@ -5835,14 +6789,55 @@ var MeshEdgebreakerDecoderImpl = class {
   // per-corner decodeNextBit work. Within each face the three corners are
   // visited in encoder edge order [base, next, prev] = [c, c+1, c+2] (the
   // caller always starts a face at its base corner, so next/prev need no wrap).
+  //
+  // The face comparison the C++ makes -- floor(oppCorner/3) >= floor(cc/3) for
+  // the face's base corner -- is just `oppCorner >= faceBaseCorner`, since the
+  // base corner is a multiple of 3. That removes the per-corner division; the
+  // invalid-corner case (-1) is still handled by the branch above it.
   _decodeAttributeConnectivities() {
     const oppositeCorners = this._cornerTable.oppositeCornerArray();
     const attributeData = this._attributeData;
     const numAttrData = attributeData.length;
     const connectivityDecoders = this._traversalDecoder._attributeConnectivityDecoders;
     const numCorners = this._cornerTable.numCorners();
+    if (numAttrData === 1) {
+      const ad = attributeData[0];
+      const seamCorners = ad.attributeSeamCorners;
+      let numSeamCorners = ad.numSeamCorners;
+      const decoder = connectivityDecoders[0];
+      const ans = decoder.ansDecoder_;
+      const p = decoder.p_;
+      const buf = ans.buf;
+      const bufStart = ans.bufStart;
+      let state = ans.state;
+      let bufOffset = ans.bufOffset;
+      for (let corner = 0; corner < numCorners; corner += 3) {
+        for (let k = 0; k < 3; ++k) {
+          const cc = corner + k;
+          const oppCorner = oppositeCorners[cc];
+          if (oppCorner === kInvalidCornerIndex6) {
+            seamCorners[numSeamCorners++] = cc;
+          } else if (oppCorner >= corner) {
+            if (state < ANS_L_BASE && bufOffset > bufStart) {
+              state = state << 8 | buf[--bufOffset];
+            }
+            const rem = state & 255;
+            const xn = (state >>> 8) * p;
+            if (rem < p) {
+              state = xn + rem;
+              seamCorners[numSeamCorners++] = cc;
+            } else {
+              state = state - xn - p;
+            }
+          }
+        }
+      }
+      ans.state = state;
+      ans.bufOffset = bufOffset;
+      ad.numSeamCorners = numSeamCorners;
+      return;
+    }
     for (let corner = 0; corner < numCorners; corner += 3) {
-      const srcFaceId = corner / 3 | 0;
       for (let k = 0; k < 3; ++k) {
         const cc = corner + k;
         const oppCorner = oppositeCorners[cc];
@@ -5851,7 +6846,7 @@ var MeshEdgebreakerDecoderImpl = class {
             const ad = attributeData[i];
             ad.attributeSeamCorners[ad.numSeamCorners++] = cc;
           }
-        } else if ((oppCorner / 3 | 0) >= srcFaceId) {
+        } else if (oppCorner >= corner) {
           for (let i = 0; i < numAttrData; ++i) {
             if (connectivityDecoders[i].decodeNextBit()) {
               const ad = attributeData[i];
@@ -5882,10 +6877,10 @@ var MeshEdgebreakerDecoderImpl = class {
     const attributeData = this._attributeData;
     const numAttrData = attributeData.length;
     let numPoints = 0;
-    const cornerToPointMap = new Int32Array(ct.numCorners());
+    const cornerToPointMap = scratchInt32(ct.numCorners());
     const numVertices = ct.numVertices();
     const vertexLeftmost = ct.vertexLeftmostCornerArray();
-    const baseOpp = ct.oppositeCornerArray();
+    const swingRight = ct.swingRightArray();
     const _baseCornerToVertex = ct.cornerToVertexArray();
     const isVertHole = this._isVertHole;
     const attCornerToVertex = new Array(numAttrData);
@@ -5899,7 +6894,7 @@ var MeshEdgebreakerDecoderImpl = class {
     if (numAttrData === 1) {
       anyAttVertexOnSeam = attVertexOnSeam[0];
     } else {
-      anyAttVertexOnSeam = new Uint8Array(numVertices);
+      anyAttVertexOnSeam = scratchUint8Zeroed(numVertices);
       for (let i = 0; i < numAttrData; ++i) {
         const attSeam = attVertexOnSeam[i];
         for (let v = 0; v < numVertices; ++v) {
@@ -5917,37 +6912,24 @@ var MeshEdgebreakerDecoderImpl = class {
         const initialC = c;
         const pointId = numPoints++;
         cornerToPointMap[initialC] = pointId;
-        let rem = initialC % 3;
-        let pv = rem === 0 ? initialC + 2 : initialC - 1;
-        let opp = baseOpp[pv];
-        c = opp < 0 ? kInvalidCornerIndex6 : opp % 3 === 0 ? opp + 2 : opp - 1;
+        c = swingRight[initialC];
         while (c !== kInvalidCornerIndex6 && c !== initialC) {
           cornerToPointMap[c] = pointId;
-          rem = c % 3;
-          pv = rem === 0 ? c + 2 : c - 1;
-          opp = baseOpp[pv];
-          c = opp < 0 ? kInvalidCornerIndex6 : opp % 3 === 0 ? opp + 2 : opp - 1;
+          c = swingRight[c];
         }
       } else {
         let deduplicationFirstCorner = c;
-        let rem, pv, opp;
         if (!isVertHole[v]) {
           if (numAttrData === 1) {
             const vertId = singleAttC2V[c];
-            rem = c % 3;
-            pv = rem === 0 ? c + 2 : c - 1;
-            opp = baseOpp[pv];
-            let actC = opp < 0 ? kInvalidCornerIndex6 : opp % 3 === 0 ? opp + 2 : opp - 1;
+            let actC = swingRight[c];
             while (actC !== c) {
               if (actC === kInvalidCornerIndex6) return false;
               if (singleAttC2V[actC] !== vertId) {
                 deduplicationFirstCorner = actC;
                 break;
               }
-              rem = actC % 3;
-              pv = rem === 0 ? actC + 2 : actC - 1;
-              opp = baseOpp[pv];
-              actC = opp < 0 ? kInvalidCornerIndex6 : opp % 3 === 0 ? opp + 2 : opp - 1;
+              actC = swingRight[actC];
             }
           } else {
             for (let i = 0; i < numAttrData; ++i) {
@@ -5956,10 +6938,7 @@ var MeshEdgebreakerDecoderImpl = class {
               }
               const attC2V = attCornerToVertex[i];
               const vertId = attC2V[c];
-              rem = c % 3;
-              pv = rem === 0 ? c + 2 : c - 1;
-              opp = baseOpp[pv];
-              let actC = opp < 0 ? kInvalidCornerIndex6 : opp % 3 === 0 ? opp + 2 : opp - 1;
+              let actC = swingRight[c];
               let seamFound = false;
               while (actC !== c) {
                 if (actC === kInvalidCornerIndex6) return false;
@@ -5968,10 +6947,7 @@ var MeshEdgebreakerDecoderImpl = class {
                   seamFound = true;
                   break;
                 }
-                rem = actC % 3;
-                pv = rem === 0 ? actC + 2 : actC - 1;
-                opp = baseOpp[pv];
-                actC = opp < 0 ? kInvalidCornerIndex6 : opp % 3 === 0 ? opp + 2 : opp - 1;
+                actC = swingRight[actC];
               }
               if (seamFound) break;
             }
@@ -5980,10 +6956,7 @@ var MeshEdgebreakerDecoderImpl = class {
         c = deduplicationFirstCorner;
         cornerToPointMap[c] = numPoints++;
         let prevC = c;
-        rem = c % 3;
-        pv = rem === 0 ? c + 2 : c - 1;
-        opp = baseOpp[pv];
-        c = opp < 0 ? kInvalidCornerIndex6 : opp % 3 === 0 ? opp + 2 : opp - 1;
+        c = swingRight[c];
         while (c !== kInvalidCornerIndex6 && c !== deduplicationFirstCorner) {
           let attributeSeam;
           if (numAttrData === 1) {
@@ -6004,10 +6977,7 @@ var MeshEdgebreakerDecoderImpl = class {
             cornerToPointMap[c] = cornerToPointMap[prevC];
           }
           prevC = c;
-          rem = c % 3;
-          pv = rem === 0 ? c + 2 : c - 1;
-          opp = baseOpp[pv];
-          c = opp < 0 ? kInvalidCornerIndex6 : opp % 3 === 0 ? opp + 2 : opp - 1;
+          c = swingRight[c];
         }
       }
     }
@@ -6033,8 +7003,8 @@ var MeshAttributeIndicesEncodingData = class {
     this._numValues = 0;
   }
   init(numVertices) {
-    this._vertexToEncodedAttributeValueIndexMap = new Int32Array(numVertices);
-    this._encodedAttributeValueIndexToCornerMap = new Int32Array(numVertices);
+    this._vertexToEncodedAttributeValueIndexMap = scratchInt32Filled(numVertices, -1);
+    this._encodedAttributeValueIndexToCornerMap = scratchInt32(numVertices);
     this._numValues = 0;
   }
   // Adopts a traversal result from an identical corner table, avoiding a
@@ -6084,6 +7054,8 @@ var CornerTable = class {
   // corner -> opposite corner
   _vertexCorners;
   // vertex -> left-most corner
+  _swingRight;
+  // corner -> next corner around its vertex, CW
   constructor() {
     this._numFaces = 0;
     this._numCorners = 0;
@@ -6091,16 +7063,42 @@ var CornerTable = class {
     this._cornerToVertex = null;
     this._oppositeCorners = null;
     this._vertexCorners = null;
+    this._swingRight = null;
   }
   reset(numFaces, numVertices) {
     this._numFaces = numFaces;
     this._numCorners = numFaces * 3;
     this._numVertices = 0;
-    this._cornerToVertex = new Int32Array(this._numCorners).fill(-1);
-    this._oppositeCorners = new Int32Array(this._numCorners).fill(-1);
-    this._vertexCorners = new Int32Array(numVertices).fill(-1);
+    this._cornerToVertex = scratchInt32Filled(this._numCorners, -1);
+    this._oppositeCorners = scratchInt32Filled(this._numCorners, -1);
+    this._vertexCorners = scratchInt32Filled(numVertices, -1);
+    this._swingRight = null;
     return true;
   }
+  // swingRight(c) = previous(opposite(previous(c))) for every corner. Walking
+  // the corner ring of a vertex is the inner loop of both the attribute-vertex
+  // recompute and the point assignment, and each of those passes otherwise
+  // pays two modulus-by-3 chains per step on top of the opposite lookup. Built
+  // lazily -- callers only reach it once connectivity is final -- from
+  // decode-scoped scratch, and dropped by reset().
+  swingRightArray() {
+    let table = this._swingRight;
+    if (table === null) {
+      const numCorners = this._numCorners;
+      const opposite = this._oppositeCorners;
+      table = scratchInt32(numCorners);
+      for (let c = 0; c < numCorners; c += 3) {
+        let o = opposite[c + 2];
+        table[c] = o < 0 ? kInvalidCornerIndex6 : o % 3 === 0 ? o + 2 : o - 1;
+        o = opposite[c];
+        table[c + 1] = o < 0 ? kInvalidCornerIndex6 : o % 3 === 0 ? o + 2 : o - 1;
+        o = opposite[c + 1];
+        table[c + 2] = o < 0 ? kInvalidCornerIndex6 : o % 3 === 0 ? o + 2 : o - 1;
+      }
+      this._swingRight = table;
+    }
+    return table;
+  }
   numFaces() {
     return this._numFaces;
   }
@@ -6144,8 +7142,7 @@ var CornerTable = class {
     this._numVertices++;
     if (newVertex >= this._vertexCorners.length) {
       const newCapacity = Math.max(newVertex + 1, this._vertexCorners.length * 2, 64);
-      const newArr = new Int32Array(newCapacity);
-      newArr.fill(-1);
+      const newArr = scratchInt32Filled(newCapacity, -1);
       newArr.set(this._vertexCorners);
       this._vertexCorners = newArr;
     }
@@ -6176,6 +7173,10 @@ var MeshEdgebreakerTraversalDecoder = class {
   _attributeConnectivityDecoders;
   _numAttributeData;
   _decoderImpl;
+  // _symbolBuffer's bit cursor, captured once bit decoding starts: decodeSymbol
+  // runs per decoded face and would otherwise reach it through two property
+  // loads and a method call per read.
+  _symbolBits;
   constructor() {
     this._buffer = new DecoderBuffer();
     this._symbolBuffer = new DecoderBuffer();
@@ -6183,6 +7184,7 @@ var MeshEdgebreakerTraversalDecoder = class {
     this._attributeConnectivityDecoders = null;
     this._numAttributeData = 0;
     this._decoderImpl = null;
+    this._symbolBits = null;
   }
   init(decoder) {
     this._decoderImpl = decoder;
@@ -6217,6 +7219,21 @@ var MeshEdgebreakerTraversalDecoder = class {
     return this._startFaceDecoder.decodeNextBit() ? true : false;
   }
   decodeSymbol() {
+    const bd = this._symbolBits;
+    if (bd !== null) {
+      const buf = bd._bitBuffer;
+      const off = bd._bitOffset;
+      const byteOffset = off >> 3;
+      if (byteOffset + 4 < bd._byteLength) {
+        const bits = (buf[byteOffset] | buf[byteOffset + 1] << 8 | buf[byteOffset + 2] << 16 | buf[byteOffset + 3] << 24) >>> (off & 7) & 7;
+        if ((bits & 1) === TOPOLOGY_C) {
+          bd._bitOffset = off + 1;
+          return TOPOLOGY_C;
+        }
+        bd._bitOffset = off + 3;
+        return bits;
+      }
+    }
     let symbol = this._symbolBuffer.decodeLeastSignificantBits32(1);
     if (symbol === TOPOLOGY_C) {
       return symbol;
@@ -6246,6 +7263,7 @@ var MeshEdgebreakerTraversalDecoder = class {
     if (traversalSize === void 0) {
       return false;
     }
+    this._symbolBits = this._symbolBuffer._bitDecoder;
     this._buffer.init(
       this._symbolBuffer.dataHead,
       this._symbolBuffer.remainingSize,
@@ -6398,7 +7416,13 @@ var MeshEdgebreakerTraversalValenceDecoder = class extends MeshEdgebreakerTraver
   _maxValence;
   _vertexValences;
   _contextSymbols;
+  // Int32Array, not number[]: read and written once per decoded symbol.
   _contextCounters;
+  // corner -> vertex of _cornerTable, cached at init(); the array is created
+  // once by CornerTable.reset() before the traversal decoder is initialized and
+  // never replaced, so the per-symbol hot path can read it without two property
+  // loads.
+  _cornerToVertex;
   constructor() {
     super();
     this._cornerTable = null;
@@ -6409,11 +7433,13 @@ var MeshEdgebreakerTraversalValenceDecoder = class extends MeshEdgebreakerTraver
     this._maxValence = 7;
     this._vertexValences = new Int32Array(0);
     this._contextSymbols = [];
-    this._contextCounters = [];
+    this._contextCounters = new Int32Array(0);
+    this._cornerToVertex = new Int32Array(0);
   }
   init(decoder) {
     super.init(decoder);
     this._cornerTable = decoder.getCornerTable();
+    this._cornerToVertex = this._cornerTable._cornerToVertex;
   }
   setNumEncodedVertices(numVertices) {
     this._numVertices = numVertices;
@@ -6431,10 +7457,11 @@ var MeshEdgebreakerTraversalValenceDecoder = class extends MeshEdgebreakerTraver
     if (this._numVertices < 0) {
       return false;
     }
-    this._vertexValences = new Int32Array(this._numVertices);
+    this._vertexValences = scratchInt32Filled(this._numVertices, 0);
     const numUniqueValences = this._maxValence - this._minValence + 1;
     this._contextSymbols = new Array(numUniqueValences);
-    this._contextCounters = new Array(numUniqueValences);
+    this._contextCounters = new Int32Array(numUniqueValences);
+    const pending = [];
     for (let i = 0; i < numUniqueValences; ++i) {
       const numSymbols = decodeVarint(outBuffer);
       if (numSymbols === void 0) {
@@ -6444,16 +7471,73 @@ var MeshEdgebreakerTraversalValenceDecoder = class extends MeshEdgebreakerTraver
         return false;
       }
       if (numSymbols > 0) {
-        this._contextSymbols[i] = new Uint32Array(numSymbols);
-        if (!decodeSymbols(numSymbols, 1, outBuffer, this._contextSymbols[i])) {
+        this._contextSymbols[i] = scratchUint32(numSymbols);
+        const scheme = outBuffer.decodeUint8();
+        if (scheme === SymbolCodingMethod.SYMBOL_CODING_TAGGED) {
+          if (!decodeTaggedSymbols(numSymbols, 1, outBuffer, this._contextSymbols[i])) {
+            return false;
+          }
+          this._contextCounters[i] = numSymbols;
+          continue;
+        }
+        if (scheme !== SymbolCodingMethod.SYMBOL_CODING_RAW) {
           return false;
         }
+        const maxBitLength = outBuffer.decodeUint8();
+        if (maxBitLength === void 0 || maxBitLength < 1 || maxBitLength > 18) {
+          return false;
+        }
+        const decoder = new RAnsSymbolDecoder(maxBitLength);
+        if (!decoder.create(outBuffer, numSymbols)) {
+          return false;
+        }
+        if (decoder.numSymbols === 0) {
+          return false;
+        }
+        if (!decoder.startDecoding(outBuffer)) {
+          return false;
+        }
+        pending.push({ decoder, out: this._contextSymbols[i], count: numSymbols });
         this._contextCounters[i] = numSymbols;
       } else {
         this._contextSymbols[i] = new Uint32Array(0);
         this._contextCounters[i] = 0;
       }
     }
+    const lockstep = pending.filter((entry) => entry.decoder.ans_.lutTable instanceof Uint8Array);
+    let p = 0;
+    while (lockstep.length - p >= 3) {
+      const a = lockstep[p];
+      const b = lockstep[p + 1];
+      const c = lockstep[p + 2];
+      ransDecodeSymbolsTrioU8(
+        a.decoder.ans_,
+        a.out,
+        a.count,
+        b.decoder.ans_,
+        b.out,
+        b.count,
+        c.decoder.ans_,
+        c.out,
+        c.count
+      );
+      p += 3;
+    }
+    if (lockstep.length - p === 2) {
+      const a = lockstep[p];
+      const b = lockstep[p + 1];
+      ransDecodeSymbolsPairU8(a.decoder.ans_, a.out, a.count, b.decoder.ans_, b.out, b.count);
+      p += 2;
+    }
+    for (; p < lockstep.length; ++p) {
+      lockstep[p].decoder.ans_.decodeSymbols(lockstep[p].out, lockstep[p].count);
+    }
+    for (const entry of pending) {
+      if (!(entry.decoder.ans_.lutTable instanceof Uint8Array)) {
+        entry.decoder.ans_.decodeSymbols(entry.out, entry.count);
+      }
+      entry.decoder.endDecoding();
+    }
     return true;
   }
   decodeSymbol() {
@@ -6473,7 +7557,7 @@ var MeshEdgebreakerTraversalValenceDecoder = class extends MeshEdgebreakerTraver
     return this._lastSymbol;
   }
   newActiveCornerReached(corner) {
-    const cornerToVertex = this._cornerTable._cornerToVertex;
+    const cornerToVertex = this._cornerToVertex;
     const valences = this._vertexValences;
     const next = corner % 3 === 2 ? corner - 2 : corner + 1;
     const prev = corner % 3 === 0 ? corner + 2 : corner - 1;