minidraco 0.8.0 → 0.9.0

package/dist/three.js

@@ -46,31 +46,31 @@ var Type = {
 var GeometryAttribute = class {
   d = null;
   y = 1;
-  S = 9 /* FLOAT32 */;
+  T = 9 /* FLOAT32 */;
   Za = false;
-  T = 0;
   U = 0;
+  V = 0;
   Ia = Type.INVALID;
   Ja = 0;
   init(attributeType, buffer, numComponents, dataType, normalized, byteStride, byteOffset) {
     this.d = buffer;
     this.y = numComponents;
-    this.S = dataType;
+    this.T = dataType;
     this.Za = normalized;
-    this.T = byteStride;
-    this.U = byteOffset;
+    this.U = byteStride;
+    this.V = byteOffset;
     this.Ia = attributeType;
   }
   resetBuffer(buffer, byteStride, byteOffset) {
     this.d = buffer;
-    this.T = byteStride;
-    this.U = byteOffset;
+    this.U = byteStride;
+    this.V = byteOffset;
   }
   get attributeType() {
     return this.Ia;
   }
   get dataType() {
-    return this.S;
+    return this.T;
   }
   get numComponents() {
     return this.y;
@@ -79,10 +79,10 @@ var GeometryAttribute = class {
     return this.d;
   }
   get byteStride() {
-    return this.T;
+    return this.U;
   }
   get byteOffset() {
-    return this.U;
+    return this.V;
   }
   get uniqueId() {
     return this.Ja;
@@ -95,7 +95,7 @@ var GeometryAttribute = class {
 // src/decoder/point_cloud/PointCloud.ts
 var NAMED_ATTRIBUTES_COUNT = 8;
 var PointCloud = class {
-  ub = 0;
+  sb = 0;
   attributes_ = [];
   // named_attribute_index_[type] = [att_id, ...], one list per named type.
   _a = [[], [], [], [], [], [], [], []];
@@ -156,10 +156,10 @@ var PointCloud = class {
     this.attributes_[attId] = pa;
   }
   numPoints() {
-    return this.ub;
+    return this.sb;
   }
   setNumPoints(num) {
-    this.ub = num;
+    this.sb = num;
   }
 };
 
@@ -169,7 +169,7 @@ var Mesh = class extends PointCloud {
   // a per-face allocation. faces_[3*f + c] is corner c of face f; corner index
   // ci maps directly to faces_[ci].
   faces_ = new Int32Array(0);
-  vb = 0;
+  tb = 0;
   // Sizes faces_ to hold numFaces faces. Called once per decode, before any
   // face index is written (edgebreaker: _assignPointsToCorners; sequential:
   // decodeConnectivity), so the buffer is allocated exactly here — the
@@ -181,124 +181,84 @@ var Mesh = class extends PointCloud {
       grown.set(this.faces_);
       this.faces_ = grown;
     }
-    this.vb = numFaces;
+    this.tb = numFaces;
   }
   numFaces() {
-    return this.vb;
+    return this.tb;
   }
 };
 
 // src/decoder/core/DataBuffer.ts
 var DataBuffer = class {
-  o = new Uint8Array(0);
+  h = new Uint8Array(0);
   // Resizes to `size` bytes (contents preserved); when `data` is given, grows
   // as needed and copies its first `size` bytes in.
   update(data, size) {
     if (data === null) {
-      this.wb(size);
+      this.ub(size);
       return;
     }
-    if (size > this.o.length) {
-      this.wb(size);
+    if (size > this.h.length) {
+      this.ub(size);
     }
-    this.o.set(data.length === size ? data : data.subarray(0, size));
+    this.h.set(data.length === size ? data : data.subarray(0, size));
   }
   // The caller passes a Uint8Array of exactly dataSize bytes in the common
   // case; avoid allocating a wrapper view per value (dominates storage time /
   // GC pressure).
   write(bytePos, inArray, dataSize) {
-    this.o.set(inArray.length === dataSize ? inArray : inArray.subarray(0, dataSize), bytePos);
+    this.h.set(inArray.length === dataSize ? inArray : inArray.subarray(0, dataSize), bytePos);
   }
   get data() {
-    return this.o;
+    return this.h;
   }
-  wb(newSize) {
-    if (newSize === this.o.length) return;
+  ub(newSize) {
+    if (newSize === this.h.length) return;
     const newData = new Uint8Array(newSize);
-    newData.set(this.o.subarray(0, Math.min(this.o.length, newSize)));
-    this.o = newData;
+    if (this.h.length > 0) newData.set(this.h.subarray(0, Math.min(this.h.length, newSize)));
+    this.h = newData;
   }
 };
 
 // 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 arena = new ArrayBuffer(1 << 16);
+var top = 0;
+var outgrown = 0;
+var carve = (bytes) => {
+  const size = bytes + 7 & ~7;
+  if (top + size > arena.byteLength) {
+    outgrown += top;
+    arena = new ArrayBuffer(Math.max(arena.byteLength * 2, size));
+    top = 0;
+  }
+  const offset = top;
+  top += size;
+  return offset;
+};
 var scratchInt32 = (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);
+  const offset = carve(size * 4);
+  return new Int32Array(arena, offset, size);
 };
 var scratchUint32 = (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);
+  const offset = carve(size * 4);
+  return new Uint32Array(arena, offset, size);
 };
-var byteCapacity = (size) => size < 8 ? 8 : size + 7 & ~7;
 var scratchUint8 = (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 scratchInt32Filled = (size, value) => {
-  const view = scratchInt32(size);
-  view.fill(value);
-  return view;
-};
-var scratchUint32Zeroed = (size) => {
-  const view = scratchUint32(size);
-  view.fill(0);
-  return view;
-};
-var scratchUint8Zeroed = (size) => {
-  const view = scratchUint8(size);
-  view.fill(0);
-  return view;
-};
-var scratchUint8Filled = (size, value) => {
-  const view = scratchUint8(size);
-  view.fill(value);
-  return view;
+  const offset = carve(size);
+  return new Uint8Array(arena, offset, size);
 };
+var scratchInt32Filled = (size, value) => scratchInt32(size).fill(value);
+var scratchUint32Zeroed = (size) => scratchUint32(size).fill(0);
+var scratchUint8Zeroed = (size) => scratchUint8(size).fill(0);
+var scratchUint8Filled = (size, value) => scratchUint8(size).fill(value);
+var EMPTY_INT32 = new Int32Array(0);
+var EMPTY_UINT8 = new Uint8Array(0);
 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);
+  if (outgrown > 0) {
+    arena = new ArrayBuffer(outgrown + top);
+    outgrown = 0;
   }
-  borrowedInt32.length = 0;
-  borrowedUint32.length = 0;
-  borrowedUint8.length = 0;
+  top = 0;
 };
 
 // src/decoder/attributes/PointAttribute.ts
@@ -329,38 +289,38 @@ var LAZY_INTEGER = 1;
 var LAZY_QUANTIZED = 2;
 var LAZY_OCTAHEDRON = 3;
 var PointAttribute = class extends GeometryAttribute {
-  D = false;
-  $a = 0;
-  E = [];
-  ca = null;
+  E = false;
+  Ka = 0;
+  F = [];
+  W = null;
   // Lazily-created cached typed-array view over the attribute buffer, keyed
   // on (constructor, underlying ArrayBuffer). An attribute only ever reads
   // through the one view type its data type dictates.
+  vb = null;
+  wb = null;
   xb = null;
-  yb = null;
-  zb = null;
   // Deferred inverse transform. The integer attribute decoders leave their
   // decoded values here as int32 -- quantized floats, octahedral normals or
   // plain integers -- with the transform's parameters, and extractTo applies
   // the transform while gathering the values into point order: one pass over
   // the points instead of an inverse-transform pass into a per-value buffer
   // followed by a gather from it, and no such buffer at all.
-  Ka = LAZY_NONE;
-  da = null;
-  Ab = [];
-  La = 0;
+  La = LAZY_NONE;
+  ea = null;
+  yb = [];
+  Ma = 0;
   // Set when the decoder knows every lazy value is below 2^24 in magnitude
   // (see _lazyFloatValues); the extraction then skips its scan.
-  ab = false;
+  $a = false;
   constructor(geometryAttribute) {
     super();
     if (geometryAttribute instanceof GeometryAttribute) {
       this.d = geometryAttribute.d;
       this.y = geometryAttribute.y;
-      this.S = geometryAttribute.S;
-      this.Za = geometryAttribute.Za;
       this.T = geometryAttribute.T;
+      this.Za = geometryAttribute.Za;
       this.U = geometryAttribute.U;
+      this.V = geometryAttribute.V;
       this.Ia = geometryAttribute.Ia;
       this.Ja = geometryAttribute.Ja;
     }
@@ -368,78 +328,87 @@ var PointAttribute = class extends GeometryAttribute {
   // Intentionally shadows GeometryAttribute.init with a different signature (matches draco.js / C++ source).
   // @ts-expect-error -- signature intentionally differs from the base class, as in the source.
   init(attributeType, numComponents, dataType, normalized, numAttributeValues) {
-    this.ca = new DataBuffer();
+    this.W = new DataBuffer();
     const byteStride = dataTypeLength(dataType) * numComponents;
-    super.init(attributeType, this.ca, numComponents, dataType, normalized, byteStride, 0);
+    super.init(attributeType, this.W, numComponents, dataType, normalized, byteStride, 0);
     this.reset(numAttributeValues);
     this.setIdentityMapping();
   }
   reset(numAttributeValues) {
-    if (this.ca === null) {
-      this.ca = new DataBuffer();
+    if (this.W === null) {
+      this.W = new DataBuffer();
     }
     const entrySize = dataTypeLength(this.dataType) * this.numComponents;
-    this.ca.update(null, numAttributeValues * entrySize);
-    this.resetBuffer(this.ca, entrySize, 0);
-    this.$a = numAttributeValues;
+    this.W.update(null, numAttributeValues * entrySize);
+    this.resetBuffer(this.W, entrySize, 0);
+    this.Ka = numAttributeValues;
     return true;
   }
+  // Takes `data` (numAttributeValues values in the attribute's layout) as its
+  // storage, without a copy.
+  resetWithData(data, numAttributeValues) {
+    const buffer = new DataBuffer();
+    buffer.h = data;
+    this.W = buffer;
+    this.resetBuffer(buffer, dataTypeLength(this.dataType) * this.numComponents, 0);
+    this.Ka = numAttributeValues;
+  }
   // Sizes the attribute without allocating storage, for the deferred
   // transforms below (the values live in the decoder's portable attribute).
   resetLazy(numAttributeValues) {
-    this.$a = numAttributeValues;
+    this.Ka = numAttributeValues;
   }
   // numValues decoded integers of the attribute's own integer type, stored as
   // int32; extractTo converts them to the requested output type.
   setLazyInteger(values) {
-    this.Ka = LAZY_INTEGER;
-    this.da = values;
+    this.La = LAZY_INTEGER;
+    this.ea = values;
   }
   // Quantized float values: value * delta + min per component (float32
   // arithmetic, see _extractQuantized), as the C++ Dequantizer computes them.
   setLazyQuantized(values, minValues, delta, bounded) {
-    this.Ka = LAZY_QUANTIZED;
-    this.da = values;
-    this.Ab = minValues;
-    this.La = delta;
-    this.ab = bounded;
+    this.La = LAZY_QUANTIZED;
+    this.ea = values;
+    this.yb = minValues;
+    this.Ma = delta;
+    this.$a = bounded;
   }
   // Octahedral normals: two quantized coordinates per value, dequantized by
   // `scale` and turned into unit vectors (see _extractOctahedron).
   setLazyOctahedron(values, scale, bounded) {
-    this.Ka = LAZY_OCTAHEDRON;
-    this.da = values;
-    this.La = scale;
-    this.ab = bounded;
+    this.La = LAZY_OCTAHEDRON;
+    this.ea = values;
+    this.Ma = scale;
+    this.$a = bounded;
   }
   get size() {
-    return this.$a;
+    return this.Ka;
   }
   mappedIndex(pointIndex) {
-    if (this.D) {
+    if (this.E) {
       return pointIndex;
     }
-    return this.E[pointIndex];
+    return this.F[pointIndex];
   }
   get isMappingIdentity() {
-    return this.D;
+    return this.E;
   }
   get indicesMapSize() {
-    if (this.D) {
+    if (this.E) {
       return 0;
     }
-    return this.E.length;
+    return this.F.length;
   }
   // Direct access to the explicit point->value index map (a Uint32Array after
   // any of the setExplicitMapping* calls). Lets hot mapping loops write
   // entries without a per-entry dispatch.
   get indicesMap() {
-    return this.E;
+    return this.F;
   }
   // Implicit mapping: point index equals attribute entry index.
   setIdentityMapping() {
-    this.D = true;
-    this.E = [];
+    this.E = true;
+    this.F = [];
   }
   // Explicit mapping without an invalid-index fill. Only for callers that
   // provably write every entry right away (the fill was ~4% of decode time on
@@ -449,31 +418,31 @@ var PointAttribute = class extends GeometryAttribute {
   // and avoids boxed-number storage; it is read once per point per attribute.
   // Must be UNSIGNED so the 0xFFFFFFFF invalid sentinel round-trips intact.
   setExplicitMappingUnfilled(numPoints) {
-    this.D = false;
-    this.E = new Uint32Array(numPoints);
+    this.E = false;
+    this.F = 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).
   setExplicitMappingShared(map) {
-    this.D = false;
-    this.E = map;
+    this.E = false;
+    this.F = 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.D = false;
-    this.E = scratchUint32(numPoints);
+    this.E = false;
+    this.F = scratchUint32(numPoints);
   }
   // Cached typed-array view of the given type over the attribute buffer.
-  Bb(Ctor, bufData) {
-    if (this.xb !== Ctor || this.yb !== bufData.buffer) {
-      this.xb = Ctor;
-      this.yb = bufData.buffer;
-      this.zb = new Ctor(bufData.buffer);
+  zb(Ctor, bufData) {
+    if (this.vb !== Ctor || this.wb !== bufData.buffer) {
+      this.vb = Ctor;
+      this.wb = bufData.buffer;
+      this.xb = new Ctor(bufData.buffer);
     }
-    return this.zb;
+    return this.xb;
   }
   // Mirrors C++ PointAttribute::ConvertValue<T>() for buffer-backed
   // attributes. Attribute buffers start at byteOffset 0 and entries are
@@ -482,13 +451,13 @@ var PointAttribute = class extends GeometryAttribute {
   convertValue(attIndex, outVal) {
     const bufData = this.d.data;
     const nc = this.y;
-    const Ctor = viewCtorFor(this.S);
+    const Ctor = viewCtorFor(this.T);
     if (Ctor === null) {
       for (let i = 0; i < nc; ++i) outVal[i] = 0;
       return;
     }
-    const view = this.Bb(Ctor, bufData);
-    const baseIndex = (bufData.byteOffset + this.U + this.T * attIndex) / Ctor.BYTES_PER_ELEMENT;
+    const view = this.zb(Ctor, bufData);
+    const baseIndex = (bufData.byteOffset + this.V + this.U * attIndex) / Ctor.BYTES_PER_ELEMENT;
     for (let i = 0; i < nc; ++i) outVal[i] = view[baseIndex + i];
   }
   // Flat-array extraction of all values into one output typed array, in point
@@ -499,26 +468,31 @@ var PointAttribute = class extends GeometryAttribute {
     if (numPoints === 0) {
       return array;
     }
-    const kind = this.Ka;
+    const kind = this.La;
     if (kind !== LAZY_NONE) {
-      if (this.da !== null) {
-        if (kind === LAZY_QUANTIZED) this.ec(array, numPoints);
-        else if (kind === LAZY_OCTAHEDRON) this.fc(array, numPoints);
-        else this.gc(array, numPoints);
+      if (this.ea !== null) {
+        if (kind === LAZY_INTEGER) {
+          this.ec(array, numPoints);
+        } else {
+          const floats = array instanceof Float32Array ? array : new Float32Array(array.length);
+          if (kind === LAZY_QUANTIZED) this.fc(floats, numPoints);
+          else this.gc(floats, numPoints);
+          if (floats !== array) array.set(floats);
+        }
       }
       return array;
     }
-    const Ctor = viewCtorFor(this.S);
+    const Ctor = viewCtorFor(this.T);
     if (this.d === null || Ctor === null) {
       return array;
     }
     const bufData = this.d.data;
-    const isIdentity = this.D;
-    const indicesMap = this.E;
-    const srcView = this.Bb(Ctor, bufData);
+    const isIdentity = this.E;
+    const indicesMap = this.F;
+    const srcView = this.zb(Ctor, bufData);
     const shift = 31 - Math.clz32(Ctor.BYTES_PER_ELEMENT);
-    const srcStart = bufData.byteOffset + this.U >> shift;
-    const strideElements = this.T >> shift;
+    const srcStart = bufData.byteOffset + this.V >> shift;
+    const strideElements = this.U >> shift;
     if (isIdentity && strideElements === numComponents) {
       const srcEnd = srcStart + numPoints * numComponents;
       if (srcView.constructor === OutputTypedArray) {
@@ -545,8 +519,8 @@ var PointAttribute = class extends GeometryAttribute {
   // are bit-identical to the reference decoder whatever the output array type.
   // Point -> value index; the identity mapping (sequential meshes) gets a
   // plain iota so the loops carry no per-point branch.
-  bb(numPoints) {
-    if (!this.D) return this.E;
+  ab(numPoints) {
+    if (!this.E) return this.F;
     const map = new Uint32Array(numPoints);
     for (let p = 0; p < numPoints; ++p) map[p] = p;
     return map;
@@ -559,9 +533,9 @@ var PointAttribute = class extends GeometryAttribute {
   // practice) are rounded in place once here, after which the same holds.
   // The decoder marks the attribute bounded when its prediction transform
   // already confines the values to that range, and the scan is skipped.
-  Cb() {
-    const values = this.da;
-    if (this.ab) return values;
+  Ab() {
+    const values = this.ea;
+    if (this.$a) return values;
     for (let i = 0; i < values.length; ++i) {
       if (values[i] >= 16777216 || values[i] <= -16777216) {
         for (let j = 0; j < values.length; ++j) values[j] = Math.fround(values[j]);
@@ -570,23 +544,24 @@ var PointAttribute = class extends GeometryAttribute {
     }
     return values;
   }
-  // C++ Dequantizer: float(value) * delta + min, all in float32.
-  ec(out, numPoints) {
-    const values = this.Cb();
-    const map = this.bb(numPoints);
+  // C++ Dequantizer: float(value) * delta + min, all in float32 (the final
+  // rounding is the Float32Array store's).
+  fc(out, numPoints) {
+    const values = this.Ab();
+    const map = this.ab(numPoints);
     const numComponents = this.y;
     const fround = Math.fround;
-    const delta = this.La;
-    const min = this.Ab;
+    const delta = this.Ma;
+    const min = this.yb;
     if (numComponents === 3) {
       const m0 = min[0];
       const m1 = min[1];
       const m2 = min[2];
       for (let p = 0, d = 0; p < numPoints; ++p, d += 3) {
         const s = map[p] * 3;
-        out[d] = fround(fround(values[s] * delta) + m0);
-        out[d + 1] = fround(fround(values[s + 1] * delta) + m1);
-        out[d + 2] = fround(fround(values[s + 2] * delta) + m2);
+        out[d] = fround(values[s] * delta) + m0;
+        out[d + 1] = fround(values[s + 1] * delta) + m1;
+        out[d + 2] = fround(values[s + 2] * delta) + m2;
       }
       return;
     }
@@ -595,54 +570,51 @@ var PointAttribute = class extends GeometryAttribute {
       const m1 = min[1];
       for (let p = 0, d = 0; p < numPoints; ++p, d += 2) {
         const s = map[p] * 2;
-        out[d] = fround(fround(values[s] * delta) + m0);
-        out[d + 1] = fround(fround(values[s + 1] * delta) + m1);
+        out[d] = fround(values[s] * delta) + m0;
+        out[d + 1] = fround(values[s + 1] * delta) + m1;
       }
       return;
     }
     for (let p = 0, d = 0; p < numPoints; ++p) {
       const s = map[p] * numComponents;
       for (let c = 0; c < numComponents; ++c) {
-        out[d++] = fround(fround(values[s + c] * delta) + min[c]);
+        out[d++] = fround(values[s + c] * delta) + min[c];
       }
     }
   }
   // OctahedronToolBox.QuantizedOctahedralCoordsToUnitVector, two quantized
-  // coordinates per value to one unit vector per point.
-  fc(out, numPoints) {
-    const values = this.Cb();
-    const map = this.bb(numPoints);
+  // coordinates per value to one unit vector per point, branch-free: the
+  // signs of the normals' components are unpredictable, so the fold picks
+  // its direction arithmetically (multiplying by +-1 is exact, zero signs
+  // included). The C++ zero-vector guard (squared norm below 1e-6) is left
+  // out because no input reaches it: |x| + |y| + |z| >= 1 before the fold,
+  // which moves y and z by at most |x|, so some component stays above 1/6.
+  gc(out, numPoints) {
+    const values = this.Ab();
+    const map = this.ab(numPoints);
     const fround = Math.fround;
-    const scale = this.La;
+    const scale = this.Ma;
     for (let p = 0, d = 0; p < numPoints; ++p, d += 3) {
       const s = map[p] * 2;
       let y = fround(fround(values[s] * scale) - 1);
       let z = fround(fround(values[s + 1] * scale) - 1);
       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) {
-        out[d] = 0;
-        out[d + 1] = 0;
-        out[d + 2] = 0;
-      } else {
-        const k = fround(1 / fround(Math.sqrt(normSquared)));
-        out[d] = fround(x * k);
-        out[d + 1] = fround(y * k);
-        out[d + 2] = fround(z * k);
-      }
+      const xOffset = Math.max(-x, 0);
+      y = fround(y + xOffset * (2 * +(y < 0) - 1));
+      z = fround(z + xOffset * (2 * +(z < 0) - 1));
+      const k = fround(1 / fround(Math.sqrt(fround(fround(fround(x * x) + fround(y * y)) + fround(z * z)))));
+      out[d] = x * k;
+      out[d + 1] = y * k;
+      out[d + 2] = z * k;
     }
   }
   // The int32 values wrap to the attribute's own integer type (as storing
   // them into it would) before the output store converts them.
-  gc(out, numPoints) {
-    const values = this.da;
-    const map = this.bb(numPoints);
+  ec(out, numPoints) {
+    const values = this.ea;
+    const map = this.ab(numPoints);
     const numComponents = this.y;
-    const dt = this.S;
+    const dt = this.T;
     const shift = 32 - 8 * dataTypeLength(dt);
     const signed = dt === 1 /* INT8 */ || dt === 3 /* INT16 */ || dt === 5 /* INT32 */;
     for (let p = 0, d = 0; p < numPoints; ++p) {
@@ -674,18 +646,18 @@ function decodeVarint(buffer) {
 
 // src/decoder/core/DecoderBuffer.ts
 var BitDecoder = class {
-  Ma = null;
-  s = 0;
+  Na = null;
+  q = 0;
   qa = 0;
-  reset(uint8Array, byteLength) {
-    this.Ma = uint8Array;
-    this.qa = byteLength;
-    this.s = 0;
+  reset(uint8Array, start, end) {
+    this.Na = uint8Array;
+    this.qa = end;
+    this.q = start * 8;
   }
   getBits(nbits) {
     if (nbits > 32) return void 0;
-    const buf = this.Ma;
-    let off = this.s;
+    const buf = this.Na;
+    let off = this.q;
     const byteOffset = off >> 3;
     const bitShift = off & 7;
     if (byteOffset + 4 < this.qa) {
@@ -699,7 +671,7 @@ var BitDecoder = class {
       } else {
         result = val >>> bitShift;
       }
-      this.s = off + nbits;
+      this.q = off + nbits;
       return nbits === 32 ? result : result & (1 << nbits) - 1;
     }
     let value = 0;
@@ -717,54 +689,68 @@ var BitDecoder = class {
       bitsRead += bitsToRead;
       currOff += bitsToRead;
     }
-    this.s = currOff;
+    this.q = currOff;
     return value;
   }
 };
+var floatBytes = new Uint8Array(4);
+var floatView = new DataView(floatBytes.buffer);
 var DecoderBuffer = class {
-  o = null;
-  Na = null;
-  O = 0;
-  e = 0;
+  h = null;
+  B = 0;
+  i = 0;
   ra = new BitDecoder();
   Oa = false;
   init(data, dataSize = data.length) {
-    this.o = data;
-    this.Na = new DataView(data.buffer, data.byteOffset, data.byteLength);
-    this.O = dataSize;
-    this.e = 0;
+    this.h = data;
+    this.B = dataSize;
+    this.i = 0;
+  }
+  // Continues where `other` stands: same bytes, same position (offsets stay
+  // absolute, so no view of the remaining bytes is made).
+  initFrom(other) {
+    this.h = other.h;
+    this.B = other.B;
+    this.i = other.i;
   }
   // Typed little-endian reads.
   decodeUint8() {
-    if (this.e + 1 > this.O) return void 0;
-    const val = this.o[this.e];
-    this.e += 1;
+    if (this.i + 1 > this.B) return void 0;
+    const val = this.h[this.i];
+    this.i += 1;
     return val;
   }
   decodeUint16() {
-    if (this.e + 2 > this.O) return void 0;
-    const val = this.Na.getUint16(this.e, true);
-    this.e += 2;
-    return val;
+    const pos = this.i;
+    if (pos + 2 > this.B) return void 0;
+    const data = this.h;
+    this.i = pos + 2;
+    return data[pos] | data[pos + 1] << 8;
   }
   decodeInt32() {
-    if (this.e + 4 > this.O) return void 0;
-    const val = this.Na.getInt32(this.e, true);
-    this.e += 4;
-    return val;
+    const pos = this.i;
+    if (pos + 4 > this.B) return void 0;
+    const data = this.h;
+    this.i = pos + 4;
+    return data[pos] | data[pos + 1] << 8 | data[pos + 2] << 16 | data[pos + 3] << 24;
   }
   decodeFloat32() {
-    if (this.e + 4 > this.O) return void 0;
-    const val = this.Na.getFloat32(this.e, true);
-    this.e += 4;
-    return val;
+    const pos = this.i;
+    if (pos + 4 > this.B) return void 0;
+    const data = this.h;
+    this.i = pos + 4;
+    floatBytes[0] = data[pos];
+    floatBytes[1] = data[pos + 1];
+    floatBytes[2] = data[pos + 2];
+    floatBytes[3] = data[pos + 3];
+    return floatView.getFloat32(0, true);
   }
   // A view into the stream (no copy), only valid until the caller's next
   // chance to mutate the buffer — copy out before keeping it.
   decodeBytesView(size) {
-    if (this.e + size > this.O) return void 0;
-    const result = this.o.subarray(this.e, this.e + size);
-    this.e += size;
+    if (this.i + size > this.B) return void 0;
+    const result = this.h.subarray(this.i, this.i + size);
+    this.i += size;
     return result;
   }
   // Only the 2.2+ layout (varint size prefix): older bitstreams are rejected
@@ -777,31 +763,28 @@ var DecoderBuffer = class {
       outSize = size;
     }
     this.Oa = true;
-    this.ra.reset(this.o.subarray(this.e), this.O - this.e);
+    this.ra.reset(this.h, this.i, this.B);
     return outSize;
   }
   endBitDecoding() {
     this.Oa = false;
-    this.e += Math.ceil(this.ra.s / 8);
+    this.i = Math.ceil(this.ra.q / 8);
   }
   decodeLeastSignificantBits32(nbits) {
     if (!this.Oa) return void 0;
     return this.ra.getBits(nbits);
   }
   advance(bytes) {
-    this.e += bytes;
+    this.i += bytes;
   }
   get data() {
-    return this.o;
-  }
-  get dataHead() {
-    return this.o.subarray(this.e);
+    return this.h;
   }
   get remainingSize() {
-    return this.O - this.e;
+    return this.B - this.i;
   }
   get decodedSize() {
-    return this.e;
+    return this.i;
   }
   get bitDecoderActive() {
     return this.Oa;
@@ -822,66 +805,66 @@ var METADATA_FLAG_MASK = 32768;
 var kMaxSubmetadataLevel = 1e3;
 var MetadataDecoder = class {
   constructor(buffer_) {
-    this.F = buffer_;
+    this.G = buffer_;
   }
   buffer_;
   // Skips per-attribute metadata followed by the geometry-level metadata.
   skipGeometryMetadata() {
-    const numAttMetadata = decodeVarint(this.F);
+    const numAttMetadata = decodeVarint(this.G);
     if (numAttMetadata === void 0) {
       return false;
     }
     for (let i = 0; i < numAttMetadata; ++i) {
-      if (decodeVarint(this.F) === void 0) {
+      if (decodeVarint(this.G) === void 0) {
         return false;
       }
-      if (!this.cb(0)) {
+      if (!this.bb(0)) {
         return false;
       }
     }
-    return this.cb(0);
+    return this.bb(0);
   }
   // Discards one metadata block (key-value entries plus nested sub-metadata).
   // Sub-blocks read depth-first in stream order, matching the C++ stack traversal.
-  cb(level) {
+  bb(level) {
     if (level > kMaxSubmetadataLevel) {
       return false;
     }
-    const numEntries = decodeVarint(this.F);
+    const numEntries = decodeVarint(this.G);
     if (numEntries === void 0) {
       return false;
     }
     for (let i = 0; i < numEntries; ++i) {
-      const nameSkipped = this.Db();
-      const dataSize = nameSkipped ? decodeVarint(this.F) : void 0;
-      if (dataSize === void 0 || dataSize === 0 || !this.Eb(dataSize)) {
+      const nameSkipped = this.Bb();
+      const dataSize = nameSkipped ? decodeVarint(this.G) : void 0;
+      if (dataSize === void 0 || dataSize === 0 || !this.Cb(dataSize)) {
         return false;
       }
     }
-    const numSubMetadata = decodeVarint(this.F);
-    if (numSubMetadata === void 0 || numSubMetadata > this.F.remainingSize) {
+    const numSubMetadata = decodeVarint(this.G);
+    if (numSubMetadata === void 0 || numSubMetadata > this.G.remainingSize) {
       return false;
     }
     for (let i = 0; i < numSubMetadata; ++i) {
-      if (!this.Db() || !this.cb(level + 1)) {
+      if (!this.Bb() || !this.bb(level + 1)) {
         return false;
       }
     }
     return true;
   }
   // Skips a name (uint8 length prefix followed by that many bytes).
-  Db() {
-    const nameLen = this.F.decodeUint8();
+  Bb() {
+    const nameLen = this.G.decodeUint8();
     if (nameLen === void 0) {
       return false;
     }
-    return this.Eb(nameLen);
+    return this.Cb(nameLen);
   }
-  Eb(size) {
-    if (size > this.F.remainingSize) {
+  Cb(size) {
+    if (size > this.G.remainingSize) {
       return false;
     }
-    this.F.advance(size);
+    this.G.advance(size);
     return true;
   }
 };
@@ -959,8 +942,8 @@ var RAnsDecoder = class {
   bucketShift = 0;
   // Uint16 unless the alphabet needs wider ids, so real streams keep one table type.
   bucketTable = null;
-  // Stream state inlined (not a nested AnsDecoder) so the ransRead() hot loop
-  // touches own props; initialized by ansReadInit.
+  // Stream state inlined (not a nested AnsDecoder) so the decode loops touch
+  // own props; initialized by ansReadInit.
   buf = null;
   bufOffset = 0;
   // First valid byte of this decoder's slice within buf (absolute offsets,
@@ -992,31 +975,8 @@ var RAnsDecoder = class {
     }
     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.
+  // Decodes count symbols into out[0..count): all fields hoisted to locals,
+  // state written back once.
   decodeSymbols(out, count) {
     if (this.coarse) {
       this.hc(out, count);
@@ -1313,9 +1273,9 @@ function ransDecodeSymbolsTrioU16(a, outA, countA, b, outB, countB, c, outC, cou
 
 // src/decoder/compression/point_cloud/PointCloudDecoder.ts
 var PointCloudDecoder = class {
-  V = null;
+  X = null;
   d = null;
-  w = [];
+  v = [];
   Pa = [];
   // Returns an error message, or '' on success (outHeader is then populated).
   static decodeHeader(buffer, outHeader) {
@@ -1346,7 +1306,7 @@ var PointCloudDecoder = class {
   // Main entry point, given the already-parsed header (see Decode.ts).
   decode(header, inBuffer, outPointCloud) {
     this.d = inBuffer;
-    this.V = outPointCloud;
+    this.X = outPointCloud;
     if (header.versionMajor !== 2 || header.versionMinor !== 2) {
       return "Unsupported bitstream version (Draco 2.2 meshes only).";
     }
@@ -1368,27 +1328,27 @@ var PointCloudDecoder = class {
     if (attDecoderId < 0) {
       return false;
     }
-    while (this.w.length <= attDecoderId) {
-      this.w.push(null);
+    while (this.v.length <= attDecoderId) {
+      this.v.push(null);
     }
-    this.w[attDecoderId] = decoder;
+    this.v[attDecoderId] = decoder;
     return true;
   }
   getPortableAttribute(parentAttId) {
-    if (parentAttId < 0 || parentAttId >= this.V.numAttributes()) {
+    if (parentAttId < 0 || parentAttId >= this.X.numAttributes()) {
       return null;
     }
     const parentAttDecoderId = this.Pa[parentAttId];
-    return this.w[parentAttDecoderId].getPortableAttribute(parentAttId);
+    return this.v[parentAttDecoderId].getPortableAttribute(parentAttId);
   }
   attributesDecoder(decId) {
-    return this.w[decId];
+    return this.v[decId];
   }
   numAttributesDecoders() {
-    return this.w.length;
+    return this.v.length;
   }
   pointCloud() {
-    return this.V;
+    return this.X;
   }
   buffer() {
     return this.d;
@@ -1414,20 +1374,20 @@ var PointCloudDecoder = class {
         return false;
       }
     }
-    for (let i = 0; i < this.w.length; ++i) {
-      if (!this.w[i].init(this, this.V)) {
+    for (let i = 0; i < this.v.length; ++i) {
+      if (!this.v[i].init(this, this.X)) {
         return false;
       }
     }
     for (let i = 0; i < numAttributesDecoders; ++i) {
-      if (!this.w[i].decodeAttributesDecoderData(this.d)) {
+      if (!this.v[i].decodeAttributesDecoderData(this.d)) {
         return false;
       }
     }
     for (let i = 0; i < numAttributesDecoders; ++i) {
-      const numAttributes = this.w[i].getNumAttributes();
+      const numAttributes = this.v[i].getNumAttributes();
       for (let j = 0; j < numAttributes; ++j) {
-        const attId = this.w[i].getAttributeId(j);
+        const attId = this.v[i].getAttributeId(j);
         while (this.Pa.length <= attId) {
           this.Pa.push(0);
         }
@@ -1437,7 +1397,7 @@ var PointCloudDecoder = class {
     return this.decodeAllAttributes();
   }
   decodeAllAttributes() {
-    const decoders = this.w;
+    const decoders = this.v;
     for (let i = 0; i < decoders.length; i++) {
       if (!decoders[i].decodeAttributesParse(this.d)) {
         return false;
@@ -1459,10 +1419,10 @@ var PointCloudDecoder = class {
 
 // src/decoder/compression/mesh/MeshDecoder.ts
 var MeshDecoder = class extends PointCloudDecoder {
-  G = null;
+  H = null;
   // Returns an error message, or '' on success.
   decodeMesh(header, inBuffer, outMesh) {
-    this.G = outMesh;
+    this.H = outMesh;
     return this.decode(header, inBuffer, outMesh);
   }
   // Connectivity accessors used by the mesh prediction schemes; the sequential
@@ -1477,7 +1437,7 @@ var MeshDecoder = class extends PointCloudDecoder {
     return null;
   }
   mesh() {
-    return this.G;
+    return this.H;
   }
   decodeGeometryData() {
     return this.decodeConnectivity() && super.decodeGeometryData();
@@ -1488,21 +1448,21 @@ var MeshDecoder = class extends PointCloudDecoder {
 var kInvalidCornerIndex = -1;
 var MeshAttributeCornerTable = class {
   // Base vertices touched by a seam edge of this table.
-  sa = new Uint8Array(0);
-  W = new Int32Array(0);
+  sa = EMPTY_UINT8;
+  Y = EMPTY_INT32;
   // Attribute vertex -> 1 when its fan is open in this table (see
   // CornerTable._vertexOnBoundary). The C++ also keeps each attribute
   // vertex's left-most corner, but the decoder only ever asked it whether
   // that corner sits on a boundary, which this answers directly.
-  B = new Uint8Array(0);
+  C = EMPTY_UINT8;
   // 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.
   ta = 0;
-  H = null;
+  I = null;
   // The base table's opposite corners with both corners of every seam edge
   // set to -1: what opposite() answers, and what the traversals read.
-  I = new Int32Array(0);
+  J = EMPTY_INT32;
   // Starts the table as a copy of the base connectivity; addSeamEdge then
   // cuts the seams and the ring pass numbers the vertices. Decode-scoped
   // scratch throughout: the table lives only until the decode finishes (the
@@ -1510,30 +1470,28 @@ var MeshAttributeCornerTable = class {
   // file from allocating a fresh set per attribute per prim.
   initEmpty(table) {
     const numCorners = table.numCorners();
-    this.H = table;
+    this.I = table;
     this.sa = scratchUint8Zeroed(table.numVertices());
-    this.I = scratchInt32(numCorners);
-    this.I.set(table.oppositeCornerArray());
-    this.W = scratchInt32(numCorners);
-    this.W.set(table.cornerToVertexArray());
+    this.J = scratchInt32(numCorners);
+    this.J.set(table.oppositeCornerArray());
+    this.Y = scratchInt32(numCorners);
+    this.Y.set(table.cornerToVertexArray());
     this.ta = 0;
   }
-  // Cuts the edge opposite corner c (and its twin) and flags its two vertices.
+  // Cuts the interior edge opposite corner c (and its twin) and flags its two
+  // vertices. (Boundary edges are open in the base table already, and flagging
+  // their vertices would only send them through the ring walk to come out
+  // unsplit.)
   addSeamEdge(c) {
-    const cornerToVertex = this.H.cornerToVertexArray();
-    const opposite = this.I;
+    const cornerToVertex = this.I.cornerToVertexArray();
+    const opposite = this.J;
     const isVert = this.sa;
     const oppCorner = opposite[c];
     opposite[c] = kInvalidCornerIndex;
-    let rem = c - (c / 3 | 0) * 3;
+    opposite[oppCorner] = kInvalidCornerIndex;
+    const rem = c - (c / 3 | 0) * 3;
     isVert[cornerToVertex[rem === 2 ? c - 2 : c + 1]] = 1;
     isVert[cornerToVertex[rem === 0 ? c + 2 : c - 1]] = 1;
-    if (oppCorner !== kInvalidCornerIndex) {
-      opposite[oppCorner] = kInvalidCornerIndex;
-      rem = oppCorner - (oppCorner / 3 | 0) * 3;
-      isVert[cornerToVertex[rem === 2 ? oppCorner - 2 : oppCorner + 1]] = 1;
-      isVert[cornerToVertex[rem === 0 ? oppCorner + 2 : oppCorner - 1]] = 1;
-    }
   }
   // Installs the vertex numbering computed by the edgebreaker decoder's ring
   // pass, which fills corner_to_vertex_map_ directly and hands over the
@@ -1541,29 +1499,29 @@ var MeshAttributeCornerTable = class {
   // least numVertices entries).
   setRecomputedVertices(onBoundary, numVertices) {
     this.ta = numVertices;
-    this.B = onBoundary;
+    this.C = onBoundary;
   }
   // A table without interior seams is the base connectivity itself: every
   // vertex ring is one attribute vertex, and the boundary edges are already
   // open in the base opposite table. Shares the base arrays (read-only from
   // here on), so its traversal also resolves to the base table's cached one.
   initAsBase(table) {
-    this.H = table;
-    this.I = table.oppositeCornerArray();
-    this.W = table.cornerToVertexArray();
+    this.I = table;
+    this.J = table.oppositeCornerArray();
+    this.Y = table.cornerToVertexArray();
     this.setRecomputedVertices(table.vertexOnBoundaryArray(), table.numVertices());
   }
   opposite(corner) {
     if (corner === kInvalidCornerIndex) {
       return kInvalidCornerIndex;
     }
-    return this.I[corner];
+    return this.J[corner];
   }
   next(corner) {
-    return this.H.next(corner);
+    return this.I.next(corner);
   }
   previous(corner) {
-    return this.H.previous(corner);
+    return this.I.previous(corner);
   }
   swingRight(corner) {
     return this.previous(this.opposite(this.previous(corner)));
@@ -1575,32 +1533,32 @@ var MeshAttributeCornerTable = class {
     return this.ta;
   }
   numFaces() {
-    return this.H.numFaces();
+    return this.I.numFaces();
   }
   numCorners() {
-    return this.H.numCorners();
+    return this.I.numCorners();
   }
   // --- Flat-array accessors: let DepthFirstTraverser avoid per-corner dispatch. ---
   cornerToVertexArray() {
-    return this.W;
+    return this.Y;
   }
   // Seam-aware opposite corners (seam edges -> -1), matching opposite().
   oppositeCornerArray() {
-    return this.I;
+    return this.J;
   }
   vertexOnBoundaryArray() {
-    return this.B;
+    return this.C;
   }
   // 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.H = other.H;
+    this.I = other.I;
     this.sa = other.sa;
-    this.W = other.W;
+    this.Y = other.Y;
     this.ta = other.ta;
-    this.B = other.B;
-    this.I = other.I;
+    this.C = other.C;
+    this.J = other.J;
   }
 };
 
@@ -1609,11 +1567,11 @@ var AttributesDecoder = class {
   Qa = [];
   // Inverse of _pointAttributeIds: point attribute id -> local id.
   ua = [];
-  Fb = null;
-  V = null;
+  Db = null;
+  X = null;
   init(decoder, pointCloud) {
-    this.Fb = decoder;
-    this.V = pointCloud;
+    this.Db = decoder;
+    this.X = pointCloud;
     return true;
   }
   decodeAttributesDecoderData(buffer) {
@@ -1622,7 +1580,7 @@ var AttributesDecoder = class {
       return false;
     }
     this.Qa.length = numAttributes;
-    const pc = this.V;
+    const pc = this.X;
     for (let i = 0; i < numAttributes; i++) {
       const attType = buffer.decodeUint8();
       if (attType === void 0) return false;
@@ -1663,7 +1621,7 @@ var AttributesDecoder = class {
     return this.Qa.length;
   }
   getDecoder() {
-    return this.Fb;
+    return this.Db;
   }
   getLocalIdForPointAttribute(pointAttributeId) {
     if (pointAttributeId >= this.ua.length) {
@@ -1675,15 +1633,15 @@ var AttributesDecoder = class {
 
 // src/decoder/compression/attributes/SequentialAttributeDecoder.ts
 var SequentialAttributeDecoder = class {
-  n = null;
-  J = null;
-  Gb = -1;
+  o = null;
+  K = null;
+  Eb = -1;
   // Decoded portable attribute (after lossless decoding).
-  ea = null;
+  Z = null;
   init(decoder, attributeId) {
-    this.n = decoder;
-    this.J = decoder.pointCloud().attribute(attributeId);
-    this.Gb = attributeId;
+    this.o = decoder;
+    this.K = decoder.pointCloud().attribute(attributeId);
+    this.Eb = attributeId;
     return true;
   }
   // --- Two-phase decode ---
@@ -1694,10 +1652,10 @@ var SequentialAttributeDecoder = class {
   // stream simply do the whole decode in Parse (decodeValues); the defaults
   // below are theirs.
   decodePortableAttributeParse(pointIds, buffer) {
-    if (this.J.numComponents <= 0) {
+    if (this.K.numComponents <= 0) {
       return false;
     }
-    if (!this.Hb(pointIds.length)) {
+    if (!this.Fb(pointIds.length)) {
       return false;
     }
     return this.decodeValues(pointIds, buffer);
@@ -1705,8 +1663,8 @@ var SequentialAttributeDecoder = class {
   // Sizes (and here allocates) the attribute's storage for numValues values;
   // the integer decoders override it to skip the allocation, their values
   // staying in the portable attribute (see PointAttribute.setLazyInteger).
-  Hb(numValues) {
-    return this.J.reset(numValues);
+  Fb(numValues) {
+    return this.K.reset(numValues);
   }
   pendingSymbolStream() {
     return null;
@@ -1723,35 +1681,35 @@ var SequentialAttributeDecoder = class {
     return true;
   }
   getPortableAttribute() {
-    if (!this.J.isMappingIdentity && this.ea && this.ea.isMappingIdentity) {
-      const size = this.J.indicesMapSize;
-      this.ea.setExplicitMappingScratch(size);
-      const src = this.J.indicesMap;
-      const dst = this.ea.indicesMap;
+    if (!this.K.isMappingIdentity && this.Z && this.Z.isMappingIdentity) {
+      const size = this.K.indicesMapSize;
+      this.Z.setExplicitMappingScratch(size);
+      const src = this.K.indicesMap;
+      const dst = this.Z.indicesMap;
       if (src.length === size) {
         dst.set(src);
       } else {
         dst.set(src.subarray(0, size));
       }
     }
-    return this.ea;
+    return this.Z;
   }
   get attribute() {
-    return this.J;
+    return this.K;
   }
   get attributeId() {
-    return this.Gb;
+    return this.Eb;
   }
   get decoder() {
-    return this.n;
+    return this.o;
   }
   initPredictionScheme(ps) {
     for (let i = 0; i < ps.getNumParentAttributes(); i++) {
-      const attId = this.n.pointCloud().getNamedAttributeId(ps.getParentAttributeType(i));
+      const attId = this.o.pointCloud().getNamedAttributeId(ps.getParentAttributeType(i));
       if (attId === -1) {
         return false;
       }
-      const pa = this.n.getPortableAttribute(attId);
+      const pa = this.o.getPortableAttribute(attId);
       if (pa === null || !ps.setParentAttribute(pa)) {
         return false;
       }
@@ -1761,13 +1719,13 @@ var SequentialAttributeDecoder = class {
   // Decodes raw attribute values in their original format.
   decodeValues(pointIds, buffer) {
     const numValues = pointIds.length;
-    const entrySize = this.J.byteStride;
+    const entrySize = this.K.byteStride;
     const totalSize = numValues * entrySize;
     const valueData = buffer.decodeBytesView(totalSize);
     if (valueData === void 0) {
       return false;
     }
-    this.J.buffer.write(0, valueData, totalSize);
+    this.K.buffer.write(0, valueData, totalSize);
     return true;
   }
 };
@@ -1782,14 +1740,14 @@ function convertSymbolsToSignedInts(input, count, output) {
 
 // src/decoder/compression/entropy/RAnsSymbolDecoder.ts
 var RAnsSymbolDecoder = class {
-  Ib = 0;
-  K;
+  Gb = 0;
+  L;
   constructor(uniqueSymbolsBitLength) {
     const unclamped = Math.trunc(3 * uniqueSymbolsBitLength / 2);
-    this.K = new RAnsDecoder(unclamped < 12 ? 12 : unclamped > 20 ? 20 : unclamped);
+    this.L = new RAnsDecoder(unclamped < 12 ? 12 : unclamped > 20 ? 20 : unclamped);
   }
   get numSymbols() {
-    return this.Ib;
+    return this.Gb;
   }
   // Initialize the decoder and decode the probability table. expectedCount is
   // the number of symbols the caller will decode (lets short streams skip the
@@ -1797,7 +1755,7 @@ var RAnsSymbolDecoder = class {
   create(buffer, expectedCount = 2147483647) {
     const numSymbols = decodeVarint(buffer);
     if (numSymbols === void 0) return false;
-    this.Ib = numSymbols;
+    this.Gb = numSymbols;
     if (Math.trunc(numSymbols / 64) > buffer.remainingSize) {
       return false;
     }
@@ -1830,7 +1788,7 @@ var RAnsSymbolDecoder = class {
       }
     }
     buffer.advance(pos - startPos);
-    return this.K.ransBuildLookUpTable(probabilityTable, numSymbols, expectedCount);
+    return this.L.ransBuildLookUpTable(probabilityTable, numSymbols, expectedCount);
   }
   // Starts decoding, advancing buffer past the encoded data.
   startDecoding(buffer) {
@@ -1841,10 +1799,10 @@ var RAnsSymbolDecoder = class {
     }
     const base = buffer.decodedSize;
     buffer.advance(Number(bytesEncoded));
-    return ansReadInit(this.K, buffer.data, base + Number(bytesEncoded), base, this.K.lRansBase, 4);
+    return ansReadInit(this.L, buffer.data, base + Number(bytesEncoded), base, this.L.lRansBase, 4);
   }
   endDecoding() {
-    this.K.readEnd();
+    this.L.readEnd();
   }
 };
 
@@ -1872,15 +1830,38 @@ function decodeTaggedSymbols(numValues, numComponents, srcBuffer, outValues) {
   if (numValues > 0 && tagDecoder.numSymbols === 0) {
     return false;
   }
-  const tagAns = tagDecoder.K;
+  const ans = tagDecoder.L;
+  const ansBuf = ans.buf;
+  const ansStart = ans.bufStart;
+  const lRansBase = ans.lRansBase;
+  const precisionBits = ans.ransPrecisionBits;
+  const precisionMask = ans.ransPrecisionMask;
+  const probTable = ans.probTable;
+  const cumProbTable = ans.cumProbTable;
+  const lutTable = ans.lutTable;
+  const bucketTable = ans.bucketTable;
+  const bucketShift = ans.bucketShift;
+  let state = ans.state;
+  let ansOffset = ans.bufOffset;
   srcBuffer.startBitDecoding(false);
   const bd = srcBuffer.ra;
-  const buf = bd.Ma;
+  const buf = bd.Na;
   const byteLength = bd.qa;
-  let bitOffset = bd.s;
+  let bitOffset = bd.q;
   let valueId = 0;
   for (let i = 0; i < numValues; i += numComponents) {
-    const bitLength = tagAns.ransRead();
+    while (state < lRansBase && ansOffset > ansStart) {
+      state = state << 8 | ansBuf[--ansOffset];
+    }
+    const rem = state & precisionMask;
+    let bitLength;
+    if (lutTable !== null) {
+      bitLength = lutTable[rem];
+    } else {
+      bitLength = bucketTable[rem >> bucketShift];
+      while (cumProbTable[bitLength + 1] <= rem) bitLength++;
+    }
+    state = (state >>> precisionBits) * probTable[bitLength] + rem - cumProbTable[bitLength];
     if (bitLength < 32) {
       const mask = (1 << bitLength) - 1;
       let j = 0;
@@ -1896,7 +1877,7 @@ function decodeTaggedSymbols(numValues, numComponents, srcBuffer, outValues) {
         outValues[valueId++] = value & mask;
       }
       if (j === numComponents) continue;
-      bd.s = bitOffset;
+      bd.q = bitOffset;
       for (; j < numComponents; ++j) {
         const val = bd.getBits(bitLength);
         if (val === void 0) {
@@ -1904,9 +1885,9 @@ function decodeTaggedSymbols(numValues, numComponents, srcBuffer, outValues) {
         }
         outValues[valueId++] = val;
       }
-      bitOffset = bd.s;
+      bitOffset = bd.q;
     } else {
-      bd.s = bitOffset;
+      bd.q = bitOffset;
       for (let j = 0; j < numComponents; ++j) {
         const val = bd.getBits(bitLength);
         if (val === void 0) {
@@ -1914,10 +1895,12 @@ function decodeTaggedSymbols(numValues, numComponents, srcBuffer, outValues) {
         }
         outValues[valueId++] = val;
       }
-      bitOffset = bd.s;
+      bitOffset = bd.q;
     }
   }
-  bd.s = bitOffset;
+  ans.state = state;
+  ans.bufOffset = ansOffset;
+  bd.q = bitOffset;
   tagDecoder.endDecoding();
   srcBuffer.endBitDecoding();
   return true;
@@ -1944,7 +1927,7 @@ function decodeRawSymbols(numValues, srcBuffer, outValues) {
   if (decoder === null) {
     return false;
   }
-  decoder.K.decodeSymbols(outValues, numValues);
+  decoder.L.decodeSymbols(outValues, numValues);
   decoder.endDecoding();
   return true;
 }
@@ -1995,16 +1978,16 @@ var RAnsBitDecoder = class {
 
 // src/decoder/compression/attributes/prediction_schemes/PredictionSchemeDecoder.ts
 var PredictionSchemeDecoder = class {
-  f;
+  e;
   constructor(transform) {
-    this.f = transform;
+    this.e = transform;
   }
   /** True if all correction values are guaranteed to be positive. */
   areCorrectionsPositive() {
-    return this.f.areCorrectionsPositive();
+    return this.e.areCorrectionsPositive();
   }
   boundsValues(limit) {
-    return this.f.boundsValues(limit);
+    return this.e.boundsValues(limit);
   }
   getNumParentAttributes() {
     return 0;
@@ -2016,7 +1999,7 @@ var PredictionSchemeDecoder = class {
     return false;
   }
   decodePredictionData(buffer) {
-    return this.f.decodeTransformData(buffer);
+    return this.e.decodeTransformData(buffer);
   }
   /**
    * Like computeOriginalValues, but inCorr still holds unsigned zigzag-coded
@@ -2092,12 +2075,12 @@ var MeshPredictionSchemeConstrainedMultiParallelogramDecoder = class extends Mes
     return super.decodePredictionData(buffer);
   }
   computeOriginalValues(inCorr, outData, _size, numComponents, _entryToPointIdMap) {
-    this.f.init(numComponents);
+    this.e.init(numComponents);
     const predVals = [];
     for (let i = 0; i < MAX_NUM_PARALLELOGRAMS; ++i) {
       predVals.push(new Int32Array(numComponents));
     }
-    this.f.computeOriginalValue(predVals[0], 0, inCorr, 0, outData, 0);
+    this.e.computeOriginalValue(predVals[0], 0, inCorr, 0, outData, 0);
     const table = this.c.cornerTable;
     const vertexToDataMap = this.c.vertexToDataMap;
     const oppositeCorners = table.oppositeCornerArray();
@@ -2156,12 +2139,12 @@ var MeshPredictionSchemeConstrainedMultiParallelogramDecoder = class extends Mes
       const dstOffset = p * numComponents;
       if (numUsedParallelograms === 0) {
         const srcOffset = (p - 1) * numComponents;
-        this.f.computeOriginalValue(outData, srcOffset, inCorr, dstOffset, outData, dstOffset);
+        this.e.computeOriginalValue(outData, srcOffset, inCorr, dstOffset, outData, dstOffset);
       } else {
         for (let c = 0; c < numComponents; ++c) {
           multiPredVals[c] = multiPredVals[c] / numUsedParallelograms | 0;
         }
-        this.f.computeOriginalValue(multiPredVals, 0, inCorr, dstOffset, outData, dstOffset);
+        this.e.computeOriginalValue(multiPredVals, 0, inCorr, dstOffset, outData, dstOffset);
       }
     }
     return true;
@@ -2230,38 +2213,38 @@ var MeshPredictionSchemeData = class {
 
 // src/decoder/compression/attributes/NormalCompressionUtils.ts
 var OctahedronToolBox = class {
-  P = -1;
+  O = -1;
   fa = -1;
-  m = -1;
+  n = -1;
   jc = 1;
-  h = -1;
+  f = -1;
   // q: quantization bits, valid range 2..30.
   setQuantizationBits(q) {
     if (q < 2 || q > 30) return false;
-    this.P = q;
+    this.O = q;
     this.fa = (1 << q) - 1;
-    this.m = this.fa - 1;
-    this.jc = Math.fround(2 / Math.fround(this.m));
-    this.h = this.m / 2 | 0;
+    this.n = this.fa - 1;
+    this.jc = Math.fround(2 / Math.fround(this.n));
+    this.f = this.n / 2 | 0;
     return true;
   }
   quantizationBits() {
-    return this.P;
+    return this.O;
   }
   // Canonicalizes edge points into consistent quadrants. Writes result into
   // out[0], out[1] (caller-owned reusable 2-element array).
   canonicalizeOctahedralCoords(s, t, out) {
-    if (s === 0 && t === 0 || s === 0 && t === this.m || s === this.m && t === 0) {
-      s = this.m;
-      t = this.m;
-    } else if (s === 0 && t > this.h) {
-      t = this.h - (t - this.h);
-    } else if (s === this.m && t < this.h) {
-      t = this.h + (this.h - t);
-    } else if (t === this.m && s < this.h) {
-      s = this.h + (this.h - s);
-    } else if (t === 0 && s > this.h) {
-      s = this.h - (s - this.h);
+    if (s === 0 && t === 0 || s === 0 && t === this.n || s === this.n && t === 0) {
+      s = this.n;
+      t = this.n;
+    } else if (s === 0 && t > this.f) {
+      t = this.f - (t - this.f);
+    } else if (s === this.n && t < this.f) {
+      t = this.f + (this.f - t);
+    } else if (t === this.n && s < this.f) {
+      s = this.f + (this.f - s);
+    } else if (t === 0 && s > this.f) {
+      s = this.f - (s - this.f);
     }
     out[0] = s;
     out[1] = t;
@@ -2271,18 +2254,18 @@ var OctahedronToolBox = class {
   integerVectorToQuantizedOctahedralCoords(intVec, out) {
     let s, t;
     if (intVec[0] >= 0) {
-      s = intVec[1] + this.h;
-      t = intVec[2] + this.h;
+      s = intVec[1] + this.f;
+      t = intVec[2] + this.f;
     } else {
       if (intVec[1] < 0) {
         s = Math.abs(intVec[2]);
       } else {
-        s = this.m - Math.abs(intVec[2]);
+        s = this.n - Math.abs(intVec[2]);
       }
       if (intVec[2] < 0) {
         t = Math.abs(intVec[1]);
       } else {
-        t = this.m - Math.abs(intVec[1]);
+        t = this.n - Math.abs(intVec[1]);
       }
     }
     this.canonicalizeOctahedralCoords(s, t, out);
@@ -2291,14 +2274,14 @@ var OctahedronToolBox = class {
   canonicalizeIntegerVector(vec) {
     const absSum = Math.abs(vec[0]) + Math.abs(vec[1]) + Math.abs(vec[2]);
     if (absSum === 0) {
-      vec[0] = this.h;
+      vec[0] = this.f;
     } else {
-      vec[0] = Math.trunc(vec[0] * this.h / absSum);
-      vec[1] = Math.trunc(vec[1] * this.h / absSum);
+      vec[0] = Math.trunc(vec[0] * this.f / absSum);
+      vec[1] = Math.trunc(vec[1] * this.f / absSum);
       if (vec[2] >= 0) {
-        vec[2] = this.h - Math.abs(vec[0]) - Math.abs(vec[1]);
+        vec[2] = this.f - Math.abs(vec[0]) - Math.abs(vec[1]);
       } else {
-        vec[2] = -(this.h - Math.abs(vec[0]) - Math.abs(vec[1]));
+        vec[2] = -(this.f - Math.abs(vec[0]) - Math.abs(vec[1]));
       }
     }
   }
@@ -2308,38 +2291,23 @@ var OctahedronToolBox = class {
 
 // src/decoder/compression/attributes/prediction_schemes/MeshPredictionSchemeGeometricNormalPredictorArea.ts
 var UPPER_BOUND = 1 << 29;
-function fillInt32PositionCache(cache, att, map, numEntries, tempPos) {
-  const bufData = att.buffer && att.buffer.data;
-  if (att.dataType === 5 /* INT32 */ && att.numComponents === 3 && bufData) {
-    const src = new Int32Array(bufData.buffer);
-    const srcStart = bufData.byteOffset + att.byteOffset >> 2;
-    const stride = att.byteStride >> 2;
-    const isIdentity = att.isMappingIdentity;
-    const indicesMap = att.indicesMap;
-    if (isIdentity) {
-      for (let d = 0; d < numEntries; ++d) {
-        const srcOffset = srcStart + map[d] * stride;
-        const o = d * 3;
-        cache[o] = src[srcOffset];
-        cache[o + 1] = src[srcOffset + 1];
-        cache[o + 2] = src[srcOffset + 2];
-      }
-    } else {
-      for (let d = 0; d < numEntries; ++d) {
-        const srcOffset = srcStart + indicesMap[map[d]] * stride;
-        const o = d * 3;
-        cache[o] = src[srcOffset];
-        cache[o + 1] = src[srcOffset + 1];
-        cache[o + 2] = src[srcOffset + 2];
-      }
+function fillInt32PositionCache(cache, att, map, numEntries) {
+  const bytes = att.buffer.data;
+  const src = new Int32Array(bytes.buffer, bytes.byteOffset, bytes.length >> 2);
+  if (att.isMappingIdentity) {
+    for (let d = 0, o = 0; d < numEntries; ++d, o += 3) {
+      const s = map[d] * 3;
+      cache[o] = src[s];
+      cache[o + 1] = src[s + 1];
+      cache[o + 2] = src[s + 2];
     }
   } else {
-    for (let d = 0; d < numEntries; ++d) {
-      att.convertValue(att.mappedIndex(map[d]), tempPos);
-      const o = d * 3;
-      cache[o] = tempPos[0];
-      cache[o + 1] = tempPos[1];
-      cache[o + 2] = tempPos[2];
+    const indicesMap = att.indicesMap;
+    for (let d = 0, o = 0; d < numEntries; ++d, o += 3) {
+      const s = indicesMap[map[d]] * 3;
+      cache[o] = src[s];
+      cache[o + 1] = src[s + 1];
+      cache[o + 2] = src[s + 2];
     }
   }
 }
@@ -2347,12 +2315,8 @@ var MeshPredictionSchemeGeometricNormalPredictorArea = class {
   xa = null;
   ya = null;
   c;
-  db = new Array(3);
-  za = null;
-  // flat Int32 positions, indexed by data id
-  q = null;
-  Jb = null;
-  // corner -> posCache offset, precomputed
+  // Per value: the area-weighted normal sum of its vertex's faces.
+  Hb = null;
   constructor(meshData) {
     this.c = meshData;
   }
@@ -2362,86 +2326,52 @@ var MeshPredictionSchemeGeometricNormalPredictorArea = class {
   setEntryToPointIdMap(map) {
     this.ya = map;
   }
-  buildPositionCache(numEntries) {
-    const posCache = scratchInt32(numEntries * 3);
-    fillInt32PositionCache(posCache, this.xa, this.ya, numEntries, this.db);
-    this.za = posCache;
-    const table = this.c.cornerTable;
-    const cornerToVertex = table.cornerToVertexArray();
-    this.q = table.oppositeCornerArray();
+  // Sums every face's area vector into its corners' values (see above).
+  computeNormalSums(numEntries) {
+    const pos = scratchInt32(numEntries * 3);
+    fillInt32PositionCache(pos, this.xa, this.ya, numEntries);
+    const cornerToVertex = this.c.cornerTable.cornerToVertexArray();
     const vertexToDataMap = this.c.vertexToDataMap;
-    const nc = cornerToVertex.length;
-    const c2o = scratchInt32(nc);
-    for (let c = 0; c < nc; ++c) {
-      const v = cornerToVertex[c];
-      c2o[c] = v < 0 ? -1 : vertexToDataMap[v] * 3;
-    }
-    this.Jb = c2o;
-  }
-  computePredictedValue(cornerId, prediction) {
-    const oppositeCorners = this.q;
-    const cornerToOffset = this.Jb;
-    const posCache = this.za;
-    const centerOffset = cornerToOffset[cornerId];
-    const centX = posCache[centerOffset];
-    const centY = posCache[centerOffset + 1];
-    const centZ = posCache[centerOffset + 2];
-    let normalX = 0, normalY = 0, normalZ = 0;
-    let currentCorner = cornerId;
-    let leftTraversal = true;
-    while (currentCorner >= 0) {
-      const rem = currentCorner - (currentCorner / 3 | 0) * 3;
-      const cNext = rem === 2 ? currentCorner - 2 : currentCorner + 1;
-      const cPrev = rem === 0 ? currentCorner + 2 : currentCorner - 1;
-      let posOffset = cornerToOffset[cNext];
-      const nextX = posCache[posOffset];
-      const nextY = posCache[posOffset + 1];
-      const nextZ = posCache[posOffset + 2];
-      posOffset = cornerToOffset[cPrev];
-      const prevX = posCache[posOffset];
-      const prevY = posCache[posOffset + 1];
-      const prevZ = posCache[posOffset + 2];
-      const dNextX = nextX - centX;
-      const dNextY = nextY - centY;
-      const dNextZ = nextZ - centZ;
-      const dPrevX = prevX - centX;
-      const dPrevY = prevY - centY;
-      const dPrevZ = prevZ - centZ;
-      normalX += dNextY * dPrevZ - dNextZ * dPrevY;
-      normalY += dNextZ * dPrevX - dNextX * dPrevZ;
-      normalZ += dNextX * dPrevY - dNextY * dPrevX;
-      if (leftTraversal) {
-        const opp = oppositeCorners[cNext];
-        if (opp < 0) {
-          currentCorner = -1;
-        } else {
-          const oppRem = opp - (opp / 3 | 0) * 3;
-          currentCorner = oppRem === 2 ? opp - 2 : opp + 1;
-        }
-        if (currentCorner < 0) {
-          const startRem = cornerId - (cornerId / 3 | 0) * 3;
-          const startPrev = startRem === 0 ? cornerId + 2 : cornerId - 1;
-          const startOpp = oppositeCorners[startPrev];
-          if (startOpp < 0) {
-            currentCorner = -1;
-          } else {
-            const startOppRem = startOpp - (startOpp / 3 | 0) * 3;
-            currentCorner = startOppRem === 0 ? startOpp + 2 : startOpp - 1;
-          }
-          leftTraversal = false;
-        } else if (currentCorner === cornerId) {
-          currentCorner = -1;
-        }
-      } else {
-        const opp = oppositeCorners[cPrev];
-        if (opp < 0) {
-          currentCorner = -1;
-        } else {
-          const oppRem = opp - (opp / 3 | 0) * 3;
-          currentCorner = oppRem === 0 ? opp + 2 : opp - 1;
-        }
-      }
-    }
+    const sums = new Float64Array(numEntries * 3);
+    const numCorners = cornerToVertex.length;
+    for (let c = 0; c < numCorners; c += 3) {
+      const v0 = cornerToVertex[c];
+      const v1 = cornerToVertex[c + 1];
+      const v2 = cornerToVertex[c + 2];
+      if ((v0 | v1 | v2) < 0) return false;
+      const o0 = vertexToDataMap[v0] * 3;
+      const o1 = vertexToDataMap[v1] * 3;
+      const o2 = vertexToDataMap[v2] * 3;
+      const x0 = pos[o0];
+      const y0 = pos[o0 + 1];
+      const z0 = pos[o0 + 2];
+      const ax = pos[o1] - x0;
+      const ay = pos[o1 + 1] - y0;
+      const az = pos[o1 + 2] - z0;
+      const bx = pos[o2] - x0;
+      const by = pos[o2 + 1] - y0;
+      const bz = pos[o2 + 2] - z0;
+      const nx = ay * bz - az * by;
+      const ny = az * bx - ax * bz;
+      const nz = ax * by - ay * bx;
+      sums[o0] += nx;
+      sums[o0 + 1] += ny;
+      sums[o0 + 2] += nz;
+      sums[o1] += nx;
+      sums[o1 + 1] += ny;
+      sums[o1 + 2] += nz;
+      sums[o2] += nx;
+      sums[o2 + 1] += ny;
+      sums[o2 + 2] += nz;
+    }
+    this.Hb = sums;
+    return true;
+  }
+  computePredictedValue(dataId, prediction) {
+    const sums = this.Hb;
+    let normalX = sums[dataId * 3];
+    let normalY = sums[dataId * 3 + 1];
+    let normalZ = sums[dataId * 3 + 2];
     const absSum = Math.abs(normalX) + Math.abs(normalY) + Math.abs(normalZ);
     if (absSum > UPPER_BOUND) {
       const quotient = Math.floor(absSum / UPPER_BOUND);
@@ -2458,12 +2388,12 @@ var MeshPredictionSchemeGeometricNormalPredictorArea = class {
 // src/decoder/compression/attributes/prediction_schemes/MeshPredictionSchemeGeometricNormalDecoder.ts
 var GEOMETRY_ATTRIBUTE_POSITION = 0;
 var MeshPredictionSchemeGeometricNormalDecoder = class extends MeshPredictionSchemeDecoder {
-  t;
+  s;
   z = new OctahedronToolBox();
-  eb = new RAnsBitDecoder();
+  cb = new RAnsBitDecoder();
   constructor(transform, meshData) {
     super(transform, meshData);
-    this.t = new MeshPredictionSchemeGeometricNormalPredictorArea(meshData);
+    this.s = new MeshPredictionSchemeGeometricNormalPredictorArea(meshData);
   }
   getNumParentAttributes() {
     return 1;
@@ -2474,34 +2404,33 @@ var MeshPredictionSchemeGeometricNormalDecoder = class extends MeshPredictionSch
   setParentAttribute(att) {
     if (att.attributeType !== GEOMETRY_ATTRIBUTE_POSITION) return false;
     if (att.numComponents !== 3) return false;
-    this.t.setPositionAttribute(att);
+    this.s.setPositionAttribute(att);
     return true;
   }
   decodePredictionData(buffer) {
-    if (!this.f.decodeTransformData(buffer)) return false;
-    return this.eb.startDecoding(buffer);
+    if (!this.e.decodeTransformData(buffer)) return false;
+    return this.cb.startDecoding(buffer);
   }
   computeOriginalValues(inCorr, outData, _size, _numComponents, entryToPointIdMap) {
-    this.z.setQuantizationBits(this.f.quantizationBits());
-    this.t.setEntryToPointIdMap(entryToPointIdMap);
+    this.z.setQuantizationBits(this.e.quantizationBits());
+    this.s.setEntryToPointIdMap(entryToPointIdMap);
     const cornerMapSize = this.c.dataToCornerMap.length;
-    this.t.buildPositionCache(cornerMapSize);
+    if (!this.s.computeNormalSums(cornerMapSize)) return false;
     const predNormal3D = new Int32Array(3);
     const predNormalOct = new Int32Array(2);
     for (let dataId = 0; dataId < cornerMapSize; ++dataId) {
-      const cornerId = this.c.dataToCornerMap[dataId];
-      this.t.computePredictedValue(cornerId, predNormal3D);
+      this.s.computePredictedValue(dataId, predNormal3D);
       this.z.canonicalizeIntegerVector(predNormal3D);
-      if (this.eb.decodeNextBit()) {
+      if (this.cb.decodeNextBit()) {
         predNormal3D[0] = -predNormal3D[0];
         predNormal3D[1] = -predNormal3D[1];
         predNormal3D[2] = -predNormal3D[2];
       }
       this.z.integerVectorToQuantizedOctahedralCoords(predNormal3D, predNormalOct);
       const dataOffset = dataId * 2;
-      this.f.computeOriginalValue(predNormalOct, 0, inCorr, dataOffset, outData, dataOffset);
+      this.e.computeOriginalValue(predNormalOct, 0, inCorr, dataOffset, outData, dataOffset);
     }
-    this.eb.endDecoding();
+    this.cb.endDecoding();
     return true;
   }
 };
@@ -2510,10 +2439,10 @@ var MeshPredictionSchemeGeometricNormalDecoder = class extends MeshPredictionSch
 var kInvalidCornerIndex3 = -1;
 var MeshPredictionSchemeMultiParallelogramDecoder = class extends MeshPredictionSchemeDecoder {
   computeOriginalValues(inCorr, outData, _size, numComponents, _entryToPointIdMap) {
-    this.f.init(numComponents);
+    this.e.init(numComponents);
     const predVals = new Int32Array(numComponents);
     const parallelogramPredVals = new Int32Array(numComponents);
-    this.f.computeOriginalValue(predVals, 0, inCorr, 0, outData, 0);
+    this.e.computeOriginalValue(predVals, 0, inCorr, 0, outData, 0);
     const table = this.c.cornerTable;
     const vertexToDataMap = this.c.vertexToDataMap;
     const oppositeCorners = table.oppositeCornerArray();
@@ -2550,12 +2479,12 @@ var MeshPredictionSchemeMultiParallelogramDecoder = class extends MeshPrediction
       const dstOffset = p * numComponents;
       if (numParallelograms === 0) {
         const srcOffset = (p - 1) * numComponents;
-        this.f.computeOriginalValue(outData, srcOffset, inCorr, dstOffset, outData, dstOffset);
+        this.e.computeOriginalValue(outData, srcOffset, inCorr, dstOffset, outData, dstOffset);
       } else {
         for (let c = 0; c < numComponents; ++c) {
           predVals[c] = predVals[c] / numParallelograms | 0;
         }
-        this.f.computeOriginalValue(predVals, 0, inCorr, dstOffset, outData, dstOffset);
+        this.e.computeOriginalValue(predVals, 0, inCorr, dstOffset, outData, dstOffset);
       }
     }
     return true;
@@ -2567,7 +2496,7 @@ var MeshPredictionSchemeParallelogramDecoder = class extends MeshPredictionSchem
   // Zigzag-fused variant: decodes corrections that are still in their unsigned
   // zigzag form, unpacking each one inline.
   computeOriginalValuesZigzag(inCorr, outData, _size, numComponents, _entryToPointIdMap) {
-    this.f.init(numComponents);
+    this.e.init(numComponents);
     return this.kc(inCorr, outData, numComponents, true);
   }
   // The wrap transform's corrections are zigzag-coded; with `zigzag` set the
@@ -2587,9 +2516,9 @@ var MeshPredictionSchemeParallelogramDecoder = class extends MeshPredictionSchem
       return this.nc(inCorr, outData, zigzag);
     }
     const parents = this.c.parallelogramParents();
-    const transform = this.f;
-    const minValue = transform.X;
-    const maxValue = transform.m;
+    const transform = this.e;
+    const minValue = transform._;
+    const maxValue = transform.n;
     const maxDif = transform.ga;
     for (let c = 0; c < numComponents; ++c) {
       let pred = 0;
@@ -2655,9 +2584,9 @@ var MeshPredictionSchemeParallelogramDecoder = class extends MeshPredictionSchem
   }
   lc(inCorr, outData, zigzag) {
     const parents = this.c.parallelogramParents();
-    const transform = this.f;
-    const minValue = transform.X;
-    const maxValue = transform.m;
+    const transform = this.e;
+    const minValue = transform._;
+    const maxValue = transform.n;
     const maxDif = transform.ga;
     let pred0 = 0;
     let pred1 = 0;
@@ -2733,9 +2662,9 @@ var MeshPredictionSchemeParallelogramDecoder = class extends MeshPredictionSchem
   }
   mc(inCorr, outData, zigzag) {
     const parents = this.c.parallelogramParents();
-    const transform = this.f;
-    const minValue = transform.X;
-    const maxValue = transform.m;
+    const transform = this.e;
+    const minValue = transform._;
+    const maxValue = transform.n;
     const maxDif = transform.ga;
     let pred0 = 0;
     let pred1 = 0;
@@ -2842,9 +2771,9 @@ var MeshPredictionSchemeParallelogramDecoder = class extends MeshPredictionSchem
   // structure as the 2/3-component loops.
   nc(inCorr, outData, zigzag) {
     const parents = this.c.parallelogramParents();
-    const transform = this.f;
-    const minValue = transform.X;
-    const maxValue = transform.m;
+    const transform = this.e;
+    const minValue = transform._;
+    const maxValue = transform.n;
     const maxDif = transform.ga;
     let pred0 = 0;
     if (pred0 > maxValue) {
@@ -2950,14 +2879,13 @@ function bigIntSqrt(value) {
 var MeshPredictionSchemeTexCoordsPortablePredictor = class {
   xa = null;
   ya = null;
-  u = new Int32Array(2);
-  Sa = new Uint8Array(0);
-  Aa = 0;
+  t = new Int32Array(2);
+  Sa = EMPTY_UINT8;
+  za = 0;
   c;
-  db = new Array(3);
   // Flat Int32 position cache so fetches are array reads, not convertValue calls.
-  za = null;
-  j = null;
+  Ib = null;
+  k = null;
   constructor(meshData) {
     this.c = meshData;
   }
@@ -2968,26 +2896,26 @@ var MeshPredictionSchemeTexCoordsPortablePredictor = class {
     this.ya = map;
   }
   get predictedValue() {
-    return this.u;
+    return this.t;
   }
   resizeOrientations(numOrientations) {
     this.Sa = new Uint8Array(numOrientations);
-    this.Aa = numOrientations;
+    this.za = numOrientations;
   }
   setOrientation(i, v) {
     this.Sa[i] = v ? 1 : 0;
   }
   buildPositionCache(numEntries) {
     const posCache = new Int32Array(numEntries * 3);
-    fillInt32PositionCache(posCache, this.xa, this.ya, numEntries, this.db);
-    this.za = posCache;
-    this.j = this.c.cornerTable.cornerToVertexArray();
+    fillInt32PositionCache(posCache, this.xa, this.ya, numEntries);
+    this.Ib = posCache;
+    this.k = this.c.cornerTable.cornerToVertexArray();
   }
   computePredictedValue(cornerId, data, dataId) {
     const rem = cornerId - (cornerId / 3 | 0) * 3;
     const nextCornerId = rem === 2 ? cornerId - 2 : cornerId + 1;
     const prevCornerId = rem === 0 ? cornerId + 2 : cornerId - 1;
-    const cornerToVertex = this.j;
+    const cornerToVertex = this.k;
     const nextVertId = cornerToVertex[nextCornerId];
     const prevVertId = cornerToVertex[prevCornerId];
     const vertexToDataMap = this.c.vertexToDataMap;
@@ -2999,11 +2927,11 @@ var MeshPredictionSchemeTexCoordsPortablePredictor = class {
       const nUV0 = data[nDataOff], nUV1 = data[nDataOff + 1];
       const pUV0 = data[pDataOff], pUV1 = data[pDataOff + 1];
       if (pUV0 === nUV0 && pUV1 === nUV1) {
-        this.u[0] = pUV0;
-        this.u[1] = pUV1;
+        this.t[0] = pUV0;
+        this.t[1] = pUV1;
         return true;
       }
-      const posCache = this.za;
+      const posCache = this.Ib;
       let posOffset = dataId * 3;
       const tip0 = posCache[posOffset];
       const tip1 = posCache[posOffset + 1];
@@ -3027,19 +2955,12 @@ var MeshPredictionSchemeTexCoordsPortablePredictor = class {
         const cnDotPn = pn0 * cn0 + pn1 * cn1 + pn2 * cn2;
         const pnUV0 = pUV0 - nUV0;
         const pnUV1 = pUV1 - nUV1;
-        const INT64_MAX = 2 ** 63;
         const nUVAbsMax = Math.max(Math.abs(nUV0), Math.abs(nUV1));
-        if (nUVAbsMax > INT64_MAX / pnNorm2Squared) {
-          return false;
-        }
         const pnUVAbsMax = Math.max(Math.abs(pnUV0), Math.abs(pnUV1));
-        if (pnUVAbsMax > 0 && Math.abs(cnDotPn) > INT64_MAX / pnUVAbsMax) {
-          return false;
-        }
         const cnNorm2 = cn0 * cn0 + cn1 * cn1 + cn2 * cn2;
         const pnAbsMaxG = Math.max(Math.abs(pn0), Math.abs(pn1), Math.abs(pn2));
         const cnDotPnAbs = Math.abs(cnDotPn);
-        if (cnNorm2 > SAFE_PRODUCT / pnNorm2Squared || nUVAbsMax > SAFE_PRODUCT / pnNorm2Squared || pnUVAbsMax > 0 && cnDotPnAbs > SAFE_PRODUCT / pnUVAbsMax || pnAbsMaxG > 0 && cnDotPnAbs > SAFE_PRODUCT / pnAbsMaxG) {
+        if (!(cnNorm2 * pnNorm2Squared < SAFE_PRODUCT && nUVAbsMax * pnNorm2Squared < SAFE_PRODUCT && cnDotPnAbs * pnUVAbsMax < SAFE_PRODUCT && cnDotPnAbs * pnAbsMaxG < SAFE_PRODUCT)) {
           return this.oc(
             tip0,
             tip1,
@@ -3059,9 +2980,6 @@ var MeshPredictionSchemeTexCoordsPortablePredictor = class {
         }
         const xUV0 = nUV0 * pnNorm2Squared + cnDotPn * pnUV0;
         const xUV1 = nUV1 * pnNorm2Squared + cnDotPn * pnUV1;
-        if (pnAbsMaxG > 0 && cnDotPnAbs > INT64_MAX / pnAbsMaxG) {
-          return false;
-        }
         const xPos0 = next0 + Math.trunc(cnDotPn * pn0 / pnNorm2Squared);
         const xPos1 = next1 + Math.trunc(cnDotPn * pn1 / pnNorm2Squared);
         const xPos2 = next2 + Math.trunc(cnDotPn * pn2 / pnNorm2Squared);
@@ -3072,16 +2990,16 @@ var MeshPredictionSchemeTexCoordsPortablePredictor = class {
         const normSquared = Math.floor(Math.sqrt(cxNorm2Squared * pnNorm2Squared));
         const cxUV0 = pnUV1 * normSquared;
         const cxUV1 = -pnUV0 * normSquared;
-        if (this.Aa === 0) {
+        if (this.za === 0) {
           return false;
         }
-        const orientation = this.Sa[--this.Aa];
+        const orientation = this.Sa[--this.za];
         if (orientation) {
-          this.u[0] = Math.trunc((xUV0 + cxUV0) / pnNorm2Squared);
-          this.u[1] = Math.trunc((xUV1 + cxUV1) / pnNorm2Squared);
+          this.t[0] = Math.trunc((xUV0 + cxUV0) / pnNorm2Squared);
+          this.t[1] = Math.trunc((xUV1 + cxUV1) / pnNorm2Squared);
         } else {
-          this.u[0] = Math.trunc((xUV0 - cxUV0) / pnNorm2Squared);
-          this.u[1] = Math.trunc((xUV1 - cxUV1) / pnNorm2Squared);
+          this.t[0] = Math.trunc((xUV0 - cxUV0) / pnNorm2Squared);
+          this.t[1] = Math.trunc((xUV1 - cxUV1) / pnNorm2Squared);
         }
         return true;
       }
@@ -3096,13 +3014,13 @@ var MeshPredictionSchemeTexCoordsPortablePredictor = class {
       if (dataId > 0) {
         dataOffset = (dataId - 1) * 2;
       } else {
-        this.u[0] = 0;
-        this.u[1] = 0;
+        this.t[0] = 0;
+        this.t[1] = 0;
         return true;
       }
     }
-    this.u[0] = data[dataOffset];
-    this.u[1] = data[dataOffset + 1];
+    this.t[0] = data[dataOffset];
+    this.t[1] = data[dataOffset + 1];
     return true;
   }
   // 64-bit-exact projection prediction, used when the double path would lose
@@ -3144,8 +3062,8 @@ var MeshPredictionSchemeTexCoordsPortablePredictor = class {
     const normSquared = bigIntSqrt(cxNorm2 * pnN2 & MASK64);
     const cxUV0 = B.asIntN(64, pnUV1 * normSquared);
     const cxUV1 = B.asIntN(64, -pnUV0 * normSquared);
-    if (this.Aa === 0) return false;
-    const orientation = this.Sa[--this.Aa];
+    if (this.za === 0) return false;
+    const orientation = this.Sa[--this.za];
     let s0, s1;
     if (orientation) {
       s0 = B.asUintN(64, B.asUintN(64, xUV0) + B.asUintN(64, cxUV0));
@@ -3154,8 +3072,8 @@ var MeshPredictionSchemeTexCoordsPortablePredictor = class {
       s0 = B.asUintN(64, B.asUintN(64, xUV0) - B.asUintN(64, cxUV0));
       s1 = B.asUintN(64, B.asUintN(64, xUV1) - B.asUintN(64, cxUV1));
     }
-    this.u[0] = Number(B.asIntN(32, B.asIntN(64, s0) / pnN2));
-    this.u[1] = Number(B.asIntN(32, B.asIntN(64, s1) / pnN2));
+    this.t[0] = Number(B.asIntN(32, B.asIntN(64, s0) / pnN2));
+    this.t[1] = Number(B.asIntN(32, B.asIntN(64, s1) / pnN2));
     return true;
   }
 };
@@ -3163,10 +3081,10 @@ var MeshPredictionSchemeTexCoordsPortablePredictor = class {
 // src/decoder/compression/attributes/prediction_schemes/MeshPredictionSchemeTexCoordsPortableDecoder.ts
 var GEOMETRY_ATTRIBUTE_POSITION2 = 0;
 var MeshPredictionSchemeTexCoordsPortableDecoder = class extends MeshPredictionSchemeDecoder {
-  t;
+  s;
   constructor(transform, meshData) {
     super(transform, meshData);
-    this.t = new MeshPredictionSchemeTexCoordsPortablePredictor(meshData);
+    this.s = new MeshPredictionSchemeTexCoordsPortablePredictor(meshData);
   }
   getNumParentAttributes() {
     return 1;
@@ -3177,13 +3095,13 @@ var MeshPredictionSchemeTexCoordsPortableDecoder = class extends MeshPredictionS
   setParentAttribute(att) {
     if (att.attributeType !== GEOMETRY_ATTRIBUTE_POSITION2) return false;
     if (att.numComponents !== 3) return false;
-    this.t.setPositionAttribute(att);
+    this.s.setPositionAttribute(att);
     return true;
   }
   decodePredictionData(buffer) {
     const numOrientations = buffer.decodeInt32();
     if (numOrientations === void 0 || numOrientations < 0) return false;
-    this.t.resizeOrientations(numOrientations);
+    this.s.resizeOrientations(numOrientations);
     let lastOrientation = true;
     const decoder = new RAnsBitDecoder();
     if (!decoder.startDecoding(buffer)) return false;
@@ -3191,7 +3109,7 @@ var MeshPredictionSchemeTexCoordsPortableDecoder = class extends MeshPredictionS
       if (!decoder.decodeNextBit()) {
         lastOrientation = !lastOrientation;
       }
-      this.t.setOrientation(i, lastOrientation);
+      this.s.setOrientation(i, lastOrientation);
     }
     decoder.endDecoding();
     return super.decodePredictionData(buffer);
@@ -3200,17 +3118,17 @@ var MeshPredictionSchemeTexCoordsPortableDecoder = class extends MeshPredictionS
     if (numComponents !== 2) {
       return false;
     }
-    this.t.setEntryToPointIdMap(entryToPointIdMap);
-    this.f.init(numComponents);
+    this.s.setEntryToPointIdMap(entryToPointIdMap);
+    this.e.init(numComponents);
     const cornerMapSize = this.c.dataToCornerMap.length;
-    this.t.buildPositionCache(cornerMapSize);
+    this.s.buildPositionCache(cornerMapSize);
     for (let p = 0; p < cornerMapSize; ++p) {
       const cornerId = this.c.dataToCornerMap[p];
-      if (!this.t.computePredictedValue(cornerId, outData, p)) {
+      if (!this.s.computePredictedValue(cornerId, outData, p)) {
         return false;
       }
       const dstOffset = p * numComponents;
-      this.f.computeOriginalValue(this.t.predictedValue, 0, inCorr, dstOffset, outData, dstOffset);
+      this.e.computeOriginalValue(this.s.predictedValue, 0, inCorr, dstOffset, outData, dstOffset);
     }
     return true;
   }
@@ -3219,7 +3137,7 @@ var MeshPredictionSchemeTexCoordsPortableDecoder = class extends MeshPredictionS
 // src/decoder/compression/attributes/prediction_schemes/PredictionSchemeDeltaDecoder.ts
 var PredictionSchemeDeltaDecoder = class extends PredictionSchemeDecoder {
   computeOriginalValues(inCorr, outData, size, numComponents, _entryToPointIdMap) {
-    const transform = this.f;
+    const transform = this.e;
     transform.init(numComponents);
     if (transform.computeOriginalValuesDelta) {
       transform.computeOriginalValuesDelta(inCorr, outData, size, numComponents);
@@ -3275,8 +3193,8 @@ function createPredictionSchemeForDecoder(method, attId, decoder, transform) {
 // src/decoder/compression/attributes/prediction_schemes/PredictionSchemeWrapDecodingTransform.ts
 var PredictionSchemeWrapDecodingTransform = class {
   y = 0;
-  X = 0;
-  m = 0;
+  _ = 0;
+  n = 0;
   ga = 0;
   getType() {
     return 1 /* PREDICTION_TRANSFORM_WRAP */;
@@ -3288,12 +3206,12 @@ var PredictionSchemeWrapDecodingTransform = class {
     return false;
   }
   boundsValues(limit) {
-    return this.m < limit && this.X > -limit;
+    return this.n < limit && this._ > -limit;
   }
   computeOriginalValue(predictedVals, predictedOffset, corrVals, corrOffset, outOriginalVals, outOffset) {
     const nc = this.y;
-    const minValue = this.X;
-    const maxValue = this.m;
+    const minValue = this._;
+    const maxValue = this.n;
     const maxDif = this.ga;
     for (let i = 0; i < nc; ++i) {
       let pred = predictedVals[predictedOffset + i];
@@ -3318,8 +3236,8 @@ var PredictionSchemeWrapDecodingTransform = class {
     if (maxValue === void 0) return false;
     const dif = maxValue - minValue;
     if (dif < 0 || dif >= 2147483647) return false;
-    this.X = minValue;
-    this.m = maxValue;
+    this._ = minValue;
+    this.n = maxValue;
     this.ga = 1 + dif;
     return true;
   }
@@ -3327,25 +3245,27 @@ var PredictionSchemeWrapDecodingTransform = class {
 
 // src/decoder/compression/attributes/SequentialIntegerAttributeDecoder.ts
 var SequentialIntegerAttributeDecoder = class extends SequentialAttributeDecoder {
-  Q = null;
+  P = null;
   // 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.
   ha = null;
-  fb = 0;
-  Kb = null;
-  // Int32 view over the portable attribute's storage (see preparePortableAttribute).
-  Y = null;
+  db = 0;
+  Jb = null;
+  // The decoded (portable) values, numComponents per entry (see
+  // preparePortableAttribute).
+  Q = null;
+  Kb = 0;
   // --- Two-phase decode (parse headers / batch symbol decode / finish) ---
   pendingSymbolStream() {
     if (this.ha === null) {
       return null;
     }
-    const portableData = this.Y;
+    const portableData = this.Q;
     return {
-      ans: this.ha.K,
-      out: new Uint32Array(portableData.buffer, portableData.byteOffset, this.fb),
-      count: this.fb
+      ans: this.ha.L,
+      out: new Uint32Array(portableData.buffer, portableData.byteOffset, this.db),
+      count: this.db
     };
   }
   decodePortableAttributeFinish() {
@@ -3353,13 +3273,13 @@ var SequentialIntegerAttributeDecoder = class extends SequentialAttributeDecoder
       this.ha.endDecoding();
       this.ha = null;
     }
-    return this.pc(this.Kb);
+    return this.pc(this.Jb);
   }
   // The parse phase of the integer decode: prediction scheme, portable
   // attribute, the symbol stream (raw streams are deferred to the finish
   // phase) and the prediction data.
   decodeValues(pointIds, buffer) {
-    this.Kb = pointIds;
+    this.Jb = pointIds;
     let predictionSchemeMethod = buffer.decodeUint8();
     if (predictionSchemeMethod !== void 0) predictionSchemeMethod = predictionSchemeMethod << 24 >> 24;
     if (predictionSchemeMethod === void 0) return false;
@@ -3373,10 +3293,10 @@ var SequentialIntegerAttributeDecoder = class extends SequentialAttributeDecoder
       if (predictionTransformType < -1 /* PREDICTION_TRANSFORM_NONE */ || predictionTransformType >= 4 /* NUM_PREDICTION_SCHEME_TRANSFORM_TYPES */) {
         return false;
       }
-      this.Q = this.createIntPredictionScheme(predictionSchemeMethod, predictionTransformType);
+      this.P = this.createIntPredictionScheme(predictionSchemeMethod, predictionTransformType);
     }
-    if (this.Q) {
-      if (!this.initPredictionScheme(this.Q)) {
+    if (this.P) {
+      if (!this.initPredictionScheme(this.P)) {
         return false;
       }
     }
@@ -3387,7 +3307,7 @@ var SequentialIntegerAttributeDecoder = class extends SequentialAttributeDecoder
     const numEntries = pointIds.length;
     const numValues = numEntries * numComponents;
     this.preparePortableAttribute(numEntries, numComponents);
-    const portableAttributeData = this.Y;
+    const portableAttributeData = this.Q;
     if (portableAttributeData === null) {
       return false;
     }
@@ -3402,7 +3322,7 @@ var SequentialIntegerAttributeDecoder = class extends SequentialAttributeDecoder
             return false;
           }
           this.ha = decoder;
-          this.fb = numValues;
+          this.db = numValues;
         } else if (scheme === 0 /* SYMBOL_CODING_TAGGED */) {
           const outUint32 = new Uint32Array(portableAttributeData.buffer, portableAttributeData.byteOffset, numValues);
           if (!decodeTaggedSymbols(numValues, numComponents, buffer, outUint32)) {
@@ -3426,8 +3346,8 @@ var SequentialIntegerAttributeDecoder = class extends SequentialAttributeDecoder
         portableAttributeData[i] = val;
       }
     }
-    if (this.Q) {
-      if (!this.Q.decodePredictionData(buffer)) {
+    if (this.P) {
+      if (!this.P.decodePredictionData(buffer)) {
         return false;
       }
     }
@@ -3437,14 +3357,14 @@ var SequentialIntegerAttributeDecoder = class extends SequentialAttributeDecoder
   pc(pointIds) {
     const numComponents = this.getNumValueComponents();
     const numValues = pointIds.length * numComponents;
-    const data = this.Y;
+    const data = this.Q;
     if (data === null) {
       return false;
     }
     if (numValues === 0) {
       return true;
     }
-    const ps = this.Q;
+    const ps = this.P;
     if (ps === null) {
       convertSymbolsToSignedInts(new Uint32Array(data.buffer, data.byteOffset, numValues), numValues, data);
       return true;
@@ -3459,7 +3379,7 @@ var SequentialIntegerAttributeDecoder = class extends SequentialAttributeDecoder
     return ps.computeOriginalValues(data, data, numValues, numComponents, pointIds);
   }
   transformAttributeToOriginalFormat(pointIds) {
-    return this.gb(pointIds.length);
+    return this.eb(pointIds.length);
   }
   // Prediction scheme for decoding integer values; subclasses override for others.
   createIntPredictionScheme(method, transformType) {
@@ -3477,43 +3397,59 @@ var SequentialIntegerAttributeDecoder = class extends SequentialAttributeDecoder
   // see PointAttribute._lazyFloatValues): true when a prediction transform
   // clamps them into such a range. Unpredicted values are unbounded.
   Lb() {
-    return this.Q !== null && this.Q.boundsValues(16777216);
+    return this.P !== null && this.P.boundsValues(16777216);
   }
   // The decoded values stay in the portable attribute; the final attribute
   // only takes its size (see PointAttribute.setLazyInteger and the overrides
   // in the quantization / normal decoders).
-  Hb(numValues) {
+  Fb(numValues) {
     this.attribute.resetLazy(numValues);
     return true;
   }
   // Hands the decoded integer values to the attribute, converted to its
   // integer type on extraction.
-  gb(_numValues) {
+  eb(_numValues) {
     const dt = this.attribute.dataType;
     if (dt < 1 /* INT8 */ || dt > 6 /* UINT32 */) {
       return false;
     }
-    this.attribute.setLazyInteger(this.Y);
+    this.attribute.setLazyInteger(this.Q);
     return true;
   }
+  // Heap-backed: the decoded values are what the final attribute hands out
+  // (see _storeValues), so they outlive the decode. The portable
+  // PointAttribute around them is only built if a dependent attribute's
+  // predictor asks for it (see getPortableAttribute).
   preparePortableAttribute(numEntries, numComponents) {
-    const ga = new GeometryAttribute();
-    ga.init(
-      this.attribute.attributeType,
-      null,
-      numComponents,
-      5 /* INT32 */,
-      false,
-      numComponents * dataTypeLength(5 /* INT32 */),
-      0
-    );
-    const portAtt = new PointAttribute(ga);
-    portAtt.setIdentityMapping();
-    portAtt.reset(numEntries);
-    portAtt.uniqueId = this.attribute.uniqueId;
-    this.ea = portAtt;
-    const data = portAtt.buffer.data;
-    this.Y = numEntries === 0 ? null : new Int32Array(data.buffer, data.byteOffset + portAtt.byteOffset, numEntries * numComponents);
+    this.Kb = numComponents;
+    this.Q = numEntries === 0 ? null : new Int32Array(numEntries * numComponents);
+  }
+  getPortableAttribute() {
+    const numComponents = this.Kb;
+    if (this.Z === null && numComponents > 0) {
+      const ga = new GeometryAttribute();
+      ga.init(
+        this.attribute.attributeType,
+        null,
+        numComponents,
+        5 /* INT32 */,
+        false,
+        numComponents * dataTypeLength(5 /* INT32 */),
+        0
+      );
+      const portAtt = new PointAttribute(ga);
+      portAtt.setIdentityMapping();
+      const data = this.Q;
+      if (data === null) portAtt.reset(0);
+      else
+        portAtt.resetWithData(
+          new Uint8Array(data.buffer, data.byteOffset, data.byteLength),
+          data.length / numComponents
+        );
+      portAtt.uniqueId = this.attribute.uniqueId;
+      this.Z = portAtt;
+    }
+    return super.getPortableAttribute();
   }
 };
 
@@ -3561,7 +3497,7 @@ var PredictionSchemeNormalOctahedronCanonicalizedDecodingTransform = class exten
   }
   computeOriginalValue(predVals, predOffset, corrVals, corrOffset, outOrigVals, outOffset) {
     const toolBox = this.z;
-    const center = toolBox.h;
+    const center = toolBox.f;
     const maxQuantizedValue = toolBox.fa;
     const corrS = corrVals[corrOffset];
     const corrT = corrVals[corrOffset + 1];
@@ -3689,7 +3625,7 @@ var PredictionSchemeNormalOctahedronCanonicalizedDecodingTransform = class exten
   // sync; only the plumbing differs.
   computeOriginalValuesDelta(inCorr, outData, size, numComponents) {
     const toolBox = this.z;
-    const center = toolBox.h;
+    const center = toolBox.f;
     const maxQuantizedValue = toolBox.fa;
     let prevS = 0;
     let prevT = 0;
@@ -3828,7 +3764,7 @@ var PredictionSchemeNormalOctahedronDecodingTransform = class extends Prediction
   }
   computeOriginalValue(predVals, predOffset, corrVals, corrOffset, outOrigVals, outOffset) {
     const toolBox = this.z;
-    const center = toolBox.h;
+    const center = toolBox.f;
     const maxQuantizedValue = toolBox.fa;
     const predS = predVals[predOffset] - center;
     const predT = predVals[predOffset + 1] - center;
@@ -3908,7 +3844,7 @@ var PredictionSchemeNormalOctahedronDecodingTransform = class extends Prediction
 
 // src/decoder/compression/attributes/SequentialNormalAttributeDecoder.ts
 var SequentialNormalAttributeDecoder = class extends SequentialIntegerAttributeDecoder {
-  P = -1;
+  O = -1;
   init(decoder, attributeId) {
     if (!super.init(decoder, attributeId)) {
       return false;
@@ -3923,16 +3859,16 @@ var SequentialNormalAttributeDecoder = class extends SequentialIntegerAttributeD
   decodeDataNeededByPortableTransform(_pointIds, buffer) {
     const qBits = buffer.decodeUint8();
     if (qBits === void 0) return false;
-    this.P = qBits;
+    this.O = qBits;
     return true;
   }
   // The octahedral-to-unit-vector transform is deferred to extractTo (see
   // PointAttribute.setLazyOctahedron).
-  gb(_numPoints) {
-    const q = this.P;
+  eb(_numPoints) {
+    const q = this.O;
     if (q < 2 || q > 30) return false;
     this.attribute.setLazyOctahedron(
-      this.Y,
+      this.Q,
       Math.fround(2 / Math.fround((1 << q) - 2)),
       this.Lb()
     );
@@ -3949,8 +3885,8 @@ var SequentialNormalAttributeDecoder = class extends SequentialIntegerAttributeD
 
 // src/decoder/compression/attributes/SequentialQuantizationAttributeDecoder.ts
 var SequentialQuantizationAttributeDecoder = class extends SequentialIntegerAttributeDecoder {
-  P = -1;
-  hb = [];
+  O = -1;
+  fb = [];
   Nb = 0;
   init(decoder, attributeId) {
     if (!super.init(decoder, attributeId)) {
@@ -3961,39 +3897,39 @@ var SequentialQuantizationAttributeDecoder = class extends SequentialIntegerAttr
   // The quantization parameters (AttributeQuantizationTransform::DecodeParameters).
   decodeDataNeededByPortableTransform(_pointIds, buffer) {
     const numComponents = this.attribute.numComponents;
-    this.hb = new Array(numComponents);
+    this.fb = new Array(numComponents);
     for (let i = 0; i < numComponents; i++) {
       const val = buffer.decodeFloat32();
       if (val === void 0) return false;
-      this.hb[i] = val;
+      this.fb[i] = val;
     }
     const range = buffer.decodeFloat32();
     if (range === void 0) return false;
     this.Nb = range;
     const qBits = buffer.decodeUint8();
     if (qBits === void 0 || qBits < 1 || qBits > 30) return false;
-    this.P = qBits;
+    this.O = qBits;
     return true;
   }
   // Dequantization is deferred to extractTo (see PointAttribute.setLazyQuantized).
-  gb(_numValues) {
-    const maxQuantizedValue = (1 << this.P >>> 0) - 1;
+  eb(_numValues) {
+    const maxQuantizedValue = (1 << this.O >>> 0) - 1;
     if (maxQuantizedValue <= 0) return false;
     const delta = Math.fround(this.Nb / Math.fround(maxQuantizedValue));
-    this.attribute.setLazyQuantized(this.Y, this.hb, delta, this.Lb());
+    this.attribute.setLazyQuantized(this.Q, this.fb, delta, this.Lb());
     return true;
   }
 };
 
 // src/decoder/compression/attributes/SequentialAttributeDecodersController.ts
 var SequentialAttributeDecodersController = class extends AttributesDecoder {
-  Ba = [];
+  ia = [];
   // Replaced by the sequencer's output in _prepareSequence.
-  Ta = new Int32Array(0);
-  Z;
+  Ta = EMPTY_INT32;
+  $;
   constructor(sequencer) {
     super();
-    this.Z = sequencer;
+    this.$ = sequencer;
   }
   decodeAttributesDecoderData(buffer) {
     if (!super.decodeAttributesDecoderData(buffer)) {
@@ -4007,19 +3943,21 @@ var SequentialAttributeDecodersController = class extends AttributesDecoder {
       if (decoder === null || !decoder.init(this.getDecoder(), this.getAttributeId(i))) {
         return false;
       }
-      this.Ba[i] = decoder;
+      this.ia[i] = decoder;
     }
     return true;
   }
-  qc() {
-    if (!this.Z.generateSequence()) {
+  qc(buffer) {
+    const first = this.ia[0];
+    const parallelogram = first instanceof SequentialIntegerAttributeDecoder && buffer.remainingSize > 0 && buffer.data[buffer.decodedSize] === 1 /* MESH_PREDICTION_PARALLELOGRAM */;
+    if (!this.$.generateSequence(parallelogram)) {
       return false;
     }
-    this.Ta = this.Z.getOutputPointIds();
+    this.Ta = this.$.getOutputPointIds();
     const numAttributes = this.getNumAttributes();
     for (let i = 0; i < numAttributes; i++) {
       const pa = this.getDecoder().pointCloud().attribute(this.getAttributeId(i));
-      if (!this.Z.updatePointToAttributeIndexMapping(pa)) {
+      if (!this.$.updatePointToAttributeIndexMapping(pa)) {
         return false;
       }
     }
@@ -4033,10 +3971,10 @@ var SequentialAttributeDecodersController = class extends AttributesDecoder {
   // 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.qc()) {
+    if (!this.qc(buffer)) {
       return false;
     }
-    const decoders = this.Ba;
+    const decoders = this.ia;
     for (let i = 0; i < decoders.length; i++) {
       if (!decoders[i].decodePortableAttributeParse(this.Ta, buffer)) {
         return false;
@@ -4050,7 +3988,7 @@ var SequentialAttributeDecodersController = class extends AttributesDecoder {
     return true;
   }
   collectPendingSymbolStreams(out) {
-    const decoders = this.Ba;
+    const decoders = this.ia;
     for (let i = 0; i < decoders.length; i++) {
       const pending = decoders[i].pendingSymbolStream();
       if (pending !== null) {
@@ -4059,7 +3997,7 @@ var SequentialAttributeDecodersController = class extends AttributesDecoder {
     }
   }
   decodeAttributesFinish() {
-    const decoders = this.Ba;
+    const decoders = this.ia;
     for (let i = 0; i < decoders.length; i++) {
       if (!decoders[i].decodePortableAttributeFinish()) {
         return false;
@@ -4077,7 +4015,7 @@ var SequentialAttributeDecodersController = class extends AttributesDecoder {
     if (locId < 0) {
       return null;
     }
-    return this.Ba[locId].getPortableAttribute();
+    return this.ia[locId].getPortableAttribute();
   }
   createSequentialDecoder(decoderType) {
     switch (decoderType) {
@@ -4116,27 +4054,35 @@ var kInvalidFaceIndex = -1;
 var kInvalidVertexIndex = -1;
 var DepthFirstTraverser = class {
   a = null;
-  Ca = null;
-  _ = null;
+  Aa = null;
+  Ba = null;
   Ob = [];
-  ia = 0;
+  Ca = 0;
   // Identifies the traversal order for the shared traversal cache
   // (MESH_TRAVERSAL_DEPTH_FIRST). See MeshTraversalSequencer.
   Pb = 0;
   // The sequencer derives the point id sequence from the corner map after
-  // the traversal (see traverseFromCorner).
+  // the traversal (see traverseAll).
   emitsPointIds = false;
-  j = null;
-  q = null;
-  B = null;
-  L = 0;
+  k = null;
+  w = null;
+  C = null;
+  M = 0;
+  // When set (see MeshTraversalSequencer.generateSequence), each new value's
+  // parallelogram parents are recorded here as it is numbered: parents[3p ..
+  // 3p+2] are the value ids of the vertices of the face opposite its corner,
+  // or parents[3p] is -1 when that face is missing or has a vertex not
+  // numbered yet -- exactly MeshPredictionSchemeData.parallelogramParents'
+  // "parent decoded after it" test, since values are numbered in order.
+  // The traversal has just touched those corners, so they are read hot.
+  Qb = null;
   init(cornerTable, observer) {
     this.a = cornerTable;
-    this.Ca = observer;
-    this.j = cornerTable.cornerToVertexArray();
-    this.q = cornerTable.oppositeCornerArray();
-    this.B = cornerTable.vertexOnBoundaryArray();
-    this.L = cornerTable.numCorners();
+    this.Aa = observer;
+    this.k = cornerTable.cornerToVertexArray();
+    this.w = cornerTable.oppositeCornerArray();
+    this.C = cornerTable.vertexOnBoundaryArray();
+    this.M = cornerTable.numCorners();
   }
   cornerTable() {
     return this.a;
@@ -4146,118 +4092,137 @@ var DepthFirstTraverser = class {
   // this entirely, including the visited-flag zero-fill (worth ~0.5% on the
   // ~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).
+  // and written on every corner of the hottest decode loop (traverseAll).
   // Decode-scoped scratch: released in bulk at the end of the decode.
   onTraversalStart() {
     const cornerTable = this.a;
-    this._ = scratchUint8Zeroed(cornerTable.numFaces());
-    this.Ob = scratchInt32(this.L);
+    this.Ba = scratchUint8Zeroed(cornerTable.numFaces());
+    this.Ob = scratchInt32(this.M);
   }
   // Traverses every face, seeding a new traversal at the first corner of each
-  // face not yet reached. The visited check lives here rather than behind a
-  // traverseFromCorner call per face: on a connected mesh nearly every face is
-  // already visited by the time its seed comes up, and that call-and-return
-  // was measurable next to the traversal itself.
+  // face not yet reached. One function for the seeds and the walks they
+  // start: a mesh cut into many pieces (small parts, or UV islands in an
+  // attribute table) seeds a new walk every few faces, and a call per seed
+  // would reload the whole traversal state each time.
   traverseAll() {
     const numFaces = this.a.numFaces();
-    const isFaceVisited = this._;
-    for (let f = 0; f < numFaces && this.ia < numFaces; ++f) {
-      if (isFaceVisited[f] === 0 && !this.traverseFromCorner(3 * f)) {
-        return false;
-      }
-    }
-    return true;
-  }
-  traverseFromCorner(cornerId) {
-    if (this._[cornerId / 3 | 0]) {
-      return true;
-    }
-    const isFaceVisited = this._;
-    const observer = this.Ca;
-    const cornerToVertex = this.j;
-    const oppositeCorners = this.q;
-    const vertexOnBoundary = this.B;
+    const isFaceVisited = this.Ba;
+    const observer = this.Aa;
+    const cornerToVertex = this.k;
+    const oppositeCorners = this.w;
+    const vertexOnBoundary = this.C;
     const stack = this.Ob;
-    let numVisitedFaces = this.ia;
+    let numVisitedFaces = this.Ca;
     const encodingData = observer.p;
-    const encodedToCornerMap = observer.ib;
-    const vertexToEncodedMap = observer.jb;
+    const encodedToCornerMap = observer.gb;
+    const vertexToEncodedMap = observer.hb;
+    const parents = this.Qb;
     let numValues = encodingData.numValues;
-    let stackSize = 0;
-    stack[stackSize++] = cornerId;
-    const nextCorner = cornerId % 3 === 2 ? cornerId - 2 : cornerId + 1;
-    const prevCorner = cornerId % 3 === 0 ? cornerId + 2 : cornerId - 1;
-    const nextVert = cornerToVertex[nextCorner];
-    const prevVert = cornerToVertex[prevCorner];
-    if (nextVert === kInvalidVertexIndex || prevVert === kInvalidVertexIndex) {
-      return false;
-    }
-    if (vertexToEncodedMap[nextVert] < 0) {
-      encodedToCornerMap[numValues] = nextCorner;
-      vertexToEncodedMap[nextVert] = numValues++;
-    }
-    if (vertexToEncodedMap[prevVert] < 0) {
-      encodedToCornerMap[numValues] = prevCorner;
-      vertexToEncodedMap[prevVert] = numValues++;
-    }
-    while (stackSize > 0) {
-      cornerId = stack[stackSize - 1];
-      let faceId = cornerId / 3 | 0;
-      if (cornerId === kInvalidCornerIndex4 || isFaceVisited[faceId]) {
-        stackSize--;
-        continue;
+    for (let f = 0; f < numFaces && numVisitedFaces < numFaces; ++f) {
+      if (isFaceVisited[f] !== 0) continue;
+      let cornerId = 3 * f;
+      let stackSize = 0;
+      stack[stackSize++] = cornerId;
+      const nextCorner = cornerId + 1;
+      const prevCorner = cornerId + 2;
+      const nextVert = cornerToVertex[nextCorner];
+      const prevVert = cornerToVertex[prevCorner];
+      if (nextVert === kInvalidVertexIndex || prevVert === kInvalidVertexIndex) {
+        encodingData.numValues = numValues;
+        return false;
       }
-      while (true) {
-        isFaceVisited[faceId] = 1;
-        numVisitedFaces++;
-        const vertId = cornerToVertex[cornerId];
-        if (vertId === kInvalidVertexIndex) {
-          encodingData.numValues = numValues;
-          return false;
+      if (vertexToEncodedMap[nextVert] < 0) {
+        encodedToCornerMap[numValues] = nextCorner;
+        if (parents !== null)
+          recordParents(parents, numValues, nextCorner, oppositeCorners, cornerToVertex, vertexToEncodedMap);
+        vertexToEncodedMap[nextVert] = numValues++;
+      }
+      if (vertexToEncodedMap[prevVert] < 0) {
+        encodedToCornerMap[numValues] = prevCorner;
+        if (parents !== null)
+          recordParents(parents, numValues, prevCorner, oppositeCorners, cornerToVertex, vertexToEncodedMap);
+        vertexToEncodedMap[prevVert] = numValues++;
+      }
+      while (stackSize > 0) {
+        cornerId = stack[stackSize - 1];
+        let faceId = cornerId / 3 | 0;
+        if (cornerId === kInvalidCornerIndex4 || isFaceVisited[faceId]) {
+          stackSize--;
+          continue;
         }
-        const faceBase = faceId * 3;
-        const nextCornerId = cornerId === faceBase + 2 ? faceBase : cornerId + 1;
-        if (vertexToEncodedMap[vertId] < 0) {
-          encodedToCornerMap[numValues] = cornerId;
-          vertexToEncodedMap[vertId] = numValues++;
-          if (vertexOnBoundary[vertId] === 0) {
-            cornerId = oppositeCorners[nextCornerId];
-            faceId = cornerId / 3 | 0;
-            continue;
+        while (true) {
+          isFaceVisited[faceId] = 1;
+          numVisitedFaces++;
+          const vertId = cornerToVertex[cornerId];
+          if (vertId === kInvalidVertexIndex) {
+            encodingData.numValues = numValues;
+            return false;
           }
-        }
-        const rightCornerId = oppositeCorners[nextCornerId];
-        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;
-        const isRightVisited = rightFaceId === kInvalidFaceIndex || isFaceVisited[rightFaceId];
-        const isLeftVisited = leftFaceId === kInvalidFaceIndex || isFaceVisited[leftFaceId];
-        if (isRightVisited) {
-          if (isLeftVisited) {
-            stackSize--;
-            break;
-          } else {
-            cornerId = leftCornerId;
-            faceId = leftFaceId;
+          const faceBase = faceId * 3;
+          const nextCornerId = cornerId === faceBase + 2 ? faceBase : cornerId + 1;
+          if (vertexToEncodedMap[vertId] < 0) {
+            encodedToCornerMap[numValues] = cornerId;
+            if (parents !== null)
+              recordParents(parents, numValues, cornerId, oppositeCorners, cornerToVertex, vertexToEncodedMap);
+            vertexToEncodedMap[vertId] = numValues++;
+            if (vertexOnBoundary[vertId] === 0) {
+              cornerId = oppositeCorners[nextCornerId];
+              faceId = cornerId / 3 | 0;
+              continue;
+            }
           }
-        } else {
-          if (isLeftVisited) {
-            cornerId = rightCornerId;
-            faceId = rightFaceId;
+          const rightCornerId = oppositeCorners[nextCornerId];
+          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;
+          const isRightVisited = rightFaceId === kInvalidFaceIndex || isFaceVisited[rightFaceId];
+          const isLeftVisited = leftFaceId === kInvalidFaceIndex || isFaceVisited[leftFaceId];
+          if (isRightVisited) {
+            if (isLeftVisited) {
+              stackSize--;
+              break;
+            } else {
+              cornerId = leftCornerId;
+              faceId = leftFaceId;
+            }
           } else {
-            stack[stackSize - 1] = leftCornerId;
-            stack[stackSize++] = rightCornerId;
-            break;
+            if (isLeftVisited) {
+              cornerId = rightCornerId;
+              faceId = rightFaceId;
+            } else {
+              stack[stackSize - 1] = leftCornerId;
+              stack[stackSize++] = rightCornerId;
+              break;
+            }
           }
         }
       }
     }
-    this.ia = numVisitedFaces;
+    this.Ca = numVisitedFaces;
     encodingData.numValues = numValues;
     return true;
   }
 };
+function recordParents(parents, value, corner, oppositeCorners, cornerToVertex, vertexToEncodedMap) {
+  const o = value * 3;
+  const oci = oppositeCorners[corner];
+  if (oci < 0) {
+    parents[o] = -1;
+    return;
+  }
+  const rem = oci - (oci / 3 | 0) * 3;
+  const a = vertexToEncodedMap[cornerToVertex[oci]];
+  const b = vertexToEncodedMap[cornerToVertex[rem === 2 ? oci - 2 : oci + 1]];
+  const c = vertexToEncodedMap[cornerToVertex[rem === 0 ? oci + 2 : oci - 1]];
+  if ((a | b | c) < 0) {
+    parents[o] = -1;
+  } else {
+    parents[o] = a;
+    parents[o + 1] = b;
+    parents[o + 2] = c;
+  }
+}
 
 // src/decoder/compression/mesh/traverser/MaxPredictionDegreeTraverser.ts
 var kInvalidCornerIndex5 = -1;
@@ -4265,18 +4230,18 @@ var kInvalidFaceIndex2 = -1;
 var kMaxPriority = 3;
 var MaxPredictionDegreeTraverser = class {
   a = null;
-  Ca = null;
-  _ = null;
-  kb = null;
-  ia = 0;
+  Aa = null;
+  Ba = null;
+  ib = null;
+  Ca = 0;
   // One stack (bucket) per priority level [0, kMaxPriority).
   Ua = null;
-  $ = 0;
+  aa = 0;
   // Prediction degree accumulated per vertex during traversal.
-  lb = null;
+  jb = null;
   // Flat connectivity arrays (see DepthFirstTraverser for why).
-  j = null;
-  q = null;
+  k = null;
+  w = null;
   // Identifies the traversal order for the shared traversal cache
   // (MESH_TRAVERSAL_PREDICTION_DEGREE). See MeshTraversalSequencer.
   Pb = 1;
@@ -4284,32 +4249,32 @@ var MaxPredictionDegreeTraverser = class {
   emitsPointIds = true;
   init(cornerTable, observer) {
     this.a = cornerTable;
-    this.Ca = observer;
-    this._ = new Uint8Array(cornerTable.numFaces());
-    this.kb = new Uint8Array(cornerTable.numVertices());
-    this.j = cornerTable.cornerToVertexArray();
-    this.q = cornerTable.oppositeCornerArray();
+    this.Aa = observer;
+    this.Ba = new Uint8Array(cornerTable.numFaces());
+    this.ib = new Uint8Array(cornerTable.numVertices());
+    this.k = cornerTable.cornerToVertexArray();
+    this.w = cornerTable.oppositeCornerArray();
     this.Ua = [[], [], []];
   }
   cornerTable() {
     return this.a;
   }
   // corner is always valid (>= 0) where these are used.
-  Qb(c) {
+  Rb(c) {
     return c % 3 === 2 ? c - 2 : c + 1;
   }
-  Rb(c) {
+  Sb(c) {
     return c % 3 === 0 ? c + 2 : c - 1;
   }
   onTraversalStart() {
-    this.lb = new Int32Array(this.a.numVertices());
+    this.jb = new Int32Array(this.a.numVertices());
   }
   // Same contract as DepthFirstTraverser.traverseAll. Seeds every face
   // through traverseFromCorner (which re-checks the first face's vertices),
   // exactly as the sequencer's loop always has.
   traverseAll() {
     const numFaces = this.a.numFaces();
-    for (let f = 0; f < numFaces && this.ia < numFaces; ++f) {
+    for (let f = 0; f < numFaces && this.Ca < numFaces; ++f) {
       if (!this.traverseFromCorner(3 * f)) {
         return false;
       }
@@ -4318,11 +4283,11 @@ var MaxPredictionDegreeTraverser = class {
   }
   // Returns the priority of traversing the edge leading to cornerId. Mutates
   // the prediction degree of the destination vertex.
-  Sb(cornerId) {
-    const vTip = this.j[cornerId];
+  Tb(cornerId) {
+    const vTip = this.k[cornerId];
     let priority = 0;
-    if (!this.kb[vTip]) {
-      const degree = ++this.lb[vTip];
+    if (!this.ib[vTip]) {
+      const degree = ++this.jb[vTip];
       priority = degree > 1 ? 1 : 2;
     }
     if (priority >= kMaxPriority) {
@@ -4330,38 +4295,38 @@ var MaxPredictionDegreeTraverser = class {
     }
     return priority;
   }
-  Tb(ci, priority) {
+  Ub(ci, priority) {
     this.Ua[priority].push(ci);
-    if (priority < this.$) {
-      this.$ = priority;
+    if (priority < this.aa) {
+      this.aa = priority;
     }
   }
   // Retrieves the next available corner to traverse, processed by priority.
   // Returns kInvalidCornerIndex when no corner is available.
   rc() {
-    for (let i = this.$; i < kMaxPriority; ++i) {
+    for (let i = this.aa; i < kMaxPriority; ++i) {
       const stack = this.Ua[i];
       if (stack.length > 0) {
         const ret = stack.pop();
-        this.$ = i;
+        this.aa = i;
         return ret;
       }
     }
     return kInvalidCornerIndex5;
   }
   traverseFromCorner(cornerId) {
-    if (this.lb.length === 0) {
+    if (this.jb.length === 0) {
       return true;
     }
-    const cornerToVertex = this.j;
-    const oppositeCorners = this.q;
-    const isFaceVisited = this._;
-    const isVertexVisited = this.kb;
-    const observer = this.Ca;
+    const cornerToVertex = this.k;
+    const oppositeCorners = this.w;
+    const isFaceVisited = this.Ba;
+    const isVertexVisited = this.ib;
+    const observer = this.Aa;
     this.Ua[0].push(cornerId);
-    this.$ = 0;
-    const firstNext = this.Qb(cornerId);
-    const firstPrev = this.Rb(cornerId);
+    this.aa = 0;
+    const firstNext = this.Rb(cornerId);
+    const firstPrev = this.Sb(cornerId);
     const nextVert = cornerToVertex[firstNext];
     const prevVert = cornerToVertex[firstPrev];
     if (!isVertexVisited[nextVert]) {
@@ -4385,34 +4350,34 @@ var MaxPredictionDegreeTraverser = class {
       while (true) {
         faceId = cornerId / 3 | 0;
         isFaceVisited[faceId] = 1;
-        this.ia++;
+        this.Ca++;
         const vertId = cornerToVertex[cornerId];
         if (!isVertexVisited[vertId]) {
           isVertexVisited[vertId] = 1;
           observer.onNewVertexVisited(vertId, cornerId);
         }
-        const rightCornerId = oppositeCorners[this.Qb(cornerId)];
-        const leftCornerId = oppositeCorners[this.Rb(cornerId)];
+        const rightCornerId = oppositeCorners[this.Rb(cornerId)];
+        const leftCornerId = oppositeCorners[this.Sb(cornerId)];
         const rightFaceId = rightCornerId === kInvalidCornerIndex5 ? kInvalidFaceIndex2 : rightCornerId / 3 | 0;
         const leftFaceId = leftCornerId === kInvalidCornerIndex5 ? kInvalidFaceIndex2 : leftCornerId / 3 | 0;
         const isRightFaceVisited = rightFaceId === kInvalidFaceIndex2 || isFaceVisited[rightFaceId] !== 0;
         const isLeftFaceVisited = leftFaceId === kInvalidFaceIndex2 || isFaceVisited[leftFaceId] !== 0;
         if (!isLeftFaceVisited) {
-          const priority = this.Sb(leftCornerId);
-          if (isRightFaceVisited && priority <= this.$) {
+          const priority = this.Tb(leftCornerId);
+          if (isRightFaceVisited && priority <= this.aa) {
             cornerId = leftCornerId;
             continue;
           } else {
-            this.Tb(leftCornerId, priority);
+            this.Ub(leftCornerId, priority);
           }
         }
         if (!isRightFaceVisited) {
-          const priority = this.Sb(rightCornerId);
-          if (priority <= this.$) {
+          const priority = this.Tb(rightCornerId);
+          if (priority <= this.aa) {
             cornerId = rightCornerId;
             continue;
           } else {
-            this.Tb(rightCornerId, priority);
+            this.Ub(rightCornerId, priority);
           }
         }
         break;
@@ -4425,65 +4390,77 @@ var MaxPredictionDegreeTraverser = class {
 // src/decoder/compression/mesh/traverser/MeshAttributeIndicesEncodingObserver.ts
 var MeshAttributeIndicesEncodingObserver = class {
   p;
-  Z;
-  jb;
-  ib;
-  Ub;
+  $;
+  hb;
+  gb;
+  Vb;
   constructor(mesh, sequencer, encodingData) {
     this.p = encodingData;
-    this.Z = sequencer;
-    this.jb = encodingData.vertexToEncodedAttributeValueIndexMap;
-    this.ib = encodingData.encodedAttributeValueIndexToCornerMap;
-    this.Ub = mesh.faces_;
+    this.$ = sequencer;
+    this.hb = encodingData.vertexToEncodedAttributeValueIndexMap;
+    this.gb = encodingData.encodedAttributeValueIndexToCornerMap;
+    this.Vb = mesh.faces_;
   }
   onNewVertexVisited(vertex, corner) {
-    const pointId = this.Ub[corner];
-    this.Z.addPointId(pointId);
+    const pointId = this.Vb[corner];
+    this.$.addPointId(pointId);
     const numValues = this.p.numValues;
-    this.ib[numValues] = corner;
-    this.jb[vertex] = numValues;
+    this.gb[numValues] = corner;
+    this.hb[vertex] = numValues;
     this.p.numValues++;
   }
 };
 
 // src/decoder/compression/mesh/traverser/MeshTraversalSequencer.ts
 var MeshTraversalSequencer = class {
-  G;
+  H;
   p;
-  Da = null;
-  x = new Int32Array(0);
-  Ea = 0;
+  ja = null;
+  x = EMPTY_INT32;
+  Da = 0;
   // Per-decode cache, keyed by corner table, shared across the attribute
   // decoders of one mesh (see MeshEdgebreakerDecoderImpl).
-  mb;
+  kb;
   // The cache entry the last generateSequence resolved to (hit or store);
   // carries the shared indicesMap.
-  nb = null;
+  lb = null;
   // One representative corner per point id, when the connectivity decoder
   // recorded them (see MeshEdgebreakerDecoderImpl._assignAttributeVerticesAndPoints).
-  ja;
-  constructor(mesh, encodingData, traversalCache, pointCorner) {
-    this.G = mesh;
+  ba;
+  // The corner table whose vertex ids are the point ids, if any.
+  Ea;
+  constructor(mesh, encodingData, traversalCache, pointCorner, pointVertexTable) {
+    this.H = mesh;
     this.p = encodingData;
-    this.mb = traversalCache;
-    this.ja = pointCorner;
+    this.kb = traversalCache;
+    this.ba = pointCorner;
+    this.Ea = pointVertexTable;
   }
   setTraverser(traverser) {
-    this.Da = traverser;
-  }
-  generateSequence() {
-    const cornerTable = this.Da.cornerTable();
-    const methodId = this.Da.Pb;
+    this.ja = traverser;
+  }
+  // With parallelogramParents set, a depth-first traversal also records the
+  // parallelogram parents of its values (see
+  // MeshPredictionSchemeData.parallelogramParents), stored with the result.
+  generateSequence(parallelogramParents) {
+    const cornerTable = this.ja.cornerTable();
+    const methodId = this.ja.Pb;
     const cacheKey = cornerTable.cornerToVertexArray();
     const encodingData = this.p;
-    let byMethod = this.mb.get(cacheKey);
+    let byMethod = this.kb.get(cacheKey);
     const cached = byMethod && byMethod.get(methodId);
     if (cached !== void 0) {
       this.x = cached.pointIds;
       encodingData.adoptTraversalResult(cached);
-      this.nb = cached;
+      this.lb = cached;
       return true;
     }
+    const traverser = this.ja;
+    let parents = null;
+    if (parallelogramParents && traverser instanceof DepthFirstTraverser) {
+      parents = scratchInt32(encodingData.vertexToEncodedAttributeValueIndexMap.length * 3);
+      traverser.Qb = parents;
+    }
     if (!this.sc()) {
       return false;
     }
@@ -4496,7 +4473,7 @@ var MeshTraversalSequencer = class {
     }
     if (byMethod === void 0) {
       byMethod = /* @__PURE__ */ new Map();
-      this.mb.set(cacheKey, byMethod);
+      this.kb.set(cacheKey, byMethod);
     }
     const entry = {
       pointIds: this.x,
@@ -4504,34 +4481,42 @@ var MeshTraversalSequencer = class {
       cornerMap: encodingData.encodedAttributeValueIndexToCornerMap,
       numValues,
       indicesMap: null,
-      parents: null
+      parents
     };
     byMethod.set(methodId, entry);
     encodingData.cacheEntry = entry;
-    this.nb = entry;
+    this.lb = entry;
     return true;
   }
   getOutputPointIds() {
     return this.x;
   }
   addPointId(pointId) {
-    this.x[this.Ea++] = pointId;
+    this.x[this.Da++] = pointId;
   }
   updatePointToAttributeIndexMapping(attribute) {
-    const entry = this.nb;
+    const entry = this.lb;
     if (entry !== null && entry.indicesMap !== null) {
       attribute.setExplicitMappingShared(entry.indicesMap);
       return true;
     }
-    const cornerTable = this.Da.cornerTable();
-    const numFaces = this.G.numFaces();
-    const numPoints = this.G.numPoints();
+    const cornerTable = this.ja.cornerTable();
+    const numFaces = this.H.numFaces();
+    const numPoints = this.H.numPoints();
     attribute.setExplicitMappingUnfilled(numPoints);
     const cornerToVertex = cornerTable.cornerToVertexArray();
     const vertexToAttEntry = this.p.vertexToEncodedAttributeValueIndexMap;
     const indicesMap = attribute.indicesMap;
-    const pointCorner = this.ja;
-    if (pointCorner !== null) {
+    const pointCorner = this.ba;
+    if (cornerTable === this.Ea) {
+      for (let p = 0; p < numPoints; ++p) {
+        const attEntryId = vertexToAttEntry[p];
+        if (attEntryId < 0 || attEntryId >= numPoints) {
+          return false;
+        }
+        indicesMap[p] = attEntryId;
+      }
+    } else if (pointCorner !== null) {
       for (let p = 0; p < numPoints; ++p) {
         const vertId = cornerToVertex[pointCorner[p]];
         if (vertId < 0) {
@@ -4545,7 +4530,7 @@ var MeshTraversalSequencer = class {
       }
     } else {
       const numCorners = numFaces * 3;
-      const faces = this.G.faces_;
+      const faces = this.H.faces_;
       for (let ci = 0; ci < numCorners; ++ci) {
         const vertId = cornerToVertex[ci];
         if (vertId < 0) {
@@ -4565,9 +4550,9 @@ var MeshTraversalSequencer = class {
     return true;
   }
   sc() {
-    this.Ea = 0;
-    this.x = scratchInt32(this.G.numPoints());
-    const traverser = this.Da;
+    this.Da = 0;
+    this.x = scratchInt32(this.H.numPoints());
+    const traverser = this.ja;
     traverser.onTraversalStart();
     if (!traverser.traverseAll()) {
       return false;
@@ -4575,15 +4560,15 @@ var MeshTraversalSequencer = class {
     if (!traverser.emitsPointIds) {
       const numValues = this.p.numValues;
       const cornerMap = this.p.encodedAttributeValueIndexToCornerMap;
-      const faces = this.G.faces_;
+      const faces = this.H.faces_;
       const outPointIds = this.x;
       for (let i = 0; i < numValues; ++i) {
         outPointIds[i] = faces[cornerMap[i]];
       }
-      this.Ea = numValues;
+      this.Da = numValues;
     }
-    if (this.Ea < this.x.length) {
-      this.x = this.x.subarray(0, this.Ea);
+    if (this.Da < this.x.length) {
+      this.x = this.x.subarray(0, this.Da);
     }
     return true;
   }
@@ -4592,38 +4577,40 @@ var MeshTraversalSequencer = class {
 // src/decoder/compression/mesh/MeshEdgebreakerDecoderImpl.ts
 var kInvalidCornerIndex6 = -1;
 var MeshEdgebreakerDecoderImpl = class {
-  n;
+  o;
   a = null;
   R = [];
-  ka = new Uint8Array(0);
-  aa = 0;
-  ob = new MeshAttributeIndicesEncodingData();
-  Vb = -1;
+  ka = EMPTY_UINT8;
+  ca = 0;
+  mb = new MeshAttributeIndicesEncodingData();
+  Wb = -1;
   // Cache of vertex-traversal results keyed by corner table, so attributes
   // sharing connectivity traverse once.
   tc = /* @__PURE__ */ new Map();
-  i = [];
-  M;
+  j = [];
+  N;
   // One corner per point id (decode-scoped scratch), filled by
-  // _assignAttributeVerticesAndPoints; null when points are the base vertices.
-  ja = null;
-  // Corners on a boundary edge, counted by _decodeAttributeConnectivities.
-  Wb = 0;
+  // _assignAttributeVerticesAndPoints; null for a mesh without attribute data
+  // (see _assignPointsToVertices).
+  ba = null;
+  // The corner table whose vertex ids are the point ids, if any (see
+  // MeshTraversalSequencer.updatePointToAttributeIndexMapping).
+  Ea = null;
   constructor(decoder, TraversalDecoderClass) {
-    this.n = decoder;
-    this.M = new TraversalDecoderClass();
+    this.o = decoder;
+    this.N = new TraversalDecoderClass();
   }
   getCornerTable() {
     return this.a;
   }
   // The attribute data set whose attributes decoder owns attId, if any.
   Xb(attId) {
-    for (let i = 0; i < this.i.length; ++i) {
-      const ad = this.i[i];
-      if (ad.decoderId < 0 || ad.decoderId >= this.n.numAttributesDecoders()) {
+    for (let i = 0; i < this.j.length; ++i) {
+      const ad = this.j[i];
+      if (ad.decoderId < 0 || ad.decoderId >= this.o.numAttributesDecoders()) {
         continue;
       }
-      const dec = this.n.attributesDecoder(ad.decoderId);
+      const dec = this.o.attributesDecoder(ad.decoderId);
       for (let j = 0; j < dec.getNumAttributes(); ++j) {
         if (dec.getAttributeId(j) === attId) {
           return ad;
@@ -4638,28 +4625,28 @@ var MeshEdgebreakerDecoderImpl = class {
   }
   getAttributeEncodingData(attId) {
     const ad = this.Xb(attId);
-    return ad !== null ? ad.encodingData : this.ob;
+    return ad !== null ? ad.encodingData : this.mb;
   }
   createAttributesDecoder(attDecoderId) {
-    const buffer = this.n.buffer();
+    const buffer = this.o.buffer();
     let attDataId = buffer.decodeUint8();
     if (attDataId !== void 0) attDataId = attDataId << 24 >> 24;
     if (attDataId === void 0) return false;
     const decoderType = buffer.decodeUint8();
     if (decoderType === void 0) return false;
     if (attDataId >= 0) {
-      if (attDataId >= this.i.length) {
+      if (attDataId >= this.j.length) {
         return false;
       }
-      if (this.i[attDataId].decoderId >= 0) {
+      if (this.j[attDataId].decoderId >= 0) {
         return false;
       }
-      this.i[attDataId].decoderId = attDecoderId;
+      this.j[attDataId].decoderId = attDecoderId;
     } else {
-      if (this.Vb >= 0) {
+      if (this.Wb >= 0) {
         return false;
       }
-      this.Vb = attDecoderId;
+      this.Wb = attDecoderId;
     }
     const traversalMethod = buffer.decodeUint8();
     if (traversalMethod === void 0 || traversalMethod >= 2 /* NUM_TRAVERSAL_METHODS */) {
@@ -4669,44 +4656,50 @@ var MeshEdgebreakerDecoderImpl = class {
     let cornerTable;
     if (decoderType === 0 /* MESH_VERTEX_ATTRIBUTE */) {
       if (attDataId < 0) {
-        encodingData = this.ob;
+        encodingData = this.mb;
       } else {
-        encodingData = this.i[attDataId].encodingData;
-        this.i[attDataId].isConnectivityUsed = false;
+        encodingData = this.j[attDataId].encodingData;
+        this.j[attDataId].isConnectivityUsed = false;
       }
       cornerTable = this.a;
     } else {
       if (traversalMethod !== 0 /* MESH_TRAVERSAL_DEPTH_FIRST */ || attDataId < 0) {
         return false;
       }
-      const ad = this.i[attDataId];
+      const ad = this.j[attDataId];
       if (ad.noInteriorSeams) this.uc(ad);
       encodingData = ad.encodingData;
       cornerTable = ad.connectivityData;
     }
-    const mesh = this.n.mesh();
-    const sequencer = new MeshTraversalSequencer(mesh, encodingData, this.tc, this.ja);
+    const mesh = this.o.mesh();
+    const sequencer = new MeshTraversalSequencer(
+      mesh,
+      encodingData,
+      this.tc,
+      this.ba,
+      this.Ea
+    );
     const observer = new MeshAttributeIndicesEncodingObserver(mesh, sequencer, encodingData);
     const traverser = traversalMethod === 1 /* MESH_TRAVERSAL_PREDICTION_DEGREE */ ? new MaxPredictionDegreeTraverser() : new DepthFirstTraverser();
     traverser.init(cornerTable, observer);
     sequencer.setTraverser(traverser);
-    return this.n.setAttributesDecoder(attDecoderId, new SequentialAttributeDecodersController(sequencer));
+    return this.o.setAttributesDecoder(attDecoderId, new SequentialAttributeDecodersController(sequencer));
   }
   decodeConnectivity() {
-    const buffer = this.n.buffer();
+    const buffer = this.o.buffer();
     const numEncodedVertices = decodeVarint(buffer);
     if (numEncodedVertices === void 0) return false;
-    this.aa = numEncodedVertices;
+    this.ca = numEncodedVertices;
     const numFaces = decodeVarint(buffer);
     if (numFaces === void 0) return false;
     if (numFaces > 2147483647 / 3) {
       return false;
     }
-    if (this.aa > numFaces * 3) {
+    if (this.ca > numFaces * 3) {
       return false;
     }
     const minNumFaceEdges = Math.floor(3 * numFaces / 2);
-    const maxNumVertexEdges = this.aa * (this.aa - 1) / 2;
+    const maxNumVertexEdges = this.ca * (this.ca - 1) / 2;
     if (maxNumVertexEdges < minNumFaceEdges) {
       return false;
     }
@@ -4731,43 +4724,42 @@ var MeshEdgebreakerDecoderImpl = class {
       const ad = new AttributeData();
       ad.attributeSeamCorners = scratchInt32(numFaces * 3);
       ad.numSeamCorners = 0;
-      this.i.push(ad);
+      this.j.push(ad);
     }
-    this.a.reset(numFaces, this.aa + numEncodedSplitSymbols);
-    this.ka = scratchUint8Filled(this.aa + numEncodedSplitSymbols, 1);
+    this.a.reset(numFaces, this.ca + numEncodedSplitSymbols);
+    this.ka = scratchUint8Filled(this.ca + numEncodedSplitSymbols, 1);
     if (!this.vc(buffer)) {
       return false;
     }
-    this.M.init(this);
-    this.M.setNumEncodedVertices(this.aa + numEncodedSplitSymbols);
-    this.M.setNumAttributeData(numAttributeData);
+    this.N.init(this);
+    this.N.setNumEncodedVertices(this.ca + numEncodedSplitSymbols);
+    this.N.setNumAttributeData(numAttributeData);
     const traversalEndBuffer = new DecoderBuffer();
-    if (!this.M.start(traversalEndBuffer)) {
+    if (!this.N.start(traversalEndBuffer)) {
       return false;
     }
     const numConnectivityVerts = this.wc(numEncodedSymbols);
     if (numConnectivityVerts === -1) {
       return false;
     }
-    buffer.init(traversalEndBuffer.dataHead, traversalEndBuffer.remainingSize);
+    buffer.initFrom(traversalEndBuffer);
     this.a.finishBoundaries();
-    if (this.i.length > 0) {
+    if (this.j.length > 0) {
       this.xc();
     }
-    this.M.done();
-    const numBoundaryCorners = this.Wb;
+    this.N.done();
     const distinctTables = [];
     const seamEdgeCounts = [];
     const adoptions = [];
     let previousConnectivityData = null;
     let previousSeamCorners = null;
     let previousSeamCount = 0;
-    for (let i = 0; i < this.i.length; ++i) {
-      const connectivityData = this.i[i].connectivityData;
-      const seamCorners = this.i[i].attributeSeamCorners;
-      const seamCount = this.i[i].numSeamCorners;
-      if (seamCount === numBoundaryCorners) {
-        this.i[i].noInteriorSeams = true;
+    for (let i = 0; i < this.j.length; ++i) {
+      const connectivityData = this.j[i].connectivityData;
+      const seamCorners = this.j[i].attributeSeamCorners;
+      const seamCount = this.j[i].numSeamCorners;
+      if (seamCount === 0) {
+        this.j[i].noInteriorSeams = true;
         continue;
       }
       let sameAsPrevious = previousConnectivityData !== null && seamCount === previousSeamCount;
@@ -4794,7 +4786,7 @@ var MeshEdgebreakerDecoderImpl = class {
       previousSeamCorners = seamCorners;
       previousSeamCount = seamCount;
     }
-    if (this.i.length === 0) {
+    if (this.j.length === 0) {
       this.yc(numConnectivityVerts);
     } else if (!this.zc(distinctTables, seamEdgeCounts)) {
       return false;
@@ -4802,13 +4794,13 @@ var MeshEdgebreakerDecoderImpl = class {
     for (let i = 0; i < adoptions.length; i += 2) {
       adoptions[i].adoptFrom(adoptions[i + 1]);
     }
-    this.ob.init(this.a.numVertices());
-    for (let i = 0; i < this.i.length; ++i) {
-      let attConnectivityVerts = this.i[i].connectivityData.numVertices();
+    this.mb.init(this.a.numVertices());
+    for (let i = 0; i < this.j.length; ++i) {
+      let attConnectivityVerts = this.j[i].connectivityData.numVertices();
       if (attConnectivityVerts < this.a.numVertices()) {
         attConnectivityVerts = this.a.numVertices();
       }
-      this.i[i].encodingData.init(attConnectivityVerts);
+      this.j[i].encodingData.init(attConnectivityVerts);
     }
     return true;
   }
@@ -4835,15 +4827,15 @@ var MeshEdgebreakerDecoderImpl = class {
     const topologySplitActiveCorners = /* @__PURE__ */ new Map();
     const splitResult = { faceEdge: 0, encoderSplitSymbolId: 0 };
     const invalidVertices = [];
-    const removeInvalidVertices = this.i.length === 0;
+    const removeInvalidVertices = this.j.length === 0;
     let maxNumVertices = this.ka.length;
     let numFacesDecoded = 0;
-    const cornerToVertex = this.a.j;
-    const oppositeCorners = this.a.q;
+    const cornerToVertex = this.a.k;
+    const oppositeCorners = this.a.w;
     const vc = this.a;
-    let vertexCorners = vc.v;
+    let vertexCorners = vc.u;
     const isVertHole = this.ka;
-    const traversalDecoder = this.M;
+    const traversalDecoder = this.N;
     for (let symbolId = 0; symbolId < numSymbols; ++symbolId) {
       const faceIndex = numFacesDecoded++;
       let checkTopologySplit = false;
@@ -4895,13 +4887,13 @@ var MeshEdgebreakerDecoderImpl = class {
         oppositeCorners[oppCorner] = cornerA;
         oppositeCorners[cornerA] = oppCorner;
         let newVertIndex;
-        if (vc.k < vertexCorners.length) {
-          newVertIndex = vc.k++;
+        if (vc.l < vertexCorners.length) {
+          newVertIndex = vc.l++;
         } else {
           newVertIndex = vc.addNewVertex();
-          vertexCorners = vc.v;
+          vertexCorners = vc.u;
         }
-        if (vc.k > maxNumVertices) return -1;
+        if (vc.l > maxNumVertices) return -1;
         cornerToVertex[oppCorner] = newVertIndex;
         vertexCorners[newVertIndex] = oppCorner;
         const pA = cornerA % 3 === 0 ? cornerA + 2 : cornerA - 1;
@@ -4962,16 +4954,16 @@ var MeshEdgebreakerDecoderImpl = class {
       } else if (symbol === TOPOLOGY_E) {
         const corner = 3 * faceIndex;
         let firstVertIndex;
-        if (vc.k + 3 <= vertexCorners.length) {
-          firstVertIndex = vc.k;
-          vc.k += 3;
+        if (vc.l + 3 <= vertexCorners.length) {
+          firstVertIndex = vc.l;
+          vc.l += 3;
         } else {
           firstVertIndex = vc.addNewVertex();
           vc.addNewVertex();
           vc.addNewVertex();
-          vertexCorners = vc.v;
+          vertexCorners = vc.u;
         }
-        if (vc.k > maxNumVertices) return -1;
+        if (vc.l > maxNumVertices) return -1;
         cornerToVertex[corner] = firstVertIndex;
         cornerToVertex[corner + 1] = firstVertIndex + 1;
         cornerToVertex[corner + 2] = firstVertIndex + 2;
@@ -5000,7 +4992,7 @@ var MeshEdgebreakerDecoderImpl = class {
         }
       }
     }
-    if (vc.k > maxNumVertices) {
+    if (vc.l > maxNumVertices) {
       return -1;
     }
     numFacesDecoded = this.Bc(activeCornerStack, activeCornerStackSize, numFacesDecoded);
@@ -5016,11 +5008,11 @@ var MeshEdgebreakerDecoderImpl = class {
   // Returns the updated decoded-face count, or -1 on malformed input.
   Bc(activeCornerStack, activeCornerStackSize, numFacesDecoded) {
     const ct = this.a;
-    const oppositeCorners = ct.q;
-    const cornerToVertex = ct.j;
-    const vertexCorners = ct.v;
+    const oppositeCorners = ct.w;
+    const cornerToVertex = ct.k;
+    const vertexCorners = ct.u;
     const isVertHole = this.ka;
-    const traversalDecoder = this.M;
+    const traversalDecoder = this.N;
     const numCorners = ct.numCorners();
     const numFaces = ct.numFaces();
     const next = (c) => c < 0 ? -1 : c % 3 === 2 ? c - 2 : c + 1;
@@ -5070,8 +5062,8 @@ var MeshEdgebreakerDecoderImpl = class {
   // forward iteration order matters). Returns the final vertex count, or -1.
   Cc(invalidVertices) {
     const ct = this.a;
-    const cornerToVertex = ct.j;
-    const vertexCorners = ct.v;
+    const cornerToVertex = ct.k;
+    const vertexCorners = ct.u;
     const isVertHole = this.ka;
     const leftMostCorner = (v) => v < 0 || v >= vertexCorners.length ? -1 : vertexCorners[v];
     let numVertices = ct.numVertices();
@@ -5153,32 +5145,24 @@ var MeshEdgebreakerDecoderImpl = class {
   //
   // 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.
+  // base corner is a multiple of 3. That removes the per-corner division, and
+  // an invalid (-1) opposite fails it too.
   xc() {
     const oppositeCorners = this.a.oppositeCornerArray();
-    const attributeData = this.i;
+    const attributeData = this.j;
     const numAttrData = attributeData.length;
-    const connectivityDecoders = this.M.Yb;
+    const connectivityDecoders = this.N.Yb;
     const numCorners = this.a.numCorners();
     const candidates = scratchInt32(numCorners);
     let numCandidates = 0;
-    let numBoundaryCorners = 0;
     for (let corner = 0; corner < numCorners; corner += 3) {
-      let opp = oppositeCorners[corner];
-      candidates[numCandidates] = corner ^ opp >> 31;
-      numCandidates -= (opp | corner - opp - 1) >> 31;
-      numBoundaryCorners -= opp >> 31;
-      opp = oppositeCorners[corner + 1];
-      candidates[numCandidates] = corner + 1 ^ opp >> 31;
-      numCandidates -= (opp | corner - opp - 1) >> 31;
-      numBoundaryCorners -= opp >> 31;
-      opp = oppositeCorners[corner + 2];
-      candidates[numCandidates] = corner + 2 ^ opp >> 31;
-      numCandidates -= (opp | corner - opp - 1) >> 31;
-      numBoundaryCorners -= opp >> 31;
-    }
-    this.Wb = numBoundaryCorners;
+      candidates[numCandidates] = corner;
+      numCandidates -= corner - oppositeCorners[corner] - 1 >> 31;
+      candidates[numCandidates] = corner + 1;
+      numCandidates -= corner - oppositeCorners[corner + 1] - 1 >> 31;
+      candidates[numCandidates] = corner + 2;
+      numCandidates -= corner - oppositeCorners[corner + 2] - 1 >> 31;
+    }
     let i = 0;
     for (; i + 2 <= numAttrData; i += 2) {
       decodeSeamBits2(
@@ -5196,7 +5180,7 @@ var MeshEdgebreakerDecoderImpl = class {
   }
   // Position-only connectivity: vertex indices equal point indices.
   yc(numConnectivityVerts) {
-    const mesh = this.n.mesh();
+    const mesh = this.o.mesh();
     const ct = this.a;
     mesh.setNumFaces(ct.numFaces());
     const numCorners = ct.numCorners();
@@ -5205,8 +5189,8 @@ var MeshEdgebreakerDecoderImpl = class {
     for (let c = 0; c < numCorners; ++c) {
       faces[c] = baseCornerToVertex[c];
     }
-    this.ja = null;
-    this.n.pointCloud().setNumPoints(numConnectivityVerts);
+    this.ba = null;
+    this.o.pointCloud().setNumPoints(numConnectivityVerts);
   }
   // Sets up an attribute corner table whose only seams are boundary edges
   // (see decodeConnectivity), for a per-corner decoder that asked for it:
@@ -5247,7 +5231,7 @@ var MeshEdgebreakerDecoderImpl = class {
   // (or left through the seam-aware table, which stops at the boundary), so
   // an open ring is walked from that corner too.
   zc(tables, seamEdgeCounts) {
-    const mesh = this.n.mesh();
+    const mesh = this.o.mesh();
     const ct = this.a;
     mesh.setNumFaces(ct.numFaces());
     const numCorners = ct.numCorners();
@@ -5259,24 +5243,41 @@ var MeshEdgebreakerDecoderImpl = class {
     const isVertHole = this.ka;
     const baseOnBoundary = ct.vertexOnBoundaryArray();
     const numTables = tables.length;
+    if (numTables === 0) {
+      let isolated = false;
+      for (let v = 0; v < numVertices; ++v) {
+        if (vertexLeftmost[v] < 0) {
+          isolated = true;
+          break;
+        }
+      }
+      if (!isolated) {
+        faces.set(baseCornerToVertex);
+        this.ba = vertexLeftmost;
+        this.Ea = ct;
+        this.o.pointCloud().setNumPoints(numVertices);
+        return true;
+      }
+    }
     const attCornerToVertex = new Array(numTables);
     const attOpposite = new Array(numTables);
     const vertexOnSeam = new Array(numTables);
     const onBoundaryMaps = new Array(numTables);
     const numExtraVertices = new Int32Array(numTables);
     for (let t = 0; t < numTables; ++t) {
-      attCornerToVertex[t] = tables[t].W;
-      attOpposite[t] = tables[t].I;
+      attCornerToVertex[t] = tables[t].Y;
+      attOpposite[t] = tables[t].J;
       vertexOnSeam[t] = tables[t].sa;
       const onBoundary = scratchUint8(numVertices + 2 * seamEdgeCounts[t]);
       onBoundary.set(baseOnBoundary);
       onBoundary.fill(1, numVertices);
       onBoundaryMaps[t] = onBoundary;
     }
-    const ring = scratchInt32(numCorners);
-    const ringNext = scratchInt32(numCorners);
+    const ringSize = numTables > 0 ? numCorners : 0;
+    const ring = scratchInt32(ringSize);
+    const ringNext = scratchInt32(ringSize);
     const pointCorner = scratchInt32(numCorners);
-    const idChange = scratchUint8Zeroed(numCorners);
+    const idChange = scratchUint8Zeroed(ringSize);
     let numPoints = 0;
     const plainPointId = scratchInt32(numVertices);
     let numWalked = 0;
@@ -5398,8 +5399,8 @@ var MeshEdgebreakerDecoderImpl = class {
     for (let t = 0; t < numTables; ++t) {
       tables[t].setRecomputedVertices(onBoundaryMaps[t], numVertices + numExtraVertices[t]);
     }
-    this.ja = pointCorner;
-    this.n.pointCloud().setNumPoints(numPoints);
+    this.ba = pointCorner;
+    this.o.pointCloud().setNumPoints(numPoints);
     return true;
   }
 };
@@ -5413,11 +5414,6 @@ function decodeSeamBits1(candidates, numCandidates, ad, decoder) {
   let state = ans.state;
   let bufOffset = ans.bufOffset;
   for (let n = 0; n < numCandidates; ++n) {
-    const cc = candidates[n];
-    if (cc < 0) {
-      seamCorners[numSeamCorners++] = ~cc;
-      continue;
-    }
     if (state < ANS_L_BASE && bufOffset > bufStart) {
       state = state << 8 | buf[--bufOffset];
     }
@@ -5426,7 +5422,7 @@ function decodeSeamBits1(candidates, numCandidates, ad, decoder) {
     const mask = rem - p >> 31;
     const stateIfZero = state - xn - p;
     state = stateIfZero + (mask & xn + rem - stateIfZero);
-    seamCorners[numSeamCorners] = cc;
+    seamCorners[numSeamCorners] = candidates[n];
     numSeamCorners -= mask;
   }
   ans.state = state;
@@ -5452,11 +5448,6 @@ function decodeSeamBits2(candidates, numCandidates, ad0, decoder0, ad1, decoder1
   let off1 = ans1.bufOffset;
   for (let n = 0; n < numCandidates; ++n) {
     const cc = candidates[n];
-    if (cc < 0) {
-      seam0[num0++] = ~cc;
-      seam1[num1++] = ~cc;
-      continue;
-    }
     if (state0 < ANS_L_BASE && off0 > start0) {
       state0 = state0 << 8 | buf0[--off0];
     }
@@ -5486,8 +5477,8 @@ function decodeSeamBits2(candidates, numCandidates, ad0, decoder0, ad1, decoder1
   ad1.numSeamCorners = num1;
 }
 var MeshAttributeIndicesEncodingData = class {
-  vertexToEncodedAttributeValueIndexMap = new Int32Array(0);
-  encodedAttributeValueIndexToCornerMap = new Int32Array(0);
+  vertexToEncodedAttributeValueIndexMap = EMPTY_INT32;
+  encodedAttributeValueIndexToCornerMap = EMPTY_INT32;
   numValues = 0;
   // The traversal cache entry the maps came from (see MeshTraversalSequencer);
   // carries what later passes derive from the traversal and share.
@@ -5513,43 +5504,43 @@ var AttributeData = class {
   connectivityData = new MeshAttributeCornerTable();
   isConnectivityUsed = true;
   encodingData = new MeshAttributeIndicesEncodingData();
-  attributeSeamCorners = new Int32Array(0);
+  attributeSeamCorners = EMPTY_INT32;
   numSeamCorners = 0;
-  // Set when every seam is a boundary edge and connectivityData was therefore
+  // Set when the set has no interior seam and connectivityData was therefore
   // left unbuilt (see decodeConnectivity); cleared once it is built on demand.
   noInteriorSeams = false;
 };
 var CornerTable = class {
   Zb = 0;
-  L = 0;
-  k = 0;
-  j = null;
+  M = 0;
+  l = 0;
+  k = null;
   // corner -> vertex
-  q = null;
+  w = null;
   // corner -> opposite corner
-  v = null;
+  u = null;
   // vertex -> left-most corner
   // vertex -> 1 when its fan is open (C++ IsOnBoundary: the edge left of
   // the left-most corner has no opposite face), computed once after the
   // connectivity decode (see finishBoundaries) for the traversals, whose
   // critical path would otherwise chase two dependent loads per new vertex.
-  B = null;
+  C = null;
   reset(numFaces, numVertices) {
     this.Zb = numFaces;
-    this.L = numFaces * 3;
-    this.k = 0;
-    this.j = scratchInt32Filled(this.L, -1);
-    this.q = scratchInt32Filled(this.L, -1);
-    this.v = scratchInt32Filled(numVertices, -1);
+    this.M = numFaces * 3;
+    this.l = 0;
+    this.k = scratchInt32Filled(this.M, -1);
+    this.w = scratchInt32Filled(this.M, -1);
+    this.u = scratchInt32Filled(numVertices, -1);
   }
   numFaces() {
     return this.Zb;
   }
   numCorners() {
-    return this.L;
+    return this.M;
   }
   numVertices() {
-    return this.k;
+    return this.l;
   }
   next(corner) {
     if (corner < 0) return -1;
@@ -5562,50 +5553,50 @@ var CornerTable = class {
     return rem === 0 ? corner + 2 : corner - 1;
   }
   vertex(corner) {
-    if (corner < 0 || corner >= this.L) return -1;
-    return this.j[corner];
+    if (corner < 0 || corner >= this.M) return -1;
+    return this.k[corner];
   }
   opposite(corner) {
-    if (corner < 0 || corner >= this.L) return -1;
-    return this.q[corner];
+    if (corner < 0 || corner >= this.M) return -1;
+    return this.w[corner];
   }
   // Flat-array accessors; let callers avoid polymorphic per-corner dispatch.
   cornerToVertexArray() {
-    return this.j;
+    return this.k;
   }
   oppositeCornerArray() {
-    return this.q;
+    return this.w;
   }
   vertexLeftmostCornerArray() {
-    return this.v;
+    return this.u;
   }
   vertexOnBoundaryArray() {
-    return this.B;
+    return this.C;
   }
   // Derives _vertexOnBoundary from the finished connectivity (decode-scoped
   // scratch). Isolated vertices count as boundary; they are never traversed.
   finishBoundaries() {
-    const numVertices = this.k;
-    const vertexCorners = this.v;
-    const oppositeCorners = this.q;
+    const numVertices = this.l;
+    const vertexCorners = this.u;
+    const oppositeCorners = this.w;
     const onBoundary = scratchUint8(numVertices);
     for (let v = 0; v < numVertices; ++v) {
       const lc = vertexCorners[v];
       onBoundary[v] = lc < 0 || oppositeCorners[lc % 3 === 2 ? lc - 2 : lc + 1] < 0 ? 1 : 0;
     }
-    this.B = onBoundary;
+    this.C = onBoundary;
   }
   // Mirrors C++ CornerTable::AddNewVertex() (push_back(kInvalidCornerIndex)).
   addNewVertex() {
-    const newVertex = this.k;
-    this.k++;
-    if (newVertex >= this.v.length) {
-      const newCapacity = Math.max(newVertex + 1, this.v.length * 2, 64);
+    const newVertex = this.l;
+    this.l++;
+    if (newVertex >= this.u.length) {
+      const newCapacity = Math.max(newVertex + 1, this.u.length * 2, 64);
       const newArr = scratchInt32Filled(newCapacity, -1);
-      newArr.set(this.v);
-      this.v = newArr;
+      newArr.set(this.u);
+      this.u = newArr;
     }
-    this.v[newVertex] = -1;
+    this.u[newVertex] = -1;
     return newVertex;
   }
   // Next corner around a vertex, CCW. SwingLeft(c) = Next(Opposite(Next(c))).
@@ -5627,8 +5618,8 @@ var CornerTable = class {
 // src/decoder/compression/mesh/MeshEdgebreakerTraversalDecoder.ts
 var MeshEdgebreakerTraversalDecoder = class {
   d = new DecoderBuffer();
-  N = new DecoderBuffer();
-  pb = null;
+  S = new DecoderBuffer();
+  nb = null;
   Yb = [];
   _b = 0;
   // _symbolBuffer's bit cursor, captured once bit decoding starts: decodeSymbol
@@ -5636,8 +5627,8 @@ var MeshEdgebreakerTraversalDecoder = class {
   // loads and a method call per read.
   $b = null;
   init(decoder) {
-    const srcBuffer = decoder.n.buffer();
-    this.d.init(srcBuffer.dataHead, srcBuffer.remainingSize);
+    const srcBuffer = decoder.o.buffer();
+    this.d.initFrom(srcBuffer);
   }
   // Ignored by default; overridden by predictive/valence decoders.
   setNumEncodedVertices(_numVertices) {
@@ -5656,33 +5647,33 @@ var MeshEdgebreakerTraversalDecoder = class {
     if (!this.decodeAttributeSeams()) {
       return false;
     }
-    outBuffer.init(this.d.dataHead, this.d.remainingSize);
+    outBuffer.initFrom(this.d);
     return true;
   }
   decodeStartFaceConfiguration() {
-    return this.pb.decodeNextBit();
+    return this.nb.decodeNextBit();
   }
   decodeSymbol() {
     const bd = this.$b;
     if (bd !== null) {
-      const buf = bd.Ma;
-      const off = bd.s;
+      const buf = bd.Na;
+      const off = bd.q;
       const byteOffset = off >> 3;
       if (byteOffset + 4 < bd.qa) {
         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.s = off + 1;
+          bd.q = off + 1;
           return TOPOLOGY_C;
         }
-        bd.s = off + 3;
+        bd.q = off + 3;
         return bits;
       }
     }
-    let symbol = this.N.decodeLeastSignificantBits32(1);
+    let symbol = this.S.decodeLeastSignificantBits32(1);
     if (symbol === TOPOLOGY_C) {
       return symbol;
     }
-    const symbolSuffix = this.N.decodeLeastSignificantBits32(2);
+    const symbolSuffix = this.S.decodeLeastSignificantBits32(2);
     symbol |= symbolSuffix << 1;
     return symbol;
   }
@@ -5691,18 +5682,18 @@ var MeshEdgebreakerTraversalDecoder = class {
   mergeVertices(_dest, _source) {
   }
   done() {
-    if (this.N.bitDecoderActive) {
-      this.N.endBitDecoding();
+    if (this.S.bitDecoderActive) {
+      this.S.endBitDecoding();
     }
   }
   decodeTraversalSymbols() {
-    this.N.init(this.d.dataHead, this.d.remainingSize);
-    const traversalSize = this.N.startBitDecoding(true);
+    this.S.initFrom(this.d);
+    const traversalSize = this.S.startBitDecoding(true);
     if (traversalSize === void 0) {
       return false;
     }
-    this.$b = this.N.ra;
-    this.d.init(this.N.dataHead, this.N.remainingSize);
+    this.$b = this.S.ra;
+    this.d.initFrom(this.S);
     if (traversalSize > this.d.remainingSize) {
       return false;
     }
@@ -5711,8 +5702,8 @@ var MeshEdgebreakerTraversalDecoder = class {
   }
   decodeStartFaces() {
     try {
-      this.pb = new RAnsBitDecoder();
-      return this.pb.startDecoding(this.d);
+      this.nb = new RAnsBitDecoder();
+      return this.nb.startDecoding(this.d);
     } catch {
       return false;
     }
@@ -5732,17 +5723,17 @@ var MeshEdgebreakerTraversalDecoder = class {
 // src/decoder/compression/mesh/MeshEdgebreakerTraversalPredictiveDecoder.ts
 var MeshEdgebreakerTraversalPredictiveDecoder = class extends MeshEdgebreakerTraversalDecoder {
   a = null;
-  k = 0;
+  l = 0;
   A = -1;
   la = -1;
-  l = [];
-  qb = null;
+  m = [];
+  ob = null;
   init(decoder) {
     super.init(decoder);
     this.a = decoder.getCornerTable();
   }
   setNumEncodedVertices(numVertices) {
-    this.k = numVertices;
+    this.l = numVertices;
   }
   start(outBuffer) {
     if (!super.start(outBuffer)) {
@@ -5752,16 +5743,16 @@ var MeshEdgebreakerTraversalPredictiveDecoder = class extends MeshEdgebreakerTra
     if (numSplitSymbols === void 0 || numSplitSymbols < 0) {
       return false;
     }
-    if (numSplitSymbols >= this.k) {
+    if (numSplitSymbols >= this.l) {
       return false;
     }
-    this.l = new Array(this.k).fill(0);
-    this.qb = new RAnsBitDecoder();
-    return this.qb.startDecoding(outBuffer);
+    this.m = new Array(this.l).fill(0);
+    this.ob = new RAnsBitDecoder();
+    return this.ob.startDecoding(outBuffer);
   }
   decodeSymbol() {
     if (this.la !== -1) {
-      if (this.qb.decodeNextBit()) {
+      if (this.ob.decodeNextBit()) {
         this.A = this.la;
         return this.la;
       }
@@ -5776,30 +5767,30 @@ var MeshEdgebreakerTraversalPredictiveDecoder = class extends MeshEdgebreakerTra
     switch (this.A) {
       case TOPOLOGY_C:
       case TOPOLOGY_S:
-        this.l[ct.vertex(next)] += 1;
-        this.l[ct.vertex(prev)] += 1;
+        this.m[ct.vertex(next)] += 1;
+        this.m[ct.vertex(prev)] += 1;
         break;
       case TOPOLOGY_R:
-        this.l[ct.vertex(corner)] += 1;
-        this.l[ct.vertex(next)] += 1;
-        this.l[ct.vertex(prev)] += 2;
+        this.m[ct.vertex(corner)] += 1;
+        this.m[ct.vertex(next)] += 1;
+        this.m[ct.vertex(prev)] += 2;
         break;
       case TOPOLOGY_L:
-        this.l[ct.vertex(corner)] += 1;
-        this.l[ct.vertex(next)] += 2;
-        this.l[ct.vertex(prev)] += 1;
+        this.m[ct.vertex(corner)] += 1;
+        this.m[ct.vertex(next)] += 2;
+        this.m[ct.vertex(prev)] += 1;
         break;
       case TOPOLOGY_E:
-        this.l[ct.vertex(corner)] += 2;
-        this.l[ct.vertex(next)] += 2;
-        this.l[ct.vertex(prev)] += 2;
+        this.m[ct.vertex(corner)] += 2;
+        this.m[ct.vertex(next)] += 2;
+        this.m[ct.vertex(prev)] += 2;
         break;
       default:
         break;
     }
     if (this.A === TOPOLOGY_C || this.A === TOPOLOGY_R) {
       const pivot = ct.vertex(ct.next(corner));
-      if (this.l[pivot] < 6) {
+      if (this.m[pivot] < 6) {
         this.la = TOPOLOGY_R;
       } else {
         this.la = TOPOLOGY_C;
@@ -5809,34 +5800,34 @@ var MeshEdgebreakerTraversalPredictiveDecoder = class extends MeshEdgebreakerTra
     }
   }
   mergeVertices(dest, source) {
-    this.l[dest] += this.l[source];
+    this.m[dest] += this.m[source];
   }
 };
 
 // src/decoder/compression/mesh/MeshEdgebreakerTraversalValenceDecoder.ts
 var MeshEdgebreakerTraversalValenceDecoder = class extends MeshEdgebreakerTraversalDecoder {
   a = null;
-  k = 0;
+  l = 0;
   A = -1;
   Va = -1;
   Wa = 2;
-  rb = 7;
-  l = new Int32Array(0);
+  pb = 7;
+  m = EMPTY_INT32;
   ma = [];
   // Int32Array, not number[]: read and written once per decoded symbol.
-  Fa = new Int32Array(0);
+  Fa = EMPTY_INT32;
   // 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.
-  j = new Int32Array(0);
+  k = EMPTY_INT32;
   init(decoder) {
     super.init(decoder);
     this.a = decoder.getCornerTable();
-    this.j = this.a.j;
+    this.k = this.a.k;
   }
   setNumEncodedVertices(numVertices) {
-    this.k = numVertices;
+    this.l = numVertices;
   }
   start(outBuffer) {
     if (!this.decodeStartFaces()) {
@@ -5845,9 +5836,9 @@ var MeshEdgebreakerTraversalValenceDecoder = class extends MeshEdgebreakerTraver
     if (!this.decodeAttributeSeams()) {
       return false;
     }
-    outBuffer.init(this.d.dataHead, this.d.remainingSize);
-    this.l = scratchInt32Filled(this.k, 0);
-    const numUniqueValences = this.rb - this.Wa + 1;
+    outBuffer.initFrom(this.d);
+    this.m = scratchInt32Filled(this.l, 0);
+    const numUniqueValences = this.pb - this.Wa + 1;
     this.ma = new Array(numUniqueValences);
     this.Fa = new Int32Array(numUniqueValences);
     const pending = [];
@@ -5888,7 +5879,7 @@ var MeshEdgebreakerTraversalValenceDecoder = class extends MeshEdgebreakerTraver
           return false;
         }
         pending.push(decoder);
-        streams.push({ ans: decoder.K, out: this.ma[i], count: numSymbols });
+        streams.push({ ans: decoder.L, out: this.ma[i], count: numSymbols });
         this.Fa[i] = numSymbols;
       } else {
         this.ma[i] = new Uint32Array(0);
@@ -5916,8 +5907,8 @@ var MeshEdgebreakerTraversalValenceDecoder = class extends MeshEdgebreakerTraver
     return this.A;
   }
   newActiveCornerReached(corner) {
-    const cornerToVertex = this.j;
-    const valences = this.l;
+    const cornerToVertex = this.k;
+    const valences = this.m;
     const next = corner % 3 === 2 ? corner - 2 : corner + 1;
     const prev = corner % 3 === 0 ? corner + 2 : corner - 1;
     const vertNext = cornerToVertex[next];
@@ -5950,15 +5941,15 @@ var MeshEdgebreakerTraversalValenceDecoder = class extends MeshEdgebreakerTraver
     let clampedValence;
     if (activeValence < this.Wa) {
       clampedValence = this.Wa;
-    } else if (activeValence > this.rb) {
-      clampedValence = this.rb;
+    } else if (activeValence > this.pb) {
+      clampedValence = this.pb;
     } else {
       clampedValence = activeValence;
     }
     this.Va = clampedValence - this.Wa;
   }
   mergeVertices(dest, source) {
-    this.l[dest] += this.l[source];
+    this.m[dest] += this.m[source];
   }
 };
 
@@ -5999,7 +5990,7 @@ var LinearSequencer = class {
   constructor(numPoints) {
     this.Xa = numPoints;
   }
-  generateSequence() {
+  generateSequence(_parallelogramParents) {
     if (this.Xa < 0) {
       return false;
     }
@@ -6189,10 +6180,10 @@ var MinidracoLoader = class extends Loader {
   // The pool, once its module has loaded; null again after dispose() so a
   // later decode spawns a fresh one.
   pa = null;
-  sb = null;
+  qb = null;
   // Set when the pool module fails to load or the pool breaks: decoding
   // transparently falls back to the main thread.
-  tb = false;
+  rb = false;
   Ga = null;
   // Accepts either a LoadingManager (three-compatible form) or an options bag.
   constructor(managerOrOptions) {
@@ -6244,7 +6235,7 @@ var MinidracoLoader = class extends Loader {
   dispose() {
     if (this.pa !== null) this.pa.dispose();
     this.pa = null;
-    this.sb = null;
+    this.qb = null;
     return this;
   }
   load(url, onLoad, onProgress, onError) {
@@ -6298,7 +6289,7 @@ var MinidracoLoader = class extends Loader {
             return this.dc(raw, taskConfig);
           } catch (error) {
             if (error?.isDecodeError) throw error;
-            this.tb = true;
+            this.rb = true;
           }
         }
       } else {
@@ -6308,20 +6299,20 @@ var MinidracoLoader = class extends Loader {
     return this._decodeBuffer(buffer, taskConfig);
   }
   bc() {
-    return this.workerLimit > 0 && typeof Worker !== "undefined" && !this.tb;
+    return this.workerLimit > 0 && typeof Worker !== "undefined" && !this.rb;
   }
   // The pool, loading its module on first use. Resolves null (and marks the
   // workers broken) when the module cannot be loaded, e.g. a bundler that does
   // not split dynamic imports out of dependencies.
   cc() {
-    this.sb ??= import("./pool.js").then(
+    this.qb ??= import("./pool.js").then(
       (module) => this.pa = new module.WorkerPool(this.workerLimit, this.Ga),
       () => {
-        this.tb = true;
+        this.rb = true;
         return null;
       }
     );
-    return this.sb;
+    return this.qb;
   }
   dc(raw, taskConfig) {
     const geometry = new BufferGeometry();