minidraco 0.7.0 → 0.8.0

package/dist/index.js

@@ -33,72 +33,72 @@ var Type = {
 };
 var GeometryAttribute = class {
   c = null;
-  w = 1;
-  L = 9 /* FLOAT32 */;
-  Qa = false;
-  M = 0;
-  N = 0;
-  Aa = Type.INVALID;
-  Ba = 0;
+  v = 1;
+  O = 9 /* FLOAT32 */;
+  Pa = false;
+  P = 0;
+  Q = 0;
+  za = Type.INVALID;
+  Aa = 0;
   init(attributeType, buffer, numComponents, dataType, normalized, byteStride, byteOffset) {
     this.c = buffer;
-    this.w = numComponents;
-    this.L = dataType;
-    this.Qa = normalized;
-    this.M = byteStride;
-    this.N = byteOffset;
-    this.Aa = attributeType;
+    this.v = numComponents;
+    this.O = dataType;
+    this.Pa = normalized;
+    this.P = byteStride;
+    this.Q = byteOffset;
+    this.za = attributeType;
   }
   resetBuffer(buffer, byteStride, byteOffset) {
     this.c = buffer;
-    this.M = byteStride;
-    this.N = byteOffset;
+    this.P = byteStride;
+    this.Q = byteOffset;
   }
   get attributeType() {
-    return this.Aa;
+    return this.za;
   }
   get dataType() {
-    return this.L;
+    return this.O;
   }
   get numComponents() {
-    return this.w;
+    return this.v;
   }
   get buffer() {
     return this.c;
   }
   get byteStride() {
-    return this.M;
+    return this.P;
   }
   get byteOffset() {
-    return this.N;
+    return this.Q;
   }
   get uniqueId() {
-    return this.Ba;
+    return this.Aa;
   }
   set uniqueId(id) {
-    this.Ba = id;
+    this.Aa = id;
   }
 };
 
 // src/decoder/point_cloud/PointCloud.ts
 var NAMED_ATTRIBUTES_COUNT = 8;
 var PointCloud = class {
-  kb = 0;
+  ib = 0;
   attributes_ = [];
   // named_attribute_index_[type] = [att_id, ...], one list per named type.
-  Ra = [[], [], [], [], [], [], [], []];
+  Qa = [[], [], [], [], [], [], [], []];
   numNamedAttributes(type) {
     if (type < 0 || type >= NAMED_ATTRIBUTES_COUNT) {
       return 0;
     }
-    return this.Ra[type].length;
+    return this.Qa[type].length;
   }
   getNamedAttributeId(type, i) {
     if (i === void 0) i = 0;
     if (this.numNamedAttributes(type) <= i) {
       return -1;
     }
-    return this.Ra[type][i];
+    return this.Qa[type][i];
   }
   getNamedAttribute(type, i) {
     if (i === void 0) i = 0;
@@ -138,16 +138,16 @@ var PointCloud = class {
       this.attributes_.push(null);
     }
     if (pa.attributeType < NAMED_ATTRIBUTES_COUNT) {
-      this.Ra[pa.attributeType].push(attId);
+      this.Qa[pa.attributeType].push(attId);
     }
     pa.uniqueId = attId;
     this.attributes_[attId] = pa;
   }
   numPoints() {
-    return this.kb;
+    return this.ib;
   }
   setNumPoints(num) {
-    this.kb = num;
+    this.ib = num;
   }
 };
 
@@ -157,7 +157,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);
-  lb = 0;
+  jb = 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
@@ -169,42 +169,42 @@ var Mesh = class extends PointCloud {
       grown.set(this.faces_);
       this.faces_ = grown;
     }
-    this.lb = numFaces;
+    this.jb = numFaces;
   }
   numFaces() {
-    return this.lb;
+    return this.jb;
   }
 };
 
 // src/decoder/core/DataBuffer.ts
 var DataBuffer = class {
-  n = new Uint8Array(0);
+  m = 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.mb(size);
+      this.kb(size);
       return;
     }
-    if (size > this.n.length) {
-      this.mb(size);
+    if (size > this.m.length) {
+      this.kb(size);
     }
-    this.n.set(data.length === size ? data : data.subarray(0, size));
+    this.m.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.n.set(inArray.length === dataSize ? inArray : inArray.subarray(0, dataSize), bytePos);
+    this.m.set(inArray.length === dataSize ? inArray : inArray.subarray(0, dataSize), bytePos);
   }
   get data() {
-    return this.n;
+    return this.m;
   }
-  mb(newSize) {
-    if (newSize === this.n.length) return;
+  kb(newSize) {
+    if (newSize === this.m.length) return;
     const newData = new Uint8Array(newSize);
-    newData.set(this.n.subarray(0, Math.min(this.n.length, newSize)));
-    this.n = newData;
+    newData.set(this.m.subarray(0, Math.min(this.m.length, newSize)));
+    this.m = newData;
   }
 };
 
