@cloudbitmaps/core 0.12.0 → 0.14.0

package/dist/index.js

@@ -102,6 +102,110 @@ async function collectWithinBudget(source, budget, op) {
   return out;
 }
 
+// src/core/chunk-window.ts
+var ChunkWindow = class {
+  constructor(keys, fetch, max, ramp) {
+    this.keys = keys;
+    this.fetch = fetch;
+    this.max = max;
+    this.ramp = ramp;
+  }
+  keys;
+  fetch;
+  max;
+  ramp;
+  open = [];
+  launched = 0;
+  taken = 0;
+  /** The next read's result in key order, or the error that read raised. */
+  async take() {
+    const width = this.ramp ? Math.min(this.max, 2 ** Math.min(this.taken, 30)) : this.max;
+    while (this.launched < this.keys.length && this.launched - this.taken < width) {
+      this.open.push(
+        this.fetch(this.keys[this.launched++]).then(
+          (value) => ({ value }),
+          (cause) => ({ value: void 0, error: { cause } })
+        )
+      );
+    }
+    const slot = await this.open.shift();
+    this.taken += 1;
+    if (slot.error) throw slot.error.cause;
+    return slot.value;
+  }
+};
+
+// src/core/crbm/format.ts
+var MAGIC = Uint8Array.of(67, 82, 66, 77);
+var VERSION_MAJOR = 1;
+var VERSION_MINOR = 0;
+var PREAMBLE_BYTES = 8;
+var PAYLOAD_START = PREAMBLE_BYTES;
+var FOOTER_BYTES = 104;
+var FOOTER = {
+  indexOffset: 0,
+  // u64
+  indexLength: 8,
+  // u64
+  indexCrc32c: 16,
+  // u32
+  flags: 20,
+  // u32
+  payloadCodecId: 24,
+  // u16 — which codec wrote the chunk payloads
+  elementWidth: 26,
+  // u8
+  containerCodec: 27,
+  // u8
+  versionMajor: 28,
+  // u8
+  versionMinor: 29,
+  // u8
+  reserved2: 30,
+  // u16
+  generation: 32,
+  // u64
+  indexNonce: 40,
+  // 12 B
+  indexTag: 52,
+  // 16 B
+  keyId: 68,
+  // 16 B
+  chunkCount: 84,
+  // u32
+  totalCardinality: 88,
+  // u64
+  footerCrc32c: 96,
+  // u32 — covers footer bytes [0, 96)
+  endMagic: 100
+  // char[4]
+};
+var FOOTER_CRC_COVERAGE = FOOTER.footerCrc32c;
+var FLAG_ENCRYPTED = 1 << 0;
+var FLAG_INDEX_COMPRESSED = 1 << 1;
+var FLAG_LITTLE_ENDIAN = 1 << 2;
+var FLAG_EXTENSION = 1 << 3;
+var KNOWN_FLAGS = FLAG_ENCRYPTED | FLAG_LITTLE_ENDIAN | FLAG_EXTENSION;
+var ELEMENT_WIDTH_32 = 32;
+var PAYLOAD_CODEC_ROARING_PORTABLE = 1;
+var KNOWN_PAYLOAD_CODEC_IDS = /* @__PURE__ */ new Set([
+  PAYLOAD_CODEC_ROARING_PORTABLE
+]);
+var CONTAINER_CODEC_NONE = 0;
+var DEFAULT_TAIL_BYTES = 256 * 1024;
+var DEFAULT_MAX_INDEX_BYTES = 8 * 1024 * 1024;
+var DEFAULT_MAX_BITMAP_BYTES = 1 << 20;
+var MAX_CHUNK_CARDINALITY = 65536;
+var EXT_MAGIC = Uint8Array.of(67, 82, 66, 88);
+var EXT_TRAILER_BYTES = 12;
+var EXT_SECTION_HEADER_BYTES = 5;
+var MAX_EXT_BYTES = 4 * 1024;
+var EXT_SECTION_METADATA = 1;
+var CRC32C_BYTES = 4;
+var AEAD_NONCE_BYTES = 12;
+var AEAD_TAG_BYTES = 16;
+var DEFAULT_MAX_PAYLOAD_BYTES = DEFAULT_MAX_BITMAP_BYTES + AEAD_NONCE_BYTES + AEAD_TAG_BYTES;
+
 // src/core/keys.ts
 var FIELD = " ";
 var NO_NAMESPACE = "/";
