@cloudbitmaps/roaring 0.24.0 → 0.26.0

package/dist/bin/export-segments.js

@@ -26,7 +26,7 @@ import {
   MAX_LEASE_MS,
   NotFoundError,
   UnsupportedError as UnsupportedError2,
-  ValidationError as ValidationError6,
+  ValidationError as ValidationError5,
   errorKind,
   WriteConflictError,
   checkBudget,
@@ -129,14 +129,99 @@ function refuseReservedNamespace(namespace) {
   }
 }
 
-// src/roaring-codec.ts
-import { ValidationError as ValidationError3, decodeSerialized } from "@cloudbitmaps/core";
-
 // src/ts-roaring/bitmap.ts
-import { IntegrityError as IntegrityError3, ValidationError as ValidationError2 } from "@cloudbitmaps/core";
+import { IntegrityError as IntegrityError3, ValidationError as ValidationError2, refusalOfId } from "@cloudbitmaps/core";
 
 // src/portable/layout.ts
 import { IntegrityError } from "@cloudbitmaps/core";
+
+// src/portable/popcount.ts
+var BITSET_WORDS = 2048;
+function popcount32(word) {
+  let w = word - (word >>> 1 & 1431655765);
+  w = (w & 858993459) + (w >>> 2 & 858993459);
+  return Math.imul(w + (w >>> 4) & 252645135, 16843009) >>> 24;
+}
+function popcountWords(d) {
+  let total = 0;
+  let ones = 0;
+  let twos = 0;
+  let fours = 0;
+  let eights = 0;
+  for (let i = 0; i < BITSET_WORDS; i += 16) {
+    let u;
+    let twosA;
+    let twosB;
+    let foursA;
+    let foursB;
+    let x = d[i];
+    let y = d[i + 1];
+    u = ones ^ x;
+    twosA = ones & x | u & y;
+    ones = u ^ y;
+    x = d[i + 2];
+    y = d[i + 3];
+    u = ones ^ x;
+    twosB = ones & x | u & y;
+    ones = u ^ y;
+    u = twos ^ twosA;
+    foursA = twos & twosA | u & twosB;
+    twos = u ^ twosB;
+    x = d[i + 4];
+    y = d[i + 5];
+    u = ones ^ x;
+    twosA = ones & x | u & y;
+    ones = u ^ y;
+    x = d[i + 6];
+    y = d[i + 7];
+    u = ones ^ x;
+    twosB = ones & x | u & y;
+    ones = u ^ y;
+    u = twos ^ twosA;
+    foursB = twos & twosA | u & twosB;
+    twos = u ^ twosB;
+    u = fours ^ foursA;
+    const eightsA = fours & foursA | u & foursB;
+    fours = u ^ foursB;
+    x = d[i + 8];
+    y = d[i + 9];
+    u = ones ^ x;
+    twosA = ones & x | u & y;
+    ones = u ^ y;
+    x = d[i + 10];
+    y = d[i + 11];
+    u = ones ^ x;
+    twosB = ones & x | u & y;
+    ones = u ^ y;
+    u = twos ^ twosA;
+    foursA = twos & twosA | u & twosB;
+    twos = u ^ twosB;
+    x = d[i + 12];
+    y = d[i + 13];
+    u = ones ^ x;
+    twosA = ones & x | u & y;
+    ones = u ^ y;
+    x = d[i + 14];
+    y = d[i + 15];
+    u = ones ^ x;
+    twosB = ones & x | u & y;
+    ones = u ^ y;
+    u = twos ^ twosA;
+    foursB = twos & twosA | u & twosB;
+    twos = u ^ twosB;
+    u = fours ^ foursA;
+    const eightsB = fours & foursA | u & foursB;
+    fours = u ^ foursB;
+    u = eights ^ eightsA;
+    const sixteens = eights & eightsA | u & eightsB;
+    eights = u ^ eightsB;
+    total += popcount32(sixteens);
+  }
+  return 16 * total + 8 * popcount32(eights) + 4 * popcount32(fours) + 2 * popcount32(twos) + popcount32(ones);
+}
+
+// src/portable/layout.ts
+var LITTLE_ENDIAN = new Uint8Array(Uint16Array.of(1).buffer)[0] === 1;
 var SERIAL_COOKIE_NO_RUNCONTAINER = 12346;
 var SERIAL_COOKIE = 12347;
 var NO_OFFSET_THRESHOLD = 4;