@@ -317,112 +317,117 @@ var LAZY_INTEGER = 1;
 var LAZY_QUANTIZED = 2;
 var LAZY_OCTAHEDRON = 3;
 var PointAttribute = class extends GeometryAttribute {
-  A = false;
-  Sa = 0;
-  B = [];
-  W = null;
+  z = false;
+  Ra = 0;
+  A = [];
+  Z = 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.
+  lb = null;
+  mb = null;
   nb = null;
-  ob = null;
-  pb = 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.
-  Ca = LAZY_NONE;
-  X = null;
-  qb = [];
-  Da = 0;
+  Ba = LAZY_NONE;
+  _ = null;
+  ob = [];
+  Ca = 0;
+  // Set when the decoder knows every lazy value is below 2^24 in magnitude
+  // (see _lazyFloatValues); the extraction then skips its scan.
+  Sa = false;
   constructor(geometryAttribute) {
     super();
     if (geometryAttribute instanceof GeometryAttribute) {
       this.c = geometryAttribute.c;
-      this.w = geometryAttribute.w;
-      this.L = geometryAttribute.L;
-      this.Qa = geometryAttribute.Qa;
-      this.M = geometryAttribute.M;
-      this.N = geometryAttribute.N;
+      this.v = geometryAttribute.v;
+      this.O = geometryAttribute.O;
+      this.Pa = geometryAttribute.Pa;
+      this.P = geometryAttribute.P;
+      this.Q = geometryAttribute.Q;
+      this.za = geometryAttribute.za;
       this.Aa = geometryAttribute.Aa;
-      this.Ba = geometryAttribute.Ba;
     }
   }
   // 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.W = new DataBuffer();
+    this.Z = new DataBuffer();
     const byteStride = dataTypeLength(dataType) * numComponents;
-    super.init(attributeType, this.W, numComponents, dataType, normalized, byteStride, 0);
+    super.init(attributeType, this.Z, numComponents, dataType, normalized, byteStride, 0);
     this.reset(numAttributeValues);
     this.setIdentityMapping();
   }
   reset(numAttributeValues) {
-    if (this.W === null) {
-      this.W = new DataBuffer();
+    if (this.Z === null) {
+      this.Z = new DataBuffer();
     }
     const entrySize = dataTypeLength(this.dataType) * this.numComponents;
-    this.W.update(null, numAttributeValues * entrySize);
-    this.resetBuffer(this.W, entrySize, 0);
-    this.Sa = numAttributeValues;
+    this.Z.update(null, numAttributeValues * entrySize);
+    this.resetBuffer(this.Z, entrySize, 0);
+    this.Ra = numAttributeValues;
     return true;
   }
   // Sizes the attribute without allocating storage, for the deferred
   // transforms below (the values live in the decoder's portable attribute).
   resetLazy(numAttributeValues) {
-    this.Sa = numAttributeValues;
+    this.Ra = 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.Ca = LAZY_INTEGER;
-    this.X = values;
+    this.Ba = LAZY_INTEGER;
+    this._ = values;
   }
   // Quantized float values: value * delta + min per component (float32
   // arithmetic, see _extractQuantized), as the C++ Dequantizer computes them.
-  setLazyQuantized(values, minValues, delta) {
-    this.Ca = LAZY_QUANTIZED;
-    this.X = values;
-    this.qb = minValues;
-    this.Da = delta;
+  setLazyQuantized(values, minValues, delta, bounded) {
+    this.Ba = LAZY_QUANTIZED;
+    this._ = values;
+    this.ob = minValues;
+    this.Ca = delta;
+    this.Sa = bounded;
   }
   // Octahedral normals: two quantized coordinates per value, dequantized by
   // `scale` and turned into unit vectors (see _extractOctahedron).
-  setLazyOctahedron(values, scale) {
-    this.Ca = LAZY_OCTAHEDRON;
-    this.X = values;
-    this.Da = scale;
+  setLazyOctahedron(values, scale, bounded) {
+    this.Ba = LAZY_OCTAHEDRON;
+    this._ = values;
+    this.Ca = scale;
+    this.Sa = bounded;
   }
   get size() {
-    return this.Sa;
+    return this.Ra;
   }
   mappedIndex(pointIndex) {
-    if (this.A) {
+    if (this.z) {
       return pointIndex;
     }
-    return this.B[pointIndex];
+    return this.A[pointIndex];
   }
   get isMappingIdentity() {
-    return this.A;
+    return this.z;
   }
   get indicesMapSize() {
-    if (this.A) {
+    if (this.z) {
       return 0;
     }
-    return this.B.length;
+    return this.A.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.B;
+    return this.A;
   }
   // Implicit mapping: point index equals attribute entry index.
   setIdentityMapping() {
-    this.A = true;
-    this.B = [];
+    this.z = true;
+    this.A = [];
   }
   // 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
@@ -432,31 +437,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.A = false;
-    this.B = new Uint32Array(numPoints);
+    this.z = false;
+    this.A = 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.A = false;
-    this.B = map;
+    this.z = false;
+    this.A = 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.A = false;
-    this.B = scratchUint32(numPoints);
+    this.z = false;
+    this.A = scratchUint32(numPoints);
   }
   // Cached typed-array view of the given type over the attribute buffer.
-  rb(Ctor, bufData) {
-    if (this.nb !== Ctor || this.ob !== bufData.buffer) {
-      this.nb = Ctor;
-      this.ob = bufData.buffer;
-      this.pb = new Ctor(bufData.buffer);
+  pb(Ctor, bufData) {
+    if (this.lb !== Ctor || this.mb !== bufData.buffer) {
+      this.lb = Ctor;
+      this.mb = bufData.buffer;
+      this.nb = new Ctor(bufData.buffer);
     }
-    return this.pb;
+    return this.nb;
   }
   // Mirrors C++ PointAttribute::ConvertValue<T>() for buffer-backed
   // attributes. Attribute buffers start at byteOffset 0 and entries are
@@ -464,44 +469,44 @@ var PointAttribute = class extends GeometryAttribute {
   // of a per-component DataView dispatch.
   convertValue(attIndex, outVal) {
     const bufData = this.c.data;
-    const nc = this.w;
-    const Ctor = viewCtorFor(this.L);
+    const nc = this.v;
+    const Ctor = viewCtorFor(this.O);
     if (Ctor === null) {
       for (let i = 0; i < nc; ++i) outVal[i] = 0;
       return;
     }
-    const view = this.rb(Ctor, bufData);
-    const baseIndex = (bufData.byteOffset + this.N + this.M * attIndex) / Ctor.BYTES_PER_ELEMENT;
+    const view = this.pb(Ctor, bufData);
+    const baseIndex = (bufData.byteOffset + this.Q + this.P * 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
   // order (applying the deferred transform, if any, on the way).
   extractTo(OutputTypedArray, numPoints) {
-    const numComponents = this.w;
+    const numComponents = this.v;
     const array = new OutputTypedArray(numPoints * numComponents);
     if (numPoints === 0) {
       return array;
     }
-    const kind = this.Ca;
+    const kind = this.Ba;
     if (kind !== LAZY_NONE) {
-      if (this.X !== null) {
-        if (kind === LAZY_QUANTIZED) this.Sb(array, numPoints);
-        else if (kind === LAZY_OCTAHEDRON) this.Tb(array, numPoints);
-        else this.Ub(array, numPoints);
+      if (this._ !== null) {
+        if (kind === LAZY_QUANTIZED) this.Qb(array, numPoints);
+        else if (kind === LAZY_OCTAHEDRON) this.Rb(array, numPoints);
+        else this.Sb(array, numPoints);
       }
       return array;
     }
-    const Ctor = viewCtorFor(this.L);
+    const Ctor = viewCtorFor(this.O);
     if (this.c === null || Ctor === null) {
       return array;
     }
     const bufData = this.c.data;
-    const isIdentity = this.A;
-    const indicesMap = this.B;
-    const srcView = this.rb(Ctor, bufData);
+    const isIdentity = this.z;
+    const indicesMap = this.A;
+    const srcView = this.pb(Ctor, bufData);
     const shift = 31 - Math.clz32(Ctor.BYTES_PER_ELEMENT);
-    const srcStart = bufData.byteOffset + this.N >> shift;
-    const strideElements = this.M >> shift;
+    const srcStart = bufData.byteOffset + this.Q >> shift;
+    const strideElements = this.P >> shift;
     if (isIdentity && strideElements === numComponents) {
       const srcEnd = srcStart + numPoints * numComponents;
       if (srcView.constructor === OutputTypedArray) {
@@ -529,7 +534,7 @@ var PointAttribute = class extends GeometryAttribute {
   // Point -> value index; the identity mapping (sequential meshes) gets a
   // plain iota so the loops carry no per-point branch.
   Ta(numPoints) {
-    if (!this.A) return this.B;
+    if (!this.z) return this.A;
     const map = new Uint32Array(numPoints);
     for (let p = 0; p < numPoints; ++p) map[p] = p;
     return map;
@@ -540,8 +545,11 @@ var PointAttribute = class extends GeometryAttribute {
   // without the (measurably costly) int-to-float32-to-double round trip per
   // component. Larger values (quantization above 24 bits, never seen in
   // practice) are rounded in place once here, after which the same holds.
-  sb() {
-    const values = this.X;
+  // The decoder marks the attribute bounded when its prediction transform
+  // already confines the values to that range, and the scan is skipped.
+  qb() {
+    const values = this._;
+    if (this.Sa) 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]);
@@ -551,13 +559,13 @@ var PointAttribute = class extends GeometryAttribute {
     return values;
   }
   // C++ Dequantizer: float(value) * delta + min, all in float32.
-  Sb(out, numPoints) {
-    const values = this.sb();
+  Qb(out, numPoints) {
+    const values = this.qb();
     const map = this.Ta(numPoints);
-    const numComponents = this.w;
+    const numComponents = this.v;
     const fround = Math.fround;
-    const delta = this.Da;
-    const min = this.qb;
+    const delta = this.Ca;
+    const min = this.ob;
     if (numComponents === 3) {
       const m0 = min[0];
       const m1 = min[1];
@@ -589,11 +597,11 @@ var PointAttribute = class extends GeometryAttribute {
   }
   // OctahedronToolBox.QuantizedOctahedralCoordsToUnitVector, two quantized
   // coordinates per value to one unit vector per point.
-  Tb(out, numPoints) {
-    const values = this.sb();
+  Rb(out, numPoints) {
+    const values = this.qb();
     const map = this.Ta(numPoints);
     const fround = Math.fround;
-    const scale = this.Da;
+    const scale = this.Ca;
     for (let p = 0, d = 0; p < numPoints; ++p, d += 3) {
       const s = map[p] * 2;
       let y = fround(fround(values[s] * scale) - 1);
@@ -618,11 +626,11 @@ var PointAttribute = class extends GeometryAttribute {
   }
   // The int32 values wrap to the attribute's own integer type (as storing
   // them into it would) before the output store converts them.
-  Ub(out, numPoints) {
-    const values = this.X;
+  Sb(out, numPoints) {
+    const values = this._;
     const map = this.Ta(numPoints);
-    const numComponents = this.w;
-    const dt = this.L;
+    const numComponents = this.v;
+    const dt = this.O;
     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) {
@@ -654,21 +662,21 @@ function decodeVarint(buffer) {
 
 // src/decoder/core/DecoderBuffer.ts
 var BitDecoder = class {
-  Ea = null;
-  o = 0;
-  ka = 0;
+  Da = null;
+  p = 0;
+  ja = 0;
   reset(uint8Array, byteLength) {
-    this.Ea = uint8Array;
-    this.ka = byteLength;
-    this.o = 0;
+    this.Da = uint8Array;
+    this.ja = byteLength;
+    this.p = 0;
   }
   getBits(nbits) {
     if (nbits > 32) return void 0;
-    const buf = this.Ea;
-    let off = this.o;
+    const buf = this.Da;
+    let off = this.p;
     const byteOffset = off >> 3;
     const bitShift = off & 7;
-    if (byteOffset + 4 < this.ka) {
+    if (byteOffset + 4 < this.ja) {
       const val = (buf[byteOffset] | buf[byteOffset + 1] << 8 | buf[byteOffset + 2] << 16 | buf[byteOffset + 3] << 24) >>> 0;
       let result;
       if (nbits > 32 - bitShift) {
@@ -679,7 +687,7 @@ var BitDecoder = class {
       } else {
         result = val >>> bitShift;
       }
-      this.o = off + nbits;
+      this.p = off + nbits;
       return nbits === 32 ? result : result & (1 << nbits) - 1;
     }
     let value = 0;
@@ -687,7 +695,7 @@ var BitDecoder = class {
     let currOff = off;
     while (bitsRead < nbits) {
       const bOff = currOff >> 3;
-      if (bOff >= this.ka) return void 0;
+      if (bOff >= this.ja) return void 0;
       const bShift = currOff & 7;
       const bitsAvail = 8 - bShift;
       const bitsNeeded = nbits - bitsRead;
@@ -697,53 +705,53 @@ var BitDecoder = class {
       bitsRead += bitsToRead;
       currOff += bitsToRead;
     }
-    this.o = currOff;
+    this.p = currOff;
     return value;
   }
 };
 var DecoderBuffer = class {
-  n = null;
-  Fa = null;
-  I = 0;
+  m = null;
+  Ea = null;
+  K = 0;
   d = 0;
-  la = new BitDecoder();
-  Ga = false;
+  ka = new BitDecoder();
+  Fa = false;
   init(data, dataSize = data.length) {
-    this.n = data;
-    this.Fa = new DataView(data.buffer, data.byteOffset, data.byteLength);
-    this.I = dataSize;
+    this.m = data;
+    this.Ea = new DataView(data.buffer, data.byteOffset, data.byteLength);
+    this.K = dataSize;
     this.d = 0;
   }
   // Typed little-endian reads.
   decodeUint8() {
-    if (this.d + 1 > this.I) return void 0;
-    const val = this.n[this.d];
+    if (this.d + 1 > this.K) return void 0;
+    const val = this.m[this.d];
     this.d += 1;
     return val;
   }
   decodeUint16() {
-    if (this.d + 2 > this.I) return void 0;
-    const val = this.Fa.getUint16(this.d, true);
+    if (this.d + 2 > this.K) return void 0;
+    const val = this.Ea.getUint16(this.d, true);
     this.d += 2;
     return val;
   }
   decodeInt32() {
-    if (this.d + 4 > this.I) return void 0;
-    const val = this.Fa.getInt32(this.d, true);
+    if (this.d + 4 > this.K) return void 0;
+    const val = this.Ea.getInt32(this.d, true);
     this.d += 4;
     return val;
   }
   decodeFloat32() {
-    if (this.d + 4 > this.I) return void 0;
-    const val = this.Fa.getFloat32(this.d, true);
+    if (this.d + 4 > this.K) return void 0;
+    const val = this.Ea.getFloat32(this.d, true);
     this.d += 4;
     return val;
   }
   // 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.d + size > this.I) return void 0;
-    const result = this.n.subarray(this.d, this.d + size);
+    if (this.d + size > this.K) return void 0;
+    const result = this.m.subarray(this.d, this.d + size);
     this.d += size;
     return result;
   }
@@ -756,35 +764,35 @@ var DecoderBuffer = class {
       if (size === void 0) return void 0;
       outSize = size;
     }
-    this.Ga = true;
-    this.la.reset(this.n.subarray(this.d), this.I - this.d);
+    this.Fa = true;
+    this.ka.reset(this.m.subarray(this.d), this.K - this.d);
     return outSize;
   }
   endBitDecoding() {
-    this.Ga = false;
-    this.d += Math.ceil(this.la.o / 8);
+    this.Fa = false;
+    this.d += Math.ceil(this.ka.p / 8);
   }
   decodeLeastSignificantBits32(nbits) {
-    if (!this.Ga) return void 0;
-    return this.la.getBits(nbits);
+    if (!this.Fa) return void 0;
+    return this.ka.getBits(nbits);
   }
   advance(bytes) {
     this.d += bytes;
   }
   get data() {
-    return this.n;
+    return this.m;
   }
   get dataHead() {
-    return this.n.subarray(this.d);
+    return this.m.subarray(this.d);
   }
   get remainingSize() {
-    return this.I - this.d;
+    return this.K - this.d;
   }
   get decodedSize() {
     return this.d;
   }
   get bitDecoderActive() {
-    return this.Ga;
+    return this.Fa;
   }
 };
 
@@ -802,17 +810,17 @@ var METADATA_FLAG_MASK = 32768;
 var kMaxSubmetadataLevel = 1e3;
 var MetadataDecoder = class {
   constructor(buffer_) {
-    this.C = buffer_;
+    this.B = buffer_;
   }
   buffer_;
   // Skips per-attribute metadata followed by the geometry-level metadata.
   skipGeometryMetadata() {
-    const numAttMetadata = decodeVarint(this.C);
+    const numAttMetadata = decodeVarint(this.B);
     if (numAttMetadata === void 0) {
       return false;
     }
     for (let i = 0; i < numAttMetadata; ++i) {
-      if (decodeVarint(this.C) === void 0) {
+      if (decodeVarint(this.B) === void 0) {
         return false;
       }
       if (!this.Ua(0)) {
@@ -827,41 +835,41 @@ var MetadataDecoder = class {
     if (level > kMaxSubmetadataLevel) {
       return false;
     }
-    const numEntries = decodeVarint(this.C);
+    const numEntries = decodeVarint(this.B);
     if (numEntries === void 0) {
       return false;
     }
     for (let i = 0; i < numEntries; ++i) {
-      const nameSkipped = this.tb();
-      const dataSize = nameSkipped ? decodeVarint(this.C) : void 0;
-      if (dataSize === void 0 || dataSize === 0 || !this.ub(dataSize)) {
+      const nameSkipped = this.rb();
+      const dataSize = nameSkipped ? decodeVarint(this.B) : void 0;
+      if (dataSize === void 0 || dataSize === 0 || !this.sb(dataSize)) {
         return false;
       }
     }
-    const numSubMetadata = decodeVarint(this.C);
-    if (numSubMetadata === void 0 || numSubMetadata > this.C.remainingSize) {
+    const numSubMetadata = decodeVarint(this.B);
+    if (numSubMetadata === void 0 || numSubMetadata > this.B.remainingSize) {
       return false;
     }
     for (let i = 0; i < numSubMetadata; ++i) {
-      if (!this.tb() || !this.Ua(level + 1)) {
+      if (!this.rb() || !this.Ua(level + 1)) {
         return false;
       }
     }
     return true;
   }
   // Skips a name (uint8 length prefix followed by that many bytes).
-  tb() {
-    const nameLen = this.C.decodeUint8();
+  rb() {
+    const nameLen = this.B.decodeUint8();
     if (nameLen === void 0) {
       return false;
     }
-    return this.ub(nameLen);
+    return this.sb(nameLen);
   }
-  ub(size) {
-    if (size > this.C.remainingSize) {
+  sb(size) {
+    if (size > this.B.remainingSize) {
       return false;
     }
-    this.C.advance(size);
+    this.B.advance(size);
     return true;
   }
 };
@@ -999,12 +1007,12 @@ var RAnsDecoder = class {
   // written back once. Removes per-symbol property reads and call indirection.
   decodeSymbols(out, count) {
     if (this.coarse) {
-      this.Vb(out, count);
+      this.Tb(out, count);
       return;
     }
-    this.Wb(out, count, this.lutTable);
+    this.Ub(out, count, this.lutTable);
   }
-  Wb(out, count, lutTable) {
+  Ub(out, count, lutTable) {
     const buf = this.buf;
     const lRansBase = this.lRansBase;
     const ransPrecisionBits = this.ransPrecisionBits;
@@ -1028,7 +1036,7 @@ var RAnsDecoder = class {
   }
   // Short-stream loop: bucket table + cumProb scan instead of the full lut.
   // Same state arithmetic as the lut loops, so the output is identical.
-  Vb(out, count) {
+  Tb(out, count) {
     const buf = this.buf;
     const lRansBase = this.lRansBase;
     const ransPrecisionBits = this.ransPrecisionBits;
@@ -1090,12 +1098,15 @@ var RAnsDecoder = class {
         return false;
       }
       cumProbTable[numSymbols] = ransPrecision;
-      const bucketShift = this.ransPrecisionBits - COARSE_BUCKET_BITS;
-      const bucketTable = numSymbols > 65536 ? acquirePooled(Uint32Array, 1 << COARSE_BUCKET_BITS) : acquirePooled(Uint16Array, 1 << COARSE_BUCKET_BITS);
+      let bucketBits = 33 - Math.clz32(numSymbols);
+      if (bucketBits > COARSE_BUCKET_BITS) bucketBits = COARSE_BUCKET_BITS;
+      const numBuckets = 1 << bucketBits;
+      const bucketShift = this.ransPrecisionBits - bucketBits;
+      const bucketTable = numSymbols > 65536 ? acquirePooled(Uint32Array, numBuckets) : acquirePooled(Uint16Array, numBuckets);
       this.bucketShift = bucketShift;
       this.bucketTable = bucketTable;
       let symbol = 0;
-      for (let b = 0; b < 1 << COARSE_BUCKET_BITS; ++b) {
+      for (let b = 0; b < numBuckets; ++b) {
         const rem = b << bucketShift;
         while (cumProbTable[symbol + 1] <= rem) symbol++;
         bucketTable[b] = symbol;
@@ -1129,12 +1140,36 @@ var RAnsDecoder = class {
     return true;
   }
 };
-function ransDecodeSymbolsPair(a, outA, countA, b, outB, countB) {
-  if (!a.coarse && !b.coarse) {
-    ransDecodeSymbolsPairU16(a, outA, countA, b, outB, countB);
-  } else {
-    a.decodeSymbols(outA, countA);
-    b.decodeSymbols(outB, countB);
+function ransDecodeStreams(streams) {
+  const live = [];
+  for (const stream of streams) {
+    if (stream.count === 0) continue;
+    if (stream.ans.coarse) stream.ans.decodeSymbols(stream.out, stream.count);
+    else live.push({ ans: stream.ans, out: stream.out, count: stream.count });
+  }
+  const byLength = (x, y) => y.count - x.count;
+  live.sort(byLength);
+  while (live.length >= 3) {
+    const a = live[0];
+    const b = live[1];
+    const c = live[2];
+    const shared = c.count;
+    ransDecodeSymbolsTrioU16(a.ans, a.out, shared, b.ans, b.out, shared, c.ans, c.out, shared);
+    live.splice(2, 1);
+    a.out = a.out.subarray(shared);
+    a.count -= shared;
+    b.out = b.out.subarray(shared);
+    b.count -= shared;
+    if (a.count === 0) live.shift();
+    if (b.count === 0) live.splice(live.indexOf(b), 1);
+    live.sort(byLength);
+  }
+  if (live.length === 2) {
+    const a = live[0];
+    const b = live[1];
+    ransDecodeSymbolsPairU16(a.ans, a.out, a.count, b.ans, b.out, b.count);
+  } else if (live.length === 1) {
+    live[0].ans.decodeSymbols(live[0].out, live[0].count);
   }
 }
 function ransDecodeSymbolsPairU16(a, outA, countA, b, outB, countB) {
@@ -1266,10 +1301,10 @@ function ransDecodeSymbolsTrioU16(a, outA, countA, b, outB, countB, c, outC, cou
 
 // src/decoder/compression/point_cloud/PointCloudDecoder.ts
 var PointCloudDecoder = class {
-  O = null;
+  R = null;
   c = null;
-  s = [];
-  Ha = [];
+  t = [];
+  Ga = [];
   // Returns an error message, or '' on success (outHeader is then populated).
   static decodeHeader(buffer, outHeader) {
     const kIoErrorMsg = "Failed to parse Draco header.";
@@ -1299,7 +1334,7 @@ var PointCloudDecoder = class {
   // Main entry point, given the already-parsed header (see Decode.ts).
   decode(header, inBuffer, outPointCloud) {
     this.c = inBuffer;
-    this.O = outPointCloud;
+    this.R = outPointCloud;
     if (header.versionMajor !== 2 || header.versionMinor !== 2) {
       return "Unsupported bitstream version (Draco 2.2 meshes only).";
     }
@@ -1321,27 +1356,27 @@ var PointCloudDecoder = class {
     if (attDecoderId < 0) {
       return false;
     }
-    while (this.s.length <= attDecoderId) {
-      this.s.push(null);
+    while (this.t.length <= attDecoderId) {
+      this.t.push(null);
     }
-    this.s[attDecoderId] = decoder;
+    this.t[attDecoderId] = decoder;
     return true;
   }
   getPortableAttribute(parentAttId) {
-    if (parentAttId < 0 || parentAttId >= this.O.numAttributes()) {
+    if (parentAttId < 0 || parentAttId >= this.R.numAttributes()) {
       return null;
     }
-    const parentAttDecoderId = this.Ha[parentAttId];
-    return this.s[parentAttDecoderId].getPortableAttribute(parentAttId);
+    const parentAttDecoderId = this.Ga[parentAttId];
+    return this.t[parentAttDecoderId].getPortableAttribute(parentAttId);
   }
   attributesDecoder(decId) {
-    return this.s[decId];
+    return this.t[decId];
   }
   numAttributesDecoders() {
-    return this.s.length;
+    return this.t.length;
   }
   pointCloud() {
-    return this.O;
+    return this.R;
   }
   buffer() {
     return this.c;
@@ -1367,52 +1402,40 @@ var PointCloudDecoder = class {
         return false;
       }
     }
-    for (let i = 0; i < this.s.length; ++i) {
-      if (!this.s[i].init(this, this.O)) {
+    for (let i = 0; i < this.t.length; ++i) {
+      if (!this.t[i].init(this, this.R)) {
         return false;
       }
     }
     for (let i = 0; i < numAttributesDecoders; ++i) {
-      if (!this.s[i].decodeAttributesDecoderData(this.c)) {
+      if (!this.t[i].decodeAttributesDecoderData(this.c)) {
         return false;
       }
     }
     for (let i = 0; i < numAttributesDecoders; ++i) {
-      const numAttributes = this.s[i].getNumAttributes();
+      const numAttributes = this.t[i].getNumAttributes();
       for (let j = 0; j < numAttributes; ++j) {
-        const attId = this.s[i].getAttributeId(j);
-        while (this.Ha.length <= attId) {
-          this.Ha.push(0);
+        const attId = this.t[i].getAttributeId(j);
+        while (this.Ga.length <= attId) {
+          this.Ga.push(0);
         }
-        this.Ha[attId] = i;
+        this.Ga[attId] = i;
       }
     }
     return this.decodeAllAttributes();
   }
   decodeAllAttributes() {
-    const decoders = this.s;
-    for (let i2 = 0; i2 < decoders.length; i2++) {
-      if (!decoders[i2].decodeAttributesParse(this.c)) {
+    const decoders = this.t;
+    for (let i = 0; i < decoders.length; i++) {
+      if (!decoders[i].decodeAttributesParse(this.c)) {
         return false;
       }
     }
     const pending = [];
-    for (let i2 = 0; i2 < decoders.length; i2++) {
-      decoders[i2].collectPendingSymbolStreams(pending);
-    }
-    const paired = pending.filter((stream) => !stream.ans.coarse);
-    let i = 0;
-    for (; i + 1 < paired.length; i += 2) {
-      const a = paired[i];
-      const b = paired[i + 1];
-      ransDecodeSymbolsPair(a.ans, a.out, a.count, b.ans, b.out, b.count);
-    }
-    if (i < paired.length) {
-      paired[i].ans.decodeSymbols(paired[i].out, paired[i].count);
-    }
-    for (const stream of pending) {
-      if (stream.ans.coarse) stream.ans.decodeSymbols(stream.out, stream.count);
+    for (let i = 0; i < decoders.length; i++) {
+      decoders[i].collectPendingSymbolStreams(pending);
     }
+    ransDecodeStreams(pending);
     for (let k = 0; k < decoders.length; k++) {
       if (!decoders[k].decodeAttributesFinish()) {
         return false;
@@ -1424,10 +1447,10 @@ var PointCloudDecoder = class {
 
 // src/decoder/compression/mesh/MeshDecoder.ts
 var MeshDecoder = class extends PointCloudDecoder {
-  D = null;
+  C = null;
   // Returns an error message, or '' on success.
   decodeMesh(header, inBuffer, outMesh) {
-    this.D = outMesh;
+    this.C = outMesh;
     return this.decode(header, inBuffer, outMesh);
   }
   // Connectivity accessors used by the mesh prediction schemes; the sequential
@@ -1442,7 +1465,7 @@ var MeshDecoder = class extends PointCloudDecoder {
     return null;
   }
   mesh() {
-    return this.D;
+    return this.C;
   }
   decodeGeometryData() {
     return this.decodeConnectivity() && super.decodeGeometryData();
@@ -1451,89 +1474,84 @@ var MeshDecoder = class extends PointCloudDecoder {
 
 // src/decoder/mesh/MeshAttributeCornerTable.ts
 var kInvalidCornerIndex = -1;
-var kInvalidVertexIndex = -1;
 var MeshAttributeCornerTable = class {
-  Y = [];
-  ma = [];
-  Z = [];
-  na = [];
+  // Base vertices touched by a seam edge of this table.
+  la = new Uint8Array(0);
+  S = new Int32Array(0);
+  // 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.
+  y = new Uint8Array(0);
   // 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.
-  oa = 0;
-  t = null;
-  // Lazily built; see oppositeCornerArray.
-  P = null;
-  // Every corner passed to addSeamEdge (may contain duplicates); lets
-  // oppositeCornerArray patch seams without scanning every corner's flag.
-  // Preallocated to its exact upper bound (2 per seam edge) by the caller via
-  // reserveSeamEdges -- a plain array grown by push() was measurable on
-  // seam-heavy files.
-  _ = [];
-  Q = 0;
+  ma = 0;
+  D = 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.
+  E = new Int32Array(0);
+  // 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
+  // result mesh keeps no reference to it), so pooling keeps a primitive-heavy
+  // file from allocating a fresh set per attribute per prim.
   initEmpty(table) {
-    if (table === null) {
-      return false;
-    }
-    this.Y = scratchUint8Zeroed(table.numCorners());
-    this.ma = scratchUint8Zeroed(table.numVertices());
-    this.Z = scratchInt32Filled(table.numCorners(), kInvalidVertexIndex);
-    this.oa = 0;
-    this.na = [];
-    this.P = null;
-    this._ = [];
-    this.Q = 0;
-    this.t = table;
-    return true;
-  }
-  // Sizes the seam-corner list for numSeamEdges upcoming addSeamEdge calls
-  // (each adds at most two corners). Decode-scoped scratch.
-  reserveSeamEdges(numSeamEdges) {
-    this._ = scratchInt32(numSeamEdges * 2);
-    this.Q = 0;
-  }
+    const numCorners = table.numCorners();
+    this.D = table;
+    this.la = scratchUint8Zeroed(table.numVertices());
+    this.E = scratchInt32(numCorners);
+    this.E.set(table.oppositeCornerArray());
+    this.S = scratchInt32(numCorners);
+    this.S.set(table.cornerToVertexArray());
+    this.ma = 0;
+  }
+  // Cuts the edge opposite corner c (and its twin) and flags its two vertices.
   addSeamEdge(c) {
-    const cornerToVertex = this.t.cornerToVertexArray();
-    const oppositeCorners = this.t.oppositeCornerArray();
-    const isEdge = this.Y;
-    const isVert = this.ma;
-    const seamCorners = this._;
-    isEdge[c] = 1;
-    seamCorners[this.Q++] = c;
+    const cornerToVertex = this.D.cornerToVertexArray();
+    const opposite = this.E;
+    const isVert = this.la;
+    const oppCorner = opposite[c];
+    opposite[c] = kInvalidCornerIndex;
     let rem = c - (c / 3 | 0) * 3;
     isVert[cornerToVertex[rem === 2 ? c - 2 : c + 1]] = 1;
     isVert[cornerToVertex[rem === 0 ? c + 2 : c - 1]] = 1;
-    const oppCorner = oppositeCorners[c];
     if (oppCorner !== kInvalidCornerIndex) {
-      isEdge[oppCorner] = 1;
-      seamCorners[this.Q++] = oppCorner;
+      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 attribute-vertex numbering computed externally (the edgebreaker
-  // decoder's fused ring pass fills corner_to_vertex_map_ directly and hands
-  // over the per-vertex left-most corners here). leftMostMap is decode-scoped
-  // scratch sized for at least numNewVertices entries.
-  setRecomputedVertices(leftMostMap, numNewVertices) {
-    this.oa = numNewVertices;
-    this.na = leftMostMap.length === numNewVertices ? leftMostMap : leftMostMap.subarray(0, numNewVertices);
-  }
-  isCornerOppositeToSeamEdge(corner) {
-    return this.Y[corner];
+  // Installs the vertex numbering computed by the edgebreaker decoder's ring
+  // pass, which fills corner_to_vertex_map_ directly and hands over the
+  // per-vertex boundary flags here (decode-scoped scratch sized for at
+  // least numVertices entries).
+  setRecomputedVertices(onBoundary, numVertices) {
+    this.ma = numVertices;
+    this.y = 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.D = table;
+    this.E = table.oppositeCornerArray();
+    this.S = table.cornerToVertexArray();
+    this.setRecomputedVertices(table.vertexOnBoundaryArray(), table.numVertices());
   }
   opposite(corner) {
-    if (corner === kInvalidCornerIndex || this.isCornerOppositeToSeamEdge(corner)) {
+    if (corner === kInvalidCornerIndex) {
       return kInvalidCornerIndex;
     }
-    return this.t.opposite(corner);
+    return this.E[corner];
   }
   next(corner) {
-    return this.t.next(corner);
+    return this.D.next(corner);
   }
   previous(corner) {
-    return this.t.previous(corner);
+    return this.D.previous(corner);
   }
   swingRight(corner) {
     return this.previous(this.opposite(this.previous(corner)));
@@ -1542,68 +1560,48 @@ var MeshAttributeCornerTable = class {
     return this.next(this.opposite(this.next(corner)));
   }
   numVertices() {
-    return this.oa;
+    return this.ma;
   }
   numFaces() {
-    return this.t.numFaces();
+    return this.D.numFaces();
   }
   numCorners() {
-    return this.t.numCorners();
+    return this.D.numCorners();
   }
   // --- Flat-array accessors: let DepthFirstTraverser avoid per-corner dispatch. ---
   cornerToVertexArray() {
-    return this.Z;
+    return this.S;
   }
-  // Seam-aware opposite corners (seam edges -> -1), matching opposite(). Cached on
-  // first use; seams and connectivity are finalized before traversal, so it's stable.
+  // Seam-aware opposite corners (seam edges -> -1), matching opposite().
   oppositeCornerArray() {
-    if (this.P === null) {
-      const nc = this.t.numCorners();
-      const base = this.t.oppositeCornerArray();
-      const seamCorners = this._;
-      const numSeamCorners = this.Q;
-      if (numSeamCorners === 0) {
-        this.P = base;
-      } else {
-        const eff = scratchInt32(nc);
-        eff.set(base.length === nc ? base : base.subarray(0, nc));
-        for (let i = 0; i < numSeamCorners; ++i) {
-          eff[seamCorners[i]] = kInvalidCornerIndex;
-        }
-        this.P = eff;
-      }
-    }
-    return this.P;
+    return this.E;
   }
-  vertexLeftmostCornerArray() {
-    return this.na;
+  vertexOnBoundaryArray() {
+    return this.y;
   }
   // 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.t = other.t;
-    this.Y = other.Y;
+    this.D = other.D;
+    this.la = other.la;
+    this.S = other.S;
     this.ma = other.ma;
-    this.Z = other.Z;
-    this.oa = other.oa;
-    this.na = other.na;
-    this.P = other.P;
-    this._ = other._;
-    this.Q = other.Q;
+    this.y = other.y;
+    this.E = other.E;
   }
 };
 
 // src/decoder/compression/attributes/AttributesDecoder.ts
 var AttributesDecoder = class {
-  Ia = [];
+  Ha = [];
   // Inverse of _pointAttributeIds: point attribute id -> local id.
-  pa = [];
-  vb = null;
-  O = null;
+  na = [];
+  tb = null;
+  R = null;
   init(decoder, pointCloud) {
-    this.vb = decoder;
-    this.O = pointCloud;
+    this.tb = decoder;
+    this.R = pointCloud;
     return true;
   }
   decodeAttributesDecoderData(buffer) {
@@ -1611,8 +1609,8 @@ var AttributesDecoder = class {
     if (numAttributes === void 0 || numAttributes === 0 || numAttributes > 5 * buffer.remainingSize) {
       return false;
     }
-    this.Ia.length = numAttributes;
-    const pc = this.O;
+    this.Ha.length = numAttributes;
+    const pc = this.R;
     for (let i = 0; i < numAttributes; i++) {
       const attType = buffer.decodeUint8();
       if (attType === void 0) return false;
@@ -1638,56 +1636,56 @@ var AttributesDecoder = class {
       ga.uniqueId = uniqueId;
       const attId = pc.addAttribute(new PointAttribute(ga));
       pc.attribute(attId).uniqueId = uniqueId;
-      this.Ia[i] = attId;
-      while (this.pa.length <= attId) {
-        this.pa.push(-1);
+      this.Ha[i] = attId;
+      while (this.na.length <= attId) {
+        this.na.push(-1);
       }
-      this.pa[attId] = i;
+      this.na[attId] = i;
     }
     return true;
   }
   getAttributeId(i) {
-    return this.Ia[i];
+    return this.Ha[i];
   }
   getNumAttributes() {
-    return this.Ia.length;
+    return this.Ha.length;
   }
   getDecoder() {
-    return this.vb;
+    return this.tb;
   }
   getLocalIdForPointAttribute(pointAttributeId) {
-    if (pointAttributeId >= this.pa.length) {
+    if (pointAttributeId >= this.na.length) {
       return -1;
     }
-    return this.pa[pointAttributeId];
+    return this.na[pointAttributeId];
   }
 };
 
 // src/decoder/compression/attributes/SequentialAttributeDecoder.ts
 var SequentialAttributeDecoder = class {
   l = null;
-  E = null;
-  wb = -1;
+  F = null;
+  ub = -1;
   // Decoded portable attribute (after lossless decoding).
   $ = null;
   init(decoder, attributeId) {
     this.l = decoder;
-    this.E = decoder.pointCloud().attribute(attributeId);
-    this.wb = attributeId;
+    this.F = decoder.pointCloud().attribute(attributeId);
+    this.ub = attributeId;
     return true;
   }
   // --- Two-phase decode ---
   // The controller calls Parse for every attribute first (headers, schemes,
   // prediction data -- all size-driven cursor movement), collects the pending
-  // rANS symbol streams, decodes them in pairs (see ransDecodeSymbolsPair),
+  // rANS symbol streams, decodes them in lockstep (see ransDecodeStreams),
   // then calls Finish per attribute in order. Decoders without a deferrable
   // stream simply do the whole decode in Parse (decodeValues); the defaults
   // below are theirs.
   decodePortableAttributeParse(pointIds, buffer) {
-    if (this.E.numComponents <= 0) {
+    if (this.F.numComponents <= 0) {
       return false;
     }
-    if (!this.xb(pointIds.length)) {
+    if (!this.vb(pointIds.length)) {
       return false;
     }
     return this.decodeValues(pointIds, buffer);
@@ -1695,8 +1693,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).
-  xb(numValues) {
-    return this.E.reset(numValues);
+  vb(numValues) {
+    return this.F.reset(numValues);
   }
   pendingSymbolStream() {
     return null;
@@ -1713,10 +1711,10 @@ var SequentialAttributeDecoder = class {
     return true;
   }
   getPortableAttribute() {
-    if (!this.E.isMappingIdentity && this.$ && this.$.isMappingIdentity) {
-      const size = this.E.indicesMapSize;
+    if (!this.F.isMappingIdentity && this.$ && this.$.isMappingIdentity) {
+      const size = this.F.indicesMapSize;
       this.$.setExplicitMappingScratch(size);
-      const src = this.E.indicesMap;
+      const src = this.F.indicesMap;
       const dst = this.$.indicesMap;
       if (src.length === size) {
         dst.set(src);
@@ -1727,10 +1725,10 @@ var SequentialAttributeDecoder = class {
     return this.$;
   }
   get attribute() {
-    return this.E;
+    return this.F;
   }
   get attributeId() {
-    return this.wb;
+    return this.ub;
   }
   get decoder() {
     return this.l;
@@ -1751,13 +1749,13 @@ var SequentialAttributeDecoder = class {
   // Decodes raw attribute values in their original format.
   decodeValues(pointIds, buffer) {
     const numValues = pointIds.length;
-    const entrySize = this.E.byteStride;
+    const entrySize = this.F.byteStride;
     const totalSize = numValues * entrySize;
     const valueData = buffer.decodeBytesView(totalSize);
     if (valueData === void 0) {
       return false;
     }
-    this.E.buffer.write(0, valueData, totalSize);
+    this.F.buffer.write(0, valueData, totalSize);
     return true;
   }
 };
@@ -1772,14 +1770,14 @@ function convertSymbolsToSignedInts(input, count, output) {
 
 // src/decoder/compression/entropy/RAnsSymbolDecoder.ts
 var RAnsSymbolDecoder = class {
-  yb = 0;
-  m;
+  wb = 0;
+  G;
   constructor(uniqueSymbolsBitLength) {
     const unclamped = Math.trunc(3 * uniqueSymbolsBitLength / 2);
-    this.m = new RAnsDecoder(unclamped < 12 ? 12 : unclamped > 20 ? 20 : unclamped);
+    this.G = new RAnsDecoder(unclamped < 12 ? 12 : unclamped > 20 ? 20 : unclamped);
   }
   get numSymbols() {
-    return this.yb;
+    return this.wb;
   }
   // Initialize the decoder and decode the probability table. expectedCount is
   // the number of symbols the caller will decode (lets short streams skip the
@@ -1787,7 +1785,7 @@ var RAnsSymbolDecoder = class {
   create(buffer, expectedCount = 2147483647) {
     const numSymbols = decodeVarint(buffer);
     if (numSymbols === void 0) return false;
-    this.yb = numSymbols;
+    this.wb = numSymbols;
     if (Math.trunc(numSymbols / 64) > buffer.remainingSize) {
       return false;
     }
@@ -1820,7 +1818,7 @@ var RAnsSymbolDecoder = class {
       }
     }
     buffer.advance(pos - startPos);
-    return this.m.ransBuildLookUpTable(probabilityTable, numSymbols, expectedCount);
+    return this.G.ransBuildLookUpTable(probabilityTable, numSymbols, expectedCount);
   }
   // Starts decoding, advancing buffer past the encoded data.
   startDecoding(buffer) {
@@ -1831,10 +1829,10 @@ var RAnsSymbolDecoder = class {
     }
     const base = buffer.decodedSize;
     buffer.advance(Number(bytesEncoded));
-    return ansReadInit(this.m, buffer.data, base + Number(bytesEncoded), base, this.m.lRansBase, 4);
+    return ansReadInit(this.G, buffer.data, base + Number(bytesEncoded), base, this.G.lRansBase, 4);
   }
   endDecoding() {
-    this.m.readEnd();
+    this.G.readEnd();
   }
 };
 
@@ -1862,12 +1860,12 @@ function decodeTaggedSymbols(numValues, numComponents, srcBuffer, outValues) {
   if (numValues > 0 && tagDecoder.numSymbols === 0) {
     return false;
   }
-  const tagAns = tagDecoder.m;
+  const tagAns = tagDecoder.G;
   srcBuffer.startBitDecoding(false);
-  const bd = srcBuffer.la;
-  const buf = bd.Ea;
-  const byteLength = bd.ka;
-  let bitOffset = bd.o;
+  const bd = srcBuffer.ka;
+  const buf = bd.Da;
+  const byteLength = bd.ja;
+  let bitOffset = bd.p;
   let valueId = 0;
   for (let i = 0; i < numValues; i += numComponents) {
     const bitLength = tagAns.ransRead();
@@ -1886,7 +1884,7 @@ function decodeTaggedSymbols(numValues, numComponents, srcBuffer, outValues) {
         outValues[valueId++] = value & mask;
       }
       if (j === numComponents) continue;
-      bd.o = bitOffset;
+      bd.p = bitOffset;
       for (; j < numComponents; ++j) {
         const val = bd.getBits(bitLength);
         if (val === void 0) {
@@ -1894,9 +1892,9 @@ function decodeTaggedSymbols(numValues, numComponents, srcBuffer, outValues) {
         }
         outValues[valueId++] = val;
       }
-      bitOffset = bd.o;
+      bitOffset = bd.p;
     } else {
-      bd.o = bitOffset;
+      bd.p = bitOffset;
       for (let j = 0; j < numComponents; ++j) {
         const val = bd.getBits(bitLength);
         if (val === void 0) {
@@ -1904,10 +1902,10 @@ function decodeTaggedSymbols(numValues, numComponents, srcBuffer, outValues) {
         }
         outValues[valueId++] = val;
       }
-      bitOffset = bd.o;
+      bitOffset = bd.p;
     }
   }
-  bd.o = bitOffset;
+  bd.p = bitOffset;
   tagDecoder.endDecoding();
   srcBuffer.endBitDecoding();
   return true;
@@ -1934,15 +1932,15 @@ function decodeRawSymbols(numValues, srcBuffer, outValues) {
   if (decoder === null) {
     return false;
   }
-  decoder.m.decodeSymbols(outValues, numValues);
+  decoder.G.decodeSymbols(outValues, numValues);
   decoder.endDecoding();
   return true;
 }
 
 // src/decoder/compression/bit_coders/RAnsBitDecoder.ts
 var RAnsBitDecoder = class {
-  Va = new AnsDecoder();
-  Wa = 0;
+  oa = new AnsDecoder();
+  pa = 0;
   // ANS_P8_PRECISION - probZero, precomputed
   // Returns false when the data is invalid.
   startDecoding(sourceBuffer) {
@@ -1950,21 +1948,21 @@ var RAnsBitDecoder = class {
     if (probZero === void 0) {
       return false;
     }
-    this.Wa = ANS_P8_PRECISION - probZero;
+    this.pa = ANS_P8_PRECISION - probZero;
     const sizeInBytes = decodeVarint(sourceBuffer);
     if (sizeInBytes === void 0 || sizeInBytes > sourceBuffer.remainingSize) {
       return false;
     }
     const base = sourceBuffer.decodedSize;
-    if (!ansReadInit(this.Va, sourceBuffer.data, base + sizeInBytes, base, ANS_L_BASE, 3)) {
+    if (!ansReadInit(this.oa, sourceBuffer.data, base + sizeInBytes, base, ANS_L_BASE, 3)) {
       return false;
     }
     sourceBuffer.advance(sizeInBytes);
     return true;
   }
   decodeNextBit() {
-    const ans = this.Va;
-    const p = this.Wa;
+    const ans = this.oa;
+    const p = this.pa;
     if (ans.state < ANS_L_BASE && ans.bufOffset > ans.bufStart) {
       ans.state = ans.state << 8 | ans.buf[--ans.bufOffset];
     }
@@ -1985,13 +1983,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.e.boundsValues(limit);
   }
   getNumParentAttributes() {
     return 0;
@@ -2003,7 +2004,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
@@ -2060,18 +2061,18 @@ var MAX_NUM_PARALLELOGRAMS = 4;
 var MeshPredictionSchemeConstrainedMultiParallelogramDecoder = class extends MeshPredictionSchemeDecoder {
   // Crease edges stored per context (number of available parallelograms),
   // one list per context up to MAX_NUM_PARALLELOGRAMS.
-  Ja = [[], [], [], []];
+  Ia = [[], [], [], []];
   decodePredictionData(buffer) {
     for (let i = 0; i < MAX_NUM_PARALLELOGRAMS; ++i) {
       const numFlags = decodeVarint(buffer);
       if (numFlags === void 0) return false;
       if (numFlags > this.b.cornerTable.numCorners()) return false;
       if (numFlags > 0) {
-        this.Ja[i] = new Array(numFlags);
+        this.Ia[i] = new Array(numFlags);
         const decoder = new RAnsBitDecoder();
         if (!decoder.startDecoding(buffer)) return false;
         for (let j = 0; j < numFlags; ++j) {
-          this.Ja[i][j] = decoder.decodeNextBit();
+          this.Ia[i][j] = decoder.decodeNextBit();
         }
         decoder.endDecoding();
       }
@@ -2079,12 +2080,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.b.cornerTable;
     const vertexToDataMap = this.b.vertexToDataMap;
     const oppositeCorners = table.oppositeCornerArray();
@@ -2130,8 +2131,8 @@ var MeshPredictionSchemeConstrainedMultiParallelogramDecoder = class extends Mes
         for (let i = 0; i < numParallelograms; ++i) {
           const context = numParallelograms - 1;
           const pos = isCreaseEdgePos[context]++;
-          if (this.Ja[context].length <= pos) return false;
-          const isCrease = this.Ja[context][pos];
+          if (this.Ia[context].length <= pos) return false;
+          const isCrease = this.Ia[context][pos];
           if (!isCrease) {
             ++numUsedParallelograms;
             for (let j = 0; j < numComponents; ++j) {
@@ -2143,12 +2144,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;
@@ -2158,34 +2159,82 @@ var MeshPredictionSchemeConstrainedMultiParallelogramDecoder = class extends Mes
 // src/decoder/compression/attributes/prediction_schemes/MeshPredictionSchemeData.ts
 var MeshPredictionSchemeData = class {
   cornerTable;
-  vertexToDataMap;
-  dataToCornerMap;
-  constructor(cornerTable, dataToCornerMap, vertexToDataMap) {
+  n;
+  constructor(cornerTable, encodingData) {
     this.cornerTable = cornerTable;
-    this.vertexToDataMap = vertexToDataMap;
-    this.dataToCornerMap = dataToCornerMap;
+    this.n = encodingData;
+  }
+  get vertexToDataMap() {
+    return this.n.vertexToEncodedAttributeValueIndexMap;
+  }
+  get dataToCornerMap() {
+    return this.n.encodedAttributeValueIndexToCornerMap;
+  }
+  // The parallelogram parents of every value: for value p, the data ids of
+  // the opposite corner's vertex and of that face's next and prev vertices
+  // (parents[3p .. 3p+2]), or -1 in parents[3p] when the value is not
+  // parallelogram-predictable (no opposite face, or a parent decoded after
+  // it). The scheme's per-value walk -- corner, opposite corner, three
+  // vertices, three data ids: four dependent random reads -- is thus done
+  // once per traversal and shared by every attribute predicted over it (a
+  // position, a texture coordinate and a colour on one connectivity all use
+  // it), and the prediction loops read it sequentially. Decode-scoped
+  // scratch, cached on the traversal entry.
+  parallelogramParents() {
+    const entry = this.n.cacheEntry;
+    if (entry !== null && entry.parents !== null) {
+      return entry.parents;
+    }
+    const table = this.cornerTable;
+    const oppositeCorners = table.oppositeCornerArray();
+    const cornerToVertex = table.cornerToVertexArray();
+    const vertexToDataMap = this.vertexToDataMap;
+    const dataToCornerMap = this.dataToCornerMap;
+    const numValues = dataToCornerMap.length;
+    const parents = scratchInt32(numValues * 3);
+    if (numValues > 0) parents[0] = -1;
+    for (let p = 1, o = 3; p < numValues; ++p, o += 3) {
+      const oci = oppositeCorners[dataToCornerMap[p]];
+      if (oci < 0) {
+        parents[o] = -1;
+        continue;
+      }
+      const rem = oci - (oci / 3 | 0) * 3;
+      const vertOpp = vertexToDataMap[cornerToVertex[oci]];
+      const vertNext = vertexToDataMap[cornerToVertex[rem === 2 ? oci - 2 : oci + 1]];
+      const vertPrev = vertexToDataMap[cornerToVertex[rem === 0 ? oci + 2 : oci - 1]];
+      if (vertOpp < p && vertNext < p && vertPrev < p) {
+        parents[o] = vertOpp;
+        parents[o + 1] = vertNext;
+        parents[o + 2] = vertPrev;
+      } else {
+        parents[o] = -1;
+      }
+    }
+    if (entry !== null) entry.parents = parents;
+    return parents;
   }
 };
 
 // src/decoder/compression/attributes/NormalCompressionUtils.ts
 var OctahedronToolBox = class {
-  J = -1;
-  qa = -1;
+  L = -1;
+  aa = -1;
   k = -1;
-  Xb = 1;
-  e = -1;
+  Vb = 1;
+  f = -1;
   // q: quantization bits, valid range 2..30.
   setQuantizationBits(q) {
     if (q < 2 || q > 30) return false;
-    this.J = q;
-    this.qa = (1 << q) - 1;
-    this.k = this.qa - 1;
-    this.Xb = Math.fround(2 / Math.fround(this.k));
-    this.e = this.k / 2 | 0;
+    this.L = q;
+    this.aa = (1 << q) - 1;
+    this.k = this.aa - 1;
+    this.Vb = Math.fround(2 / Math.fround(this.k));
+    this.f = this.k / 2 | 0;
     return true;
   }
   quantizationBits() {
-    return this.J;
+    return this.L;
   }
   // Canonicalizes edge points into consistent quadrants. Writes result into
   // out[0], out[1] (caller-owned reusable 2-element array).
@@ -2193,14 +2242,14 @@ var OctahedronToolBox = class {
     if (s === 0 && t === 0 || s === 0 && t === this.k || s === this.k && t === 0) {
       s = this.k;
       t = this.k;
-    } else if (s === 0 && t > this.e) {
-      t = this.e - (t - this.e);
-    } else if (s === this.k && t < this.e) {
-      t = this.e + (this.e - t);
-    } else if (t === this.k && s < this.e) {
-      s = this.e + (this.e - s);
-    } else if (t === 0 && s > this.e) {
-      s = this.e - (s - this.e);
+    } else if (s === 0 && t > this.f) {
+      t = this.f - (t - this.f);
+    } else if (s === this.k && t < this.f) {
+      t = this.f + (this.f - t);
+    } else if (t === this.k && 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;
@@ -2210,8 +2259,8 @@ var OctahedronToolBox = class {
   integerVectorToQuantizedOctahedralCoords(intVec, out) {
     let s, t;
     if (intVec[0] >= 0) {
-      s = intVec[1] + this.e;
-      t = intVec[2] + this.e;
+      s = intVec[1] + this.f;
+      t = intVec[2] + this.f;
     } else {
       if (intVec[1] < 0) {
         s = Math.abs(intVec[2]);
@@ -2230,14 +2279,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.e;
+      vec[0] = this.f;
     } else {
-      vec[0] = Math.trunc(vec[0] * this.e / absSum);
-      vec[1] = Math.trunc(vec[1] * this.e / 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.e - Math.abs(vec[0]) - Math.abs(vec[1]);
+        vec[2] = this.f - Math.abs(vec[0]) - Math.abs(vec[1]);
       } else {
-        vec[2] = -(this.e - Math.abs(vec[0]) - Math.abs(vec[1]));
+        vec[2] = -(this.f - Math.abs(vec[0]) - Math.abs(vec[1]));
       }
     }
   }
@@ -2283,31 +2332,31 @@ function fillInt32PositionCache(cache, att, map, numEntries, tempPos) {
   }
 }
 var MeshPredictionSchemeGeometricNormalPredictorArea = class {
+  qa = null;
   ra = null;
-  sa = null;
   b;
-  Xa = new Array(3);
-  ta = null;
+  Va = new Array(3);
+  sa = null;
   // flat Int32 positions, indexed by data id
-  p = null;
-  zb = null;
+  o = null;
+  xb = null;
   // corner -> posCache offset, precomputed
   constructor(meshData) {
     this.b = meshData;
   }
   setPositionAttribute(positionAttribute) {
-    this.ra = positionAttribute;
+    this.qa = positionAttribute;
   }
   setEntryToPointIdMap(map) {
-    this.sa = map;
+    this.ra = map;
   }
   buildPositionCache(numEntries) {
     const posCache = scratchInt32(numEntries * 3);
-    fillInt32PositionCache(posCache, this.ra, this.sa, numEntries, this.Xa);
-    this.ta = posCache;
+    fillInt32PositionCache(posCache, this.qa, this.ra, numEntries, this.Va);
+    this.sa = posCache;
     const table = this.b.cornerTable;
     const cornerToVertex = table.cornerToVertexArray();
-    this.p = table.oppositeCornerArray();
+    this.o = table.oppositeCornerArray();
     const vertexToDataMap = this.b.vertexToDataMap;
     const nc = cornerToVertex.length;
     const c2o = scratchInt32(nc);
@@ -2315,12 +2364,12 @@ var MeshPredictionSchemeGeometricNormalPredictorArea = class {
       const v = cornerToVertex[c];
       c2o[c] = v < 0 ? -1 : vertexToDataMap[v] * 3;
     }
-    this.zb = c2o;
+    this.xb = c2o;
   }
   computePredictedValue(cornerId, prediction) {
-    const oppositeCorners = this.p;
-    const cornerToOffset = this.zb;
-    const posCache = this.ta;
+    const oppositeCorners = this.o;
+    const cornerToOffset = this.xb;
+    const posCache = this.sa;
     const centerOffset = cornerToOffset[cornerId];
     const centX = posCache[centerOffset];
     const centY = posCache[centerOffset + 1];
@@ -2398,8 +2447,8 @@ var MeshPredictionSchemeGeometricNormalPredictorArea = class {
 var GEOMETRY_ATTRIBUTE_POSITION = 0;
 var MeshPredictionSchemeGeometricNormalDecoder = class extends MeshPredictionSchemeDecoder {
   q;
-  y = new OctahedronToolBox();
-  Ya = new RAnsBitDecoder();
+  w = new OctahedronToolBox();
+  Wa = new RAnsBitDecoder();
   constructor(transform, meshData) {
     super(transform, meshData);
     this.q = new MeshPredictionSchemeGeometricNormalPredictorArea(meshData);
@@ -2417,11 +2466,11 @@ var MeshPredictionSchemeGeometricNormalDecoder = class extends MeshPredictionSch
     return true;
   }
   decodePredictionData(buffer) {
-    if (!this.f.decodeTransformData(buffer)) return false;
-    return this.Ya.startDecoding(buffer);
+    if (!this.e.decodeTransformData(buffer)) return false;
+    return this.Wa.startDecoding(buffer);
   }
   computeOriginalValues(inCorr, outData, _size, _numComponents, entryToPointIdMap) {
-    this.y.setQuantizationBits(this.f.quantizationBits());
+    this.w.setQuantizationBits(this.e.quantizationBits());
     this.q.setEntryToPointIdMap(entryToPointIdMap);
     const cornerMapSize = this.b.dataToCornerMap.length;
     this.q.buildPositionCache(cornerMapSize);
@@ -2430,17 +2479,17 @@ var MeshPredictionSchemeGeometricNormalDecoder = class extends MeshPredictionSch
     for (let dataId = 0; dataId < cornerMapSize; ++dataId) {
       const cornerId = this.b.dataToCornerMap[dataId];
       this.q.computePredictedValue(cornerId, predNormal3D);
-      this.y.canonicalizeIntegerVector(predNormal3D);
-      if (this.Ya.decodeNextBit()) {
+      this.w.canonicalizeIntegerVector(predNormal3D);
+      if (this.Wa.decodeNextBit()) {
         predNormal3D[0] = -predNormal3D[0];
         predNormal3D[1] = -predNormal3D[1];
         predNormal3D[2] = -predNormal3D[2];
       }
-      this.y.integerVectorToQuantizedOctahedralCoords(predNormal3D, predNormalOct);
+      this.w.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.Ya.endDecoding();
+    this.Wa.endDecoding();
     return true;
   }
 };
@@ -2449,10 +2498,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.b.cornerTable;
     const vertexToDataMap = this.b.vertexToDataMap;
     const oppositeCorners = table.oppositeCornerArray();
@@ -2489,12 +2538,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;
@@ -2506,8 +2555,8 @@ 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);
-    return this.Yb(inCorr, outData, numComponents, true);
+    this.e.init(numComponents);
+    return this.Wb(inCorr, outData, numComponents, true);
   }
   // The wrap transform's corrections are zigzag-coded; with `zigzag` set the
   // decode folds the (val >>> 1) ^ -(val & 1) unpacking into each correction
@@ -2515,23 +2564,19 @@ var MeshPredictionSchemeParallelogramDecoder = class extends MeshPredictionSchem
   // whole array (see computeOriginalValuesZigzag). Every correction is read
   // exactly once before its slot is overwritten, so the in-place aliasing of
   // inCorr and outData is preserved.
-  Yb(inCorr, outData, numComponents, zigzag) {
+  Wb(inCorr, outData, numComponents, zigzag) {
     if (numComponents === 2) {
-      return this.Zb(inCorr, outData, zigzag);
+      return this.Xb(inCorr, outData, zigzag);
     }
     if (numComponents === 3) {
-      return this._b(inCorr, outData, zigzag);
+      return this.Yb(inCorr, outData, zigzag);
     }
     if (numComponents === 4) {
-      return this.$b(inCorr, outData, zigzag);
+      return this.Zb(inCorr, outData, zigzag);
     }
-    const table = this.b.cornerTable;
-    const vertexToDataMap = this.b.vertexToDataMap;
-    const oppositeCorners = table.oppositeCornerArray();
-    const cornerToVertex = table.cornerToVertexArray();
-    const dataToCornerMap = this.b.dataToCornerMap;
-    const transform = this.f;
-    const minValue = transform.aa;
+    const parents = this.b.parallelogramParents();
+    const transform = this.e;
+    const minValue = transform.T;
     const maxValue = transform.k;
     const maxDif = transform.ba;
     for (let c = 0; c < numComponents; ++c) {
@@ -2550,30 +2595,14 @@ var MeshPredictionSchemeParallelogramDecoder = class extends MeshPredictionSchem
       }
       outData[c] = orig;
     }
-    const cornerMapSize = dataToCornerMap.length;
-    for (let p = 1; p < cornerMapSize; ++p) {
-      const cornerId = dataToCornerMap[p];
+    const numValues = this.b.dataToCornerMap.length;
+    for (let p = 1, o = 3; p < numValues; ++p, o += 3) {
       const dstOffset = p * numComponents;
-      const oci = oppositeCorners[cornerId];
-      let hasPrediction = false;
-      let vOppOff = 0;
-      let vNextOff = 0;
-      let vPrevOff = 0;
-      if (oci >= 0) {
-        const rem = oci - (oci / 3 | 0) * 3;
-        const nextOci = rem === 2 ? oci - 2 : oci + 1;
-        const prevOci = rem === 0 ? oci + 2 : oci - 1;
-        const vertOpp = vertexToDataMap[cornerToVertex[oci]];
-        const vertNext = vertexToDataMap[cornerToVertex[nextOci]];
-        const vertPrev = vertexToDataMap[cornerToVertex[prevOci]];
-        if (vertOpp < p && vertNext < p && vertPrev < p) {
-          vOppOff = vertOpp * numComponents;
-          vNextOff = vertNext * numComponents;
-          vPrevOff = vertPrev * numComponents;
-          hasPrediction = true;
-        }
-      }
-      if (hasPrediction) {
+      const vertOpp = parents[o];
+      if (vertOpp >= 0) {
+        const vOppOff = vertOpp * numComponents;
+        const vNextOff = parents[o + 1] * numComponents;
+        const vPrevOff = parents[o + 2] * numComponents;
         for (let c = 0; c < numComponents; ++c) {
           let pred = outData[vNextOff + c] + outData[vPrevOff + c] - outData[vOppOff + c] | 0;
           if (pred > maxValue) {
@@ -2591,7 +2620,7 @@ var MeshPredictionSchemeParallelogramDecoder = class extends MeshPredictionSchem
           outData[dstOffset + c] = orig;
         }
       } else {
-        const srcOffset = (p - 1) * numComponents;
+        const srcOffset = dstOffset - numComponents;
         for (let c = 0; c < numComponents; ++c) {
           let pred = outData[srcOffset + c];
           if (pred > maxValue) {
@@ -2612,14 +2641,10 @@ var MeshPredictionSchemeParallelogramDecoder = class extends MeshPredictionSchem
     }
     return true;
   }
-  Zb(inCorr, outData, zigzag) {
-    const table = this.b.cornerTable;
-    const vertexToDataMap = this.b.vertexToDataMap;
-    const oppositeCorners = table.oppositeCornerArray();
-    const cornerToVertex = table.cornerToVertexArray();
-    const dataToCornerMap = this.b.dataToCornerMap;
-    const transform = this.f;
-    const minValue = transform.aa;
+  Xb(inCorr, outData, zigzag) {
+    const parents = this.b.parallelogramParents();
+    const transform = this.e;
+    const minValue = transform.T;
     const maxValue = transform.k;
     const maxDif = transform.ba;
     let pred0 = 0;
@@ -2650,30 +2675,14 @@ var MeshPredictionSchemeParallelogramDecoder = class extends MeshPredictionSchem
     }
     outData[0] = orig0;
     outData[1] = orig1;
-    const cornerMapSize = dataToCornerMap.length;
-    for (let p = 1; p < cornerMapSize; ++p) {
-      const cornerId = dataToCornerMap[p];
+    const numValues = this.b.dataToCornerMap.length;
+    for (let p = 1, o = 3; p < numValues; ++p, o += 3) {
       const dstOffset = p * 2;
-      const oci = oppositeCorners[cornerId];
-      let hasPrediction = false;
-      let vOppOff = 0;
-      let vNextOff = 0;
-      let vPrevOff = 0;
-      if (oci >= 0) {
-        const rem = oci - (oci / 3 | 0) * 3;
-        const nextOci = rem === 2 ? oci - 2 : oci + 1;
-        const prevOci = rem === 0 ? oci + 2 : oci - 1;
-        const vertOpp = vertexToDataMap[cornerToVertex[oci]];
-        const vertNext = vertexToDataMap[cornerToVertex[nextOci]];
-        const vertPrev = vertexToDataMap[cornerToVertex[prevOci]];
-        if (vertOpp < p && vertNext < p && vertPrev < p) {
-          vOppOff = vertOpp * 2;
-          vNextOff = vertNext * 2;
-          vPrevOff = vertPrev * 2;
-          hasPrediction = true;
-        }
-      }
-      if (hasPrediction) {
+      const vertOpp = parents[o];
+      if (vertOpp >= 0) {
+        const vOppOff = vertOpp * 2;
+        const vNextOff = parents[o + 1] * 2;
+        const vPrevOff = parents[o + 2] * 2;
         pred0 = outData[vNextOff] + outData[vPrevOff] - outData[vOppOff] | 0;
         pred1 = outData[vNextOff + 1] + outData[vPrevOff + 1] - outData[vOppOff + 1] | 0;
       } else {
@@ -2710,14 +2719,10 @@ var MeshPredictionSchemeParallelogramDecoder = class extends MeshPredictionSchem
     }
     return true;
   }
-  _b(inCorr, outData, zigzag) {
-    const table = this.b.cornerTable;
-    const vertexToDataMap = this.b.vertexToDataMap;
-    const oppositeCorners = table.oppositeCornerArray();
-    const cornerToVertex = table.cornerToVertexArray();
-    const dataToCornerMap = this.b.dataToCornerMap;
-    const transform = this.f;
-    const minValue = transform.aa;
+  Yb(inCorr, outData, zigzag) {
+    const parents = this.b.parallelogramParents();
+    const transform = this.e;
+    const minValue = transform.T;
     const maxValue = transform.k;
     const maxDif = transform.ba;
     let pred0 = 0;
@@ -2762,30 +2767,14 @@ var MeshPredictionSchemeParallelogramDecoder = class extends MeshPredictionSchem
     outData[0] = orig0;
     outData[1] = orig1;
     outData[2] = orig2;
-    const cornerMapSize = dataToCornerMap.length;
-    for (let p = 1; p < cornerMapSize; ++p) {
-      const cornerId = dataToCornerMap[p];
+    const numValues = this.b.dataToCornerMap.length;
+    for (let p = 1, o = 3; p < numValues; ++p, o += 3) {
       const dstOffset = p * 3;
-      const oci = oppositeCorners[cornerId];
-      let hasPrediction = false;
-      let vOppOff = 0;
-      let vNextOff = 0;
-      let vPrevOff = 0;
-      if (oci >= 0) {
-        const rem = oci - (oci / 3 | 0) * 3;
-        const nextOci = rem === 2 ? oci - 2 : oci + 1;
-        const prevOci = rem === 0 ? oci + 2 : oci - 1;
-        const vertOpp = vertexToDataMap[cornerToVertex[oci]];
-        const vertNext = vertexToDataMap[cornerToVertex[nextOci]];
-        const vertPrev = vertexToDataMap[cornerToVertex[prevOci]];
-        if (vertOpp < p && vertNext < p && vertPrev < p) {
-          vOppOff = vertOpp * 3;
-          vNextOff = vertNext * 3;
-          vPrevOff = vertPrev * 3;
-          hasPrediction = true;
-        }
-      }
-      if (hasPrediction) {
+      const vertOpp = parents[o];
+      if (vertOpp >= 0) {
+        const vOppOff = vertOpp * 3;
+        const vNextOff = parents[o + 1] * 3;
+        const vPrevOff = parents[o + 2] * 3;
         pred0 = outData[vNextOff] + outData[vPrevOff] - outData[vOppOff] | 0;
         pred1 = outData[vNextOff + 1] + outData[vPrevOff + 1] - outData[vOppOff + 1] | 0;
         pred2 = outData[vNextOff + 2] + outData[vPrevOff + 2] - outData[vOppOff + 2] | 0;
@@ -2839,14 +2828,10 @@ var MeshPredictionSchemeParallelogramDecoder = class extends MeshPredictionSchem
   }
   // Four components: tangents, RGBA colors, skin joints/weights. Same
   // structure as the 2/3-component loops.
-  $b(inCorr, outData, zigzag) {
-    const table = this.b.cornerTable;
-    const vertexToDataMap = this.b.vertexToDataMap;
-    const oppositeCorners = table.oppositeCornerArray();
-    const cornerToVertex = table.cornerToVertexArray();
-    const dataToCornerMap = this.b.dataToCornerMap;
-    const transform = this.f;
-    const minValue = transform.aa;
+  Zb(inCorr, outData, zigzag) {
+    const parents = this.b.parallelogramParents();
+    const transform = this.e;
+    const minValue = transform.T;
     const maxValue = transform.k;
     const maxDif = transform.ba;
     let pred0 = 0;
@@ -2858,31 +2843,15 @@ var MeshPredictionSchemeParallelogramDecoder = class extends MeshPredictionSchem
     let pred1 = pred0;
     let pred2 = pred0;
     let pred3 = pred0;
-    const cornerMapSize = dataToCornerMap.length;
-    for (let p = 0; p < cornerMapSize; ++p) {
+    const numValues = this.b.dataToCornerMap.length;
+    for (let p = 0, o = 0; p < numValues; ++p, o += 3) {
       const dstOffset = p * 4;
       if (p > 0) {
-        const cornerId = dataToCornerMap[p];
-        const oci = oppositeCorners[cornerId];
-        let hasPrediction = false;
-        let vOppOff = 0;
-        let vNextOff = 0;
-        let vPrevOff = 0;
-        if (oci >= 0) {
-          const rem = oci - (oci / 3 | 0) * 3;
-          const nextOci = rem === 2 ? oci - 2 : oci + 1;
-          const prevOci = rem === 0 ? oci + 2 : oci - 1;
-          const vertOpp = vertexToDataMap[cornerToVertex[oci]];
-          const vertNext = vertexToDataMap[cornerToVertex[nextOci]];
-          const vertPrev = vertexToDataMap[cornerToVertex[prevOci]];
-          if (vertOpp < p && vertNext < p && vertPrev < p) {
-            vOppOff = vertOpp * 4;
-            vNextOff = vertNext * 4;
-            vPrevOff = vertPrev * 4;
-            hasPrediction = true;
-          }
-        }
-        if (hasPrediction) {
+        const vertOpp = parents[o];
+        if (vertOpp >= 0) {
+          const vOppOff = vertOpp * 4;
+          const vNextOff = parents[o + 1] * 4;
+          const vPrevOff = parents[o + 2] * 4;
           pred0 = outData[vNextOff] + outData[vPrevOff] - outData[vOppOff] | 0;
           pred1 = outData[vNextOff + 1] + outData[vPrevOff + 1] - outData[vOppOff + 1] | 0;
           pred2 = outData[vNextOff + 2] + outData[vPrevOff + 2] - outData[vOppOff + 2] | 0;
@@ -2967,39 +2936,39 @@ function bigIntSqrt(value) {
   return x;
 }
 var MeshPredictionSchemeTexCoordsPortablePredictor = class {
+  qa = null;
   ra = null;
-  sa = null;
   r = new Int32Array(2);
-  Ka = new Uint8Array(0);
-  ua = 0;
+  Ja = new Uint8Array(0);
+  ta = 0;
   b;
-  Xa = new Array(3);
+  Va = new Array(3);
   // Flat Int32 position cache so fetches are array reads, not convertValue calls.
-  ta = null;
+  sa = null;
   h = null;
   constructor(meshData) {
     this.b = meshData;
   }
   setPositionAttribute(positionAttribute) {
-    this.ra = positionAttribute;
+    this.qa = positionAttribute;
   }
   setEntryToPointIdMap(map) {
-    this.sa = map;
+    this.ra = map;
   }
   get predictedValue() {
     return this.r;
   }
   resizeOrientations(numOrientations) {
-    this.Ka = new Uint8Array(numOrientations);
-    this.ua = numOrientations;
+    this.Ja = new Uint8Array(numOrientations);
+    this.ta = numOrientations;
   }
   setOrientation(i, v) {
-    this.Ka[i] = v ? 1 : 0;
+    this.Ja[i] = v ? 1 : 0;
   }
   buildPositionCache(numEntries) {
     const posCache = new Int32Array(numEntries * 3);
-    fillInt32PositionCache(posCache, this.ra, this.sa, numEntries, this.Xa);
-    this.ta = posCache;
+    fillInt32PositionCache(posCache, this.qa, this.ra, numEntries, this.Va);
+    this.sa = posCache;
     this.h = this.b.cornerTable.cornerToVertexArray();
   }
   computePredictedValue(cornerId, data, dataId) {
@@ -3022,7 +2991,7 @@ var MeshPredictionSchemeTexCoordsPortablePredictor = class {
         this.r[1] = pUV1;
         return true;
       }
-      const posCache = this.ta;
+      const posCache = this.sa;
       let posOffset = dataId * 3;
       const tip0 = posCache[posOffset];
       const tip1 = posCache[posOffset + 1];
@@ -3059,7 +3028,7 @@ var MeshPredictionSchemeTexCoordsPortablePredictor = class {
         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) {
-          return this.ac(
+          return this._b(
             tip0,
             tip1,
             tip2,
@@ -3091,10 +3060,10 @@ var MeshPredictionSchemeTexCoordsPortablePredictor = class {
         const normSquared = Math.floor(Math.sqrt(cxNorm2Squared * pnNorm2Squared));
         const cxUV0 = pnUV1 * normSquared;
         const cxUV1 = -pnUV0 * normSquared;
-        if (this.ua === 0) {
+        if (this.ta === 0) {
           return false;
         }
-        const orientation = this.Ka[--this.ua];
+        const orientation = this.Ja[--this.ta];
         if (orientation) {
           this.r[0] = Math.trunc((xUV0 + cxUV0) / pnNorm2Squared);
           this.r[1] = Math.trunc((xUV1 + cxUV1) / pnNorm2Squared);
@@ -3129,7 +3098,7 @@ var MeshPredictionSchemeTexCoordsPortablePredictor = class {
   // <uint64_t>, including the uint64 wraparound in IntSqrt(cxNorm2*pnNorm2) and
   // the unsigned add/sub forming the final UV. Returns false in the same
   // overflow cases as the double path so encoder and decoder agree on fallback.
-  ac(tip0, tip1, tip2, next0, next1, next2, pn0, pn1, pn2, nUV0, nUV1, pUV0, pUV1, pnNorm2SquaredNum) {
+  _b(tip0, tip1, tip2, next0, next1, next2, pn0, pn1, pn2, nUV0, nUV1, pUV0, pUV1, pnNorm2SquaredNum) {
     const B = BigInt;
     const tip = [B(tip0), B(tip1), B(tip2)];
     const nxt = [B(next0), B(next1), B(next2)];
@@ -3163,8 +3132,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.ua === 0) return false;
-    const orientation = this.Ka[--this.ua];
+    if (this.ta === 0) return false;
+    const orientation = this.Ja[--this.ta];
     let s0, s1;
     if (orientation) {
       s0 = B.asUintN(64, B.asUintN(64, xUV0) + B.asUintN(64, cxUV0));
@@ -3220,7 +3189,7 @@ var MeshPredictionSchemeTexCoordsPortableDecoder = class extends MeshPredictionS
       return false;
     }
     this.q.setEntryToPointIdMap(entryToPointIdMap);
-    this.f.init(numComponents);
+    this.e.init(numComponents);
     const cornerMapSize = this.b.dataToCornerMap.length;
     this.q.buildPositionCache(cornerMapSize);
     for (let p = 0; p < cornerMapSize; ++p) {
@@ -3229,7 +3198,7 @@ var MeshPredictionSchemeTexCoordsPortableDecoder = class extends MeshPredictionS
         return false;
       }
       const dstOffset = p * numComponents;
-      this.f.computeOriginalValue(this.q.predictedValue, 0, inCorr, dstOffset, outData, dstOffset);
+      this.e.computeOriginalValue(this.q.predictedValue, 0, inCorr, dstOffset, outData, dstOffset);
     }
     return true;
   }
@@ -3238,7 +3207,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);
@@ -3284,11 +3253,7 @@ function createPredictionSchemeForDecoder(method, attId, decoder, transform) {
   const encodingData = meshDecoder.getAttributeEncodingData(attId);
   if (cornerTable !== null && encodingData !== null) {
     const attCornerTable = meshDecoder.getAttributeCornerTable(attId);
-    const meshData = new MeshPredictionSchemeData(
-      attCornerTable !== null ? attCornerTable : cornerTable,
-      encodingData.encodedAttributeValueIndexToCornerMap,
-      encodingData.vertexToEncodedAttributeValueIndexMap
-    );
+    const meshData = new MeshPredictionSchemeData(attCornerTable !== null ? attCornerTable : cornerTable, encodingData);
     const ret = createMeshPredictionSchemeDecoder(method, transform, meshData);
     if (ret !== null) return ret;
   }
@@ -3297,22 +3262,25 @@ function createPredictionSchemeForDecoder(method, attId, decoder, transform) {
 
 // src/decoder/compression/attributes/prediction_schemes/PredictionSchemeWrapDecodingTransform.ts
 var PredictionSchemeWrapDecodingTransform = class {
-  w = 0;
-  aa = 0;
+  v = 0;
+  T = 0;
   k = 0;
   ba = 0;
   getType() {
     return 1 /* PREDICTION_TRANSFORM_WRAP */;
   }
   init(numComponents) {
-    this.w = numComponents;
+    this.v = numComponents;
   }
   areCorrectionsPositive() {
     return false;
   }
+  boundsValues(limit) {
+    return this.k < limit && this.T > -limit;
+  }
   computeOriginalValue(predictedVals, predictedOffset, corrVals, corrOffset, outOriginalVals, outOffset) {
-    const nc = this.w;
-    const minValue = this.aa;
+    const nc = this.v;
+    const minValue = this.T;
     const maxValue = this.k;
     const maxDif = this.ba;
     for (let i = 0; i < nc; ++i) {
@@ -3338,7 +3306,7 @@ var PredictionSchemeWrapDecodingTransform = class {
     if (maxValue === void 0) return false;
     const dif = maxValue - minValue;
     if (dif < 0 || dif >= 2147483647) return false;
-    this.aa = minValue;
+    this.T = minValue;
     this.k = maxValue;
     this.ba = 1 + dif;
     return true;
@@ -3347,39 +3315,39 @@ var PredictionSchemeWrapDecodingTransform = class {
 
 // src/decoder/compression/attributes/SequentialIntegerAttributeDecoder.ts
 var SequentialIntegerAttributeDecoder = class extends SequentialAttributeDecoder {
-  ca = null;
+  M = 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.
-  da = null;
-  Za = 0;
-  Ab = null;
+  ca = null;
+  Xa = 0;
+  yb = null;
   // Int32 view over the portable attribute's storage (see preparePortableAttribute).
-  R = null;
+  U = null;
   // --- Two-phase decode (parse headers / batch symbol decode / finish) ---
   pendingSymbolStream() {
-    if (this.da === null) {
+    if (this.ca === null) {
       return null;
     }
-    const portableData = this.R;
+    const portableData = this.U;
     return {
-      ans: this.da.m,
-      out: new Uint32Array(portableData.buffer, portableData.byteOffset, this.Za),
-      count: this.Za
+      ans: this.ca.G,
+      out: new Uint32Array(portableData.buffer, portableData.byteOffset, this.Xa),
+      count: this.Xa
     };
   }
   decodePortableAttributeFinish() {
-    if (this.da !== null) {
-      this.da.endDecoding();
-      this.da = null;
+    if (this.ca !== null) {
+      this.ca.endDecoding();
+      this.ca = null;
     }
-    return this.bc(this.Ab);
+    return this.$b(this.yb);
   }
   // 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.Ab = pointIds;
+    this.yb = pointIds;
     let predictionSchemeMethod = buffer.decodeUint8();
     if (predictionSchemeMethod !== void 0) predictionSchemeMethod = predictionSchemeMethod << 24 >> 24;
     if (predictionSchemeMethod === void 0) return false;
@@ -3393,10 +3361,10 @@ var SequentialIntegerAttributeDecoder = class extends SequentialAttributeDecoder
       if (predictionTransformType < -1 /* PREDICTION_TRANSFORM_NONE */ || predictionTransformType >= 4 /* NUM_PREDICTION_SCHEME_TRANSFORM_TYPES */) {
         return false;
       }
-      this.ca = this.createIntPredictionScheme(predictionSchemeMethod, predictionTransformType);
+      this.M = this.createIntPredictionScheme(predictionSchemeMethod, predictionTransformType);
     }
-    if (this.ca) {
-      if (!this.initPredictionScheme(this.ca)) {
+    if (this.M) {
+      if (!this.initPredictionScheme(this.M)) {
         return false;
       }
     }
@@ -3407,7 +3375,7 @@ var SequentialIntegerAttributeDecoder = class extends SequentialAttributeDecoder
     const numEntries = pointIds.length;
     const numValues = numEntries * numComponents;
     this.preparePortableAttribute(numEntries, numComponents);
-    const portableAttributeData = this.R;
+    const portableAttributeData = this.U;
     if (portableAttributeData === null) {
       return false;
     }
@@ -3421,8 +3389,8 @@ var SequentialIntegerAttributeDecoder = class extends SequentialAttributeDecoder
           if (decoder === null) {
             return false;
           }
-          this.da = decoder;
-          this.Za = numValues;
+          this.ca = decoder;
+          this.Xa = numValues;
         } else if (scheme === 0 /* SYMBOL_CODING_TAGGED */) {
           const outUint32 = new Uint32Array(portableAttributeData.buffer, portableAttributeData.byteOffset, numValues);
           if (!decodeTaggedSymbols(numValues, numComponents, buffer, outUint32)) {
@@ -3446,25 +3414,25 @@ var SequentialIntegerAttributeDecoder = class extends SequentialAttributeDecoder
         portableAttributeData[i] = val;
       }
     }
-    if (this.ca) {
-      if (!this.ca.decodePredictionData(buffer)) {
+    if (this.M) {
+      if (!this.M.decodePredictionData(buffer)) {
         return false;
       }
     }
     return true;
   }
   // The post-symbol tail of the decode: zigzag unpacking and prediction.
-  bc(pointIds) {
+  $b(pointIds) {
     const numComponents = this.getNumValueComponents();
     const numValues = pointIds.length * numComponents;
-    const data = this.R;
+    const data = this.U;
     if (data === null) {
       return false;
     }
     if (numValues === 0) {
       return true;
     }
-    const ps = this.ca;
+    const ps = this.M;
     if (ps === null) {
       convertSymbolsToSignedInts(new Uint32Array(data.buffer, data.byteOffset, numValues), numValues, data);
       return true;
@@ -3479,7 +3447,7 @@ var SequentialIntegerAttributeDecoder = class extends SequentialAttributeDecoder
     return ps.computeOriginalValues(data, data, numValues, numComponents, pointIds);
   }
   transformAttributeToOriginalFormat(pointIds) {
-    return this._a(pointIds.length);
+    return this.Ya(pointIds.length);
   }
   // Prediction scheme for decoding integer values; subclasses override for others.
   createIntPredictionScheme(method, transformType) {
@@ -3492,21 +3460,28 @@ var SequentialIntegerAttributeDecoder = class extends SequentialAttributeDecoder
   getNumValueComponents() {
     return this.attribute.numComponents;
   }
+  // Whether the decoded values are known to lie below 2^24 in magnitude (the
+  // range in which the float extraction needs no per-value float32 rounding,
+  // see PointAttribute._lazyFloatValues): true when a prediction transform
+  // clamps them into such a range. Unpredicted values are unbounded.
+  zb() {
+    return this.M !== null && this.M.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).
-  xb(numValues) {
+  vb(numValues) {
     this.attribute.resetLazy(numValues);
     return true;
   }
   // Hands the decoded integer values to the attribute, converted to its
   // integer type on extraction.
-  _a(_numValues) {
+  Ya(_numValues) {
     const dt = this.attribute.dataType;
     if (dt < 1 /* INT8 */ || dt > 6 /* UINT32 */) {
       return false;
     }
-    this.attribute.setLazyInteger(this.R);
+    this.attribute.setLazyInteger(this.U);
     return true;
   }
   preparePortableAttribute(numEntries, numComponents) {
@@ -3526,23 +3501,27 @@ var SequentialIntegerAttributeDecoder = class extends SequentialAttributeDecoder
     portAtt.uniqueId = this.attribute.uniqueId;
     this.$ = portAtt;
     const data = portAtt.buffer.data;
-    this.R = numEntries === 0 ? null : new Int32Array(data.buffer, data.byteOffset + portAtt.byteOffset, numEntries * numComponents);
+    this.U = numEntries === 0 ? null : new Int32Array(data.buffer, data.byteOffset + portAtt.byteOffset, numEntries * numComponents);
   }
 };
 
 // src/decoder/compression/attributes/prediction_schemes/PredictionSchemeNormalOctahedronTransformBase.ts
 var PredictionSchemeNormalOctahedronTransformBase = class {
-  y = new OctahedronToolBox();
+  w = new OctahedronToolBox();
   areCorrectionsPositive() {
     return true;
   }
+  // Outputs are origS/origT + center with origS/origT in [-center, center].
+  boundsValues(limit) {
+    return this.w.aa < limit;
+  }
   /** No-op to fulfill the transform interface. */
   init(_numComponents) {
   }
   quantizationBits() {
-    return this.y.quantizationBits();
+    return this.w.quantizationBits();
   }
-  Bb(maxQuantizedValue) {
+  Ab(maxQuantizedValue) {
     if (maxQuantizedValue % 2 === 0) return false;
     let q = 0;
     let v = maxQuantizedValue;
@@ -3550,7 +3529,7 @@ var PredictionSchemeNormalOctahedronTransformBase = class {
       v >>>= 1;
       q++;
     }
-    return this.y.setQuantizationBits(q);
+    return this.w.setQuantizationBits(q);
   }
 };
 
@@ -3564,14 +3543,14 @@ var PredictionSchemeNormalOctahedronCanonicalizedDecodingTransform = class exten
     if (maxQuantizedValue === void 0) return false;
     const centerValue = buffer.decodeInt32();
     if (centerValue === void 0) return false;
-    if (!this.Bb(maxQuantizedValue)) return false;
-    const q = this.y.quantizationBits();
+    if (!this.Ab(maxQuantizedValue)) return false;
+    const q = this.w.quantizationBits();
     return q >= 2 && q <= 30;
   }
   computeOriginalValue(predVals, predOffset, corrVals, corrOffset, outOrigVals, outOffset) {
-    const toolBox = this.y;
-    const center = toolBox.e;
-    const maxQuantizedValue = toolBox.qa;
+    const toolBox = this.w;
+    const center = toolBox.f;
+    const maxQuantizedValue = toolBox.aa;
     const corrS = corrVals[corrOffset];
     const corrT = corrVals[corrOffset + 1];
     let predS = predVals[predOffset] - center;
@@ -3697,9 +3676,9 @@ var PredictionSchemeNormalOctahedronCanonicalizedDecodingTransform = class exten
   // The arithmetic is computeOriginalValue above verbatim -- keep them in
   // sync; only the plumbing differs.
   computeOriginalValuesDelta(inCorr, outData, size, numComponents) {
-    const toolBox = this.y;
-    const center = toolBox.e;
-    const maxQuantizedValue = toolBox.qa;
+    const toolBox = this.w;
+    const center = toolBox.f;
+    const maxQuantizedValue = toolBox.aa;
     let prevS = 0;
     let prevT = 0;
     for (let i = 0; i < size; i += numComponents) {
@@ -3833,12 +3812,12 @@ var PredictionSchemeNormalOctahedronDecodingTransform = class extends Prediction
   decodeTransformData(buffer) {
     const maxQuantizedValue = buffer.decodeInt32();
     if (maxQuantizedValue === void 0) return false;
-    return this.Bb(maxQuantizedValue);
+    return this.Ab(maxQuantizedValue);
   }
   computeOriginalValue(predVals, predOffset, corrVals, corrOffset, outOrigVals, outOffset) {
-    const toolBox = this.y;
-    const center = toolBox.e;
-    const maxQuantizedValue = toolBox.qa;
+    const toolBox = this.w;
+    const center = toolBox.f;
+    const maxQuantizedValue = toolBox.aa;
     const predS = predVals[predOffset] - center;
     const predT = predVals[predOffset + 1] - center;
     const corrS = corrVals[corrOffset];
@@ -3917,7 +3896,7 @@ var PredictionSchemeNormalOctahedronDecodingTransform = class extends Prediction
 
 // src/decoder/compression/attributes/SequentialNormalAttributeDecoder.ts
 var SequentialNormalAttributeDecoder = class extends SequentialIntegerAttributeDecoder {
-  J = -1;
+  L = -1;
   init(decoder, attributeId) {
     if (!super.init(decoder, attributeId)) {
       return false;
@@ -3932,15 +3911,19 @@ var SequentialNormalAttributeDecoder = class extends SequentialIntegerAttributeD
   decodeDataNeededByPortableTransform(_pointIds, buffer) {
     const qBits = buffer.decodeUint8();
     if (qBits === void 0) return false;
-    this.J = qBits;
+    this.L = qBits;
     return true;
   }
   // The octahedral-to-unit-vector transform is deferred to extractTo (see
   // PointAttribute.setLazyOctahedron).
-  _a(_numPoints) {
-    const q = this.J;
+  Ya(_numPoints) {
+    const q = this.L;
     if (q < 2 || q > 30) return false;
-    this.attribute.setLazyOctahedron(this.R, Math.fround(2 / Math.fround((1 << q) - 2)));
+    this.attribute.setLazyOctahedron(
+      this.U,
+      Math.fround(2 / Math.fround((1 << q) - 2)),
+      this.zb()
+    );
     return true;
   }
   createIntPredictionScheme(method, transformType) {
@@ -3954,9 +3937,9 @@ var SequentialNormalAttributeDecoder = class extends SequentialIntegerAttributeD
 
 // src/decoder/compression/attributes/SequentialQuantizationAttributeDecoder.ts
 var SequentialQuantizationAttributeDecoder = class extends SequentialIntegerAttributeDecoder {
-  J = -1;
-  $a = [];
-  Cb = 0;
+  L = -1;
+  Za = [];
+  Bb = 0;
   init(decoder, attributeId) {
     if (!super.init(decoder, attributeId)) {
       return false;
@@ -3966,39 +3949,39 @@ var SequentialQuantizationAttributeDecoder = class extends SequentialIntegerAttr
   // The quantization parameters (AttributeQuantizationTransform::DecodeParameters).
   decodeDataNeededByPortableTransform(_pointIds, buffer) {
     const numComponents = this.attribute.numComponents;
-    this.$a = new Array(numComponents);
+    this.Za = new Array(numComponents);
     for (let i = 0; i < numComponents; i++) {
       const val = buffer.decodeFloat32();
       if (val === void 0) return false;
-      this.$a[i] = val;
+      this.Za[i] = val;
     }
     const range = buffer.decodeFloat32();
     if (range === void 0) return false;
-    this.Cb = range;
+    this.Bb = range;
     const qBits = buffer.decodeUint8();
     if (qBits === void 0 || qBits < 1 || qBits > 30) return false;
-    this.J = qBits;
+    this.L = qBits;
     return true;
   }
   // Dequantization is deferred to extractTo (see PointAttribute.setLazyQuantized).
-  _a(_numValues) {
-    const maxQuantizedValue = (1 << this.J >>> 0) - 1;
+  Ya(_numValues) {
+    const maxQuantizedValue = (1 << this.L >>> 0) - 1;
     if (maxQuantizedValue <= 0) return false;
-    const delta = Math.fround(this.Cb / Math.fround(maxQuantizedValue));
-    this.attribute.setLazyQuantized(this.R, this.$a, delta);
+    const delta = Math.fround(this.Bb / Math.fround(maxQuantizedValue));
+    this.attribute.setLazyQuantized(this.U, this.Za, delta, this.zb());
     return true;
   }
 };
 
 // src/decoder/compression/attributes/SequentialAttributeDecodersController.ts
 var SequentialAttributeDecodersController = class extends AttributesDecoder {
-  va = [];
+  ua = [];
   // Replaced by the sequencer's output in _prepareSequence.
-  La = new Int32Array(0);
-  S;
+  Ka = new Int32Array(0);
+  V;
   constructor(sequencer) {
     super();
-    this.S = sequencer;
+    this.V = sequencer;
   }
   decodeAttributesDecoderData(buffer) {
     if (!super.decodeAttributesDecoderData(buffer)) {
@@ -4012,19 +3995,19 @@ var SequentialAttributeDecodersController = class extends AttributesDecoder {
       if (decoder === null || !decoder.init(this.getDecoder(), this.getAttributeId(i))) {
         return false;
       }
-      this.va[i] = decoder;
+      this.ua[i] = decoder;
     }
     return true;
   }
-  cc() {
-    if (!this.S.generateSequence()) {
+  ac() {
+    if (!this.V.generateSequence()) {
       return false;
     }
-    this.La = this.S.getOutputPointIds();
+    this.Ka = this.V.getOutputPointIds();
     const numAttributes = this.getNumAttributes();
     for (let i = 0; i < numAttributes; i++) {
       const pa = this.getDecoder().pointCloud().attribute(this.getAttributeId(i));
-      if (!this.S.updatePointToAttributeIndexMapping(pa)) {
+      if (!this.V.updatePointToAttributeIndexMapping(pa)) {
         return false;
       }
     }
@@ -4038,24 +4021,24 @@ 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.cc()) {
+    if (!this.ac()) {
       return false;
     }
-    const decoders = this.va;
+    const decoders = this.ua;
     for (let i = 0; i < decoders.length; i++) {
-      if (!decoders[i].decodePortableAttributeParse(this.La, buffer)) {
+      if (!decoders[i].decodePortableAttributeParse(this.Ka, buffer)) {
         return false;
       }
     }
     for (let i = 0; i < decoders.length; i++) {
-      if (!decoders[i].decodeDataNeededByPortableTransform(this.La, buffer)) {
+      if (!decoders[i].decodeDataNeededByPortableTransform(this.Ka, buffer)) {
         return false;
       }
     }
     return true;
   }
   collectPendingSymbolStreams(out) {
-    const decoders = this.va;
+    const decoders = this.ua;
     for (let i = 0; i < decoders.length; i++) {
       const pending = decoders[i].pendingSymbolStream();
       if (pending !== null) {
@@ -4064,14 +4047,14 @@ var SequentialAttributeDecodersController = class extends AttributesDecoder {
     }
   }
   decodeAttributesFinish() {
-    const decoders = this.va;
+    const decoders = this.ua;
     for (let i = 0; i < decoders.length; i++) {
       if (!decoders[i].decodePortableAttributeFinish()) {
         return false;
       }
     }
     for (let i = 0; i < decoders.length; i++) {
-      if (!decoders[i].transformAttributeToOriginalFormat(this.La)) {
+      if (!decoders[i].transformAttributeToOriginalFormat(this.Ka)) {
         return false;
       }
     }
@@ -4082,7 +4065,7 @@ var SequentialAttributeDecodersController = class extends AttributesDecoder {
     if (locId < 0) {
       return null;
     }
-    return this.va[locId].getPortableAttribute();
+    return this.ua[locId].getPortableAttribute();
   }
   createSequentialDecoder(decoderType) {
     switch (decoderType) {
@@ -4118,30 +4101,30 @@ var TopologySplitEventData = class {
 // src/decoder/compression/mesh/traverser/DepthFirstTraverser.ts
 var kInvalidCornerIndex4 = -1;
 var kInvalidFaceIndex = -1;
-var kInvalidVertexIndex2 = -1;
+var kInvalidVertexIndex = -1;
 var DepthFirstTraverser = class {
   a = null;
-  wa = null;
-  T = null;
-  Db = [];
-  ea = 0;
+  va = null;
+  W = null;
+  Cb = [];
+  da = 0;
   // Identifies the traversal order for the shared traversal cache
   // (MESH_TRAVERSAL_DEPTH_FIRST). See MeshTraversalSequencer.
-  Eb = 0;
+  Db = 0;
   // The sequencer derives the point id sequence from the corner map after
   // the traversal (see traverseFromCorner).
   emitsPointIds = false;
   h = null;
-  p = null;
-  Fb = null;
-  F = 0;
+  o = null;
+  y = null;
+  H = 0;
   init(cornerTable, observer) {
     this.a = cornerTable;
-    this.wa = observer;
+    this.va = observer;
     this.h = cornerTable.cornerToVertexArray();
-    this.p = cornerTable.oppositeCornerArray();
-    this.Fb = cornerTable.vertexLeftmostCornerArray();
-    this.F = cornerTable.numCorners();
+    this.o = cornerTable.oppositeCornerArray();
+    this.y = cornerTable.vertexOnBoundaryArray();
+    this.H = cornerTable.numCorners();
   }
   cornerTable() {
     return this.a;
@@ -4155,8 +4138,8 @@ var DepthFirstTraverser = class {
   // Decode-scoped scratch: released in bulk at the end of the decode.
   onTraversalStart() {
     const cornerTable = this.a;
-    this.T = scratchUint8Zeroed(cornerTable.numFaces());
-    this.Db = scratchInt32(this.F);
+    this.W = scratchUint8Zeroed(cornerTable.numFaces());
+    this.Cb = scratchInt32(this.H);
   }
   // 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
@@ -4165,8 +4148,8 @@ var DepthFirstTraverser = class {
   // was measurable next to the traversal itself.
   traverseAll() {
     const numFaces = this.a.numFaces();
-    const isFaceVisited = this.T;
-    for (let f = 0; f < numFaces && this.ea < numFaces; ++f) {
+    const isFaceVisited = this.W;
+    for (let f = 0; f < numFaces && this.da < numFaces; ++f) {
       if (isFaceVisited[f] === 0 && !this.traverseFromCorner(3 * f)) {
         return false;
       }
@@ -4174,19 +4157,19 @@ var DepthFirstTraverser = class {
     return true;
   }
   traverseFromCorner(cornerId) {
-    if (this.T[cornerId / 3 | 0]) {
+    if (this.W[cornerId / 3 | 0]) {
       return true;
     }
-    const isFaceVisited = this.T;
-    const observer = this.wa;
+    const isFaceVisited = this.W;
+    const observer = this.va;
     const cornerToVertex = this.h;
-    const oppositeCorners = this.p;
-    const vertexLeftmost = this.Fb;
-    const stack = this.Db;
-    let numVisitedFaces = this.ea;
-    const encodingData = observer.z;
-    const encodedToCornerMap = observer.ab;
-    const vertexToEncodedMap = observer.bb;
+    const oppositeCorners = this.o;
+    const vertexOnBoundary = this.y;
+    const stack = this.Cb;
+    let numVisitedFaces = this.da;
+    const encodingData = observer.n;
+    const encodedToCornerMap = observer._a;
+    const vertexToEncodedMap = observer.$a;
     let numValues = encodingData.numValues;
     let stackSize = 0;
     stack[stackSize++] = cornerId;
@@ -4194,7 +4177,7 @@ var DepthFirstTraverser = class {
     const prevCorner = cornerId % 3 === 0 ? cornerId + 2 : cornerId - 1;
     const nextVert = cornerToVertex[nextCorner];
     const prevVert = cornerToVertex[prevCorner];
-    if (nextVert === kInvalidVertexIndex2 || prevVert === kInvalidVertexIndex2) {
+    if (nextVert === kInvalidVertexIndex || prevVert === kInvalidVertexIndex) {
       return false;
     }
     if (vertexToEncodedMap[nextVert] < 0) {
@@ -4216,22 +4199,16 @@ var DepthFirstTraverser = class {
         isFaceVisited[faceId] = 1;
         numVisitedFaces++;
         const vertId = cornerToVertex[cornerId];
-        if (vertId === kInvalidVertexIndex2) {
+        if (vertId === kInvalidVertexIndex) {
           encodingData.numValues = numValues;
           return false;
         }
         const faceBase = faceId * 3;
         const nextCornerId = cornerId === faceBase + 2 ? faceBase : cornerId + 1;
         if (vertexToEncodedMap[vertId] < 0) {
-          const lc = vertexLeftmost[vertId];
-          let onBoundary = true;
-          if (lc >= 0) {
-            const nextLc = lc % 3 === 2 ? lc - 2 : lc + 1;
-            onBoundary = oppositeCorners[nextLc] < 0;
-          }
           encodedToCornerMap[numValues] = cornerId;
           vertexToEncodedMap[vertId] = numValues++;
-          if (!onBoundary) {
+          if (vertexOnBoundary[vertId] === 0) {
             cornerId = oppositeCorners[nextCornerId];
             faceId = cornerId / 3 | 0;
             continue;
@@ -4264,7 +4241,7 @@ var DepthFirstTraverser = class {
         }
       }
     }
-    this.ea = numVisitedFaces;
+    this.da = numVisitedFaces;
     encodingData.numValues = numValues;
     return true;
   }
@@ -4276,51 +4253,51 @@ var kInvalidFaceIndex2 = -1;
 var kMaxPriority = 3;
 var MaxPredictionDegreeTraverser = class {
   a = null;
-  wa = null;
-  T = null;
-  cb = null;
-  ea = 0;
+  va = null;
+  W = null;
+  ab = null;
+  da = 0;
   // One stack (bucket) per priority level [0, kMaxPriority).
-  Ma = null;
-  U = 0;
+  La = null;
+  X = 0;
   // Prediction degree accumulated per vertex during traversal.
-  db = null;
+  bb = null;
   // Flat connectivity arrays (see DepthFirstTraverser for why).
   h = null;
-  p = null;
+  o = null;
   // Identifies the traversal order for the shared traversal cache
   // (MESH_TRAVERSAL_PREDICTION_DEGREE). See MeshTraversalSequencer.
-  Eb = 1;
+  Db = 1;
   // Point ids are appended through the observer as vertices are visited.
   emitsPointIds = true;
   init(cornerTable, observer) {
     this.a = cornerTable;
-    this.wa = observer;
-    this.T = new Uint8Array(cornerTable.numFaces());
-    this.cb = new Uint8Array(cornerTable.numVertices());
+    this.va = observer;
+    this.W = new Uint8Array(cornerTable.numFaces());
+    this.ab = new Uint8Array(cornerTable.numVertices());
     this.h = cornerTable.cornerToVertexArray();
-    this.p = cornerTable.oppositeCornerArray();
-    this.Ma = [[], [], []];
+    this.o = cornerTable.oppositeCornerArray();
+    this.La = [[], [], []];
   }
   cornerTable() {
     return this.a;
   }
   // corner is always valid (>= 0) where these are used.
-  Gb(c) {
+  Eb(c) {
     return c % 3 === 2 ? c - 2 : c + 1;
   }
-  Hb(c) {
+  Fb(c) {
     return c % 3 === 0 ? c + 2 : c - 1;
   }
   onTraversalStart() {
-    this.db = new Int32Array(this.a.numVertices());
+    this.bb = 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.ea < numFaces; ++f) {
+    for (let f = 0; f < numFaces && this.da < numFaces; ++f) {
       if (!this.traverseFromCorner(3 * f)) {
         return false;
       }
@@ -4329,11 +4306,11 @@ var MaxPredictionDegreeTraverser = class {
   }
   // Returns the priority of traversing the edge leading to cornerId. Mutates
   // the prediction degree of the destination vertex.
-  Ib(cornerId) {
+  Gb(cornerId) {
     const vTip = this.h[cornerId];
     let priority = 0;
-    if (!this.cb[vTip]) {
-      const degree = ++this.db[vTip];
+    if (!this.ab[vTip]) {
+      const degree = ++this.bb[vTip];
       priority = degree > 1 ? 1 : 2;
     }
     if (priority >= kMaxPriority) {
@@ -4341,38 +4318,38 @@ var MaxPredictionDegreeTraverser = class {
     }
     return priority;
   }
-  Jb(ci, priority) {
-    this.Ma[priority].push(ci);
-    if (priority < this.U) {
-      this.U = priority;
+  Hb(ci, priority) {
+    this.La[priority].push(ci);
+    if (priority < this.X) {
+      this.X = priority;
     }
   }
   // Retrieves the next available corner to traverse, processed by priority.
   // Returns kInvalidCornerIndex when no corner is available.
-  dc() {
-    for (let i = this.U; i < kMaxPriority; ++i) {
-      const stack = this.Ma[i];
+  bc() {
+    for (let i = this.X; i < kMaxPriority; ++i) {
+      const stack = this.La[i];
       if (stack.length > 0) {
         const ret = stack.pop();
-        this.U = i;
+        this.X = i;
         return ret;
       }
     }
     return kInvalidCornerIndex5;
   }
   traverseFromCorner(cornerId) {
-    if (this.db.length === 0) {
+    if (this.bb.length === 0) {
       return true;
     }
     const cornerToVertex = this.h;
-    const oppositeCorners = this.p;
-    const isFaceVisited = this.T;
-    const isVertexVisited = this.cb;
-    const observer = this.wa;
-    this.Ma[0].push(cornerId);
-    this.U = 0;
-    const firstNext = this.Gb(cornerId);
-    const firstPrev = this.Hb(cornerId);
+    const oppositeCorners = this.o;
+    const isFaceVisited = this.W;
+    const isVertexVisited = this.ab;
+    const observer = this.va;
+    this.La[0].push(cornerId);
+    this.X = 0;
+    const firstNext = this.Eb(cornerId);
+    const firstPrev = this.Fb(cornerId);
     const nextVert = cornerToVertex[firstNext];
     const prevVert = cornerToVertex[firstPrev];
     if (!isVertexVisited[nextVert]) {
@@ -4388,7 +4365,7 @@ var MaxPredictionDegreeTraverser = class {
       isVertexVisited[tipVertex] = 1;
       observer.onNewVertexVisited(tipVertex, cornerId);
     }
-    while ((cornerId = this.dc()) !== kInvalidCornerIndex5) {
+    while ((cornerId = this.bc()) !== kInvalidCornerIndex5) {
       let faceId = cornerId / 3 | 0;
       if (isFaceVisited[faceId]) {
         continue;
@@ -4396,34 +4373,34 @@ var MaxPredictionDegreeTraverser = class {
       while (true) {
         faceId = cornerId / 3 | 0;
         isFaceVisited[faceId] = 1;
-        this.ea++;
+        this.da++;
         const vertId = cornerToVertex[cornerId];
         if (!isVertexVisited[vertId]) {
           isVertexVisited[vertId] = 1;
           observer.onNewVertexVisited(vertId, cornerId);
         }
-        const rightCornerId = oppositeCorners[this.Gb(cornerId)];
-        const leftCornerId = oppositeCorners[this.Hb(cornerId)];
+        const rightCornerId = oppositeCorners[this.Eb(cornerId)];
+        const leftCornerId = oppositeCorners[this.Fb(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.Ib(leftCornerId);
-          if (isRightFaceVisited && priority <= this.U) {
+          const priority = this.Gb(leftCornerId);
+          if (isRightFaceVisited && priority <= this.X) {
             cornerId = leftCornerId;
             continue;
           } else {
-            this.Jb(leftCornerId, priority);
+            this.Hb(leftCornerId, priority);
           }
         }
         if (!isRightFaceVisited) {
-          const priority = this.Ib(rightCornerId);
-          if (priority <= this.U) {
+          const priority = this.Gb(rightCornerId);
+          if (priority <= this.X) {
             cornerId = rightCornerId;
             continue;
           } else {
-            this.Jb(rightCornerId, priority);
+            this.Hb(rightCornerId, priority);
           }
         }
         break;
@@ -4435,67 +4412,67 @@ var MaxPredictionDegreeTraverser = class {
 
 // src/decoder/compression/mesh/traverser/MeshAttributeIndicesEncodingObserver.ts
 var MeshAttributeIndicesEncodingObserver = class {
-  z;
-  S;
-  bb;
-  ab;
-  Kb;
+  n;
+  V;
+  $a;
+  _a;
+  Ib;
   constructor(mesh, sequencer, encodingData) {
-    this.z = encodingData;
-    this.S = sequencer;
-    this.bb = encodingData.vertexToEncodedAttributeValueIndexMap;
-    this.ab = encodingData.encodedAttributeValueIndexToCornerMap;
-    this.Kb = mesh.faces_;
+    this.n = encodingData;
+    this.V = sequencer;
+    this.$a = encodingData.vertexToEncodedAttributeValueIndexMap;
+    this._a = encodingData.encodedAttributeValueIndexToCornerMap;
+    this.Ib = mesh.faces_;
   }
   onNewVertexVisited(vertex, corner) {
-    const pointId = this.Kb[corner];
-    this.S.addPointId(pointId);
-    const numValues = this.z.numValues;
-    this.ab[numValues] = corner;
-    this.bb[vertex] = numValues;
-    this.z.numValues++;
+    const pointId = this.Ib[corner];
+    this.V.addPointId(pointId);
+    const numValues = this.n.numValues;
+    this._a[numValues] = corner;
+    this.$a[vertex] = numValues;
+    this.n.numValues++;
   }
 };
 
 // src/decoder/compression/mesh/traverser/MeshTraversalSequencer.ts
 var MeshTraversalSequencer = class {
-  D;
-  z;
-  xa = null;
+  C;
+  n;
+  wa = null;
   u = new Int32Array(0);
-  ya = 0;
+  xa = 0;
   // Per-decode cache, keyed by corner table, shared across the attribute
   // decoders of one mesh (see MeshEdgebreakerDecoderImpl).
-  eb;
+  cb;
   // The cache entry the last generateSequence resolved to (hit or store);
   // carries the shared indicesMap.
-  fb = null;
+  db = null;
   // One representative corner per point id, when the connectivity decoder
   // recorded them (see MeshEdgebreakerDecoderImpl._assignAttributeVerticesAndPoints).
-  fa;
+  ea;
   constructor(mesh, encodingData, traversalCache, pointCorner) {
-    this.D = mesh;
-    this.z = encodingData;
-    this.eb = traversalCache;
-    this.fa = pointCorner;
+    this.C = mesh;
+    this.n = encodingData;
+    this.cb = traversalCache;
+    this.ea = pointCorner;
   }
   setTraverser(traverser) {
-    this.xa = traverser;
+    this.wa = traverser;
   }
   generateSequence() {
-    const cornerTable = this.xa.cornerTable();
-    const methodId = this.xa.Eb;
+    const cornerTable = this.wa.cornerTable();
+    const methodId = this.wa.Db;
     const cacheKey = cornerTable.cornerToVertexArray();
-    const encodingData = this.z;
-    let byMethod = this.eb.get(cacheKey);
+    const encodingData = this.n;
+    let byMethod = this.cb.get(cacheKey);
     const cached = byMethod && byMethod.get(methodId);
     if (cached !== void 0) {
       this.u = cached.pointIds;
-      encodingData.adoptTraversalResult(cached.vertexMap, cached.cornerMap, cached.numValues);
-      this.fb = cached;
+      encodingData.adoptTraversalResult(cached);
+      this.db = cached;
       return true;
     }
-    if (!this.ec()) {
+    if (!this.cc()) {
       return false;
     }
     const numValues = encodingData.numValues;
@@ -4507,39 +4484,41 @@ var MeshTraversalSequencer = class {
     }
     if (byMethod === void 0) {
       byMethod = /* @__PURE__ */ new Map();
-      this.eb.set(cacheKey, byMethod);
+      this.cb.set(cacheKey, byMethod);
     }
     const entry = {
       pointIds: this.u,
       vertexMap: encodingData.vertexToEncodedAttributeValueIndexMap,
       cornerMap: encodingData.encodedAttributeValueIndexToCornerMap,
       numValues,
-      indicesMap: null
+      indicesMap: null,
+      parents: null
     };
     byMethod.set(methodId, entry);
-    this.fb = entry;
+    encodingData.cacheEntry = entry;
+    this.db = entry;
     return true;
   }
   getOutputPointIds() {
     return this.u;
   }
   addPointId(pointId) {
-    this.u[this.ya++] = pointId;
+    this.u[this.xa++] = pointId;
   }
   updatePointToAttributeIndexMapping(attribute) {
-    const entry = this.fb;
+    const entry = this.db;
     if (entry !== null && entry.indicesMap !== null) {
       attribute.setExplicitMappingShared(entry.indicesMap);
       return true;
     }
-    const cornerTable = this.xa.cornerTable();
-    const numFaces = this.D.numFaces();
-    const numPoints = this.D.numPoints();
+    const cornerTable = this.wa.cornerTable();
+    const numFaces = this.C.numFaces();
+    const numPoints = this.C.numPoints();
     attribute.setExplicitMappingUnfilled(numPoints);
     const cornerToVertex = cornerTable.cornerToVertexArray();
-    const vertexToAttEntry = this.z.vertexToEncodedAttributeValueIndexMap;
+    const vertexToAttEntry = this.n.vertexToEncodedAttributeValueIndexMap;
     const indicesMap = attribute.indicesMap;
-    const pointCorner = this.fa;
+    const pointCorner = this.ea;
     if (pointCorner !== null) {
       for (let p = 0; p < numPoints; ++p) {
         const vertId = cornerToVertex[pointCorner[p]];
@@ -4554,7 +4533,7 @@ var MeshTraversalSequencer = class {
       }
     } else {
       const numCorners = numFaces * 3;
-      const faces = this.D.faces_;
+      const faces = this.C.faces_;
       for (let ci = 0; ci < numCorners; ++ci) {
         const vertId = cornerToVertex[ci];
         if (vertId < 0) {
@@ -4573,26 +4552,26 @@ var MeshTraversalSequencer = class {
     }
     return true;
   }
-  ec() {
-    this.ya = 0;
-    this.u = scratchInt32(this.D.numPoints());
-    const traverser = this.xa;
+  cc() {
+    this.xa = 0;
+    this.u = scratchInt32(this.C.numPoints());
+    const traverser = this.wa;
     traverser.onTraversalStart();
     if (!traverser.traverseAll()) {
       return false;
     }
     if (!traverser.emitsPointIds) {
-      const numValues = this.z.numValues;
-      const cornerMap = this.z.encodedAttributeValueIndexToCornerMap;
-      const faces = this.D.faces_;
+      const numValues = this.n.numValues;
+      const cornerMap = this.n.encodedAttributeValueIndexToCornerMap;
+      const faces = this.C.faces_;
       const outPointIds = this.u;
       for (let i = 0; i < numValues; ++i) {
         outPointIds[i] = faces[cornerMap[i]];
       }
-      this.ya = numValues;
+      this.xa = numValues;
     }
-    if (this.ya < this.u.length) {
-      this.u = this.u.subarray(0, this.ya);
+    if (this.xa < this.u.length) {
+      this.u = this.u.subarray(0, this.xa);
     }
     return true;
   }
@@ -4603,30 +4582,30 @@ var kInvalidCornerIndex6 = -1;
 var MeshEdgebreakerDecoderImpl = class {
   l;
   a = null;
-  K = [];
-  ga = new Uint8Array(0);
-  V = 0;
-  gb = new MeshAttributeIndicesEncodingData();
-  Lb = -1;
+  N = [];
+  fa = new Uint8Array(0);
+  Y = 0;
+  eb = new MeshAttributeIndicesEncodingData();
+  Jb = -1;
   // Cache of vertex-traversal results keyed by corner table, so attributes
   // sharing connectivity traverse once.
-  fc = /* @__PURE__ */ new Map();
+  dc = /* @__PURE__ */ new Map();
   g = [];
-  G;
+  I;
   // One corner per point id (decode-scoped scratch), filled by
   // _assignAttributeVerticesAndPoints; null when points are the base vertices.
-  fa = null;
+  ea = null;
   // Corners on a boundary edge, counted by _decodeAttributeConnectivities.
-  Mb = 0;
+  Kb = 0;
   constructor(decoder, TraversalDecoderClass) {
     this.l = decoder;
-    this.G = new TraversalDecoderClass();
+    this.I = new TraversalDecoderClass();
   }
   getCornerTable() {
     return this.a;
   }
   // The attribute data set whose attributes decoder owns attId, if any.
-  Nb(attId) {
+  Lb(attId) {
     for (let i = 0; i < this.g.length; ++i) {
       const ad = this.g[i];
       if (ad.decoderId < 0 || ad.decoderId >= this.l.numAttributesDecoders()) {
@@ -4642,12 +4621,12 @@ var MeshEdgebreakerDecoderImpl = class {
     return null;
   }
   getAttributeCornerTable(attId) {
-    const ad = this.Nb(attId);
+    const ad = this.Lb(attId);
     return ad !== null && ad.isConnectivityUsed ? ad.connectivityData : null;
   }
   getAttributeEncodingData(attId) {
-    const ad = this.Nb(attId);
-    return ad !== null ? ad.encodingData : this.gb;
+    const ad = this.Lb(attId);
+    return ad !== null ? ad.encodingData : this.eb;
   }
   createAttributesDecoder(attDecoderId) {
     const buffer = this.l.buffer();
@@ -4665,10 +4644,10 @@ var MeshEdgebreakerDecoderImpl = class {
       }
       this.g[attDataId].decoderId = attDecoderId;
     } else {
-      if (this.Lb >= 0) {
+      if (this.Jb >= 0) {
         return false;
       }
-      this.Lb = attDecoderId;
+      this.Jb = attDecoderId;
     }
     const traversalMethod = buffer.decodeUint8();
     if (traversalMethod === void 0 || traversalMethod >= 2 /* NUM_TRAVERSAL_METHODS */) {
@@ -4678,7 +4657,7 @@ var MeshEdgebreakerDecoderImpl = class {
     let cornerTable;
     if (decoderType === 0 /* MESH_VERTEX_ATTRIBUTE */) {
       if (attDataId < 0) {
-        encodingData = this.gb;
+        encodingData = this.eb;
       } else {
         encodingData = this.g[attDataId].encodingData;
         this.g[attDataId].isConnectivityUsed = false;
@@ -4689,12 +4668,12 @@ var MeshEdgebreakerDecoderImpl = class {
         return false;
       }
       const ad = this.g[attDataId];
-      if (ad.noInteriorSeams) this.gc(ad);
+      if (ad.noInteriorSeams) this.ec(ad);
       encodingData = ad.encodingData;
       cornerTable = ad.connectivityData;
     }
     const mesh = this.l.mesh();
-    const sequencer = new MeshTraversalSequencer(mesh, encodingData, this.fc, this.fa);
+    const sequencer = new MeshTraversalSequencer(mesh, encodingData, this.dc, 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);
@@ -4705,17 +4684,17 @@ var MeshEdgebreakerDecoderImpl = class {
     const buffer = this.l.buffer();
     const numEncodedVertices = decodeVarint(buffer);
     if (numEncodedVertices === void 0) return false;
-    this.V = numEncodedVertices;
+    this.Y = numEncodedVertices;
     const numFaces = decodeVarint(buffer);
     if (numFaces === void 0) return false;
     if (numFaces > 2147483647 / 3) {
       return false;
     }
-    if (this.V > numFaces * 3) {
+    if (this.Y > numFaces * 3) {
       return false;
     }
     const minNumFaceEdges = Math.floor(3 * numFaces / 2);
-    const maxNumVertexEdges = this.V * (this.V - 1) / 2;
+    const maxNumVertexEdges = this.Y * (this.Y - 1) / 2;
     if (maxNumVertexEdges < minNumFaceEdges) {
       return false;
     }
@@ -4742,29 +4721,31 @@ var MeshEdgebreakerDecoderImpl = class {
       ad.numSeamCorners = 0;
       this.g.push(ad);
     }
-    this.a.reset(numFaces, this.V + numEncodedSplitSymbols);
-    this.ga = scratchUint8Filled(this.V + numEncodedSplitSymbols, 1);
-    if (!this.hc(buffer)) {
+    this.a.reset(numFaces, this.Y + numEncodedSplitSymbols);
+    this.fa = scratchUint8Filled(this.Y + numEncodedSplitSymbols, 1);
+    if (!this.fc(buffer)) {
       return false;
     }
-    this.G.init(this);
-    this.G.setNumEncodedVertices(this.V + numEncodedSplitSymbols);
-    this.G.setNumAttributeData(numAttributeData);
+    this.I.init(this);
+    this.I.setNumEncodedVertices(this.Y + numEncodedSplitSymbols);
+    this.I.setNumAttributeData(numAttributeData);
     const traversalEndBuffer = new DecoderBuffer();
-    if (!this.G.start(traversalEndBuffer)) {
+    if (!this.I.start(traversalEndBuffer)) {
       return false;
     }
-    const numConnectivityVerts = this.ic(numEncodedSymbols);
+    const numConnectivityVerts = this.gc(numEncodedSymbols);
     if (numConnectivityVerts === -1) {
       return false;
     }
     buffer.init(traversalEndBuffer.dataHead, traversalEndBuffer.remainingSize);
+    this.a.finishBoundaries();
     if (this.g.length > 0) {
-      this.jc();
+      this.hc();
     }
-    this.G.done();
-    const numBoundaryCorners = this.Mb;
+    this.I.done();
+    const numBoundaryCorners = this.Kb;
     const distinctTables = [];
+    const seamEdgeCounts = [];
     const adoptions = [];
     let previousConnectivityData = null;
     let previousSeamCorners = null;
@@ -4791,25 +4772,25 @@ var MeshEdgebreakerDecoderImpl = class {
         adoptions.push(connectivityData, previousConnectivityData);
       } else {
         connectivityData.initEmpty(this.a);
-        connectivityData.reserveSeamEdges(seamCount);
         for (let s = 0; s < seamCount; ++s) {
           connectivityData.addSeamEdge(seamCorners[s]);
         }
         distinctTables.push(connectivityData);
+        seamEdgeCounts.push(seamCount);
       }
       previousConnectivityData = connectivityData;
       previousSeamCorners = seamCorners;
       previousSeamCount = seamCount;
     }
     if (this.g.length === 0) {
-      this.kc(numConnectivityVerts);
-    } else if (!this.lc(distinctTables)) {
+      this.ic(numConnectivityVerts);
+    } else if (!this.jc(distinctTables, seamEdgeCounts)) {
       return false;
     }
     for (let i = 0; i < adoptions.length; i += 2) {
       adoptions[i].adoptFrom(adoptions[i + 1]);
     }
-    this.gb.init(this.a.numVertices());
+    this.eb.init(this.a.numVertices());
     for (let i = 0; i < this.g.length; ++i) {
       let attConnectivityVerts = this.g[i].connectivityData.numVertices();
       if (attConnectivityVerts < this.a.numVertices()) {
@@ -4819,11 +4800,11 @@ var MeshEdgebreakerDecoderImpl = class {
     }
     return true;
   }
-  mc(encoderSymbolId, outResult) {
-    if (this.K.length === 0) {
+  kc(encoderSymbolId, outResult) {
+    if (this.N.length === 0) {
       return false;
     }
-    const back = this.K[this.K.length - 1];
+    const back = this.N[this.N.length - 1];
     if (back.sourceSymbolId > encoderSymbolId) {
       outResult.encoderSplitSymbolId = -1;
       return true;
@@ -4833,24 +4814,24 @@ var MeshEdgebreakerDecoderImpl = class {
     }
     outResult.faceEdge = back.sourceEdge;
     outResult.encoderSplitSymbolId = back.splitSymbolId;
-    this.K.pop();
+    this.N.pop();
     return true;
   }
-  ic(numSymbols) {
-    const activeCornerStack = scratchInt32(numSymbols + this.K.length + 16);
+  gc(numSymbols) {
+    const activeCornerStack = scratchInt32(numSymbols + this.N.length + 16);
     let activeCornerStackSize = 0;
     const topologySplitActiveCorners = /* @__PURE__ */ new Map();
     const splitResult = { faceEdge: 0, encoderSplitSymbolId: 0 };
     const invalidVertices = [];
     const removeInvalidVertices = this.g.length === 0;
-    let maxNumVertices = this.ga.length;
+    let maxNumVertices = this.fa.length;
     let numFacesDecoded = 0;
     const cornerToVertex = this.a.h;
-    const oppositeCorners = this.a.p;
+    const oppositeCorners = this.a.o;
     const vc = this.a;
-    let vertexCorners = vc.v;
-    const isVertHole = this.ga;
-    const traversalDecoder = this.G;
+    let vertexCorners = vc.s;
+    const isVertHole = this.fa;
+    const traversalDecoder = this.I;
     for (let symbolId = 0; symbolId < numSymbols; ++symbolId) {
       const faceIndex = numFacesDecoded++;
       let checkTopologySplit = false;
@@ -4902,13 +4883,13 @@ var MeshEdgebreakerDecoderImpl = class {
         oppositeCorners[oppCorner] = cornerA;
         oppositeCorners[cornerA] = oppCorner;
         let newVertIndex;
-        if (vc.j < vertexCorners.length) {
-          newVertIndex = vc.j++;
+        if (vc.i < vertexCorners.length) {
+          newVertIndex = vc.i++;
         } else {
           newVertIndex = vc.addNewVertex();
-          vertexCorners = vc.v;
+          vertexCorners = vc.s;
         }
-        if (vc.j > maxNumVertices) return -1;
+        if (vc.i > maxNumVertices) return -1;
         cornerToVertex[oppCorner] = newVertIndex;
         vertexCorners[newVertIndex] = oppCorner;
         const pA = cornerA % 3 === 0 ? cornerA + 2 : cornerA - 1;
@@ -4969,16 +4950,16 @@ var MeshEdgebreakerDecoderImpl = class {
       } else if (symbol === TOPOLOGY_E) {
         const corner = 3 * faceIndex;
         let firstVertIndex;
-        if (vc.j + 3 <= vertexCorners.length) {
-          firstVertIndex = vc.j;
-          vc.j += 3;
+        if (vc.i + 3 <= vertexCorners.length) {
+          firstVertIndex = vc.i;
+          vc.i += 3;
         } else {
           firstVertIndex = vc.addNewVertex();
           vc.addNewVertex();
           vc.addNewVertex();
-          vertexCorners = vc.v;
+          vertexCorners = vc.s;
         }
-        if (vc.j > maxNumVertices) return -1;
+        if (vc.i > maxNumVertices) return -1;
         cornerToVertex[corner] = firstVertIndex;
         cornerToVertex[corner + 1] = firstVertIndex + 1;
         cornerToVertex[corner + 2] = firstVertIndex + 2;
@@ -4991,9 +4972,9 @@ var MeshEdgebreakerDecoderImpl = class {
         return -1;
       }
       traversalDecoder.newActiveCornerReached(activeCornerStack[activeCornerStackSize - 1]);
-      if (checkTopologySplit && this.K.length > 0) {
+      if (checkTopologySplit && this.N.length > 0) {
         const encoderSymbolId = numSymbols - symbolId - 1;
-        while (this.mc(encoderSymbolId, splitResult)) {
+        while (this.kc(encoderSymbolId, splitResult)) {
           if (splitResult.encoderSplitSymbolId < 0) return -1;
           const actTopCorner = activeCornerStack[activeCornerStackSize - 1];
           let newActiveCorner;
@@ -5007,27 +4988,27 @@ var MeshEdgebreakerDecoderImpl = class {
         }
       }
     }
-    if (vc.j > maxNumVertices) {
+    if (vc.i > maxNumVertices) {
       return -1;
     }
-    numFacesDecoded = this.nc(activeCornerStack, activeCornerStackSize, numFacesDecoded);
+    numFacesDecoded = this.lc(activeCornerStack, activeCornerStackSize, numFacesDecoded);
     if (numFacesDecoded === -1) {
       return -1;
     }
     if (numFacesDecoded !== this.a.numFaces()) {
       return -1;
     }
-    return this.oc(invalidVertices);
+    return this.mc(invalidVertices);
   }
   // Connects the remaining active-stack corners to newly decoded start faces.
   // Returns the updated decoded-face count, or -1 on malformed input.
-  nc(activeCornerStack, activeCornerStackSize, numFacesDecoded) {
+  lc(activeCornerStack, activeCornerStackSize, numFacesDecoded) {
     const ct = this.a;
-    const oppositeCorners = ct.p;
+    const oppositeCorners = ct.o;
     const cornerToVertex = ct.h;
-    const vertexCorners = ct.v;
-    const isVertHole = this.ga;
-    const traversalDecoder = this.G;
+    const vertexCorners = ct.s;
+    const isVertHole = this.fa;
+    const traversalDecoder = this.I;
     const numCorners = ct.numCorners();
     const numFaces = ct.numFaces();
     const next = (c) => c < 0 ? -1 : c % 3 === 2 ? c - 2 : c + 1;
@@ -5075,11 +5056,11 @@ var MeshEdgebreakerDecoderImpl = class {
   // Removes invalid (isolated) vertices by swapping them with the last valid
   // vertex in the table, matching C++ mesh_edgebreaker_decoder_impl.cc (the
   // forward iteration order matters). Returns the final vertex count, or -1.
-  oc(invalidVertices) {
+  mc(invalidVertices) {
     const ct = this.a;
     const cornerToVertex = ct.h;
-    const vertexCorners = ct.v;
-    const isVertHole = this.ga;
+    const vertexCorners = ct.s;
+    const isVertHole = this.fa;
     const leftMostCorner = (v) => v < 0 || v >= vertexCorners.length ? -1 : vertexCorners[v];
     let numVertices = ct.numVertices();
     for (let ivIdx = 0; ivIdx < invalidVertices.length; ++ivIdx) {
@@ -5121,7 +5102,7 @@ var MeshEdgebreakerDecoderImpl = class {
   }
   // Hole events were removed from the bitstream in 2.1; for 2.2 this only
   // decodes the inline topology-split events.
-  hc(decoderBuffer) {
+  fc(decoderBuffer) {
     const numTopologySplits = decodeVarint(decoderBuffer);
     if (numTopologySplits === void 0) return false;
     if (numTopologySplits > 0) {
@@ -5139,12 +5120,12 @@ var MeshEdgebreakerDecoderImpl = class {
         if (delta2 > eventData.sourceSymbolId) return false;
         eventData.splitSymbolId = eventData.sourceSymbolId - delta2;
         lastSourceSymbolId = eventData.sourceSymbolId;
-        this.K.push(eventData);
+        this.N.push(eventData);
       }
       decoderBuffer.startBitDecoding(false);
       for (let i = 0; i < numTopologySplits; ++i) {
         const edgeData = decoderBuffer.decodeLeastSignificantBits32(1);
-        this.K[i].sourceEdge = edgeData & 1;
+        this.N[i].sourceEdge = edgeData & 1;
       }
       decoderBuffer.endBitDecoding();
     }
@@ -5162,11 +5143,11 @@ var MeshEdgebreakerDecoderImpl = class {
   // 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.
-  jc() {
+  hc() {
     const oppositeCorners = this.a.oppositeCornerArray();
     const attributeData = this.g;
     const numAttrData = attributeData.length;
-    const connectivityDecoders = this.G.Ob;
+    const connectivityDecoders = this.I.Mb;
     const numCorners = this.a.numCorners();
     const candidates = scratchInt32(numCorners);
     let numCandidates = 0;
@@ -5185,42 +5166,24 @@ var MeshEdgebreakerDecoderImpl = class {
       numCandidates -= (opp | corner - opp - 1) >> 31;
       numBoundaryCorners -= opp >> 31;
     }
-    this.Mb = numBoundaryCorners;
-    for (let i = 0; i < numAttrData; ++i) {
-      const ad = attributeData[i];
-      const seamCorners = ad.attributeSeamCorners;
-      let numSeamCorners = ad.numSeamCorners;
-      const decoder = connectivityDecoders[i];
-      const ans = decoder.Va;
-      const p = decoder.Wa;
-      const buf = ans.buf;
-      const bufStart = ans.bufStart;
-      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];
-        }
-        const rem = state & 255;
-        const xn = (state >>> 8) * p;
-        const mask = rem - p >> 31;
-        const stateIfZero = state - xn - p;
-        state = stateIfZero + (mask & xn + rem - stateIfZero);
-        seamCorners[numSeamCorners] = cc;
-        numSeamCorners -= mask;
-      }
-      ans.state = state;
-      ans.bufOffset = bufOffset;
-      ad.numSeamCorners = numSeamCorners;
+    this.Kb = numBoundaryCorners;
+    let i = 0;
+    for (; i + 2 <= numAttrData; i += 2) {
+      decodeSeamBits2(
+        candidates,
+        numCandidates,
+        attributeData[i],
+        connectivityDecoders[i],
+        attributeData[i + 1],
+        connectivityDecoders[i + 1]
+      );
+    }
+    if (i < numAttrData) {
+      decodeSeamBits1(candidates, numCandidates, attributeData[i], connectivityDecoders[i]);
     }
   }
   // Position-only connectivity: vertex indices equal point indices.
-  kc(numConnectivityVerts) {
+  ic(numConnectivityVerts) {
     const mesh = this.l.mesh();
     const ct = this.a;
     mesh.setNumFaces(ct.numFaces());
@@ -5230,58 +5193,48 @@ var MeshEdgebreakerDecoderImpl = class {
     for (let c = 0; c < numCorners; ++c) {
       faces[c] = baseCornerToVertex[c];
     }
-    this.fa = null;
+    this.ea = null;
     this.l.pointCloud().setNumPoints(numConnectivityVerts);
   }
-  // Builds an attribute corner table whose only seams are boundary edges (see
-  // decodeConnectivity), for a per-corner decoder that asked for it. With no
-  // interior seam every vertex ring is one attribute vertex, numbered in
-  // vertex order with isolated vertices skipped -- what the ring walk in
-  // _assignAttributeVerticesAndPoints assigns such a table, without the walk.
-  gc(ad) {
-    const ct = this.a;
-    const table = ad.connectivityData;
-    table.initEmpty(ct);
-    table.reserveSeamEdges(ad.numSeamCorners);
-    for (let s = 0; s < ad.numSeamCorners; ++s) table.addSeamEdge(ad.attributeSeamCorners[s]);
-    const numVertices = ct.numVertices();
-    const numCorners = ct.numCorners();
-    const vertexLeftmost = ct.vertexLeftmostCornerArray();
-    const cornerToVertex = ct.cornerToVertexArray();
-    const vertexIds = scratchInt32(numVertices);
-    const leftMost = scratchInt32(numVertices);
-    let numAttVertices = 0;
-    for (let v = 0; v < numVertices; ++v) {
-      const c = vertexLeftmost[v];
-      vertexIds[v] = c === kInvalidCornerIndex6 ? -1 : numAttVertices;
-      if (c !== kInvalidCornerIndex6) leftMost[numAttVertices++] = c;
-    }
-    const c2v = table.Z;
-    for (let c = 0; c < numCorners; ++c) c2v[c] = vertexIds[cornerToVertex[c]];
-    table.setRecomputedVertices(leftMost, numAttVertices);
+  // Sets up an attribute corner table whose only seams are boundary edges
+  // (see decodeConnectivity), for a per-corner decoder that asked for it:
+  // the base connectivity itself.
+  ec(ad) {
+    ad.connectivityData.initAsBase(this.a);
     ad.noInteriorSeams = false;
   }
-  // One walk around every vertex ring that (a) numbers the attribute vertices
-  // of every distinct attribute corner table (C++ MeshAttributeCornerTable::
-  // RecomputeVertices, one per table) and (b) assigns the mesh's point ids
-  // (C++ AssignPointsToCorners). Each of those is a per-vertex procedure that
-  // only reads the ring's own corners and its table's running counter, so
-  // running them side by side on one buffered ring produces exactly the ids
-  // the separate passes would -- while the ring's corner chain (a serial,
-  // cache-missing pointer chase through swingRight) is followed once instead
-  // of once per table plus once for the points. Also records one corner per
-  // point (_pointCorner) so point-to-value maps can be built per point rather
-  // than per corner (see MeshTraversalSequencer).
+  // One walk around the ring of every seam vertex that (a) numbers the
+  // attribute vertices of every distinct attribute corner table (C++
+  // MeshAttributeCornerTable::RecomputeVertices, one per table) and (b)
+  // assigns the mesh's point ids (C++ AssignPointsToCorners). Each of those
+  // is a per-vertex procedure that only reads the ring's own corners and its
+  // table's running counter, so running them side by side on one buffered
+  // ring produces exactly the ids the separate passes would -- while the
+  // ring's corner chain (a serial, cache-missing pointer chase through
+  // swingRight) is followed once instead of once per table plus once for the
+  // points. Also records one corner per point (_pointCorner) so
+  // point-to-value maps can be built per point rather than per corner (see
+  // MeshTraversalSequencer).
+  //
+  // A vertex on no table's seam -- interior or on a boundary -- is one
+  // attribute vertex per table and one point whatever its ring holds (the
+  // C++ passes swing right from its leftmost corner and never meet a split),
+  // so it needs no walk at all: every table starts as a copy of the base
+  // numbering (see MeshAttributeCornerTable.initEmpty), its point id is taken
+  // in vertex order here, and its corners get that id in a sequential pass
+  // after the loop (or none at all, when the points turn out to be the base
+  // vertices). Attribute vertex ids need not be compact (only their identity
+  // is ever used), so a seam vertex keeps its base id for its first
+  // sub-vertex and the further sub-vertices take fresh ids past the base
+  // vertex count; the ring walk only rewrites those corners.
   //
   // The buffered ring makes the swing-left prefix of the seam-vertex recompute
   // an index walk: swingLeft(ring[j]) is ring[j - 1] (the opposite table is
-  // symmetric), and for a closed ring ring[k - 1] when j is 0. An open ring
-  // whose leftmost corner still has a left neighbor (never the case for the
-  // corner table the edgebreaker decoder builds, which keeps the left-most
-  // corner of every boundary vertex, but allowed for by the C++ code) is
-  // extended leftwards first, so the walk covers exactly the corners the
-  // separate passes would have reached.
-  lc(tables) {
+  // symmetric), and for a closed ring ring[k - 1] when j is 0. The C++ walks
+  // start at the vertex's leftmost corner and only ever swing right from it
+  // (or left through the seam-aware table, which stops at the boundary), so
+  // an open ring is walked from that corner too.
+  jc(tables, seamEdgeCounts) {
     const mesh = this.l.mesh();
     const ct = this.a;
     mesh.setNumFaces(ct.numFaces());
@@ -5290,18 +5243,23 @@ var MeshEdgebreakerDecoderImpl = class {
     const faces = mesh.faces_;
     const vertexLeftmost = ct.vertexLeftmostCornerArray();
     const baseOpposite = ct.oppositeCornerArray();
-    const isVertHole = this.ga;
+    const baseCornerToVertex = ct.cornerToVertexArray();
+    const isVertHole = this.fa;
+    const baseOnBoundary = ct.vertexOnBoundaryArray();
     const numTables = tables.length;
     const attCornerToVertex = new Array(numTables);
-    const edgeOnSeam = new Array(numTables);
+    const attOpposite = new Array(numTables);
     const vertexOnSeam = new Array(numTables);
-    const leftMostMaps = new Array(numTables);
-    const numAttVertices = new Int32Array(numTables);
+    const onBoundaryMaps = new Array(numTables);
+    const numExtraVertices = new Int32Array(numTables);
     for (let t = 0; t < numTables; ++t) {
-      attCornerToVertex[t] = tables[t].Z;
-      edgeOnSeam[t] = tables[t].Y;
-      vertexOnSeam[t] = tables[t].ma;
-      leftMostMaps[t] = scratchInt32(numCorners);
+      attCornerToVertex[t] = tables[t].S;
+      attOpposite[t] = tables[t].E;
+      vertexOnSeam[t] = tables[t].la;
+      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);
@@ -5309,12 +5267,10 @@ var MeshEdgebreakerDecoderImpl = class {
     const idChange = scratchUint8Zeroed(numCorners);
     let numPoints = 0;
     const plainPointId = scratchInt32(numVertices);
-    const plainVertIds = new Array(numTables);
-    for (let t = 0; t < numTables; ++t) plainVertIds[t] = scratchInt32(numVertices);
+    let numWalked = 0;
     for (let v = 0; v < numVertices; ++v) {
       const c = vertexLeftmost[v];
       if (c === kInvalidCornerIndex6) continue;
-      const hole = isVertHole[v] !== 0;
       let anySeam = false;
       for (let t = 0; t < numTables; ++t) {
         if (vertexOnSeam[t][v] !== 0) {
@@ -5322,20 +5278,14 @@ var MeshEdgebreakerDecoderImpl = class {
           break;
         }
       }
-      if (!hole && !anySeam) {
-        for (let t = 0; t < numTables; ++t) {
-          const vertId = numAttVertices[t];
-          leftMostMaps[t][vertId] = c;
-          plainVertIds[t][v] = vertId;
-          numAttVertices[t] = vertId + 1;
-        }
+      if (!anySeam) {
         const pointId2 = numPoints++;
         pointCorner[pointId2] = c;
         plainPointId[v] = pointId2;
         continue;
       }
       plainPointId[v] = -1;
-      let start = 0;
+      numWalked++;
       let k = 0;
       let actC = c;
       for (; ; ) {
@@ -5352,50 +5302,14 @@ var MeshEdgebreakerDecoderImpl = class {
         if (k === numCorners) return false;
       }
       const closed = actC === c;
-      if (!closed) {
-        const o = baseOpposite[ringNext[0]];
-        let left = o < 0 ? kInvalidCornerIndex6 : o % 3 === 2 ? o - 2 : o + 1;
-        if (left !== kInvalidCornerIndex6) {
-          let m = 0;
-          let cur = left;
-          while (cur !== kInvalidCornerIndex6 && cur !== c) {
-            if (k + ++m > numCorners) return false;
-            const ln = cur % 3 === 2 ? cur - 2 : cur + 1;
-            const lo = baseOpposite[ln];
-            cur = lo < 0 ? kInvalidCornerIndex6 : lo % 3 === 2 ? lo - 2 : lo + 1;
-          }
-          for (let j2 = k - 1; j2 >= 0; --j2) {
-            ring[j2 + m] = ring[j2];
-            ringNext[j2 + m] = ringNext[j2];
-          }
-          cur = left;
-          for (let i = 1; i <= m; ++i) {
-            const ln = cur % 3 === 2 ? cur - 2 : cur + 1;
-            ring[m - i] = cur;
-            ringNext[m - i] = ln;
-            const lo = baseOpposite[ln];
-            cur = lo < 0 ? kInvalidCornerIndex6 : lo % 3 === 2 ? lo - 2 : lo + 1;
-          }
-          start = m;
-          k += m;
-        }
-      }
       const end = k;
       for (let t = 0; t < numTables; ++t) {
+        if (vertexOnSeam[t][v] === 0) continue;
         const c2v = attCornerToVertex[t];
-        const leftMostMap = leftMostMaps[t];
-        let vertId = numAttVertices[t];
-        if (vertexOnSeam[t][v] === 0) {
-          leftMostMap[vertId] = c;
-          for (let j3 = start; j3 < end; ++j3) c2v[ring[j3]] = vertId;
-          numAttVertices[t] = vertId + 1;
-          continue;
-        }
-        const isEdgeOnSeam = edgeOnSeam[t];
-        let j2 = start;
+        const opposite = attOpposite[t];
+        let j2 = 0;
         for (; ; ) {
-          const rn = ringNext[j2];
-          if (isEdgeOnSeam[rn] !== 0 || baseOpposite[rn] < 0) break;
+          if (opposite[ringNext[j2]] < 0) break;
           if (j2 > 0) {
             --j2;
           } else if (closed) {
@@ -5403,39 +5317,39 @@ var MeshEdgebreakerDecoderImpl = class {
           } else {
             break;
           }
-          if (j2 === start) return false;
+          if (j2 === 0) return false;
         }
         const first = ring[j2];
-        const firstVertId = vertId;
-        c2v[first] = vertId;
-        leftMostMap[vertId] = first;
+        let vertId = v;
+        onBoundaryMaps[t][v] = 1;
+        let numExtra = numExtraVertices[t];
         const steps2 = closed ? end - 1 : end - 1 - j2;
         for (let s = 0; s < steps2; ++s) {
           if (++j2 === end) j2 = 0;
           const rc = ring[j2];
-          if (isEdgeOnSeam[ringNext[j2]] !== 0) {
-            leftMostMap[++vertId] = rc;
+          if (opposite[ringNext[j2]] < 0) {
+            vertId = numVertices + numExtra++;
             idChange[rc] = 1;
           }
           c2v[rc] = vertId;
         }
-        if (vertId !== firstVertId) idChange[first] = 1;
-        numAttVertices[t] = vertId + 1;
+        if (vertId !== v) idChange[first] = 1;
+        numExtraVertices[t] = numExtra;
       }
-      let j = start;
-      if (!hole) {
+      let j = 0;
+      if (isVertHole[v] === 0) {
         for (let t = 0; t < numTables; ++t) {
           if (vertexOnSeam[t][v] === 0) continue;
           const c2v = attCornerToVertex[t];
           const vertId = c2v[c];
-          let jj = start;
+          let jj = 0;
           let found = false;
           for (; ; ) {
             if (++jj === end) {
               if (!closed) return false;
               jj = 0;
             }
-            if (jj === start) break;
+            if (jj === 0) break;
             if (c2v[ring[jj]] !== vertId) {
               found = true;
               break;
@@ -5461,38 +5375,125 @@ var MeshEdgebreakerDecoderImpl = class {
         faces[rc] = pointId;
       }
     }
-    const baseCornerToVertex = ct.cornerToVertexArray();
-    for (let c = 0; c < numCorners; ++c) {
-      const v = baseCornerToVertex[c];
-      const pointId = plainPointId[v];
-      if (pointId < 0) continue;
-      faces[c] = pointId;
-      for (let t = 0; t < numTables; ++t) attCornerToVertex[t][c] = plainVertIds[t][v];
+    if (numWalked === 0 && numPoints === numVertices) {
+      faces.set(baseCornerToVertex);
+    } else {
+      for (let c = 0; c < numCorners; ++c) {
+        const pointId = plainPointId[baseCornerToVertex[c]];
+        if (pointId >= 0) faces[c] = pointId;
+      }
     }
     for (let t = 0; t < numTables; ++t) {
-      tables[t].setRecomputedVertices(leftMostMaps[t], numAttVertices[t]);
+      tables[t].setRecomputedVertices(onBoundaryMaps[t], numVertices + numExtraVertices[t]);
     }
-    this.fa = pointCorner;
+    this.ea = pointCorner;
     this.l.pointCloud().setNumPoints(numPoints);
     return true;
   }
 };
+function decodeSeamBits1(candidates, numCandidates, ad, decoder) {
+  const seamCorners = ad.attributeSeamCorners;
+  let numSeamCorners = ad.numSeamCorners;
+  const ans = decoder.oa;
+  const p = decoder.pa;
+  const buf = ans.buf;
+  const bufStart = ans.bufStart;
+  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];
+    }
+    const rem = state & 255;
+    const xn = (state >>> 8) * p;
+    const mask = rem - p >> 31;
+    const stateIfZero = state - xn - p;
+    state = stateIfZero + (mask & xn + rem - stateIfZero);
+    seamCorners[numSeamCorners] = cc;
+    numSeamCorners -= mask;
+  }
+  ans.state = state;
+  ans.bufOffset = bufOffset;
+  ad.numSeamCorners = numSeamCorners;
+}
+function decodeSeamBits2(candidates, numCandidates, ad0, decoder0, ad1, decoder1) {
+  const seam0 = ad0.attributeSeamCorners;
+  const seam1 = ad1.attributeSeamCorners;
+  let num0 = ad0.numSeamCorners;
+  let num1 = ad1.numSeamCorners;
+  const ans0 = decoder0.oa;
+  const ans1 = decoder1.oa;
+  const p0 = decoder0.pa;
+  const p1 = decoder1.pa;
+  const buf0 = ans0.buf;
+  const buf1 = ans1.buf;
+  const start0 = ans0.bufStart;
+  const start1 = ans1.bufStart;
+  let state0 = ans0.state;
+  let state1 = ans1.state;
+  let off0 = ans0.bufOffset;
+  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];
+    }
+    if (state1 < ANS_L_BASE && off1 > start1) {
+      state1 = state1 << 8 | buf1[--off1];
+    }
+    const rem0 = state0 & 255;
+    const rem1 = state1 & 255;
+    const xn0 = (state0 >>> 8) * p0;
+    const xn1 = (state1 >>> 8) * p1;
+    const mask0 = rem0 - p0 >> 31;
+    const mask1 = rem1 - p1 >> 31;
+    const zero0 = state0 - xn0 - p0;
+    const zero1 = state1 - xn1 - p1;
+    state0 = zero0 + (mask0 & xn0 + rem0 - zero0);
+    state1 = zero1 + (mask1 & xn1 + rem1 - zero1);
+    seam0[num0] = cc;
+    seam1[num1] = cc;
+    num0 -= mask0;
+    num1 -= mask1;
+  }
+  ans0.state = state0;
+  ans0.bufOffset = off0;
+  ad0.numSeamCorners = num0;
+  ans1.state = state1;
+  ans1.bufOffset = off1;
+  ad1.numSeamCorners = num1;
+}
 var MeshAttributeIndicesEncodingData = class {
   vertexToEncodedAttributeValueIndexMap = new Int32Array(0);
   encodedAttributeValueIndexToCornerMap = new Int32Array(0);
   numValues = 0;
+  // The traversal cache entry the maps came from (see MeshTraversalSequencer);
+  // carries what later passes derive from the traversal and share.
+  cacheEntry = null;
   init(numVertices) {
     this.vertexToEncodedAttributeValueIndexMap = scratchInt32Filled(numVertices, -1);
     this.encodedAttributeValueIndexToCornerMap = scratchInt32(numVertices);
     this.numValues = 0;
+    this.cacheEntry = null;
   }
   // Adopts a traversal result from an identical corner table, avoiding a
   // redundant traversal. The maps depend only on connectivity and are read-only
   // downstream, so sharing is safe.
-  adoptTraversalResult(vertexToEncodedMap, encodedToCornerMap, numValues) {
-    this.vertexToEncodedAttributeValueIndexMap = vertexToEncodedMap;
-    this.encodedAttributeValueIndexToCornerMap = encodedToCornerMap;
-    this.numValues = numValues;
+  adoptTraversalResult(entry) {
+    this.vertexToEncodedAttributeValueIndexMap = entry.vertexMap;
+    this.encodedAttributeValueIndexToCornerMap = entry.cornerMap;
+    this.numValues = entry.numValues;
+    this.cacheEntry = entry;
   }
 };
 var AttributeData = class {
@@ -5507,31 +5508,36 @@ var AttributeData = class {
   noInteriorSeams = false;
 };
 var CornerTable = class {
-  Pb = 0;
-  F = 0;
-  j = 0;
+  Nb = 0;
+  H = 0;
+  i = 0;
   h = null;
   // corner -> vertex
-  p = null;
+  o = null;
   // corner -> opposite corner
-  v = null;
+  s = 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.
+  y = null;
   reset(numFaces, numVertices) {
-    this.Pb = numFaces;
-    this.F = numFaces * 3;
-    this.j = 0;
-    this.h = scratchInt32Filled(this.F, -1);
-    this.p = scratchInt32Filled(this.F, -1);
-    this.v = scratchInt32Filled(numVertices, -1);
+    this.Nb = numFaces;
+    this.H = numFaces * 3;
+    this.i = 0;
+    this.h = scratchInt32Filled(this.H, -1);
+    this.o = scratchInt32Filled(this.H, -1);
+    this.s = scratchInt32Filled(numVertices, -1);
   }
   numFaces() {
-    return this.Pb;
+    return this.Nb;
   }
   numCorners() {
-    return this.F;
+    return this.H;
   }
   numVertices() {
-    return this.j;
+    return this.i;
   }
   next(corner) {
     if (corner < 0) return -1;
@@ -5544,34 +5550,50 @@ var CornerTable = class {
     return rem === 0 ? corner + 2 : corner - 1;
   }
   vertex(corner) {
-    if (corner < 0 || corner >= this.F) return -1;
+    if (corner < 0 || corner >= this.H) return -1;
     return this.h[corner];
   }
   opposite(corner) {
-    if (corner < 0 || corner >= this.F) return -1;
-    return this.p[corner];
+    if (corner < 0 || corner >= this.H) return -1;
+    return this.o[corner];
   }
   // Flat-array accessors; let callers avoid polymorphic per-corner dispatch.
   cornerToVertexArray() {
     return this.h;
   }
   oppositeCornerArray() {
-    return this.p;
+    return this.o;
   }
   vertexLeftmostCornerArray() {
-    return this.v;
+    return this.s;
+  }
+  vertexOnBoundaryArray() {
+    return this.y;
+  }
+  // Derives _vertexOnBoundary from the finished connectivity (decode-scoped
+  // scratch). Isolated vertices count as boundary; they are never traversed.
+  finishBoundaries() {
+    const numVertices = this.i;
+    const vertexCorners = this.s;
+    const oppositeCorners = this.o;
+    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.y = onBoundary;
   }
   // Mirrors C++ CornerTable::AddNewVertex() (push_back(kInvalidCornerIndex)).
   addNewVertex() {
-    const newVertex = this.j;
-    this.j++;
-    if (newVertex >= this.v.length) {
-      const newCapacity = Math.max(newVertex + 1, this.v.length * 2, 64);
+    const newVertex = this.i;
+    this.i++;
+    if (newVertex >= this.s.length) {
+      const newCapacity = Math.max(newVertex + 1, this.s.length * 2, 64);
       const newArr = scratchInt32Filled(newCapacity, -1);
-      newArr.set(this.v);
-      this.v = newArr;
+      newArr.set(this.s);
+      this.s = newArr;
     }
-    this.v[newVertex] = -1;
+    this.s[newVertex] = -1;
     return newVertex;
   }
   // Next corner around a vertex, CCW. SwingLeft(c) = Next(Opposite(Next(c))).
@@ -5593,14 +5615,14 @@ var CornerTable = class {
 // src/decoder/compression/mesh/MeshEdgebreakerTraversalDecoder.ts
 var MeshEdgebreakerTraversalDecoder = class {
   c = new DecoderBuffer();
-  H = new DecoderBuffer();
-  hb = null;
-  Ob = [];
-  Qb = 0;
+  J = new DecoderBuffer();
+  fb = null;
+  Mb = [];
+  Ob = 0;
   // _symbolBuffer's bit cursor, captured once bit decoding starts: decodeSymbol
   // runs per decoded face and would otherwise reach it through two property
   // loads and a method call per read.
-  Rb = null;
+  Pb = null;
   init(decoder) {
     const srcBuffer = decoder.l.buffer();
     this.c.init(srcBuffer.dataHead, srcBuffer.remainingSize);
@@ -5609,7 +5631,7 @@ var MeshEdgebreakerTraversalDecoder = class {
   setNumEncodedVertices(_numVertices) {
   }
   setNumAttributeData(numData) {
-    this.Qb = numData;
+    this.Ob = numData;
   }
   // Sets outBuffer to the data encoded after the traversal section.
   start(outBuffer) {
@@ -5626,29 +5648,29 @@ var MeshEdgebreakerTraversalDecoder = class {
     return true;
   }
   decodeStartFaceConfiguration() {
-    return this.hb.decodeNextBit();
+    return this.fb.decodeNextBit();
   }
   decodeSymbol() {
-    const bd = this.Rb;
+    const bd = this.Pb;
     if (bd !== null) {
-      const buf = bd.Ea;
-      const off = bd.o;
+      const buf = bd.Da;
+      const off = bd.p;
       const byteOffset = off >> 3;
-      if (byteOffset + 4 < bd.ka) {
+      if (byteOffset + 4 < bd.ja) {
         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.o = off + 1;
+          bd.p = off + 1;
           return TOPOLOGY_C;
         }
-        bd.o = off + 3;
+        bd.p = off + 3;
         return bits;
       }
     }
-    let symbol = this.H.decodeLeastSignificantBits32(1);
+    let symbol = this.J.decodeLeastSignificantBits32(1);
     if (symbol === TOPOLOGY_C) {
       return symbol;
     }
-    const symbolSuffix = this.H.decodeLeastSignificantBits32(2);
+    const symbolSuffix = this.J.decodeLeastSignificantBits32(2);
     symbol |= symbolSuffix << 1;
     return symbol;
   }
@@ -5657,18 +5679,18 @@ var MeshEdgebreakerTraversalDecoder = class {
   mergeVertices(_dest, _source) {
   }
   done() {
-    if (this.H.bitDecoderActive) {
-      this.H.endBitDecoding();
+    if (this.J.bitDecoderActive) {
+      this.J.endBitDecoding();
     }
   }
   decodeTraversalSymbols() {
-    this.H.init(this.c.dataHead, this.c.remainingSize);
-    const traversalSize = this.H.startBitDecoding(true);
+    this.J.init(this.c.dataHead, this.c.remainingSize);
+    const traversalSize = this.J.startBitDecoding(true);
     if (traversalSize === void 0) {
       return false;
     }
-    this.Rb = this.H.la;
-    this.c.init(this.H.dataHead, this.H.remainingSize);
+    this.Pb = this.J.ka;
+    this.c.init(this.J.dataHead, this.J.remainingSize);
     if (traversalSize > this.c.remainingSize) {
       return false;
     }
@@ -5677,19 +5699,19 @@ var MeshEdgebreakerTraversalDecoder = class {
   }
   decodeStartFaces() {
     try {
-      this.hb = new RAnsBitDecoder();
-      return this.hb.startDecoding(this.c);
+      this.fb = new RAnsBitDecoder();
+      return this.fb.startDecoding(this.c);
     } catch {
       return false;
     }
   }
   decodeAttributeSeams() {
-    for (let i = 0; i < this.Qb; ++i) {
+    for (let i = 0; i < this.Ob; ++i) {
       const decoder = new RAnsBitDecoder();
       if (!decoder.startDecoding(this.c)) {
         return false;
       }
-      this.Ob.push(decoder);
+      this.Mb.push(decoder);
     }
     return true;
   }
@@ -5698,17 +5720,17 @@ var MeshEdgebreakerTraversalDecoder = class {
 // src/decoder/compression/mesh/MeshEdgebreakerTraversalPredictiveDecoder.ts
 var MeshEdgebreakerTraversalPredictiveDecoder = class extends MeshEdgebreakerTraversalDecoder {
   a = null;
-  j = 0;
+  i = 0;
   x = -1;
-  ha = -1;
-  i = [];
-  ib = null;
+  ga = -1;
+  j = [];
+  gb = null;
   init(decoder) {
     super.init(decoder);
     this.a = decoder.getCornerTable();
   }
   setNumEncodedVertices(numVertices) {
-    this.j = numVertices;
+    this.i = numVertices;
   }
   start(outBuffer) {
     if (!super.start(outBuffer)) {
@@ -5718,18 +5740,18 @@ var MeshEdgebreakerTraversalPredictiveDecoder = class extends MeshEdgebreakerTra
     if (numSplitSymbols === void 0 || numSplitSymbols < 0) {
       return false;
     }
-    if (numSplitSymbols >= this.j) {
+    if (numSplitSymbols >= this.i) {
       return false;
     }
-    this.i = new Array(this.j).fill(0);
-    this.ib = new RAnsBitDecoder();
-    return this.ib.startDecoding(outBuffer);
+    this.j = new Array(this.i).fill(0);
+    this.gb = new RAnsBitDecoder();
+    return this.gb.startDecoding(outBuffer);
   }
   decodeSymbol() {
-    if (this.ha !== -1) {
-      if (this.ib.decodeNextBit()) {
-        this.x = this.ha;
-        return this.ha;
+    if (this.ga !== -1) {
+      if (this.gb.decodeNextBit()) {
+        this.x = this.ga;
+        return this.ga;
       }
     }
     this.x = super.decodeSymbol();
@@ -5742,55 +5764,55 @@ var MeshEdgebreakerTraversalPredictiveDecoder = class extends MeshEdgebreakerTra
     switch (this.x) {
       case TOPOLOGY_C:
       case TOPOLOGY_S:
-        this.i[ct.vertex(next)] += 1;
-        this.i[ct.vertex(prev)] += 1;
+        this.j[ct.vertex(next)] += 1;
+        this.j[ct.vertex(prev)] += 1;
         break;
       case TOPOLOGY_R:
-        this.i[ct.vertex(corner)] += 1;
-        this.i[ct.vertex(next)] += 1;
-        this.i[ct.vertex(prev)] += 2;
+        this.j[ct.vertex(corner)] += 1;
+        this.j[ct.vertex(next)] += 1;
+        this.j[ct.vertex(prev)] += 2;
         break;
       case TOPOLOGY_L:
-        this.i[ct.vertex(corner)] += 1;
-        this.i[ct.vertex(next)] += 2;
-        this.i[ct.vertex(prev)] += 1;
+        this.j[ct.vertex(corner)] += 1;
+        this.j[ct.vertex(next)] += 2;
+        this.j[ct.vertex(prev)] += 1;
         break;
       case TOPOLOGY_E:
-        this.i[ct.vertex(corner)] += 2;
-        this.i[ct.vertex(next)] += 2;
-        this.i[ct.vertex(prev)] += 2;
+        this.j[ct.vertex(corner)] += 2;
+        this.j[ct.vertex(next)] += 2;
+        this.j[ct.vertex(prev)] += 2;
         break;
       default:
         break;
     }
     if (this.x === TOPOLOGY_C || this.x === TOPOLOGY_R) {
       const pivot = ct.vertex(ct.next(corner));
-      if (this.i[pivot] < 6) {
-        this.ha = TOPOLOGY_R;
+      if (this.j[pivot] < 6) {
+        this.ga = TOPOLOGY_R;
       } else {
-        this.ha = TOPOLOGY_C;
+        this.ga = TOPOLOGY_C;
       }
     } else {
-      this.ha = -1;
+      this.ga = -1;
     }
   }
   mergeVertices(dest, source) {
-    this.i[dest] += this.i[source];
+    this.j[dest] += this.j[source];
   }
 };
 
 // src/decoder/compression/mesh/MeshEdgebreakerTraversalValenceDecoder.ts
 var MeshEdgebreakerTraversalValenceDecoder = class extends MeshEdgebreakerTraversalDecoder {
   a = null;
-  j = 0;
+  i = 0;
   x = -1;
-  Na = -1;
-  Oa = 2;
-  jb = 7;
-  i = new Int32Array(0);
-  ia = [];
+  Ma = -1;
+  Na = 2;
+  hb = 7;
+  j = new Int32Array(0);
+  ha = [];
   // Int32Array, not number[]: read and written once per decoded symbol.
-  za = new Int32Array(0);
+  ya = new Int32Array(0);
   // 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
@@ -5802,7 +5824,7 @@ var MeshEdgebreakerTraversalValenceDecoder = class extends MeshEdgebreakerTraver
     this.h = this.a.h;
   }
   setNumEncodedVertices(numVertices) {
-    this.j = numVertices;
+    this.i = numVertices;
   }
   start(outBuffer) {
     if (!this.decodeStartFaces()) {
@@ -5812,11 +5834,12 @@ var MeshEdgebreakerTraversalValenceDecoder = class extends MeshEdgebreakerTraver
       return false;
     }
     outBuffer.init(this.c.dataHead, this.c.remainingSize);
-    this.i = scratchInt32Filled(this.j, 0);
-    const numUniqueValences = this.jb - this.Oa + 1;
-    this.ia = new Array(numUniqueValences);
-    this.za = new Int32Array(numUniqueValences);
+    this.j = scratchInt32Filled(this.i, 0);
+    const numUniqueValences = this.hb - this.Na + 1;
+    this.ha = new Array(numUniqueValences);
+    this.ya = new Int32Array(numUniqueValences);
     const pending = [];
+    const streams = [];
     for (let i = 0; i < numUniqueValences; ++i) {
       const numSymbols = decodeVarint(outBuffer);
       if (numSymbols === void 0) {
@@ -5826,13 +5849,13 @@ var MeshEdgebreakerTraversalValenceDecoder = class extends MeshEdgebreakerTraver
         return false;
       }
       if (numSymbols > 0) {
-        this.ia[i] = scratchUint32(numSymbols);
+        this.ha[i] = scratchUint32(numSymbols);
         const scheme = outBuffer.decodeUint8();
         if (scheme === 0 /* SYMBOL_CODING_TAGGED */) {
-          if (!decodeTaggedSymbols(numSymbols, 1, outBuffer, this.ia[i])) {
+          if (!decodeTaggedSymbols(numSymbols, 1, outBuffer, this.ha[i])) {
             return false;
           }
-          this.za[i] = numSymbols;
+          this.ya[i] = numSymbols;
           continue;
         }
         if (scheme !== 1 /* SYMBOL_CODING_RAW */) {
@@ -5852,56 +5875,25 @@ var MeshEdgebreakerTraversalValenceDecoder = class extends MeshEdgebreakerTraver
         if (!decoder.startDecoding(outBuffer)) {
           return false;
         }
-        pending.push({ decoder, out: this.ia[i], count: numSymbols });
-        this.za[i] = numSymbols;
+        pending.push(decoder);
+        streams.push({ ans: decoder.G, out: this.ha[i], count: numSymbols });
+        this.ya[i] = numSymbols;
       } else {
-        this.ia[i] = new Uint32Array(0);
-        this.za[i] = 0;
-      }
-    }
-    const lockstep = pending.filter((entry) => !entry.decoder.m.coarse);
-    let p = 0;
-    while (lockstep.length - p >= 3) {
-      const a = lockstep[p];
-      const b = lockstep[p + 1];
-      const c = lockstep[p + 2];
-      ransDecodeSymbolsTrioU16(
-        a.decoder.m,
-        a.out,
-        a.count,
-        b.decoder.m,
-        b.out,
-        b.count,
-        c.decoder.m,
-        c.out,
-        c.count
-      );
-      p += 3;
-    }
-    if (lockstep.length - p === 2) {
-      const a = lockstep[p];
-      const b = lockstep[p + 1];
-      ransDecodeSymbolsPairU16(a.decoder.m, a.out, a.count, b.decoder.m, b.out, b.count);
-      p += 2;
-    }
-    for (; p < lockstep.length; ++p) {
-      lockstep[p].decoder.m.decodeSymbols(lockstep[p].out, lockstep[p].count);
-    }
-    for (const entry of pending) {
-      if (entry.decoder.m.coarse) {
-        entry.decoder.m.decodeSymbols(entry.out, entry.count);
+        this.ha[i] = new Uint32Array(0);
+        this.ya[i] = 0;
       }
-      entry.decoder.endDecoding();
     }
+    ransDecodeStreams(streams);
+    for (const decoder of pending) decoder.endDecoding();
     return true;
   }
   decodeSymbol() {
-    if (this.Na !== -1) {
-      const contextCounter = --this.za[this.Na];
+    if (this.Ma !== -1) {
+      const contextCounter = --this.ya[this.Ma];
       if (contextCounter < 0) {
         return TOPOLOGY_INVALID;
       }
-      const symbolId = this.ia[this.Na][contextCounter];
+      const symbolId = this.ha[this.Ma][contextCounter];
       if (symbolId > 4) {
         return TOPOLOGY_INVALID;
       }
@@ -5913,7 +5905,7 @@ var MeshEdgebreakerTraversalValenceDecoder = class extends MeshEdgebreakerTraver
   }
   newActiveCornerReached(corner) {
     const cornerToVertex = this.h;
-    const valences = this.i;
+    const valences = this.j;
     const next = corner % 3 === 2 ? corner - 2 : corner + 1;
     const prev = corner % 3 === 0 ? corner + 2 : corner - 1;
     const vertNext = cornerToVertex[next];
@@ -5944,32 +5936,32 @@ var MeshEdgebreakerTraversalValenceDecoder = class extends MeshEdgebreakerTraver
     }
     const activeValence = valences[vertNext];
     let clampedValence;
-    if (activeValence < this.Oa) {
-      clampedValence = this.Oa;
-    } else if (activeValence > this.jb) {
-      clampedValence = this.jb;
+    if (activeValence < this.Na) {
+      clampedValence = this.Na;
+    } else if (activeValence > this.hb) {
+      clampedValence = this.hb;
     } else {
       clampedValence = activeValence;
     }
-    this.Na = clampedValence - this.Oa;
+    this.Ma = clampedValence - this.Na;
   }
   mergeVertices(dest, source) {
-    this.i[dest] += this.i[source];
+    this.j[dest] += this.j[source];
   }
 };
 
 // src/decoder/compression/mesh/MeshEdgebreakerDecoder.ts
 var MeshEdgebreakerDecoder = class extends MeshDecoder {
   // Set by initializeDecoder(), which runs before anything below is reached.
-  ja = null;
+  ia = null;
   getCornerTable() {
-    return this.ja.getCornerTable();
+    return this.ia.getCornerTable();
   }
   getAttributeCornerTable(attId) {
-    return this.ja.getAttributeCornerTable(attId);
+    return this.ia.getAttributeCornerTable(attId);
   }
   getAttributeEncodingData(attId) {
-    return this.ja.getAttributeEncodingData(attId);
+    return this.ia.getAttributeEncodingData(attId);
   }
   initializeDecoder() {
     const traversalDecoderType = this.buffer().decodeUint8();
@@ -5977,30 +5969,30 @@ var MeshEdgebreakerDecoder = class extends MeshDecoder {
     if (TraversalDecoderClass === null) {
       return false;
     }
-    this.ja = new MeshEdgebreakerDecoderImpl(this, TraversalDecoderClass);
+    this.ia = new MeshEdgebreakerDecoderImpl(this, TraversalDecoderClass);
     return true;
   }
   createAttributesDecoder(attDecoderId) {
-    return this.ja.createAttributesDecoder(attDecoderId);
+    return this.ia.createAttributesDecoder(attDecoderId);
   }
   decodeConnectivity() {
-    return this.ja.decodeConnectivity();
+    return this.ia.decodeConnectivity();
   }
 };
 
 // src/decoder/compression/attributes/LinearSequencer.ts
 var LinearSequencer = class {
-  Pa;
+  Oa;
   u = new Int32Array(0);
   constructor(numPoints) {
-    this.Pa = numPoints;
+    this.Oa = numPoints;
   }
   generateSequence() {
-    if (this.Pa < 0) {
+    if (this.Oa < 0) {
       return false;
     }
-    const ids = new Int32Array(this.Pa);
-    for (let i = 0; i < this.Pa; ++i) {
+    const ids = new Int32Array(this.Oa);
+    for (let i = 0; i < this.Oa; ++i) {
       ids[i] = i;
     }
     this.u = ids;
@@ -6034,7 +6026,7 @@ var MeshSequentialDecoder = class extends MeshDecoder {
       return false;
     }
     if (connectivityMethod === 0) {
-      if (!this.pc(numFaces)) {
+      if (!this.nc(numFaces)) {
         return false;
       }
     } else {
@@ -6073,7 +6065,7 @@ var MeshSequentialDecoder = class extends MeshDecoder {
       new SequentialAttributeDecodersController(new LinearSequencer(this.pointCloud().numPoints()))
     );
   }
-  pc(numFaces) {
+  nc(numFaces) {
     const numIndices = numFaces * 3;
     const indicesBuffer = new Uint32Array(numIndices);
     if (!decodeSymbols(numIndices, 1, this.buffer(), indicesBuffer)) {