@@ -214,8 +318,8 @@ var CountingMetricsSink = class _CountingMetricsSink {
 };
 
 // src/core/engine.ts
-var DEFAULT_MAX_BITMAP_BYTES = 1 << 20;
-var DEFAULT_INTERSECT_CONCURRENCY = 8;
+var DEFAULT_INTERSECT_CONCURRENCY = 32;
+var COMBINE_WINDOW_START = 8;
 var ZERO_CLOCK = { now: () => 0 };
 function windowOf(range) {
   const after = range?.after;
@@ -268,37 +372,65 @@ function keysWithin(keys, w) {
   };
   return keys.slice(firstAtLeast(w.loKey), firstAtLeast(w.hiKey + 1));
 }
-var ChunkWindow = class {
-  constructor(keys, fetch, max, ramp) {
+var CombineWindow = class {
+  constructor(keys, limit, read) {
     this.keys = keys;
-    this.fetch = fetch;
-    this.max = max;
-    this.ramp = ramp;
+    this.limit = limit;
+    this.read = read;
+    this.fill();
   }
   keys;
-  fetch;
-  max;
-  ramp;
-  open = [];
-  launched = 0;
+  limit;
+  read;
+  inFlight = [];
+  next_ = 0;
   taken = 0;
-  /** The next chunk in key order (null if the source holds none), or the error its read raised. */
-  async take() {
-    const width = this.ramp ? Math.min(this.max, 2 ** Math.min(this.taken, 30)) : this.max;
-    while (this.launched < this.keys.length && this.launched - this.taken < width) {
-      this.open.push(
-        this.fetch(this.keys[this.launched++]).then(
-          (chunk) => ({ chunk }),
-          (cause) => ({ chunk: null, error: { cause } })
+  fill() {
+    const width = Math.min(
+      this.limit,
+      Math.max(COMBINE_WINDOW_START, 2 ** Math.min(this.taken, 30))
+    );
+    while (this.next_ < this.keys.length && this.inFlight.length < width) {
+      const key = this.keys[this.next_++];
+      this.inFlight.push(
+        this.read(key).then(
+          (result) => ({ key, result }),
+          (error) => ({ key, result: null, error })
         )
       );
     }
-    const slot = await this.open.shift();
+  }
+  /** The next key's chunk in ascending key order, `undefined` when the keys are used up; throws that key's error. */
+  async next() {
+    if (this.inFlight.length === 0) return void 0;
+    const slot = await this.inFlight.shift();
     this.taken += 1;
-    if (slot.error) throw slot.error.cause;
-    return slot.chunk;
+    this.fill();
+    if (slot.error !== void 0) throw slot.error;
+    return slot;
   }
 };
+function chunkIds(chunk, chunkKey, w) {
+  let rem = chunk.toUint32Array ? chunk.toUint32Array() : Uint32Array.from(chunk);
+  if (w !== null && isEdge(chunkKey, w)) {
+    const from = chunkKey === w.loKey ? w.loRem : 0;
+    const to = chunkKey === w.hiKey ? w.hiRem : MAX_REMAINDER;
+    rem = rem.slice(firstAbove(rem, from - 1), firstAbove(rem, to));
+  }
+  const base = chunkKey * CHUNK_COUNT;
+  for (let i = 0; i < rem.length; i++) rem[i] = base + (rem[i] & MAX_REMAINDER);
+  return rem;
+}
+function firstAbove(a, value) {
+  let lo = 0;
+  let hi = a.length;
+  while (lo < hi) {
+    const mid = lo + hi >>> 1;
+    if (a[mid] <= value) lo = mid + 1;
+    else hi = mid;
+  }
+  return lo;
+}
 var SegmentEngine = class {
   storage;
   cache;
@@ -309,6 +441,12 @@ var SegmentEngine = class {
   metricsOn;
   /** Resolved per-op budget (null = disabled); undefined deps ⇒ the generous default. */
   budget;
+  /**
+   * The chunk reads open right now, by cache key: a caller that misses the cache and finds its key here awaits that
+   * read instead of making its own. An entry lives from the request until it settles, so the map holds at most one
+   * promise per distinct key in flight.
+   */
+  openReads = /* @__PURE__ */ new Map();
   constructor(deps) {
     this.storage = deps.storage;
     this.cache = deps.cache;
@@ -389,7 +527,7 @@ var SegmentEngine = class {
     );
   }
   /**
-   * Every id, ascending, reading ahead through a window of up to 8 chunk fetches that opens 1, 2, 4, 8 wide, so a
+   * Every id, ascending, reading ahead through a window of up to 32 chunk fetches that opens 1, 2, 4 … 32 wide, so a
    * read that stops early has fetched only a handful of chunks past the one it stopped in; with `range`, only the ids in `(after, through]`, fetching only the
    * chunks the range overlaps (see {@link IdRange}).
    *
@@ -428,6 +566,26 @@ var SegmentEngine = class {
       }
     }
   }
+  /**
+   * {@link iterate}, one `Uint32Array` per chunk instead of one id at a time: the same chunks, in the same order, with
+   * the same ids (a range cut at its edges the same way), and no array for a chunk that holds none of them. The
+   * reads, the budget charge and the window are the per-id read's. Each array is at most 65,536 ids (256 KiB) and is
+   * the caller's to keep.
+   */
+  async *iterateBatches(seg, range) {
+    const w = windowOf(range);
+    if (w === "empty") return;
+    const chunkKeys = w === null ? await this.chunkKeys(seg) : keysWithin(await this.chunkKeys(seg), w);
+    checkBudget(this.budget, chunkKeys.length, "iterate");
+    const gen = await this.cacheVersion(seg);
+    const window = this.chunkWindow(seg, chunkKeys, gen, true);
+    for (const chunkKey of chunkKeys) {
+      const chunk = await window.take();
+      if (chunk === null) continue;
+      const ids = chunkIds(chunk, chunkKey, w);
+      if (ids.length > 0) yield ids;
+    }
+  }
   /**
    * `segs[0] ∩ segs[1] ∩ …`, minus every id in `options.exclude` — streamed ascending.
    *
@@ -482,7 +640,24 @@ var SegmentEngine = class {
   andNot(seg, excludes, options) {
     return this.combine([seg], excludes, "all", "andNot", options);
   }
-  async *combine(segs, excludeSegs, mode, op, options) {
+  /** {@link intersect}, one `Uint32Array` per chunk — see {@link iterateBatches}. */
+  intersectBatches(segs, options) {
+    return this.combineBatches(segs, options?.exclude ?? [], "all", "intersect", options);
+  }
+  /** {@link union}, one `Uint32Array` per chunk — see {@link iterateBatches}. */
+  unionBatches(segs, options) {
+    return this.combineBatches(segs, options?.exclude ?? [], "any", "union", options);
+  }
+  /** {@link andNot}, one `Uint32Array` per chunk — see {@link iterateBatches}. */
+  andNotBatches(seg, excludes, options) {
+    return this.combineBatches([seg], excludes, "all", "andNot", options);
+  }
+  /**
+   * Everything a combine decides before it reads a chunk: validation, each operand's keys and generation, the
+   * absent-operand refusal, key alignment, the budget and the metric. `null` when the range is empty. The per-id
+   * read and the batch read share it, so the two cannot disagree about what is read or charged.
+   */
+  async combinePlan(segs, excludeSegs, mode, op, options) {
     if (segs.length === 0) {
       throw new ValidationError(`${op} requires at least one segment`);
     }
@@ -497,7 +672,7 @@ var SegmentEngine = class {
     }
     const budget = resolvePerOpBudget(options?.budget, this.budget);
     const w = windowOf(options);
-    if (w === "empty") return;
+    if (w === "empty") return null;
     const extract = async (seg) => {
       const all = await this.chunkKeys(seg);
       const gen = await this.cacheVersion(seg);
@@ -542,17 +717,20 @@ var SegmentEngine = class {
         skippedChunks: distinctKeys.size - common.length
       });
     }
-    const startAt = (key) => this.combineChunk(operands, excludes, mode, key).then(
-      (result) => ({ key, result }),
-      (error) => ({ key, result: null, error })
-    );
-    const inFlight = [];
-    let next = 0;
-    while (next < common.length && inFlight.length < limit) inFlight.push(startAt(common[next++]));
-    while (inFlight.length > 0) {
-      const slot = await inFlight.shift();
-      if (next < common.length) inFlight.push(startAt(common[next++]));
-      if (slot.error !== void 0) throw slot.error;
+    return {
+      w,
+      window: new CombineWindow(
+        common,
+        limit,
+        (key) => this.combineChunk(operands, excludes, mode, key)
+      )
+    };
+  }
+  async *combine(segs, excludeSegs, mode, op, options) {
+    const plan = await this.combinePlan(segs, excludeSegs, mode, op, options);
+    if (plan === null) return;
+    const { w, window } = plan;
+    for (let slot = await window.next(); slot !== void 0; slot = await window.next()) {
       if (slot.result && !slot.result.isEmpty) {
         if (w !== null && isEdge(slot.key, w)) {
           for (const id of edgeIds(slot.result, slot.key, w)) yield id;
@@ -562,6 +740,17 @@ var SegmentEngine = class {
       }
     }
   }
+  async *combineBatches(segs, excludeSegs, mode, op, options) {
+    const plan = await this.combinePlan(segs, excludeSegs, mode, op, options);
+    if (plan === null) return;
+    const { w, window } = plan;
+    for (let slot = await window.next(); slot !== void 0; slot = await window.next()) {
+      if (slot.result) {
+        const ids = chunkIds(slot.result, slot.key, w);
+        if (ids.length > 0) yield ids;
+      }
+    }
+  }
   /**
    * The AND (or OR) of one chunk key across all operands, minus the excludes that hold it, or `null` if empty.
    * Operand chunks are fetched **in parallel** (the spec's parallel byte-range reads).
@@ -574,9 +763,13 @@ var SegmentEngine = class {
   async combineChunk(operands, excludes, mode, chunkKey) {
     const present = mode === "all" ? operands : operands.filter((o) => o.keys.has(chunkKey));
     if (present.length === 0) return null;
-    const chunks = await Promise.all(
-      present.map((op) => this.storageChunk({ ...op.seg, chunkKey }, op.gen))
+    const relevant = excludes.filter((e) => e.keys.has(chunkKey));
+    const together = relevant.length > 0 && (mode === "any" || present.length === 1);
+    const reads = together ? [...present, ...relevant] : present;
+    const fetched = await Promise.all(
+      reads.map((op) => this.storageChunk({ ...op.seg, chunkKey }, op.gen))
     );
+    const chunks = together ? fetched.slice(0, present.length) : fetched;
     if (mode === "all" && chunks.some((c) => c === null)) return null;
     const first = chunks[0];
     const acc = first ? first.clone() : this.codec.empty();
@@ -591,11 +784,8 @@ var SegmentEngine = class {
       }
     }
     if (acc.isEmpty) return null;
-    const relevant = excludes.filter((e) => e.keys.has(chunkKey));
     if (relevant.length > 0) {
-      const cuts = await Promise.all(
-        relevant.map((e) => this.storageChunk({ ...e.seg, chunkKey }, e.gen))
-      );
+      const cuts = together ? fetched.slice(present.length) : await Promise.all(relevant.map((e) => this.storageChunk({ ...e.seg, chunkKey }, e.gen)));
       for (const cut of cuts) {
         if (cut === null) continue;
         acc.andNotInPlace(cut);
@@ -699,6 +889,7 @@ var SegmentEngine = class {
   invalidate(ref) {
     const prefix = segmentPrefix(ref);
     this.cache?.deleteWhere((key) => key.startsWith(prefix));
+    for (const key of this.openReads.keys()) if (key.startsWith(prefix)) this.openReads.delete(key);
     this.storage.invalidate?.(ref);
   }
   /** The segment's current generation, resolved once per op (`undefined` ⇒ source can't report it). */
@@ -728,7 +919,13 @@ var SegmentEngine = class {
    * `gen === undefined` ⇒ the source can't report a generation (it only ever serves one) ⇒ the key stays
    * generation-free. Superseded-generation entries age out under the LRU ceiling — no active purge.
    *
-   * The returned instance is **shared** (it may be the cached one): callers read it or clone it, never mutate it.
+   * Concurrent misses of one key share **one** request, with or without a cache: the first caller starts the read,
+   * later ones await it, and the entry goes when the read settles, so a failure is every waiting caller's and the
+   * next call reads again. The key carries the version exactly as the cache's does, so two versions of one chunk
+   * are two reads, never one.
+   *
+   * The returned instance is **shared** (it may be the cached one, and every caller that joined a read gets the same
+   * one): callers read it or clone it, never mutate it.
    */
   async storageChunk(ref, gen) {
     if (gen === null) return null;
@@ -741,6 +938,19 @@ var SegmentEngine = class {
       }
       if (this.metricsOn) this.metrics.onEvent({ kind: "cache", hit: false });
     }
+    const open4 = this.openReads.get(cacheKey);
+    if (open4) return open4.read;
+    const token = {};
+    const entry = { token, read: this.fetchChunk(ref, cacheKey, token) };
+    this.openReads.set(cacheKey, entry);
+    const settled = () => {
+      if (this.openReads.get(cacheKey) === entry) this.openReads.delete(cacheKey);
+    };
+    entry.read.then(settled, settled);
+    return entry.read;
+  }
+  /** One request for one chunk, decoded, range-checked and cached. */
+  async fetchChunk(ref, cacheKey, token) {
     const startedAt = this.metricsOn ? this.clock.now() : 0;
     const bytes = await this.storage.getChunk(ref);
     if (this.metricsOn) {
@@ -755,7 +965,7 @@ var SegmentEngine = class {
     if (!bytes) return null;
     const bitmap = this.codec.safeDeserialize(bytes, this.maxBitmapBytes);
     this.assertChunkPayloadInRange(bitmap, ref.chunkKey);
-    this.cache?.set(cacheKey, bitmap);
+    if (this.openReads.get(cacheKey)?.token === token) this.cache?.set(cacheKey, bitmap);
     return bitmap;
   }
 };
@@ -2269,76 +2479,6 @@ function aadFor(ref, generation, scope) {
   return out;
 }
 
-// src/core/crbm/format.ts
-var MAGIC = Uint8Array.of(67, 82, 66, 77);
-var VERSION_MAJOR = 1;
-var VERSION_MINOR = 0;
-var PREAMBLE_BYTES = 8;
-var PAYLOAD_START = PREAMBLE_BYTES;
-var FOOTER_BYTES = 104;
-var FOOTER = {
-  indexOffset: 0,
-  // u64
-  indexLength: 8,
-  // u64
-  indexCrc32c: 16,
-  // u32
-  flags: 20,
-  // u32
-  payloadCodecId: 24,
-  // u16 — which codec wrote the chunk payloads
-  elementWidth: 26,
-  // u8
-  containerCodec: 27,
-  // u8
-  versionMajor: 28,
-  // u8
-  versionMinor: 29,
-  // u8
-  reserved2: 30,
-  // u16
-  generation: 32,
-  // u64
-  indexNonce: 40,
-  // 12 B
-  indexTag: 52,
-  // 16 B
-  keyId: 68,
-  // 16 B
-  chunkCount: 84,
-  // u32
-  totalCardinality: 88,
-  // u64
-  footerCrc32c: 96,
-  // u32 — covers footer bytes [0, 96)
-  endMagic: 100
-  // char[4]
-};
-var FOOTER_CRC_COVERAGE = FOOTER.footerCrc32c;
-var FLAG_ENCRYPTED = 1 << 0;
-var FLAG_INDEX_COMPRESSED = 1 << 1;
-var FLAG_LITTLE_ENDIAN = 1 << 2;
-var FLAG_EXTENSION = 1 << 3;
-var KNOWN_FLAGS = FLAG_ENCRYPTED | FLAG_LITTLE_ENDIAN | FLAG_EXTENSION;
-var ELEMENT_WIDTH_32 = 32;
-var PAYLOAD_CODEC_ROARING_PORTABLE = 1;
-var KNOWN_PAYLOAD_CODEC_IDS = /* @__PURE__ */ new Set([
-  PAYLOAD_CODEC_ROARING_PORTABLE
-]);
-var CONTAINER_CODEC_NONE = 0;
-var DEFAULT_TAIL_BYTES = 256 * 1024;
-var DEFAULT_MAX_INDEX_BYTES = 8 * 1024 * 1024;
-var DEFAULT_MAX_PAYLOAD_BYTES = 16 * 1024 * 1024;
-var MAX_CHUNK_CARDINALITY = 65536;
-var EXT_MAGIC = Uint8Array.of(67, 82, 66, 88);
-var EXT_TRAILER_BYTES = 12;
-var EXT_SECTION_HEADER_BYTES = 5;
-var MAX_EXT_BYTES = 4 * 1024;
-var EXT_SECTION_METADATA = 1;
-var CRC32C_BYTES = 4;
-var AEAD_NONCE_BYTES = 12;
-var AEAD_TAG_BYTES = 16;
-
 // src/core/crbm/crc32c.ts
 var TABLES = (() => {
   const POLY = 2197175160;
@@ -2540,7 +2680,6 @@ var CrbmReader = class _CrbmReader {
   }
   static async open(blob, options = {}) {
     const tailBytes = Math.max(options.tailBytes ?? DEFAULT_TAIL_BYTES, FOOTER_BYTES);
-    const maxPayloadBytes = options.maxPayloadBytes ?? DEFAULT_MAX_PAYLOAD_BYTES;
     const maxIndexBytes = options.maxIndexBytes ?? DEFAULT_MAX_INDEX_BYTES;
     const { bytes: tail, size } = await blob.getTail(tailBytes);
     const { footer, fview, storedFooterCrc } = checkedFooter(tail, size);
@@ -2682,7 +2821,7 @@ var CrbmReader = class _CrbmReader {
     const index = parseIndex(
       indexForParse,
       payloadEnd,
-      maxPayloadBytes,
+      options.maxPayloadBytes ?? (encrypted ? DEFAULT_MAX_PAYLOAD_BYTES : DEFAULT_MAX_BITMAP_BYTES),
       encrypted ? AEAD_NONCE_BYTES + AEAD_TAG_BYTES : 1
     );
     if (encrypted) {
@@ -2869,7 +3008,9 @@ function parseIndex(indexBytes, payloadEnd, maxPayloadBytes, minPayloadBytes = 1
     }
     if (chunkKey > 65535) throw new IntegrityError(`.crbm chunkKey ${chunkKey} out of range`);
     if (len < minPayloadBytes || len > maxPayloadBytes) {
-      throw new IntegrityError(`.crbm chunk ${chunkKey} length ${len} invalid`);
+      throw new IntegrityError(
+        `.crbm chunk ${chunkKey} length ${len} invalid (most is ${maxPayloadBytes})`
+      );
     }
     if (card < 1 || card > MAX_CHUNK_CARDINALITY) {
       throw new IntegrityError(`.crbm chunk ${chunkKey} cardinality ${card} invalid`);
@@ -5094,12 +5235,11 @@ function describingSummary(record) {
 }
 
 // src/core/erase-id.ts
-var DEFAULT_MAX_BITMAP_BYTES2 = 1 << 20;
 async function eraseIdFromSegment(ref, id, deps, options = {}) {
   validateUserRef(ref);
   const { chunkKey, remainder } = splitId(id);
   const codec = requireCodec(deps.codec, "eraseIdFromSegment");
-  const maxBytes = deps.maxBitmapBytes ?? DEFAULT_MAX_BITMAP_BYTES2;
+  const maxBytes = deps.maxBitmapBytes ?? DEFAULT_MAX_BITMAP_BYTES;
   const base = { segment: ref.segment, namespace: ref.namespace };
   const read = (op) => retryRead(op, deps.readRetry);
   const record = await deps.registry.get(ref);
@@ -5311,14 +5451,21 @@ async function eraseIdFromSegment(ref, id, deps, options = {}) {
   if (left !== void 0) throw cannotRemove(left);
   return { ...base, erased: true, fromGeneration: from, generation, collected };
 }
+var REWRITE_READ_AHEAD = 32;
 async function* rewrite(reader, chunkKey, replacement, codec, maxBytes, read) {
   const keys = [...reader.chunkKeys()].sort((a, b) => a - b);
+  const window = new ChunkWindow(
+    keys.filter((k) => k !== chunkKey),
+    (k) => read(() => reader.getChunk(k)),
+    REWRITE_READ_AHEAD,
+    false
+  );
   for (const k of keys) {
     if (k === chunkKey) {
       yield { chunkKey: k, bitmap: replacement };
       continue;
     }
-    const bytes = await read(() => reader.getChunk(k));
+    const bytes = await window.take();
     if (bytes === null) continue;
     const bitmap = codec.safeDeserialize(bytes, maxBytes);
     assertRemaindersInRange(bitmap, k);