@@ -201,7 +286,7 @@ function walk(bytes, out) {
     const key = view.getUint16(descriptiveAt + i * 4, true);
     if (key <= previousKey) {
       throw new IntegrityError(
-        `portable roaring: container keys are not strictly ascending (${previousKey} then ${key} at index ${i})`
+        `portable roaring: container keys are not strictly ascending at index ${i}`
       );
     }
     previousKey = key;
@@ -234,7 +319,7 @@ function checkContainer(bytes, view, pos, kind, cardinality, i) {
     if (pos + BITMAP_CONTAINER_BYTES > length) {
       throw overrun(bytes, pos, BITMAP_CONTAINER_BYTES, `container ${i} (bitmap)`);
     }
-    const bits = popcount(view, pos);
+    const bits = bitsetBits(bytes, pos);
     if (bits !== cardinality) {
       throw new IntegrityError(
         `portable roaring: container ${i} (bitmap) holds ${bits} values, but its header says ${cardinality}`
@@ -294,25 +379,22 @@ function checkRuns(view, at, runs, index) {
   }
   return covered;
 }
-function popcount(view, at) {
-  let bits = 0;
-  for (let p = at, end = at + BITMAP_CONTAINER_BYTES; p < end; p += 4) {
-    let w = view.getUint32(p, true);
-    w -= w >>> 1 & 1431655765;
-    w = (w & 858993459) + (w >>> 2 & 858993459);
-    bits += Math.imul(w + (w >>> 4) & 252645135, 16843009) >>> 24;
-  }
-  return bits;
+function bitsetBits(bytes, at) {
+  const offset = bytes.byteOffset + at;
+  if ((offset & 3) === 0) return popcountWords(new Uint32Array(bytes.buffer, offset, BITSET_WORDS));
+  scratchBytes.set(bytes.subarray(at, at + BITMAP_CONTAINER_BYTES));
+  return popcountWords(scratchWords);
 }
+var scratchWords = new Uint32Array(BITSET_WORDS);
+var scratchBytes = new Uint8Array(scratchWords.buffer);
 
 // src/ts-roaring/containers.ts
 var ARRAY2 = 0;
 var BITSET = 1;
 var RUN2 = 2;
-var WORDS = 2048;
+var WORDS = BITSET_WORDS;
 var BITSET_BYTES = 8192;
 var GALLOP_SKEW = 16;
-var LITTLE_ENDIAN = new Uint8Array(Uint16Array.of(1).buffer)[0] === 1;
 var Container = class {
   constructor(kind, data, off, len, card, shared) {
     this.kind = kind;
@@ -362,12 +444,7 @@ function pairs16(n) {
 function arrayOfScratch(scratch, n) {
   return n === 0 ? null : arrayContainer(scratch.slice(0, n), n);
 }
-function popcount32(word) {
-  let w = word - (word >>> 1 & 1431655765);
-  w = (w & 858993459) + (w >>> 2 & 858993459);
-  return Math.imul(w + (w >>> 4) & 252645135, 16843009) >>> 24;
-}
-function popcountWords(d) {
+function popcountAnd(d, e) {
   let total = 0;
   let ones = 0;
   let twos = 0;
@@ -379,26 +456,26 @@ function popcountWords(d) {
     let twosB;
     let foursA;
     let foursB;
-    let x = d[i];
-    let y = d[i + 1];
+    let x = d[i] & e[i];
+    let y = d[i + 1] & e[i + 1];
     u = ones ^ x;
     twosA = ones & x | u & y;
     ones = u ^ y;
-    x = d[i + 2];
-    y = d[i + 3];
+    x = d[i + 2] & e[i + 2];
+    y = d[i + 3] & e[i + 3];
     u = ones ^ x;
     twosB = ones & x | u & y;
     ones = u ^ y;
     u = twos ^ twosA;
     foursA = twos & twosA | u & twosB;
     twos = u ^ twosB;
-    x = d[i + 4];
-    y = d[i + 5];
+    x = d[i + 4] & e[i + 4];
+    y = d[i + 5] & e[i + 5];
     u = ones ^ x;
     twosA = ones & x | u & y;
     ones = u ^ y;
-    x = d[i + 6];
-    y = d[i + 7];
+    x = d[i + 6] & e[i + 6];
+    y = d[i + 7] & e[i + 7];
     u = ones ^ x;
     twosB = ones & x | u & y;
     ones = u ^ y;
@@ -408,26 +485,26 @@ function popcountWords(d) {
     u = fours ^ foursA;
     const eightsA = fours & foursA | u & foursB;
     fours = u ^ foursB;
-    x = d[i + 8];
-    y = d[i + 9];
+    x = d[i + 8] & e[i + 8];
+    y = d[i + 9] & e[i + 9];
     u = ones ^ x;
     twosA = ones & x | u & y;
     ones = u ^ y;
-    x = d[i + 10];
-    y = d[i + 11];
+    x = d[i + 10] & e[i + 10];
+    y = d[i + 11] & e[i + 11];
     u = ones ^ x;
     twosB = ones & x | u & y;
     ones = u ^ y;
     u = twos ^ twosA;
     foursA = twos & twosA | u & twosB;
     twos = u ^ twosB;
-    x = d[i + 12];
-    y = d[i + 13];
+    x = d[i + 12] & e[i + 12];
+    y = d[i + 13] & e[i + 13];
     u = ones ^ x;
     twosA = ones & x | u & y;
     ones = u ^ y;
-    x = d[i + 14];
-    y = d[i + 15];
+    x = d[i + 14] & e[i + 14];
+    y = d[i + 15] & e[i + 15];
     u = ones ^ x;
     twosB = ones & x | u & y;
     ones = u ^ y;
@@ -470,6 +547,19 @@ function clearRange(words, start, end) {
   for (let i = first + 1; i < last; i++) words[i] = 0;
   words[last] = words[last] & ~tail;
 }
+function flipRange(words, start, end) {
+  const first = start >>> 5;
+  const last = end >>> 5;
+  const head = 4294967295 << (start & 31) >>> 0;
+  const tail = 4294967295 >>> 31 - (end & 31);
+  if (first === last) {
+    words[first] = words[first] ^ head & tail;
+    return;
+  }
+  words[first] = words[first] ^ head;
+  for (let i = first + 1; i < last; i++) words[i] = ~words[i];
+  words[last] = words[last] ^ tail;
+}
 function fromSortedIds(ids, from, to) {
   const n = to - from;
   if (n <= ARRAY_MAX_CARDINALITY) {
@@ -525,11 +615,12 @@ function writeLows(c, out) {
     }
   }
 }
+var SMALL_IDS = 32;
 function appendIds(c, out, at, base) {
   if (c.kind === ARRAY2) {
     const u162 = lows16(c);
     const end = c.off + c.len;
-    if (base === 0) {
+    if (base === 0 && c.len >= SMALL_IDS) {
       out.set(u162.subarray(c.off, end), at);
       return at + c.len;
     }
@@ -552,14 +643,15 @@ function appendIds(c, out, at, base) {
   const u16 = lows16(c);
   for (let r = 0; r < c.len; r++) {
     const start = u16[c.off + 2 * r];
-    const last = start + u16[c.off + 2 * r + 1];
-    if (last - start < LONG_RUN) {
-      for (let v = base + start; v <= base + last; v++) out[at++] = v;
+    const length = u16[c.off + 2 * r + 1];
+    if (length < LONG_RUN) {
+      const last = base + start + length;
+      for (let v = base + start; v <= last; v++) out[at++] = v;
       continue;
     }
     const from = at;
-    out.set(iota().subarray(start, last + 1), at);
-    at += last - start + 1;
+    out.set(iota().subarray(start, start + length + 1), at);
+    at += length + 1;
     if (base !== 0) for (let i = from; i < at; i++) out[i] = out[i] + base;
   }
   return at;
@@ -645,31 +737,130 @@ function containerHas(c, low) {
   const r = c.off + 2 * (after - 1);
   return low <= u16[r] + u16[r + 1];
 }
+function runsAfter(data, off, from, len, value) {
+  let step = 1;
+  let lo = from;
+  let hi = from;
+  while (hi < len && data[off + 2 * hi] <= value) {
+    lo = hi + 1;
+    hi += step;
+    step *= 2;
+  }
+  if (hi > len) hi = len;
+  while (lo < hi) {
+    const mid = lo + hi >>> 1;
+    if (data[off + 2 * mid] <= value) lo = mid + 1;
+    else hi = mid;
+  }
+  return lo;
+}
+function runsOrPlain(pairs, runs, card, copy) {
+  const plain = card <= ARRAY_MAX_CARDINALITY ? 2 * card : BITSET_BYTES;
+  if (2 + 4 * runs < plain) {
+    return runContainer(copy ? pairs.slice(0, 2 * runs) : pairs, runs, card);
+  }
+  return fromRunPairs(pairs, runs, card);
+}
+function addToRuns(c, low) {
+  const u16 = lows16(c);
+  const next = runsAfter(u16, c.off, 0, c.len, low);
+  const prev = next - 1;
+  const joinPrev = prev >= 0 && u16[c.off + 2 * prev] + u16[c.off + 2 * prev + 1] + 1 === low;
+  const joinNext = next < c.len && u16[c.off + 2 * next] === low + 1;
+  const runs = c.len + 1 - (joinPrev ? 1 : 0) - (joinNext ? 1 : 0);
+  const out = new Uint16Array(2 * runs);
+  const head = joinPrev ? prev : next;
+  out.set(u16.subarray(c.off, c.off + 2 * head));
+  let at = 2 * head;
+  if (joinPrev && joinNext) {
+    out[at++] = u16[c.off + 2 * prev];
+    out[at++] = u16[c.off + 2 * next] + u16[c.off + 2 * next + 1] - u16[c.off + 2 * prev];
+  } else if (joinPrev) {
+    out[at++] = u16[c.off + 2 * prev];
+    out[at++] = u16[c.off + 2 * prev + 1] + 1;
+  } else if (joinNext) {
+    out[at++] = low;
+    out[at++] = u16[c.off + 2 * next + 1] + 1;
+  } else {
+    out[at++] = low;
+    out[at++] = 0;
+  }
+  const rest = joinNext ? next + 1 : next;
+  out.set(u16.subarray(c.off + 2 * rest, c.off + 2 * c.len), at);
+  return runsOrPlain(out, runs, c.card + 1, false);
+}
 function containerAdd(c, low) {
   if (containerHas(c, low)) return c;
-  const plain = demote(c);
-  if (plain.kind === BITSET) {
-    const words = writableWords(plain);
+  if (c.kind === RUN2) return addToRuns(c, low);
+  if (c.kind === BITSET) {
+    const words = writableWords(c);
     words[low >>> 5] = words[low >>> 5] | 1 << (low & 31);
-    return bitsetContainer(words, plain.card + 1);
+    return bitsetContainer(words, c.card + 1);
   }
-  if (plain.card === ARRAY_MAX_CARDINALITY) {
-    const words = toWords(plain);
+  if (c.card === ARRAY_MAX_CARDINALITY) {
+    const words = toWords(c);
     words[low >>> 5] = words[low >>> 5] | 1 << (low & 31);
-    return bitsetContainer(words, plain.card + 1);
+    return bitsetContainer(words, c.card + 1);
   }
-  const old = lows16(plain);
-  const at = lowerBound(old, plain.off, plain.len, low, 1);
+  const old = lows16(c);
+  const at = lowerBound(old, c.off, c.len, low, 1);
   let u16 = old;
-  if (!plain.shared && plain.off === 0 && old.length > plain.len) {
-    u16.copyWithin(at + 1, at, plain.len);
+  if (!c.shared && c.off === 0 && old.length > c.len) {
+    u16.copyWithin(at + 1, at, c.len);
   } else {
-    u16 = new Uint16Array(Math.min(ARRAY_MAX_CARDINALITY, Math.max(8, plain.len * 2)));
-    u16.set(old.subarray(plain.off, plain.off + at));
-    u16.set(old.subarray(plain.off + at, plain.off + plain.len), at + 1);
+    u16 = new Uint16Array(Math.min(ARRAY_MAX_CARDINALITY, Math.max(8, c.len * 2)));
+    u16.set(old.subarray(c.off, c.off + at));
+    u16.set(old.subarray(c.off + at, c.off + c.len), at + 1);
   }
   u16[at] = low;
-  return arrayContainer(u16, plain.card + 1);
+  return arrayContainer(u16, c.card + 1);
+}
+function addFewToRuns(c, ids, from, to) {
+  const x = lows16(c);
+  let data = x;
+  let base = c.off;
+  let out = null;
+  let n = c.len;
+  let added = 0;
+  for (let k = from; k < to; k++) {
+    const low = ids[k] & 65535;
+    const next = runsAfter(data, base, 0, n, low);
+    const prev = next - 1;
+    const prevEnd = prev >= 0 ? data[base + 2 * prev] + data[base + 2 * prev + 1] : -2;
+    if (prevEnd >= low) continue;
+    if (out === null) {
+      out = new Uint16Array(2 * (c.len + to - from));
+      out.set(x.subarray(c.off, c.off + 2 * c.len));
+      data = out;
+      base = 0;
+    }
+    const joinPrev = prevEnd + 1 === low;
+    const joinNext = next < n && out[2 * next] === low + 1;
+    if (joinPrev && joinNext) {
+      out[2 * prev + 1] = out[2 * next] + out[2 * next + 1] - out[2 * prev];
+      out.copyWithin(2 * next, 2 * next + 2, 2 * n);
+      n--;
+    } else if (joinPrev) {
+      out[2 * prev + 1] = out[2 * prev + 1] + 1;
+    } else if (joinNext) {
+      out[2 * next] = low;
+      out[2 * next + 1] = out[2 * next + 1] + 1;
+    } else {
+      out.copyWithin(2 * next + 2, 2 * next, 2 * n);
+      out[2 * next] = low;
+      out[2 * next + 1] = 0;
+      n++;
+    }
+    added++;
+  }
+  if (out === null) return c;
+  return runsOrPlain(out, n, c.card + added, true);
+}
+function containerAddSorted(c, ids, from, to) {
+  if (c.kind === RUN2) return addFewToRuns(c, ids, from, to);
+  let cur = c;
+  for (let k = from; k < to; k++) cur = containerAdd(cur, ids[k] & 65535);
+  return cur;
 }
 function containerRemove(c, low) {
   if (!containerHas(c, low)) return c;
@@ -691,6 +882,15 @@ function containerRemove(c, low) {
   u16.set(old.subarray(plain.off + at + 1, plain.off + plain.len), at);
   return arrayContainer(u16, plain.card - 1);
 }
+function containerMin(c) {
+  if (c.kind === ARRAY2 || c.kind === RUN2) return c.data[c.off];
+  const words = words32(c);
+  for (let i = 0; i < WORDS; i++) {
+    const w = words[i];
+    if (w !== 0) return i * 32 + 31 - Math.clz32(w & -w);
+  }
+  throw new RangeError("a bitset container holds no bits");
+}
 function containerMax(c) {
   if (c.kind === ARRAY2) return c.data[c.off + c.len - 1];
   if (c.kind === RUN2) {
@@ -785,6 +985,7 @@ function skewed(shorter, longer) {
   return longer >= GALLOP_SKEW * shorter;
 }
 var PROBE_MIN = 32;
+var MERGE_FIRST = 64;
 var probeWords = new Uint32Array(WORDS);
 function andArrays(a, b) {
   const small = a.len <= b.len ? a : b;
@@ -959,6 +1160,70 @@ function orArrays(a, b) {
   while (j < je) out[n++] = y[j++];
   return arrayOfScratch(out, n);
 }
+function andWords(out, x, y) {
+  for (let i = 0; i < WORDS; i += 4) {
+    const X0 = x[i];
+    const Y0 = y[i];
+    const X1 = x[i + 1];
+    const Y1 = y[i + 1];
+    const X2 = x[i + 2];
+    const Y2 = y[i + 2];
+    const X3 = x[i + 3];
+    const Y3 = y[i + 3];
+    out[i] = X0 & Y0;
+    out[i + 1] = X1 & Y1;
+    out[i + 2] = X2 & Y2;
+    out[i + 3] = X3 & Y3;
+  }
+}
+function orWords(out, x, y) {
+  for (let i = 0; i < WORDS; i += 4) {
+    const X0 = x[i];
+    const Y0 = y[i];
+    const X1 = x[i + 1];
+    const Y1 = y[i + 1];
+    const X2 = x[i + 2];
+    const Y2 = y[i + 2];
+    const X3 = x[i + 3];
+    const Y3 = y[i + 3];
+    out[i] = X0 | Y0;
+    out[i + 1] = X1 | Y1;
+    out[i + 2] = X2 | Y2;
+    out[i + 3] = X3 | Y3;
+  }
+}
+function xorWords(out, x, y) {
+  for (let i = 0; i < WORDS; i += 4) {
+    const X0 = x[i];
+    const Y0 = y[i];
+    const X1 = x[i + 1];
+    const Y1 = y[i + 1];
+    const X2 = x[i + 2];
+    const Y2 = y[i + 2];
+    const X3 = x[i + 3];
+    const Y3 = y[i + 3];
+    out[i] = X0 ^ Y0;
+    out[i + 1] = X1 ^ Y1;
+    out[i + 2] = X2 ^ Y2;
+    out[i + 3] = X3 ^ Y3;
+  }
+}
+function andNotWords(out, x, y) {
+  for (let i = 0; i < WORDS; i += 4) {
+    const X0 = x[i];
+    const Y0 = y[i];
+    const X1 = x[i + 1];
+    const Y1 = y[i + 1];
+    const X2 = x[i + 2];
+    const Y2 = y[i + 2];
+    const X3 = x[i + 3];
+    const Y3 = y[i + 3];
+    out[i] = X0 & ~Y0;
+    out[i + 1] = X1 & ~Y1;
+    out[i + 2] = X2 & ~Y2;
+    out[i + 3] = X3 & ~Y3;
+  }
+}
 function orIntoBitset(dest, other, inPlace) {
   const words = inPlace ? words32(dest) : words32(dest).slice();
   if (other.kind === ARRAY2) {
@@ -976,8 +1241,7 @@ function orIntoBitset(dest, other, inPlace) {
     return bitsetContainer(words, card);
   }
   if (other.kind === BITSET) {
-    const o = words32(other);
-    for (let i = 0; i < WORDS; i++) words[i] = words[i] | o[i];
+    orWords(words, words, words32(other));
   } else {
     const pairs = lows16(other);
     for (let r = 0; r < other.len; r++) {
@@ -987,6 +1251,81 @@ function orIntoBitset(dest, other, inPlace) {
   }
   return bitsetContainer(words, popcountWords(words));
 }
+function orBitsetWords(list) {
+  const bits = [];
+  for (const c of list) if (c.kind === BITSET) bits.push(words32(c));
+  const n = bits.length;
+  if (n === 0) return new Uint32Array(WORDS);
+  let k;
+  let words;
+  if (n >= 4) {
+    const a = bits[0];
+    const b = bits[1];
+    const c = bits[2];
+    const d = bits[3];
+    words = new Uint32Array(WORDS);
+    for (let i = 0; i < WORDS; i++)
+      words[i] = a[i] | b[i] | c[i] | d[i];
+    k = 4;
+  } else {
+    words = bits[0].slice();
+    k = 1;
+  }
+  for (; k + 4 <= n; k += 4) {
+    const a = bits[k];
+    const b = bits[k + 1];
+    const c = bits[k + 2];
+    const d = bits[k + 3];
+    for (let i = 0; i < WORDS; i++) {
+      words[i] = words[i] | a[i] | b[i] | c[i] | d[i];
+    }
+  }
+  for (; k < n; k++) {
+    const o = bits[k];
+    for (let i = 0; i < WORDS; i++) words[i] = words[i] | o[i];
+  }
+  return words;
+}
+function orManyContainers(list) {
+  let total = 0;
+  let allArrays = true;
+  for (const c of list) {
+    total += c.card;
+    if (c.kind !== ARRAY2) allArrays = false;
+  }
+  if (allArrays && total <= ARRAY_MAX_CARDINALITY) {
+    const out = values16(total);
+    let n = 0;
+    for (const c of list) {
+      out.set(lows16(c).subarray(c.off, c.off + c.len), n);
+      n += c.len;
+    }
+    const sorted = out.subarray(0, n).sort();
+    let distinct = 0;
+    for (let i = 0; i < n; i++) {
+      const v = sorted[i];
+      if (i === 0 || v !== sorted[distinct - 1]) sorted[distinct++] = v;
+    }
+    return arrayContainer(sorted.slice(0, distinct), distinct);
+  }
+  const words = orBitsetWords(list);
+  for (const c of list) {
+    if (c.kind === ARRAY2) {
+      const u16 = lows16(c);
+      for (let i = c.off; i < c.off + c.len; i++) {
+        const v = u16[i];
+        words[v >>> 5] = words[v >>> 5] | 1 << (v & 31);
+      }
+    } else if (c.kind === RUN2) {
+      const pairs = lows16(c);
+      for (let r = 0; r < c.len; r++) {
+        const start = pairs[c.off + 2 * r];
+        setRange(words, start, start + pairs[c.off + 2 * r + 1]);
+      }
+    }
+  }
+  return fromWordsCard(words, popcountWords(words));
+}
 function fromRunPairs(pairs, runs, card) {
   if (card === 0) return null;
   if (card <= ARRAY_MAX_CARDINALITY) {
@@ -1030,7 +1369,7 @@ function andRuns(a, b) {
     if (ae < be) i++;
     else j++;
   }
-  return fromRunPairs(out, runs, card);
+  return card === 0 ? null : runsOrPlain(out, runs, card, true);
 }
 function orRuns(a, b) {
   const x = lows16(a);
@@ -1070,7 +1409,7 @@ function orRuns(a, b) {
     }
   }
   flush();
-  return fromRunPairs(out, runs, card);
+  return runsOrPlain(out, runs, card, true);
 }
 function andNotRuns(a, b) {
   const x = lows16(a);
@@ -1104,7 +1443,7 @@ function andNotRuns(a, b) {
       k++;
     }
   }
-  return fromRunPairs(out, runs, card);
+  return card === 0 ? null : runsOrPlain(out, runs, card, true);
 }
 function bitsetInRuns(a, b) {
   const words = words32(a);
@@ -1156,7 +1495,7 @@ function containerAnd(a, b, inPlace = false) {
     const x = words32(a);
     const y = words32(b);
     const out = inPlace ? x : new Uint32Array(WORDS);
-    for (let i = 0; i < WORDS; i++) out[i] = x[i] & y[i];
+    andWords(out, x, y);
     return fromWordsCard(out, popcountWords(out));
   }
   if (a.kind > b.kind) return containerAnd(b, a);
@@ -1164,48 +1503,738 @@ function containerAnd(a, b, inPlace = false) {
     if (b.kind === ARRAY2) return andArrays(a, b);
     return b.kind === BITSET ? filterByBits(a, b, true) : filterByRuns(a, b, true);
   }
-  return b.kind === RUN2 && a.kind === RUN2 ? andRuns(a, b) : bitsetInRuns(a, b);
-}
-function containerOr(a, b, inPlace = false) {
-  if (a.kind === BITSET) return orIntoBitset(a, b, inPlace);
-  if (b.kind === BITSET) return orIntoBitset(b, a, false);
-  if (a.kind === ARRAY2 && b.kind === ARRAY2) return orArrays(a, b);
-  if (a.kind === RUN2 && b.kind === RUN2) return orRuns(a, b);
-  const words = toWords(a.kind === RUN2 ? a : b);
-  return orIntoBitsetWords(words, a.kind === RUN2 ? b : a);
+  return b.kind === RUN2 && a.kind === RUN2 ? andRuns(a, b) : bitsetInRuns(a, b);
+}
+function containerOr(a, b, inPlace = false) {
+  if (a.kind === BITSET) return orIntoBitset(a, b, inPlace);
+  if (b.kind === BITSET) return orIntoBitset(b, a, false);
+  if (a.kind === ARRAY2 && b.kind === ARRAY2) return orArrays(a, b);
+  if (a.kind === RUN2 && b.kind === RUN2) return orRuns(a, b);
+  return a.kind === RUN2 ? orRunArray(a, b, inPlace) : orRunArray(b, a, false);
+}
+var EXPAND_MIN_STEPS = 1024;
+function expandsRunArray(runs, array) {
+  return expandsRunSteps(runs, array.len);
+}
+function expandsRunSteps(runs, values) {
+  const steps = runs.len + values;
+  if (steps < EXPAND_MIN_STEPS) return false;
+  const cardMax = runs.card + values;
+  const plainMax = cardMax <= ARRAY_MAX_CARDINALITY ? 2 * cardMax : BITSET_BYTES;
+  return 2 + 4 * steps >= plainMax;
+}
+function walksRunIds(runs, count) {
+  return runs.kind === RUN2 && !expandsRunSteps(runs, count);
+}
+function orRunArrayExpand(runs, array, keep) {
+  const words = toWords(runs);
+  const v = lows16(array);
+  let added = 0;
+  for (let i = array.off; i < array.off + array.len; i++) {
+    const value = v[i];
+    const word = words[value >>> 5];
+    const bit = 1 << (value & 31);
+    if ((word & bit) === 0) {
+      words[value >>> 5] = word | bit;
+      added++;
+    }
+  }
+  if (added === 0 && keep) return runs;
+  return optimize(fromWordsCard(words, runs.card + added));
+}
+function orRunArray(runs, array, keep) {
+  return expandsRunArray(runs, array) ? orRunArrayExpand(runs, array, keep) : orRunArrayWalk(runs, array, keep);
+}
+function orRunArrayWalk(runs, array, keep) {
+  const x = lows16(runs);
+  const v = lows16(array);
+  const out = pairs16(2 * (runs.len + array.len));
+  const runEnd = runs.off + 2 * runs.len;
+  const valueEnd = array.off + array.len;
+  let r = runs.off;
+  let vi = array.off;
+  let at = 0;
+  let from = 0;
+  let to = -2;
+  let added = 0;
+  while (vi < valueEnd) {
+    const value = v[vi++];
+    while (r < runEnd && x[r] <= value) {
+      const start = x[r];
+      const end = start + x[r + 1];
+      r += 2;
+      if (start <= to + 1) {
+        if (end > to) to = end;
+      } else {
+        if (to >= 0) {
+          out[at++] = from;
+          out[at++] = to - from;
+        }
+        from = start;
+        to = end;
+      }
+    }
+    if (value <= to) continue;
+    added++;
+    if (value === to + 1) {
+      to = value;
+    } else {
+      if (to >= 0) {
+        out[at++] = from;
+        out[at++] = to - from;
+      }
+      from = value;
+      to = value;
+    }
+  }
+  while (r < runEnd) {
+    const start = x[r];
+    const end = start + x[r + 1];
+    r += 2;
+    if (start <= to + 1) {
+      if (end > to) to = end;
+    } else {
+      if (to >= 0) {
+        out[at++] = from;
+        out[at++] = to - from;
+      }
+      from = start;
+      to = end;
+    }
+  }
+  out[at++] = from;
+  out[at++] = to - from;
+  if (added === 0 && keep) return runs;
+  return runsOrPlain(out, at >>> 1, runs.card + added, true);
+}
+function orRunIdsWalk(runs, ids, from, to) {
+  const x = lows16(runs);
+  const out = pairs16(2 * (runs.len + to - from));
+  const runEnd = runs.off + 2 * runs.len;
+  let r = runs.off;
+  let vi = from;
+  let at = 0;
+  let start = 0;
+  let last = -2;
+  let added = 0;
+  while (vi < to) {
+    const value = ids[vi++] & 65535;
+    while (r < runEnd && x[r] <= value) {
+      const s = x[r];
+      const end = s + x[r + 1];
+      r += 2;
+      if (s <= last + 1) {
+        if (end > last) last = end;
+      } else {
+        if (last >= 0) {
+          out[at++] = start;
+          out[at++] = last - start;
+        }
+        start = s;
+        last = end;
+      }
+    }
+    if (value <= last) continue;
+    added++;
+    if (value === last + 1) {
+      last = value;
+    } else {
+      if (last >= 0) {
+        out[at++] = start;
+        out[at++] = last - start;
+      }
+      start = value;
+      last = value;
+    }
+  }
+  while (r < runEnd) {
+    const s = x[r];
+    const end = s + x[r + 1];
+    r += 2;
+    if (s <= last + 1) {
+      if (end > last) last = end;
+    } else {
+      if (last >= 0) {
+        out[at++] = start;
+        out[at++] = last - start;
+      }
+      start = s;
+      last = end;
+    }
+  }
+  out[at++] = start;
+  out[at++] = last - start;
+  if (added === 0) return runs;
+  return runsOrPlain(out, at >>> 1, runs.card + added, true);
+}
+function containerAndNot(a, b, inPlace = false) {
+  if (a.kind === ARRAY2) {
+    if (b.kind === ARRAY2) return andNotArrays(a, b);
+    return b.kind === BITSET ? filterByBits(a, b, false) : filterByRuns(a, b, false);
+  }
+  if (a.kind === RUN2 && b.kind === RUN2) return andNotRuns(a, b);
+  const words = a.kind === BITSET ? inPlace ? words32(a) : words32(a).slice() : toWords(a);
+  if (b.kind === ARRAY2) {
+    const u16 = lows16(b);
+    for (let i = b.off; i < b.off + b.len; i++) {
+      const v = u16[i];
+      words[v >>> 5] = words[v >>> 5] & ~(1 << (v & 31));
+    }
+  } else if (b.kind === BITSET) {
+    andNotWords(words, words, words32(b));
+  } else {
+    const pairs = lows16(b);
+    for (let r = 0; r < b.len; r++) {
+      const start = pairs[b.off + 2 * r];
+      clearRange(words, start, start + pairs[b.off + 2 * r + 1]);
+    }
+  }
+  return fromWordsCard(words, popcountWords(words));
+}
+function xorArrays(a, b) {
+  const x = lows16(a);
+  const y = lows16(b);
+  const ie = a.off + a.len;
+  const je = b.off + b.len;
+  const out = values16(a.len + b.len);
+  let n = 0;
+  let i = a.off;
+  let j = b.off;
+  while (i < ie && j < je) {
+    const p = x[i];
+    const q = y[j];
+    out[n] = p < q ? p : q;
+    n += p === q ? 0 : 1;
+    i += p <= q ? 1 : 0;
+    j += p >= q ? 1 : 0;
+  }
+  while (i < ie) out[n++] = x[i++];
+  while (j < je) out[n++] = y[j++];
+  if (n <= ARRAY_MAX_CARDINALITY) return arrayOfScratch(out, n);
+  const words = new Uint32Array(WORDS);
+  for (let k = 0; k < n; k++) {
+    const v = out[k];
+    words[v >>> 5] = words[v >>> 5] | 1 << (v & 31);
+  }
+  return bitsetContainer(words, n);
+}
+function xorRuns(a, b) {
+  const x = lows16(a);
+  const y = lows16(b);
+  const na = 2 * a.len;
+  const nb = 2 * b.len;
+  const out = pairs16(2 * (a.len + b.len));
+  const NONE = 2147483647;
+  let i = 0;
+  let j = 0;
+  let pa = na > 0 ? boundary(x, a.off, 0) : NONE;
+  let pb = nb > 0 ? boundary(y, b.off, 0) : NONE;
+  let open2 = -1;
+  let runs = 0;
+  let card = 0;
+  while (i < na || j < nb) {
+    let p;
+    if (pa === pb) {
+      i++;
+      j++;
+      pa = i < na ? boundary(x, a.off, i) : NONE;
+      pb = j < nb ? boundary(y, b.off, j) : NONE;
+      continue;
+    }
+    if (pa < pb) {
+      p = pa;
+      i++;
+      pa = i < na ? boundary(x, a.off, i) : NONE;
+    } else {
+      p = pb;
+      j++;
+      pb = j < nb ? boundary(y, b.off, j) : NONE;
+    }
+    if (open2 < 0) {
+      open2 = p;
+    } else {
+      out[2 * runs] = open2;
+      out[2 * runs + 1] = p - 1 - open2;
+      runs++;
+      card += p - open2;
+      open2 = -1;
+    }
+  }
+  return card === 0 ? null : runsOrPlain(out, runs, card, true);
+}
+function boundary(u16, off, k) {
+  const at = off + (k & ~1);
+  return u16[at] + ((k & 1) === 0 ? 0 : u16[at + 1] + 1);
+}
+function containerXor(a, b, inPlace = false) {
+  if (a.kind === BITSET || b.kind === BITSET) {
+    const base = a.kind === BITSET ? a : b;
+    const other = base === a ? b : a;
+    if (other.kind === BITSET) {
+      const x = words32(a);
+      const y = words32(b);
+      const out = inPlace ? x : new Uint32Array(WORDS);
+      xorWords(out, x, y);
+      return fromWordsCard(out, popcountWords(out));
+    }
+    const words2 = inPlace && base === a ? words32(base) : words32(base).slice();
+    if (other.kind === ARRAY2) {
+      return fromWordsCard(words2, flipValues(words2, other, base.card));
+    }
+    const pairs = lows16(other);
+    for (let r = 0; r < other.len; r++) {
+      const start = pairs[other.off + 2 * r];
+      flipRange(words2, start, start + pairs[other.off + 2 * r + 1]);
+    }
+    return fromWordsCard(words2, popcountWords(words2));
+  }
+  if (a.kind === ARRAY2 && b.kind === ARRAY2) return xorArrays(a, b);
+  if (a.kind === RUN2 && b.kind === RUN2) return xorRuns(a, b);
+  const runs = a.kind === RUN2 ? a : b;
+  const array = runs === a ? b : a;
+  const words = toWords(runs);
+  return fromWordsCard(words, flipValues(words, array, runs.card));
+}
+function flipValues(words, array, card) {
+  const u16 = lows16(array);
+  let n = card;
+  for (let i = array.off; i < array.off + array.len; i++) {
+    const v = u16[i];
+    const w = words[v >>> 5];
+    words[v >>> 5] = w ^ 1 << (v & 31);
+    n += 1 - 2 * (w >>> (v & 31) & 1);
+  }
+  return n;
+}
+function bitsInRange(words, start, end) {
+  const first = start >>> 5;
+  const last = end >>> 5;
+  const head = 4294967295 << (start & 31) >>> 0;
+  const tail = 4294967295 >>> 31 - (end & 31);
+  if (first === last) return popcount32(words[first] & head & tail);
+  let n = popcount32(words[first] & head) + popcount32(words[last] & tail);
+  for (let i = first + 1; i < last; i++) n += popcount32(words[i]);
+  return n;
+}
+function andCountArrays(a, b) {
+  const small = a.len <= b.len ? a : b;
+  const big = small === a ? b : a;
+  const s = lows16(small);
+  const l = lows16(big);
+  const se = small.off + small.len;
+  const le = big.off + big.len;
+  let n = 0;
+  if (skewed(small.len, big.len)) {
+    let at = big.off;
+    for (let i2 = small.off; i2 < se; i2++) {
+      const v = s[i2];
+      at = gallop(l, 0, at, le, v);
+      if (at === le) break;
+      if (l[at] === v) n++;
+    }
+    return n;
+  }
+  if (small.len >= PROBE_MIN) {
+    const first = s[small.off];
+    const last = s[se - 1];
+    if (last < l[big.off] || first > l[le - 1]) return 0;
+    const from = gallop(l, 0, big.off, le, first);
+    const to = gallop(l, 0, from, le, last + 1);
+    const words = probeWords;
+    for (let i2 = small.off; i2 < se; i2++) {
+      const v = s[i2];
+      words[v >>> 5] = words[v >>> 5] | 1 << (v & 31);
+    }
+    for (let j2 = from; j2 < to; j2++) {
+      const v = l[j2];
+      n += words[v >>> 5] >>> (v & 31) & 1;
+    }
+    for (let i2 = small.off; i2 < se; i2++) words[s[i2] >>> 5] = 0;
+    return n;
+  }
+  let i = small.off;
+  let j = big.off;
+  while (i < se && j < le) {
+    const x = s[i];
+    const y = l[j];
+    n += x === y ? 1 : 0;
+    i += x <= y ? 1 : 0;
+    j += x >= y ? 1 : 0;
+  }
+  return n;
+}
+function andCountArrayBitset(a, b) {
+  const u16 = lows16(a);
+  const words = words32(b);
+  let n = 0;
+  for (let i = a.off; i < a.off + a.len; i++) {
+    const v = u16[i];
+    n += words[v >>> 5] >>> (v & 31) & 1;
+  }
+  return n;
+}
+function andCountArrayRuns(a, b) {
+  const u16 = lows16(a);
+  const pairs = lows16(b);
+  const ae = a.off + a.len;
+  let n = 0;
+  if (skewed(a.len, b.len)) {
+    for (let i2 = a.off; i2 < ae; i2++) {
+      const v = u16[i2];
+      const after = lowerBound(pairs, b.off, b.len, v + 1, 2);
+      if (after === 0) continue;
+      const r = b.off + 2 * (after - 1);
+      if (v <= pairs[r] + pairs[r + 1]) n++;
+    }
+    return n;
+  }
+  let i = a.off;
+  for (let r = 0; r < b.len && i < ae; r++) {
+    const start = pairs[b.off + 2 * r];
+    const end = start + pairs[b.off + 2 * r + 1];
+    while (i < ae && u16[i] < start) i++;
+    while (i < ae && u16[i] <= end) {
+      n++;
+      i++;
+    }
+  }
+  return n;
+}
+function andCountBitsetRuns(a, b) {
+  const words = words32(a);
+  const pairs = lows16(b);
+  let n = 0;
+  for (let r = 0; r < b.len; r++) {
+    const start = pairs[b.off + 2 * r];
+    n += bitsInRange(words, start, start + pairs[b.off + 2 * r + 1]);
+  }
+  return n;
+}
+function andCountRuns(a, b) {
+  const x = lows16(a);
+  const y = lows16(b);
+  let n = 0;
+  let i = 0;
+  let j = 0;
+  while (i < a.len && j < b.len) {
+    const as = x[a.off + 2 * i];
+    const ae = as + x[a.off + 2 * i + 1];
+    const bs = y[b.off + 2 * j];
+    const be = bs + y[b.off + 2 * j + 1];
+    const lo = as > bs ? as : bs;
+    const hi = ae < be ? ae : be;
+    if (lo <= hi) n += hi - lo + 1;
+    if (ae < be) i++;
+    else j++;
+  }
+  return n;
+}
+function containerAndCard(a, b) {
+  if (a.kind === BITSET && b.kind === BITSET) {
+    return popcountAnd(words32(a), words32(b));
+  }
+  if (a.kind > b.kind) return containerAndCard(b, a);
+  if (a.kind === ARRAY2) {
+    if (b.kind === ARRAY2) return andCountArrays(a, b);
+    return b.kind === BITSET ? andCountArrayBitset(a, b) : andCountArrayRuns(a, b);
+  }
+  return b.kind === RUN2 && a.kind === RUN2 ? andCountRuns(a, b) : andCountBitsetRuns(a, b);
+}
+function anyBitInRange(words, start, end) {
+  const first = start >>> 5;
+  const last = end >>> 5;
+  const head = 4294967295 << (start & 31) >>> 0;
+  const tail = 4294967295 >>> 31 - (end & 31);
+  if (first === last) return (words[first] & head & tail) !== 0;
+  if ((words[first] & head) !== 0 || (words[last] & tail) !== 0)
+    return true;
+  for (let i = first + 1; i < last; i++) if (words[i] !== 0) return true;
+  return false;
+}
+function allBitsInRange(words, start, end) {
+  const first = start >>> 5;
+  const last = end >>> 5;
+  const head = 4294967295 << (start & 31) >>> 0;
+  const tail = 4294967295 >>> 31 - (end & 31);
+  if (first === last) return (~words[first] & head & tail) === 0;
+  if ((~words[first] & head) !== 0 || (~words[last] & tail) !== 0)
+    return false;
+  for (let i = first + 1; i < last; i++) if (words[i] !== 4294967295) return false;
+  return true;
+}
+function subsetArrays(a, b) {
+  const x = lows16(a);
+  const y = lows16(b);
+  const ie = a.off + a.len;
+  const je = b.off + b.len;
+  let j = b.off;
+  if (skewed(a.len, b.len)) {
+    for (let i2 = a.off; i2 < ie; i2++) {
+      const v = x[i2];
+      j = gallop(y, 0, j, je, v);
+      if (j === je || y[j] !== v) return false;
+    }
+    return true;
+  }
+  let i = a.off;
+  while (i < ie && j < je) {
+    const p = x[i];
+    const q = y[j];
+    if (p < q) return false;
+    i += p === q ? 1 : 0;
+    j++;
+  }
+  return i === ie;
+}
+function subsetArrayRuns(a, b) {
+  const u16 = lows16(a);
+  const pairs = lows16(b);
+  let r = 0;
+  for (let i = a.off; i < a.off + a.len; i++) {
+    const v = u16[i];
+    while (r < b.len && pairs[b.off + 2 * r] + pairs[b.off + 2 * r + 1] < v)
+      r++;
+    if (r === b.len || pairs[b.off + 2 * r] > v) return false;
+  }
+  return true;
+}
+function subsetRunsArray(a, b) {
+  const pairs = lows16(a);
+  const y = lows16(b);
+  const je = b.off + b.len;
+  let j = b.off;
+  for (let r = 0; r < a.len; r++) {
+    const start = pairs[a.off + 2 * r];
+    const last = start + pairs[a.off + 2 * r + 1];
+    j = gallop(y, 0, j, je, start);
+    const end = j + (last - start);
+    if (end >= je || y[j] !== start || y[end] !== last) return false;
+    j = end + 1;
+  }
+  return true;
+}
+function subsetRuns(a, b) {
+  const x = lows16(a);
+  const y = lows16(b);
+  let j = 0;
+  for (let i = 0; i < a.len; i++) {
+    const start = x[a.off + 2 * i];
+    const last = start + x[a.off + 2 * i + 1];
+    while (j < b.len && y[b.off + 2 * j] + y[b.off + 2 * j + 1] < start)
+      j++;
+    if (j === b.len || y[b.off + 2 * j] > start) return false;
+    if (y[b.off + 2 * j] + y[b.off + 2 * j + 1] < last) return false;
+  }
+  return true;
+}
+function subsetBitsetRuns(a, b) {
+  const words = words32(a);
+  const pairs = lows16(b);
+  let from = 0;
+  for (let r = 0; r < b.len; r++) {
+    const start = pairs[b.off + 2 * r];
+    if (start > from && anyBitInRange(words, from, start - 1)) return false;
+    from = start + pairs[b.off + 2 * r + 1] + 1;
+  }
+  return from > 65535 || !anyBitInRange(words, from, 65535);
+}
+function containersSubset(a, b) {
+  if (a.card > b.card) return false;
+  if (a.kind === ARRAY2) {
+    if (b.kind === ARRAY2) return subsetArrays(a, b);
+    if (b.kind === RUN2) return subsetArrayRuns(a, b);
+    const u16 = lows16(a);
+    const words2 = words32(b);
+    for (let i = a.off; i < a.off + a.len; i++) {
+      const v = u16[i];
+      if ((words2[v >>> 5] >>> (v & 31) & 1) === 0) return false;
+    }
+    return true;
+  }
+  if (a.kind === BITSET) {
+    if (b.kind === BITSET) {
+      const x = words32(a);
+      const y = words32(b);
+      for (let i = 0; i < WORDS; i += 8) {
+        const lack = x[i] & ~y[i] | x[i + 1] & ~y[i + 1] | x[i + 2] & ~y[i + 2] | x[i + 3] & ~y[i + 3] | x[i + 4] & ~y[i + 4] | x[i + 5] & ~y[i + 5] | x[i + 6] & ~y[i + 6] | x[i + 7] & ~y[i + 7];
+        if (lack !== 0) return false;
+      }
+      return true;
+    }
+    if (b.kind === RUN2) return subsetBitsetRuns(a, b);
+    return containerAndCard(a, b) === a.card;
+  }
+  if (b.kind === ARRAY2) return subsetRunsArray(a, b);
+  if (b.kind === RUN2) return subsetRuns(a, b);
+  const words = words32(b);
+  const pairs = lows16(a);
+  for (let r = 0; r < a.len; r++) {
+    const start = pairs[a.off + 2 * r];
+    if (!allBitsInRange(words, start, start + pairs[a.off + 2 * r + 1])) return false;
+  }
+  return true;
+}
+function containersEqual(a, b) {
+  if (a.card !== b.card) return false;
+  if (a.kind !== b.kind) return containerAndCard(a, b) === a.card;
+  if (a.kind === BITSET) return equalWords(words32(a), 0, words32(b), 0, WORDS);
+  if (a.len !== b.len) return false;
+  const x = lows16(a);
+  const y = lows16(b);
+  const n = a.kind === ARRAY2 ? a.len : 2 * a.len;
+  if (n < EQUAL_VIEW_MIN) {
+    if (a.off === 0 && b.off === 0) return equalU16(x, 0, y, 0, n);
+    return equalU16(x, a.off, y, b.off, n);
+  }
+  const xb = x.byteOffset + 2 * a.off;
+  const yb = y.byteOffset + 2 * b.off;
+  if (usesEqualView(n, xb, yb)) {
+    const m = n >>> 1;
+    if (!equalWords(new Uint32Array(x.buffer, xb, m), 0, new Uint32Array(y.buffer, yb, m), 0, m))
+      return false;
+    return (n & 1) === 0 || x[a.off + n - 1] === y[b.off + n - 1];
+  }
+  return equalU16(x, a.off, y, b.off, n);
+}
+var EQUAL_VIEW_MIN = 512;
+function usesEqualView(n, xb, yb) {
+  return n >= EQUAL_VIEW_MIN && (xb & 3) === 0 && (yb & 3) === 0;
+}
+function equalWords(x, xo, y, yo, n) {
+  let i = 0;
+  for (const end = n - 7; i < end; i += 8) {
+    const d = x[xo + i] ^ y[yo + i] | x[xo + i + 1] ^ y[yo + i + 1] | x[xo + i + 2] ^ y[yo + i + 2] | x[xo + i + 3] ^ y[yo + i + 3] | x[xo + i + 4] ^ y[yo + i + 4] | x[xo + i + 5] ^ y[yo + i + 5] | x[xo + i + 6] ^ y[yo + i + 6] | x[xo + i + 7] ^ y[yo + i + 7];
+    if (d !== 0) return false;
+  }
+  for (; i < n; i++) if (x[xo + i] !== y[yo + i]) return false;
+  return true;
+}
+function equalU16(x, xo, y, yo, n) {
+  let i = 0;
+  for (const end = n - 7; i < end; i += 8) {
+    const d = x[xo + i] ^ y[yo + i] | x[xo + i + 1] ^ y[yo + i + 1] | x[xo + i + 2] ^ y[yo + i + 2] | x[xo + i + 3] ^ y[yo + i + 3] | x[xo + i + 4] ^ y[yo + i + 4] | x[xo + i + 5] ^ y[yo + i + 5] | x[xo + i + 6] ^ y[yo + i + 6] | x[xo + i + 7] ^ y[yo + i + 7];
+    if (d !== 0) return false;
+  }
+  for (; i < n; i++) if (x[xo + i] !== y[yo + i]) return false;
+  return true;
+}
+function intersectsArrays(a, b) {
+  const small = a.len <= b.len ? a : b;
+  const big = small === a ? b : a;
+  const s = lows16(small);
+  const l = lows16(big);
+  const se = small.off + small.len;
+  const le = big.off + big.len;
+  if (s[se - 1] < l[big.off] || s[small.off] > l[le - 1]) {
+    return false;
+  }
+  if (skewed(small.len, big.len)) {
+    let at = big.off;
+    for (let i2 = small.off; i2 < se; i2++) {
+      const v = s[i2];
+      at = gallop(l, 0, at, le, v);
+      if (at === le) return false;
+      if (l[at] === v) return true;
+    }
+    return false;
+  }
+  let i = small.off;
+  let j = big.off;
+  if (small.len >= PROBE_MIN) {
+    for (let step = 0; step < MERGE_FIRST && i < se && j < le; step++) {
+      const x = s[i];
+      const y = l[j];
+      if (x === y) return true;
+      if (x < y) i++;
+      else j++;
+    }
+    if (i === se || j === le) return false;
+    const left = i;
+    const from = gallop(l, 0, j, le, s[left]);
+    const to = gallop(l, 0, from, le, s[se - 1] + 1);
+    const words = probeWords;
+    for (let k = left; k < se; k++) {
+      const v = s[k];
+      words[v >>> 5] = words[v >>> 5] | 1 << (v & 31);
+    }
+    let hit = false;
+    for (let k = from; k < to; k++) {
+      const v = l[k];
+      if ((words[v >>> 5] >>> (v & 31) & 1) === 1) {
+        hit = true;
+        break;
+      }
+    }
+    for (let k = left; k < se; k++) words[s[k] >>> 5] = 0;
+    return hit;
+  }
+  while (i < se && j < le) {
+    const x = s[i];
+    const y = l[j];
+    if (x === y) return true;
+    if (x < y) i++;
+    else j++;
+  }
+  return false;
 }
-function orIntoBitsetWords(words, array) {
-  const u16 = lows16(array);
-  for (let i = array.off; i < array.off + array.len; i++) {
+function intersectsArrayRuns(a, b) {
+  const u16 = lows16(a);
+  const pairs = lows16(b);
+  let r = 0;
+  for (let i = a.off; i < a.off + a.len; i++) {
     const v = u16[i];
-    words[v >>> 5] = words[v >>> 5] | 1 << (v & 31);
+    while (r < b.len && pairs[b.off + 2 * r] + pairs[b.off + 2 * r + 1] < v) {
+      r++;
+    }
+    if (r === b.len) return false;
+    if (pairs[b.off + 2 * r] <= v) return true;
   }
-  return fromWordsCard(words, popcountWords(words));
+  return false;
 }
-function containerAndNot(a, b, inPlace = false) {
+function containersIntersect(a, b) {
+  if (a.kind > b.kind) return containersIntersect(b, a);
   if (a.kind === ARRAY2) {
-    if (b.kind === ARRAY2) return andNotArrays(a, b);
-    return b.kind === BITSET ? filterByBits(a, b, false) : filterByRuns(a, b, false);
+    if (b.kind === ARRAY2) return intersectsArrays(a, b);
+    if (b.kind === RUN2) return intersectsArrayRuns(a, b);
+    const u16 = lows16(a);
+    const words = words32(b);
+    for (let i2 = a.off; i2 < a.off + a.len; i2++) {
+      const v = u16[i2];
+      if ((words[v >>> 5] >>> (v & 31) & 1) === 1) return true;
+    }
+    return false;
   }
-  if (a.kind === RUN2 && b.kind === RUN2) return andNotRuns(a, b);
-  const words = a.kind === BITSET ? inPlace ? words32(a) : words32(a).slice() : toWords(a);
-  if (b.kind === ARRAY2) {
-    const u16 = lows16(b);
-    for (let i = b.off; i < b.off + b.len; i++) {
-      const v = u16[i];
-      words[v >>> 5] = words[v >>> 5] & ~(1 << (v & 31));
+  if (a.kind === BITSET) {
+    const x2 = words32(a);
+    if (b.kind === BITSET) {
+      const y2 = words32(b);
+      for (let i2 = 0; i2 < WORDS; i2 += 8) {
+        const both = x2[i2] & y2[i2] | x2[i2 + 1] & y2[i2 + 1] | x2[i2 + 2] & y2[i2 + 2] | x2[i2 + 3] & y2[i2 + 3] | x2[i2 + 4] & y2[i2 + 4] | x2[i2 + 5] & y2[i2 + 5] | x2[i2 + 6] & y2[i2 + 6] | x2[i2 + 7] & y2[i2 + 7];
+        if (both !== 0) return true;
+      }
+      return false;
     }
-  } else if (b.kind === BITSET) {
-    const y = words32(b);
-    for (let i = 0; i < WORDS; i++) words[i] = words[i] & ~y[i];
-  } else {
     const pairs = lows16(b);
     for (let r = 0; r < b.len; r++) {
       const start = pairs[b.off + 2 * r];
-      clearRange(words, start, start + pairs[b.off + 2 * r + 1]);
+      if (anyBitInRange(x2, start, start + pairs[b.off + 2 * r + 1])) return true;
     }
+    return false;
   }
-  return fromWordsCard(words, popcountWords(words));
+  const x = lows16(a);
+  const y = lows16(b);
+  let i = 0;
+  let j = 0;
+  while (i < a.len && j < b.len) {
+    const as = x[a.off + 2 * i];
+    const ae = as + x[a.off + 2 * i + 1];
+    const bs = y[b.off + 2 * j];
+    const be = bs + y[b.off + 2 * j + 1];
+    if ((as > bs ? as : bs) <= (ae < be ? ae : be)) return true;
+    if (ae < be) i++;
+    else j++;
+  }
+  return false;
 }
 
 // src/ts-roaring/iterator.ts
@@ -1302,7 +2331,16 @@ function bodySize(c) {
   if (c.kind === BITSET) return BITSET_BYTES;
   return 2 + 4 * c.len;
 }
+var SMALL_BODY = 64;
 function putU16s(out, at, src, from, count) {
+  if (count < SMALL_BODY) {
+    for (let i = 0; i < count; i++) {
+      const v = src[from + i];
+      out[at++] = v & 255;
+      out[at++] = v >>> 8;
+    }
+    return;
+  }
   if (LITTLE_ENDIAN) {
     out.set(new Uint8Array(src.buffer, src.byteOffset + 2 * from, 2 * count), at);
     return;
@@ -1357,7 +2395,7 @@ function serializeContainers(keys, conts) {
   }
   return out;
 }
-function decodeContainers(input) {
+function decodeContainers(input, detached = false) {
   const bytes = Uint8Array.prototype.slice.call(input);
   const layout = parsePortableLayout(bytes);
   const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
@@ -1367,18 +2405,21 @@ function decodeContainers(input) {
   let end = bytes.byteLength === 0 ? 0 : 8;
   let slabLength = 0;
   let small = 0;
-  for (const { cardinality, kind, offset } of layout) {
-    if (kind === ARRAY) {
-      slabLength += cardinality;
-      small++;
-    } else if (kind !== BITMAP) {
-      slabLength += 2 * view.getUint16(offset, true);
-      small++;
+  if (!detached) {
+    for (const { cardinality, kind, offset } of layout) {
+      if (kind === ARRAY) {
+        slabLength += cardinality;
+        small++;
+      } else if (kind !== BITMAP) {
+        slabLength += 2 * view.getUint16(offset, true);
+        small++;
+      }
     }
   }
   const own = LITTLE_ENDIAN && bytes.byteOffset === 0 && bytes.buffer instanceof ArrayBuffer && bytes.buffer.byteLength === bytes.byteLength;
-  const alias = own && small === 1;
-  const slab = alias ? NO_U16 : new Uint16Array(slabLength);
+  const alias = !detached && own && small === 1;
+  const solo = alias || detached;
+  const slab = solo ? NO_U16 : new Uint16Array(slabLength);
   let used = 0;
   for (const { key, cardinality, kind, offset } of layout) {
     keys[n] = key;
@@ -1387,22 +2428,22 @@ function decodeContainers(input) {
         const values = new Uint16Array(bytes.buffer, offset, cardinality);
         conts[n++] = new Container(ARRAY2, values, 0, cardinality, cardinality, false);
       } else {
-        const into = alias ? new Uint16Array(cardinality) : slab;
-        getU16s(bytes, view, offset, into, alias ? 0 : used, cardinality);
+        const into = solo ? new Uint16Array(cardinality) : slab;
+        getU16s(bytes, view, offset, into, solo ? 0 : used, cardinality);
         conts[n++] = new Container(
           ARRAY2,
           into,
-          alias ? 0 : used,
+          solo ? 0 : used,
           cardinality,
           cardinality,
-          small > 1
+          !solo && small > 1
         );
         used += cardinality;
       }
       end = offset + 2 * cardinality;
     } else if (kind === BITMAP) {
       let words;
-      if (own && offset % 4 === 0) {
+      if (!detached && own && offset % 4 === 0) {
         words = new Uint32Array(bytes.buffer, offset, WORDS);
       } else {
         words = new Uint32Array(WORDS);
@@ -1420,9 +2461,16 @@ function decodeContainers(input) {
         const pairs = new Uint16Array(bytes.buffer, offset + 2, 2 * runs);
         conts[n++] = new Container(RUN2, pairs, 0, runs, cardinality, false);
       } else {
-        const into = alias ? new Uint16Array(2 * runs) : slab;
-        getU16s(bytes, view, offset + 2, into, alias ? 0 : used, 2 * runs);
-        conts[n++] = new Container(RUN2, into, alias ? 0 : used, runs, cardinality, small > 1);
+        const into = solo ? new Uint16Array(2 * runs) : slab;
+        getU16s(bytes, view, offset + 2, into, solo ? 0 : used, 2 * runs);
+        conts[n++] = new Container(
+          RUN2,
+          into,
+          solo ? 0 : used,
+          runs,
+          cardinality,
+          !solo && small > 1
+        );
         used += 2 * runs;
       }
       end = offset + 2 + 4 * runs;
@@ -1449,11 +2497,8 @@ var MAX_ID = 4294967295;
 function isId(value) {
   return Number.isInteger(value) && value >= 0 && value <= MAX_ID;
 }
-function badId(value) {
-  return new ValidationError2(`${String(value)} is not an integer from 0 to ${MAX_ID}`);
-}
 function checkedId(value) {
-  if (!isId(value)) throw badId(value);
+  if (!isId(value)) throw refusalOfId(value);
   return value;
 }
 function collect(values) {
@@ -1461,10 +2506,17 @@ function collect(values) {
   if (Array.isArray(values)) {
     const list = values;
     const out2 = new Uint32Array(list.length);
-    for (let i = 0; i < list.length; i++) {
+    let i = 0;
+    try {
+      for (; i < list.length; i++) {
+        const v = list[i];
+        if (v >>> 0 !== v) throw refusalOfId(v);
+        out2[i] = v;
+      }
+    } catch (error) {
       const v = list[i];
-      if (v >>> 0 !== v) throw badId(v);
-      out2[i] = v;
+      if (typeof v !== "number") throw refusalOfId(v);
+      throw error;
     }
     return out2;
   }
@@ -1481,6 +2533,7 @@ function collect(values) {
   return out.subarray(0, n);
 }
 function collectLenient(values) {
+  if (values instanceof Uint32Array) return values.slice();
   const list = Array.isArray(values) ? values : Array.from(values);
   const out = new Uint32Array(list.length);
   let n = 0;
@@ -1490,6 +2543,11 @@ function collectLenient(values) {
   }
   return out.subarray(0, n);
 }
+var FEW_IDS = 4;
+function groupPath(before, count) {
+  if (count <= FEW_IDS) return "few";
+  return walksRunIds(before, count) ? "walk" : "merge";
+}
 function sortedIds(ids, owned) {
   for (let i = 1; i < ids.length; i++) {
     if (ids[i - 1] > ids[i]) return (owned ? ids : ids.slice()).sort();
@@ -1530,9 +2588,11 @@ function lowerBoundIn(keys, key, from, to) {
 var OR = 0;
 var AND = 1;
 var AND_NOT = 2;
+var XOR = 3;
 function combineContainers(op, a, b) {
-  if (op === OR) return containerOr(a, b, !a.shared);
+  if (op === OR) return containerOr(a, b, !a.shared || a.kind === RUN2);
   if (op === AND) return containerAnd(a, b, !a.shared);
+  if (op === XOR) return containerXor(a, b, !a.shared);
   return containerAndNot(a, b, !a.shared);
 }
 var TsBitmap = class _TsBitmap {
@@ -1554,7 +2614,9 @@ var TsBitmap = class _TsBitmap {
   }
   /**
    * Cap the size, check the structure, then build the containers. With `whole`, bytes after the last container are
-   * refused too; without it they are ignored.
+   * refused too; without it they are ignored. With `detached`, every container gets storage of its own, copied out of
+   * the input, so nothing the result holds is a view of one shared buffer: a bitmap that is kept and then reduced
+   * does not keep the whole input alive.
    *
    * @throws {IntegrityError} if the input exceeds `maxBytes`, is not a well-formed portable bitmap, or (with `whole`)
    * has bytes after it.
@@ -1563,7 +2625,7 @@ var TsBitmap = class _TsBitmap {
     if (bytes.length > maxBytes) {
       throw new IntegrityError3(`serialized bitmap is ${bytes.length}B, exceeds cap ${maxBytes}B`);
     }
-    const { keys, conts, end } = decodeContainers(bytes);
+    const { keys, conts, end } = decodeContainers(bytes, options.detached === true);
     if (options.whole === true && end !== bytes.byteLength) {
       throw trailingBytes(bytes.byteLength, end);
     }
@@ -1579,6 +2641,12 @@ var TsBitmap = class _TsBitmap {
     const conts = this.#conts;
     for (let i = 0; i < conts.length; i++) conts[i] = optimize(conts[i]);
   }
+  /** Whether at least one container is held as runs. */
+  hasRunContainer() {
+    for (let i = 0; i < this.#conts.length; i++)
+      if (this.#conts[i].kind === RUN2) return true;
+    return false;
+  }
   /**
    * The set as storage chunks: each payload is the portable bytes of a one-container bitmap holding that chunk's low 16
    * bits, optimized the way {@link optimize} does. Nothing is built until a chunk is asked for, so a writer that yields
@@ -1603,6 +2671,11 @@ var TsBitmap = class _TsBitmap {
       }
     };
   }
+  /** The smallest id, or `undefined` when the bitmap is empty. */
+  minimum() {
+    if (this.#conts.length === 0) return void 0;
+    return this.#keys[0] * 65536 + containerMin(this.#conts[0]);
+  }
   maximum() {
     const last = this.#conts.length - 1;
     if (last < 0) return void 0;
@@ -1636,36 +2709,50 @@ var TsBitmap = class _TsBitmap {
       const key = ids[i] >>> 16;
       let end = i + 1;
       while (end < ids.length && ids[end] >>> 16 === key) end++;
-      const group = fromSortedIds(ids, i, end);
+      const first = i;
       i = end;
       at = gallopKeys(this.#keys, key, at);
       if (this.#keys[at] === key) {
         const before = this.#conts[at];
-        const after = containerOr(before, group, !before.shared);
+        const path = groupPath(before, end - first);
+        const after = path === "few" ? containerAddSorted(before, ids, first, end) : path === "walk" ? orRunIdsWalk(before, ids, first, end) : containerOr(
+          before,
+          fromSortedIds(ids, first, end),
+          !before.shared || before.kind === RUN2
+        );
         this.#conts[at] = after;
         this.#size += after.card - before.card;
       } else {
+        const group = fromSortedIds(ids, first, end);
         fresh.push({ key, group });
         this.#size += group.card;
       }
     }
     if (fresh.length > 0) this.#insertAll(fresh);
   }
+  /** Remove the id (anything that is not an id is ignored); whether it was there. */
   remove(value) {
-    if (!isId(value)) return;
+    if (!isId(value)) return false;
     const key = value >>> 16;
     const at = lowerBound2(this.#keys, key);
-    if (this.#keys[at] !== key) return;
+    if (this.#keys[at] !== key) return false;
     const before = this.#conts[at];
     const after = containerRemove(before, value & 65535);
     if (after === null) {
       this.#keys.splice(at, 1);
       this.#conts.splice(at, 1);
       this.#size -= before.card;
-      return;
+      return true;
     }
     this.#conts[at] = after;
     this.#size += after.card - before.card;
+    return after.card !== before.card;
+  }
+  /** Remove every id. Containers a clone shares are left to it. */
+  clear() {
+    this.#keys = [];
+    this.#conts = [];
+    this.#size = 0;
   }
   /** Remove the ids (anything that is not an id is ignored), grouped by key; the keys left empty go in one pass. */
   removeMany(values) {
@@ -1725,6 +2812,90 @@ var TsBitmap = class _TsBitmap {
   andNotInPlace(other) {
     this.#combine(_TsBitmap.#of(other), AND_NOT);
   }
+  /** Flip the ids `other` holds, in one pass over the pair of each key. */
+  xorInPlace(other) {
+    this.#combine(_TsBitmap.#of(other), XOR);
+  }
+  /** How many ids both bitmaps hold, counted without building the intersection. */
+  andCardinality(other) {
+    const that = _TsBitmap.#of(other);
+    const a = this.#keys;
+    const b = that.#keys;
+    let n = 0;
+    let i = 0;
+    let j = 0;
+    while (i < a.length && j < b.length) {
+      const ka = a[i];
+      const kb = b[j];
+      if (ka === kb) {
+        n += containerAndCard(this.#conts[i++], that.#conts[j++]);
+      } else if (ka < kb) {
+        i = gallopKeys(a, kb, i + 1);
+      } else {
+        j = gallopKeys(b, ka, j + 1);
+      }
+    }
+    return n;
+  }
+  /** How many ids either bitmap holds. */
+  orCardinality(other) {
+    return this.#size + _TsBitmap.#of(other).#size - this.andCardinality(other);
+  }
+  /** How many ids exactly one of the bitmaps holds. */
+  xorCardinality(other) {
+    return this.#size + _TsBitmap.#of(other).#size - 2 * this.andCardinality(other);
+  }
+  /** How many ids this bitmap holds that `other` lacks. */
+  andNotCardinality(other) {
+    return this.#size - this.andCardinality(other);
+  }
+  /** Whether the bitmaps share an id; stops at the first one found. */
+  intersects(other) {
+    const that = _TsBitmap.#of(other);
+    const a = this.#keys;
+    const b = that.#keys;
+    let i = 0;
+    let j = 0;
+    while (i < a.length && j < b.length) {
+      const ka = a[i];
+      const kb = b[j];
+      if (ka === kb) {
+        if (containersIntersect(this.#conts[i++], that.#conts[j++])) {
+          return true;
+        }
+      } else if (ka < kb) {
+        i = gallopKeys(a, kb, i + 1);
+      } else {
+        j = gallopKeys(b, ka, j + 1);
+      }
+    }
+    return false;
+  }
+  /** Whether every id of this bitmap is in `other`; stops at the first container that is not inside its partner. */
+  isSubset(other) {
+    const that = _TsBitmap.#of(other);
+    if (this.#size > that.#size) return false;
+    const a = this.#keys;
+    const b = that.#keys;
+    let j = 0;
+    for (let i = 0; i < a.length; i++) {
+      j = gallopKeys(b, a[i], j);
+      if (j === b.length || b[j] !== a[i]) return false;
+      const c = this.#conts[i];
+      if (!containersSubset(c, that.#conts[j++])) return false;
+    }
+    return true;
+  }
+  /** Whether both hold the same ids, whatever the kinds of their containers. */
+  isEqual(other) {
+    const that = _TsBitmap.#of(other);
+    if (this.#size !== that.#size || this.#keys.length !== that.#keys.length) return false;
+    for (let i = 0; i < this.#keys.length; i++) {
+      if (this.#keys[i] !== that.#keys[i]) return false;
+      if (!containersEqual(this.#conts[i], that.#conts[i])) return false;
+    }
+    return true;
+  }
   [Symbol.iterator]() {
     return new BitmapIterator(this.#keys, this.#conts);
   }
@@ -1831,7 +3002,7 @@ var TsBitmap = class _TsBitmap {
       } else if (op === AND) {
         j = gallopKeys(b, ka, j + 1);
       } else {
-        if (op === OR) {
+        if (op === OR || op === XOR) {
           keys.push(kb);
           conts.push(cloneContainer(cb[j]));
           size += cb[j].card;
@@ -1846,7 +3017,7 @@ var TsBitmap = class _TsBitmap {
         size += ca[i].card;
       }
     }
-    if (op === OR) {
+    if (op === OR || op === XOR) {
       for (; j < b.length; j++) {
         keys.push(b[j]);
         conts.push(cloneContainer(cb[j]));
@@ -1857,7 +3028,122 @@ var TsBitmap = class _TsBitmap {
     this.#conts = conts;
     this.#size = size;
   }
+  /** The ids both bitmaps hold, as a new bitmap; neither operand changes and no container of either is kept. */
+  static and(a, b) {
+    return _TsBitmap.#fresh(_TsBitmap.#of(a), _TsBitmap.#of(b), AND);
+  }
+  /** The ids either holds, as a new bitmap; neither operand changes. */
+  static or(a, b) {
+    return _TsBitmap.#fresh(_TsBitmap.#of(a), _TsBitmap.#of(b), OR);
+  }
+  /**
+   * The ids any of `bitmaps` holds, as a new bitmap that owns all its storage; no operand changes and none is flagged.
+   * The containers of each key are gathered across the inputs and united in one pass (see {@link orManyContainers}),
+   * counted once. A key only one input holds is copied as it is, a run included.
+   */
+  static orMany(bitmaps) {
+    const byKey = /* @__PURE__ */ new Map();
+    for (const input of bitmaps) {
+      const that = _TsBitmap.#of(input);
+      for (let i = 0; i < that.#keys.length; i++) {
+        const key = that.#keys[i];
+        const held = byKey.get(key);
+        if (held === void 0) byKey.set(key, [that.#conts[i]]);
+        else held.push(that.#conts[i]);
+      }
+    }
+    const keys = Array.from(byKey.keys()).sort((x, y) => x - y);
+    const conts = [];
+    let size = 0;
+    for (const key of keys) {
+      const held = byKey.get(key);
+      const c = held.length === 1 ? cloneContainer(held[0]) : orManyContainers(held);
+      conts.push(c);
+      size += c.card;
+    }
+    return new _TsBitmap(keys, conts, size);
+  }
+  /** The ids exactly one holds, as a new bitmap; neither operand changes. */
+  static xor(a, b) {
+    return _TsBitmap.#fresh(_TsBitmap.#of(a), _TsBitmap.#of(b), XOR);
+  }
+  /** The ids of `a` that `b` lacks, as a new bitmap; neither operand changes. */
+  static andNot(a, b) {
+    return _TsBitmap.#fresh(_TsBitmap.#of(a), _TsBitmap.#of(b), AND_NOT);
+  }
+  /**
+   * The same walk as {@link TsBitmap.#combine}, building a new bitmap and leaving both operands whole. Where both hold
+   * a key, the pair combines into a fresh container (the in-place form is never taken, so no storage of either operand
+   * is written). A container only `x` holds is kept by reference and flagged shared, so a later write to `x` or to the
+   * result copies it once; for an intersection nothing of `x` is kept, so nothing is flagged. A container only `y`
+   * holds is copied in for a union or a symmetric difference.
+   */
+  static #fresh(x, y, op) {
+    const a = x.#keys;
+    const b = y.#keys;
+    const ca = x.#conts;
+    const cb = y.#conts;
+    const keys = [];
+    const conts = [];
+    let size = 0;
+    let i = 0;
+    let j = 0;
+    while (i < a.length && j < b.length) {
+      const ka = a[i];
+      const kb = b[j];
+      if (ka === kb) {
+        const c = freshPair(op, ca[i++], cb[j++]);
+        if (c !== null) {
+          keys.push(ka);
+          conts.push(c);
+          size += c.card;
+        }
+      } else if (ka < kb) {
+        if (op === AND) {
+          i = gallopKeys(a, kb, i + 1);
+        } else {
+          const c = ca[i++];
+          c.shared = true;
+          keys.push(ka);
+          conts.push(c);
+          size += c.card;
+        }
+      } else if (op === AND) {
+        j = gallopKeys(b, ka, j + 1);
+      } else {
+        if (op === OR || op === XOR) {
+          keys.push(kb);
+          conts.push(cloneContainer(cb[j]));
+          size += cb[j].card;
+        }
+        j++;
+      }
+    }
+    if (op !== AND) {
+      for (; i < a.length; i++) {
+        const c = ca[i];
+        c.shared = true;
+        keys.push(a[i]);
+        conts.push(c);
+        size += c.card;
+      }
+    }
+    if (op === OR || op === XOR) {
+      for (; j < b.length; j++) {
+        keys.push(b[j]);
+        conts.push(cloneContainer(cb[j]));
+        size += cb[j].card;
+      }
+    }
+    return new _TsBitmap(keys, conts, size);
+  }
 };
+function freshPair(op, a, b) {
+  if (op === OR) return containerOr(a, b, false);
+  if (op === AND) return containerAnd(a, b, false);
+  if (op === AND_NOT) return containerAndNot(a, b, false);
+  return containerXor(a, b, false);
+}
 var EMPTIED = arrayContainer(new Uint16Array(0), 0);
 var tsRoaringCodec = {
   empty: () => TsBitmap.empty(),
@@ -2017,7 +3303,7 @@ import {
   DEFAULT_RETRY_POLICY,
   NOOP_METRICS,
   RetryingStorageChunkSource,
-  ValidationError as ValidationError4,
+  ValidationError as ValidationError3,
   isStorageBackend
 } from "@cloudbitmaps/core";
 function resolveRetryPolicy(partial) {
@@ -2041,7 +3327,7 @@ function wireStore(options, clock, rng, metrics) {
   if (options.retry !== false) {
     const { onRetry: userOnRetry, ...ov } = options.retry ?? {};
     if (userOnRetry !== void 0 && typeof userOnRetry !== "function") {
-      throw new ValidationError4("retry.onRetry must be a function");
+      throw new ValidationError3("retry.onRetry must be a function");
     }
     retryOptions = {
       clock,
@@ -2072,7 +3358,7 @@ function wireStore(options, clock, rng, metrics) {
 function resolveStorageSource(options, clock) {
   const storage = options.storage;
   if (storage === null || typeof storage !== "object") {
-    throw new ValidationError4(
+    throw new ValidationError3(
       "`storage` must be a StorageBackend, an IStorageDriver, or a StorageChunkSource"
     );
   }
@@ -2082,14 +3368,14 @@ function resolveStorageSource(options, clock) {
   const hasPutImmutable = typeof storage.putImmutable === "function";
   const isBackend = isStorageBackend(storage);
   if (isBackend && (hasGetChunk || hasPutImmutable)) {
-    throw new ValidationError4(
+    throw new ValidationError3(
       `\`storage\` is a StorageBackend that also exposes ${hasGetChunk ? "`getChunk`" : "`putImmutable`"} \u2014 ambiguous. A backend must not also be a driver or a source; pass whichever one you mean.`
     );
   }
   const hasStorageHalf = isObject(asBackend.storage);
   const hasRegistryHalf = isObject(asBackend.registry);
   if (!isBackend && hasPutImmutable && hasRegistryHalf) {
-    throw new ValidationError4(
+    throw new ValidationError3(
       "`storage` looks like a driver that also carries a `registry`. Passed as a bare driver it would have no pointer at all \u2014 generations would resolve by list-scan, so reads could serve a generation that was written but never published. If you meant a backend, use a backend class \u2014 S3Storage, GcsStorage, AzureBlobStorage, LocalFsStorage or MemoryStorage \u2014 or, to pair a driver of your own with a registry, brand the pair with `brandAsBackend` from `@cloudbitmaps/core/driver-kit`."
     );
   }
@@ -2098,11 +3384,11 @@ function resolveStorageSource(options, clock) {
     const registryOk = typeof asBackend.registry.compareAndSwap === "function";
     if (!storageOk || !registryOk) {
       const bad = !storageOk ? "`storage` half is not an IStorageDriver (no `putImmutable`)" : "`registry` half is not an IRegistryDriver (no `compareAndSwap`)";
-      throw new ValidationError4(
+      throw new ValidationError3(
         "`storage` looks like a backend but its " + bad + " \u2014 use a backend class, or brand a pair of drivers with `brandAsBackend` from `@cloudbitmaps/core/driver-kit`."
       );
     }
-    throw new ValidationError4(
+    throw new ValidationError3(
       "`storage` must be a backend \u2014 S3Storage, GcsStorage, AzureBlobStorage, LocalFsStorage or MemoryStorage. An object with `.storage` and `.registry` is not one: a backend builds both halves from a single bucket and prefix, so they cannot disagree, and hand-assembling them re-opens exactly that mismatch \u2014 a store whose pointer and generations live in different places reads as empty rather than failing. A driver author who genuinely wants halves of their own \u2014 an instrumented driver, a registry in a database you already run \u2014 brands the pair with `brandAsBackend` from `@cloudbitmaps/core/driver-kit`, which is taking on that they agree."
     );
   }
@@ -2123,18 +3409,18 @@ function resolveStorageSource(options, clock) {
     };
   }
   if (hasGetChunk && hasPutImmutable) {
-    throw new ValidationError4(
+    throw new ValidationError3(
       "`storage` exposes both `getChunk` and `putImmutable` \u2014 ambiguous; pass a StorageBackend, an IStorageDriver, or a StorageChunkSource, not a hybrid"
     );
   }
   if (!hasGetChunk && !hasPutImmutable) {
-    throw new ValidationError4(
+    throw new ValidationError3(
       "`storage` must be a StorageBackend, an IStorageDriver, or a StorageChunkSource"
     );
   }
   if (hasGetChunk) {
     if (options.encryption?.keystore !== void 0 || options.encryption?.required === true) {
-      throw new ValidationError4(
+      throw new ValidationError3(
         "keystore/requireEncryption apply only when the store builds its own read path: a StorageChunkSource of your own reads an encrypted segment by itself, if it must; to have the store decrypt, pass a backend"
       );
     }
@@ -2156,32 +3442,32 @@ function resolveStorageSource(options, clock) {
 }
 
 // src/options.ts
-import { ValidationError as ValidationError5 } from "@cloudbitmaps/core";
+import { ValidationError as ValidationError4 } from "@cloudbitmaps/core";
 var keysOf = () => (keys) => keys;
 var kindOf = (v) => v === null ? "null" : Array.isArray(v) ? "an array" : `a ${typeof v}`;
 function optionsError(options, op, known, booleans = [], misplaced = []) {
   if (options === void 0 || options === null) return void 0;
   if (typeof options !== "object" || Array.isArray(options)) {
-    return new ValidationError5(`${op}: options must be an object; got ${kindOf(options)}`);
+    return new ValidationError4(`${op}: options must be an object; got ${kindOf(options)}`);
   }
   const bag = options;
   const unknown = Object.keys(bag).filter((k) => !known.includes(k) && bag[k] !== void 0);
   for (const k of misplaced) if (!unknown.includes(k) && bag[k] !== void 0) unknown.push(k);
   if (unknown.length > 0) {
-    return new ValidationError5(
+    return new ValidationError4(
       `${op}: unknown option${unknown.length > 1 ? "s" : ""} ${unknown.map((k) => `"${k}"`).join(", ")}; it takes { ${known.join(", ")} }`
     );
   }
   const audit = bag.audit;
   if (audit !== void 0 && audit !== null && typeof audit.onEvent !== "function") {
-    return new ValidationError5(
+    return new ValidationError4(
       `${op}: audit must be a sink with an onEvent(event) method, such as a RecordingAuditSink`
     );
   }
   for (const name of booleans) {
     const v = bag[name];
     if (v !== void 0 && typeof v !== "boolean") {
-      return new ValidationError5(`${op}: \`${name}\` must be a boolean; got ${kindOf(v)}`);
+      return new ValidationError4(`${op}: \`${name}\` must be a boolean; got ${kindOf(v)}`);
     }
   }
   return void 0;
@@ -2206,7 +3492,7 @@ import {
   excludingReservedRows as excludingReservedRows2,
   readRetentionPolicy,
   CloudRoaringError,
-  ValidationError as ValidationError7,
+  ValidationError as ValidationError6,
   WriteConflictError as WriteConflictError2,
   IntegrityError as IntegrityError4,
   NotFoundError as NotFoundError2,
@@ -2230,7 +3516,7 @@ var SystemRng = class {
 };
 function validateRef(ref, verb) {
   if (typeof ref !== "object" || ref === null) {
-    throw new ValidationError6(
+    throw new ValidationError5(
       "a segment ref is an object such as { segment: 'name' }; store.segment() takes the bare name"
     );
   }
@@ -2251,7 +3537,7 @@ function validateConcurrency(concurrency) {
 function requireScope(options, op) {
   if (options.namespace !== void 0) {
     if (typeof options.namespace !== "string") {
-      throw new ValidationError6(
+      throw new ValidationError5(
         `${op}: namespace must be a string; got ${kindOf(options.namespace)}`
       );
     }
@@ -2259,12 +3545,12 @@ function requireScope(options, op) {
   }
   refuseReservedNamespace(options.namespace);
   if (options.namespace !== void 0 && options.allNamespaces === true) {
-    throw new ValidationError6(
+    throw new ValidationError5(
       `${op}: pass a namespace or { allNamespaces: true }, not both: with both, it is unclear whether to scan one namespace or every one`
     );
   }
   if (options.namespace === void 0 && options.allNamespaces !== true) {
-    throw new ValidationError6(
+    throw new ValidationError5(
       `${op} scans the global id space across all namespaces \u2014 pass an explicit \`namespace\`, or \`{ allNamespaces: true }\` to intentionally sweep the whole fleet`
     );
   }
@@ -2286,6 +3572,29 @@ var CALL_KEYS = {
     "allowAbsentOperands",
     "exclude"
   ]),
+  intersectCount: keysOf()([
+    "after",
+    "through",
+    "concurrency",
+    "budget",
+    "allowAbsentOperands",
+    "exclude"
+  ]),
+  unionCount: keysOf()([
+    "after",
+    "through",
+    "concurrency",
+    "budget",
+    "allowAbsentOperands",
+    "exclude"
+  ]),
+  andNotCount: keysOf()([
+    "after",
+    "through",
+    "concurrency",
+    "budget",
+    "allowAbsentOperands"
+  ]),
   into: keysOf()([
     "after",
     "through",
@@ -2363,6 +3672,9 @@ var MISPLACED = {
   range: outside(CALL_KEYS.into, CALL_KEYS.range),
   andNot: outside(CALL_KEYS.into, CALL_KEYS.andNot),
   combine: outside(CALL_KEYS.into, CALL_KEYS.combine),
+  intersectCount: outside(CALL_KEYS.into, CALL_KEYS.intersectCount),
+  unionCount: outside(CALL_KEYS.into, CALL_KEYS.unionCount),
+  andNotCount: outside(CALL_KEYS.into, CALL_KEYS.andNotCount),
   andNotInto: outside(CALL_KEYS.into, CALL_KEYS.andNotInto),
   exportSegments: ["codec"]
 };
@@ -2372,16 +3684,16 @@ var originOf;
 function assertOneStore(verb, role, h, origin) {
   if (h instanceof Segment) {
     if (originOf(h) === origin) return;
-    throw new ValidationError6(
+    throw new ValidationError5(
       `${verb}: ${role} belongs to another store; combine segments of one store: open each with this store's segment()`
     );
   }
   if (typeof h === "object" && h !== null && h[SEGMENT_BRAND] === true) {
-    throw new ValidationError6(
+    throw new ValidationError5(
       `${verb}: ${role} comes from another installed copy of @cloudbitmaps/roaring, so it belongs to another store; install one copy and combine segments of one store`
     );
   }
-  throw new ValidationError6(`${verb}: ${role} must be a segment from this store's segment()`);
+  throw new ValidationError5(`${verb}: ${role} must be a segment from this store's segment()`);
 }
 var MATERIALIZE_MANY_KEYS = [
   "operands",
@@ -2471,7 +3783,7 @@ var CloudRoaring = class _CloudRoaring {
    */
   static rejectUnknownOptions(options) {
     if (options === null || options === void 0 || typeof options !== "object") {
-      throw new ValidationError6(
+      throw new ValidationError5(
         "CloudRoaring needs an options object with a `storage` key \u2014 got " + (options === null ? "null" : typeof options)
       );
     }
@@ -2489,7 +3801,7 @@ var CloudRoaring = class _CloudRoaring {
       const tag = Object.prototype.toString.call(value).slice(8, -1);
       if (typeof value !== "object" || value === null || NOT_A_GROUP[tag] !== void 0) {
         const got = typeof value !== "object" ? typeof value : NOT_A_GROUP[tag];
-        throw new ValidationError6(
+        throw new ValidationError5(
           `CloudRoaring's \`${group}\` must be an object${offOk ? " or `false`" : ""} \u2014 got ${got}`
         );
       }
@@ -2499,7 +3811,7 @@ var CloudRoaring = class _CloudRoaring {
     if (unknown.length === 0) return;
     const takes = (keys) => keys.map((k) => `\`${k}\``).join(", ");
     const named = [...new Set(unknown.map((u) => u.group))];
-    throw new ValidationError6(
+    throw new ValidationError5(
       `CloudRoaring does not take ${takes(unknown.map((u) => u.group === null ? u.key : `${u.group}.${u.key}`))}. ` + named.map(
         (g) => g === null ? `The store takes ${takes(OPTION_KEYS.top)}.` : `\`${g}\` takes ${takes(OPTION_KEYS[g])}.`
       ).join(" ") + " https://github.com/cloudbitmaps/cloudbitmaps/blob/main/docs/guide/api-reference.md#build-a-store--new-cloudroaringoptions"
@@ -2517,7 +3829,7 @@ var CloudRoaring = class _CloudRoaring {
     ];
     const entropy = options.seams?.entropy;
     if (entropy !== void 0 && typeof entropy !== "function") {
-      throw new ValidationError6(
+      throw new ValidationError5(
         "CloudRoaring's `seams.entropy` must be a function `(length) => Uint8Array` returning that many random bytes"
       );
     }
@@ -2525,7 +3837,7 @@ var CloudRoaring = class _CloudRoaring {
       if (seam === void 0) continue;
       const has = (m) => seam !== null && typeof seam[m] === "function";
       if (seam === null || typeof seam !== "object" || !needs.every(has)) {
-        throw new ValidationError6(
+        throw new ValidationError5(
           `CloudRoaring's \`${name}\` must be an object with ${needs.map((m) => `\`${m}()\``).join(" and ")}`
         );
       }
@@ -2545,7 +3857,7 @@ var CloudRoaring = class _CloudRoaring {
       requirePositiveInt("cache.readerMaxBytes", cache.readerMaxBytes);
       const ttl = cache.ttlMs;
       if (ttl !== void 0 && (typeof ttl !== "number" || !Number.isFinite(ttl) || ttl <= 0)) {
-        throw new ValidationError6(
+        throw new ValidationError5(
           `cache.ttlMs must be a finite number above 0 (milliseconds); got ${typeof ttl === "string" ? JSON.stringify(ttl) : String(ttl)}`
         );
       }
@@ -2637,17 +3949,17 @@ var CloudRoaring = class _CloudRoaring {
    */
   segment(name, options) {
     if (typeof name === "object" && name !== null) {
-      throw new ValidationError6(
+      throw new ValidationError5(
         Array.isArray(name) ? "segment: the name is a string, store.segment('name'), not an array" : "segment: the name is a string, not a ref: for a ref, call store.segment(ref.segment, { namespace: ref.namespace })"
       );
     }
     if (options !== void 0 && options !== null) {
       if (typeof options !== "object" || Array.isArray(options)) {
-        throw new ValidationError6("segment: options must be an object such as { namespace }");
+        throw new ValidationError5("segment: options must be an object such as { namespace }");
       }
       const proto = Object.getPrototypeOf(options);
       if (proto !== null && Object.getPrototypeOf(proto) !== null) {
-        throw new ValidationError6(
+        throw new ValidationError5(
           "segment: options must be a plain object such as { namespace }, not a class instance or an object built on another"
         );
       }
@@ -2655,7 +3967,7 @@ var CloudRoaring = class _CloudRoaring {
         (k) => k !== "namespace" && options[k] !== void 0
       );
       if (unknown.length > 0) {
-        throw new ValidationError6(
+        throw new ValidationError5(
           `segment: unknown option${unknown.length > 1 ? "s" : ""} ${unknown.map((k) => `"${k}"`).join(", ")}; a handle takes { namespace } only`
         );
       }
@@ -2765,20 +4077,20 @@ var CloudRoaring = class _CloudRoaring {
   /** The one body of the forms above. */
   async materializeMany(options) {
     if (typeof options !== "object" || options === null) {
-      throw new ValidationError6(
+      throw new ValidationError5(
         "materializeMany needs an options object with `operands`, `outputs` and `keep`"
       );
     }
     const epochAt = options.feed === void 0 ? 0 : this.epochNow();
     const unknown = unknownManyKeys(options);
     if (unknown.length > 0) {
-      throw new ValidationError6(
+      throw new ValidationError5(
         `materializeMany: unknown option${unknown.length > 1 ? "s" : ""} ${unknown.map((k) => `"${k}"`).join(", ")}`
       );
     }
     const dryRunIn = options.dryRun;
     if (dryRunIn !== void 0 && typeof dryRunIn !== "boolean") {
-      throw new ValidationError6("materializeMany: dryRun must be a boolean");
+      throw new ValidationError5("materializeMany: dryRun must be a boolean");
     }
     const dryRun = dryRunIn === true;
     const operandsIn = options.operands;
@@ -2790,7 +4102,7 @@ var CloudRoaring = class _CloudRoaring {
     const feedIn = options.feed;
     const mayBeEmptyIn = options.mayBeEmpty;
     if (feedIn !== void 0 && options.maxBufferedBytes === void 0) {
-      throw new ValidationError6(
+      throw new ValidationError5(
         "materializeMany: maxBufferedBytes is required with a feed: the feed is read once, so the call runs as one group and the budget is what bounds it"
       );
     }
@@ -2800,15 +4112,15 @@ var CloudRoaring = class _CloudRoaring {
     const budgetOption = options.budget;
     const allowAbsentOperands = options.allowAbsentOperands;
     if (typeof pinOption !== "boolean")
-      throw new ValidationError6("materializeMany: pin must be a boolean");
+      throw new ValidationError5("materializeMany: pin must be a boolean");
     if (allowAbsentOperands !== void 0 && typeof allowAbsentOperands !== "boolean") {
-      throw new ValidationError6("materializeMany: allowAbsentOperands must be a boolean");
+      throw new ValidationError5("materializeMany: allowAbsentOperands must be a boolean");
     }
     if (typeof operandsIn !== "object" || operandsIn === null || Array.isArray(operandsIn)) {
-      throw new ValidationError6("materializeMany: operands must be an object of name to segment");
+      throw new ValidationError5("materializeMany: operands must be an object of name to segment");
     }
     if (!Array.isArray(outputsIn) || outputsIn.length === 0) {
-      throw new ValidationError6("materializeMany: outputs must be a non-empty array");
+      throw new ValidationError5("materializeMany: outputs must be a non-empty array");
     }
     const names = Object.keys(operandsIn);
     const handles = /* @__PURE__ */ new Map();
@@ -2819,14 +4131,14 @@ var CloudRoaring = class _CloudRoaring {
     }
     if (mayBeEmptyIn !== void 0 && feedIn === void 0) {
       if (!Array.isArray(mayBeEmptyIn)) {
-        throw new ValidationError6(
+        throw new ValidationError5(
           "materializeMany: mayBeEmpty must be an array of fed operand names"
         );
       }
       if (mayBeEmptyIn.length > 0) {
         const first = mayBeEmptyIn[0];
         const what = typeof first !== "string" ? "something that is not a name" : handles.has(first) ? `"${first}", a stored operand` : `"${first}", which is not an operand of this call`;
-        throw new ValidationError6(
+        throw new ValidationError5(
           `materializeMany: mayBeEmpty names ${what}; it names fed operands, and this call has no feed`
         );
       }
@@ -2836,13 +4148,13 @@ var CloudRoaring = class _CloudRoaring {
     const destKeys = /* @__PURE__ */ new Set();
     outputsIn.forEach((raw, i) => {
       if (typeof raw !== "object" || raw === null) {
-        throw new ValidationError6(`outputs[${i}] must be an object`);
+        throw new ValidationError5(`outputs[${i}] must be an object`);
       }
       const bad = Object.keys(raw).filter(
         (k) => !MATERIALIZE_MANY_OUTPUT_KEYS.includes(k)
       );
       if (bad.length > 0) {
-        throw new ValidationError6(
+        throw new ValidationError5(
           `outputs[${i}]: unknown option${bad.length > 1 ? "s" : ""} ${bad.map((k) => `"${k}"`).join(", ")}`
         );
       }
@@ -2850,12 +4162,12 @@ var CloudRoaring = class _CloudRoaring {
       const dest = spec.dest;
       assertOneStore("materializeMany", `outputs[${i}].dest`, dest, this.origin);
       if (operandKeys.has(dest.key())) {
-        throw new ValidationError6(
+        throw new ValidationError5(
           `outputs[${i}].dest is also an operand of the call: one call is one pass over operands that do not change under it, so chain two calls`
         );
       }
       if (destKeys.has(dest.key())) {
-        throw new ValidationError6(
+        throw new ValidationError5(
           `outputs[${i}].dest names a segment another output of the call writes`
         );
       }
@@ -2928,13 +4240,13 @@ var CloudRoaring = class _CloudRoaring {
         held.set(key, { at, handle });
       } else if (prior.at !== void 0 && at !== void 0) {
         if (!samePin(prior.at, at)) {
-          throw new ValidationError6(
+          throw new ValidationError5(
             `materializeMany: operand "${name}" holds a segment another operand holds, ${twoPins(prior.at, at)}: one call reads a segment at one generation`
           );
         }
       } else if (prior.at !== void 0 || at !== void 0) {
         if (!pinOption) {
-          throw new ValidationError6(
+          throw new ValidationError5(
             `materializeMany: operand "${name}" holds a segment another operand holds, ${twoPins(prior.at, at)}: one call reads a segment at one generation`
           );
         }
@@ -3022,7 +4334,7 @@ var CloudRoaring = class _CloudRoaring {
   /** A call's feed with the store's erasure counter: read once here, checked by the combine before any record is read. */
   feedOf(feed, mayBeEmpty, epochAt) {
     if (typeof feed !== "object" || feed === null || Array.isArray(feed)) {
-      throw new ValidationError6(
+      throw new ValidationError5(
         "materializeMany: feed must be an object with names, records and counts"
       );
     }
@@ -3466,8 +4778,8 @@ var CloudRoaring = class _CloudRoaring {
    * with `serialize('portable')` such as `roaring`'s `RoaringBitmap32`, or `{ serialized }`, portable Roaring bytes.
    * A bitmap is checked (size cap, structure, safe deserializer) before the first request, written from its own
    * containers with no per-id work, and gives the generation chunk for chunk what its ids would. An
-   * iterable with a `serialize` method (a `RoaringBitmap32`, another copy's bitmap, or a bitmap `deserializePortable`
-   * returned) passed as ids loads as `{ bitmap }` and is not iterated. A `Uint8Array` or `Buffer` passed as ids is
+   * iterable with a `serialize` method (a `RoaringBitmap32`, another copy's bitmap, or a `RoaringBitmap`
+   * of this package) passed as ids loads as `{ bitmap }` and is not iterated. A `Uint8Array` or `Buffer` passed as ids is
    * refused with `ValidationError`, since each byte would load as an id, even when it has a `serialize` of its own:
    * pass bytes as `{ serialized }`.
    *
@@ -3570,7 +4882,7 @@ var CloudRoaring = class _CloudRoaring {
       const sameBackend = reads !== void 0 && (reads.origin === this.origin || this.registry !== void 0 && REGISTRY_OF.get(reads.origin) === this.registry);
       if (sameBackend && reads.keys.includes(segmentKey(ref))) {
         const named = ref.namespace === void 0 ? ref.segment : `${ref.namespace}/${ref.segment}`;
-        throw new ValidationError6(
+        throw new ValidationError5(
           `load: the ids come from a read of the segment "${named}" that is being loaded, and a load publishes over whatever the segment is by then, so another process's newer load of it can be replaced by a result built from the one before, with no conflict reported. This release has no fenced in-place update: write the result into a new segment and point readers at it`
         );
       }
@@ -3634,7 +4946,7 @@ var CloudRoaring = class _CloudRoaring {
   async dropSegment(ref, options) {
     ref = validateRef(ref, "dropSegment");
     if (options === void 0 || options === null) {
-      throw new ValidationError6("dropSegment: options { confirmSegment } are required");
+      throw new ValidationError5("dropSegment: options { confirmSegment } are required");
     }
     checkOptions(options, "dropSegment", CALL_KEYS.dropSegment, ["dryRun"]);
     const deps = this.lifecycleDeps("dropSegment");
@@ -3953,7 +5265,7 @@ var CloudRoaring = class _CloudRoaring {
       if (held.has(key)) {
         const before = held.get(key);
         if (!samePin(before, at)) {
-          throw new ValidationError6(
+          throw new ValidationError5(
             `the same segment is in this combine twice, ${twoPins(before, at)}: one call reads a segment at one generation, so materialise one of them into a segment of its own first, with \`materializeMany({ operands: { src: seg }, outputs: [{ dest, expr: { or: ['src'] } }], keep })\``
           );
         }
@@ -4073,7 +5385,7 @@ var CloudRoaring = class _CloudRoaring {
   /**
    * **Export ("eject") every registered segment's current generation** through the injected `sink`, using only
    * public read APIs — so your data is readable **without CloudRoaring** (the exit path; see the README's "Your
-   * data stays yours"). `format: 'roaring'` (default) writes one **portable RoaringBitmap32** per segment
+   * data stays yours"). `format: 'roaring'` (default) writes one **portable Roaring bitmap** per segment
    * (loadable by any roaring library); `'ndjson'` writes newline-delimited ids (zero-dependency, streaming).
    * Enumerates via the store's **own** registry (needs one — throws {@link UnsupportedError} otherwise) so the
    * enumeration and the read path provably share one registry. Encrypted segments are decrypted transparently
@@ -4115,7 +5427,7 @@ var readOptions = (options) => ({
 });
 var NO_SEGMENTS = [];
 function segmentList(list, what) {
-  if (!Array.isArray(list)) throw new ValidationError6(`${what} must be an array of segments`);
+  if (!Array.isArray(list)) throw new ValidationError5(`${what} must be an array of segments`);
   return list;
 }
 var STREAM_SOURCES = /* @__PURE__ */ new WeakMap();
@@ -4128,8 +5440,8 @@ function operandsLabel(verb) {
   return verb === "andNot" ? "andNot: `excludes`" : `${verb}: \`others\``;
 }
 function refuseNoOperands(verb) {
-  throw new ValidationError6(
-    verb === "intersect" ? "intersect requires at least one segment to intersect with; to read every id of one segment, use iterate()" : "intersectInto requires at least one segment to intersect with; to copy this segment into dest, call materializeMany({ operands: { src: thisSegment }, outputs: [{ dest, expr: { or: ['src'] } }], keep })"
+  throw new ValidationError5(
+    verb === "intersect" ? "intersect requires at least one segment to intersect with; to read every id of one segment, use iterate()" : verb === "intersectCount" ? "intersectCount requires at least one segment to intersect with; to count one segment, use count()" : "intersectInto requires at least one segment to intersect with; to copy this segment into dest, call materializeMany({ operands: { src: thisSegment }, outputs: [{ dest, expr: { or: ['src'] } }], keep })"
   );
 }
 var AS_IDS = {
@@ -4209,7 +5521,7 @@ var Segment = class _Segment {
    */
   constructor(parts) {
     if (!minting) {
-      throw new ValidationError6(
+      throw new ValidationError5(
         "a Segment is not constructed directly; call `store.segment(name)`"
       );
     }
@@ -4323,11 +5635,11 @@ var Segment = class _Segment {
   leaseUntilOf(op, options) {
     if (options === void 0 || options === null) return void 0;
     if (typeof options !== "object" || Array.isArray(options)) {
-      throw new ValidationError6(`${op}: options must be an object such as { leaseUntil }`);
+      throw new ValidationError5(`${op}: options must be an object such as { leaseUntil }`);
     }
     const unknown = Object.keys(options).filter((k) => k !== "leaseUntil");
     if (unknown.length > 0) {
-      throw new ValidationError6(
+      throw new ValidationError5(
         `${op}: unknown option${unknown.length > 1 ? "s" : ""} ${unknown.map((k) => `"${k}"`).join(", ")}; this version takes { leaseUntil } only`
       );
     }
@@ -4335,17 +5647,17 @@ var Segment = class _Segment {
     if (until === void 0) return void 0;
     const now = this.clock.now();
     if (typeof until !== "number" || !Number.isSafeInteger(until)) {
-      throw new ValidationError6(
+      throw new ValidationError5(
         `${op}: leaseUntil must be an integer epoch-MILLISECONDS; got ${String(until)}`
       );
     }
     if (until <= now) {
-      throw new ValidationError6(
+      throw new ValidationError5(
         `${op}: leaseUntil (${until}) is not after now (${now}); it is epoch MILLISECONDS, so a value in seconds reads as long past. Use \`Date.now() + hours * 3_600_000\``
       );
     }
     if (until > now + MAX_LEASE_MS) {
-      throw new ValidationError6(
+      throw new ValidationError5(
         `${op}: leaseUntil is more than 14 days away; the longest lease is ${MAX_LEASE_MS} ms. Take a new lease when a job outlasts it`
       );
     }
@@ -4449,22 +5761,22 @@ var Segment = class _Segment {
     const { generation, fingerprint, version } = at ?? {};
     const unknown = typeof at === "object" && at !== null ? Object.keys(at).filter((k) => !["generation", "fingerprint", "version"].includes(k)) : [];
     if (unknown.length > 0) {
-      throw new ValidationError6(
+      throw new ValidationError5(
         `pinAt: unknown option${unknown.length > 1 ? "s" : ""} ${unknown.map((k) => `"${k}"`).join(", ")}; pinAt takes { generation, fingerprint } and a pin's \`version\`, which it does not read`
       );
     }
     if (generation === null) {
-      throw new ValidationError6(
+      throw new ValidationError5(
         "pinAt: the pin named no generation (the segment had none when it was pinned), so there is nothing to reopen"
       );
     }
     if (version !== void 0 && typeof version !== "string") {
-      throw new ValidationError6(
+      throw new ValidationError5(
         "pinAt: `version`, when given, is the string a pin recorded in its pinnedAt; pinAt does not read it, so leave it out if you have none"
       );
     }
     if (typeof generation !== "number" || !Number.isSafeInteger(generation) || generation < 0 || typeof fingerprint !== "string" || !/^\d+:\d+$/.test(fingerprint)) {
-      throw new ValidationError6(
+      throw new ValidationError5(
         "pinAt: pass { generation, fingerprint } as recorded by an earlier pin (its pinnedAt); a generation number without the fingerprint of its object does not identify it"
       );
     }
@@ -4513,7 +5825,7 @@ var Segment = class _Segment {
     if (role === void 0) return;
     const { namespace, segment } = dest.ref;
     const named = namespace === void 0 ? segment : `${namespace}/${segment}`;
-    throw new ValidationError6(
+    throw new ValidationError5(
       `${verb}: the destination "${named}" is also ${role} of the call, and a call that reads a segment while it publishes to it can replace a newer load of it with a result built from an older one, with no conflict reported. This release has no fenced in-place update: combine into a new segment and point readers at it`
     );
   }
@@ -4839,6 +6151,111 @@ var Segment = class _Segment {
     );
     return this.combineInto("andNotInto", dest, excludes, options);
   }
+  /**
+   * How many ids `this ∩ others…` holds (minus `exclude`): the length of what {@link intersect} streams, without
+   * streaming it. Every key all the operands hold is decoded and counted as the stream reads it, and a key only some
+   * operands hold is not read, so the call makes the requests {@link intersect} makes and returns a number instead of
+   * the ids. It is exact: it never answers a key from an index, so it trusts nothing {@link count} trusts.
+   *
+   * The range, `concurrency`, `budget`, `allowAbsentOperands` and `exclude` are {@link intersect}'s; a write option fails
+   * the call with {@link ValidationError} before any request, and so does an empty `others` (to count one segment, use
+   * {@link count}).
+   *
+   * Like a stream, a count that runs while a segment is erased or reloaded can describe two instants, within the bound
+   * the streams state. A union or a difference, and an intersection with an `exclude`, looks at its operands'
+   * generations every `concurrency` keys; an intersection with no `exclude` makes no such look, since it decodes every
+   * key and so shows a move in the chunks it decodes, as its stream does. Either way it plans again above the last key
+   * it took when one moved. A pinned handle counts the generation it pinned, and each pinned operand's object is
+   * looked up once before the first key (one footer read each, which `budget` does not charge, and which the stream
+   * does not make), and again at each look where there is one, so an erasure of what it pinned fails the count with
+   * {@link NotFoundError}; a
+   * fault the look meets other than a transient one, which is retried, is raised as it is. A call that involves a
+   * handle whose lease has ended, or has ended by the next look, throws {@link LeaseExpiredError}.
+   */
+  async intersectCount(others, options) {
+    checkOptions(
+      options,
+      "intersectCount",
+      CALL_KEYS.intersectCount,
+      ["allowAbsentOperands"],
+      MISPLACED.intersectCount
+    );
+    return this.countCombine("intersect", others, options ?? void 0);
+  }
+  /**
+   * How many ids `this ∪ others…` holds (minus `exclude`): the length of what {@link union} streams, without streaming
+   * it. A chunk key only one operand holds, that no `exclude` holds and the range does not cut, is answered from that
+   * operand's index, so a union of segments that mostly do not overlap reads little of them; every other key is
+   * decoded and counted. On handles that are not pinned it makes no more requests than {@link union} does, and reads
+   * fewer bytes when the shared keys are few. An empty `others`, with no `exclude` and no range, is {@link count} of
+   * `this`, answered from the registry row when it can be; when that figure is 0 it adds one registry read, to refuse
+   * a segment that does not exist as the stream does.
+   *
+   * What it trusts: the index, for each key it answers without decoding, as {@link count} does, so a party who can write
+   * an object's index can make that key's figure wrong; a decoded key is exact. A source with no per-chunk counts
+   * decodes every key. It takes the options {@link intersectCount} takes; the erasure bound, the lease checks and the
+   * pinned handles are as for {@link intersectCount}, a pinned operand adding a footer read before the first key and at
+   * each look. An empty `others` on a pinned handle is {@link count} of the pin, with no look.
+   */
+  async unionCount(others, options) {
+    checkOptions(
+      options,
+      "unionCount",
+      CALL_KEYS.unionCount,
+      ["allowAbsentOperands"],
+      MISPLACED.unionCount
+    );
+    return this.countCombine("union", others, options ?? void 0);
+  }
+  /**
+   * How many ids `this \ (excludes…)` holds: the length of what {@link andNot} streams, without streaming it. A chunk
+   * key of `this` that no exclude holds and the range does not cut is answered from its index and not read; a key an
+   * exclude shares is decoded and counted. On handles that are not pinned it makes no more requests than {@link andNot}
+   * does, and reads fewer bytes when the excludes overlap little of `this`. An empty `excludes`, with no range, is
+   * {@link count} of `this` (the stream of it is the whole of `this`), answered from the registry row when it can be,
+   * with one registry read added when that figure is 0.
+   *
+   * It takes the options {@link andNot} takes (every one of {@link intersectCount}'s but `exclude`, which a count of a
+   * difference has no use for, since `excludes` is its subtraction) and trusts what {@link unionCount} trusts. The
+   * erasure bound, the lease checks and the pinned handles are as for {@link intersectCount}.
+   */
+  async andNotCount(excludes, options) {
+    checkOptions(
+      options,
+      "andNotCount",
+      CALL_KEYS.andNotCount,
+      ["allowAbsentOperands"],
+      MISPLACED.andNotCount
+    );
+    return this.countCombine("andNot", excludes, options ?? void 0);
+  }
+  /** The one body of the three count methods, after each has checked its own options. */
+  async countCombine(verb, operands, options) {
+    const name = `${verb}Count`;
+    const exclude = verb === "andNot" ? NO_SEGMENTS : this.excludesOf(options);
+    const others = segmentList(
+      operands,
+      verb === "andNot" ? `${name}: \`excludes\`` : `${name}: \`others\``
+    );
+    if (verb === "intersect" && others.length === 0) refuseNoOperands("intersectCount");
+    const handles = [this, ...others, ...exclude];
+    this.assertSegments(name, verb === "andNot" ? "an exclude" : "an operand", others);
+    this.assertSegments(name, "an exclude", exclude);
+    this.assertLeases(handles);
+    const engine = this.combineEngine(handles) ?? this.engine;
+    const read = options == null ? void 0 : readOptions(options);
+    const guard2 = handles.some((h) => h.leaseHold !== void 0) ? () => this.assertLeases(handles) : void 0;
+    const opts = guard2 === void 0 ? read : { ...read, guard: guard2 };
+    const refs = others.map((o) => o.ref);
+    if (verb === "andNot") return engine.combineCount([this.ref], refs, "all", verb, opts);
+    return engine.combineCount(
+      [this.ref, ...refs],
+      exclude.map((o) => o.ref),
+      verb === "union" ? "any" : "all",
+      verb,
+      opts
+    );
+  }
   /**
    * The one body of the three combines, read as ids or as chunks. `operands` is `others` for `intersect` and
    * `union`, and `excludes` for `andNot`, which takes no `exclude` option.
@@ -4943,25 +6360,25 @@ function parseConfig(env) {
   );
   if (unknown.length > 0) {
     const which = unknown.length > 1 ? `${unknown.join(", ")} are not settings export-segments takes.` : `${unknown[0]} is not a setting export-segments takes.`;
-    throw new ValidationError7(
+    throw new ValidationError6(
       `${which} It takes ${EXPORT_VARIABLES.join(", ")}; run export-segments --help`
     );
   }
   const root = env.CR_EXPORT_ROOT;
   if (root === void 0 || root === "") {
-    throw new ValidationError7(
+    throw new ValidationError6(
       "CR_EXPORT_ROOT is not set: the directory that holds the store's storage/ and registry/. export-segments also needs CR_EXPORT_OUT; run export-segments --help"
     );
   }
   const out = env.CR_EXPORT_OUT;
   if (out === void 0 || out === "") {
-    throw new ValidationError7(
+    throw new ValidationError6(
       "CR_EXPORT_OUT is not set: the directory to write the dump to. export-segments also needs CR_EXPORT_ROOT; run export-segments --help"
     );
   }
   const format = env.CR_EXPORT_FORMAT || "roaring";
   if (format !== "roaring" && format !== "ndjson") {
-    throw new ValidationError7(`CR_EXPORT_FORMAT must be "roaring" or "ndjson"; got ${format}`);
+    throw new ValidationError6(`CR_EXPORT_FORMAT must be "roaring" or "ndjson"; got ${format}`);
   }
   const namespace = env.CR_EXPORT_NAMESPACE || void 0;
   return { root, out, format, namespace };
@@ -4976,7 +6393,7 @@ async function ensureOwnDirectory(out, dir) {
   }
   const found = await lstat(dir);
   const refuse = (why) => {
-    throw new ValidationError7(`the export directory is not one this tool made: ${why}`);
+    throw new ValidationError6(`the export directory is not one this tool made: ${why}`);
   };
   if (found.isSymbolicLink()) refuse("a namespace directory is a symbolic link");
   if (!found.isDirectory()) refuse("a namespace path is not a directory");
@@ -4991,7 +6408,7 @@ function fsSink(out) {
     async open(ref, ext) {
       const part = namespacePathPart(ref.namespace);
       if (part.toLowerCase() === MANIFEST_NAME) {
-        throw new ValidationError7(
+        throw new ValidationError6(
           `a namespace named ${MANIFEST_NAME} (in any letter case) cannot be exported to a directory: its folder would be the manifest's path`
         );
       }
@@ -5036,10 +6453,10 @@ async function requireStoreRoot(root) {
   try {
     entries = await readdir(root);
   } catch {
-    throw new ValidationError7("CR_EXPORT_ROOT does not name a directory that can be read");
+    throw new ValidationError6("CR_EXPORT_ROOT does not name a directory that can be read");
   }
   if (entries.length === 0) {
-    throw new ValidationError7(
+    throw new ValidationError6(
       "CR_EXPORT_ROOT is empty: it holds no store (an unmounted volume, or the wrong directory)"
     );
   }
@@ -5055,7 +6472,7 @@ async function main(env = process.env, now = () => Date.now()) {
   const store = new CloudRoaring({ storage });
   const priorManifest = await lstat(join(config.out, MANIFEST_NAME)).catch(() => null);
   if (priorManifest?.isDirectory() === true) {
-    throw new ValidationError7(
+    throw new ValidationError6(
       `${join(config.out, MANIFEST_NAME)} is a directory, so the manifest cannot be written there: remove or rename it, or export to a fresh directory`
     );
   }