@cloudbitmaps/roaring 0.13.0 → 0.14.0

package/README.md

@@ -71,7 +71,7 @@ name.
 
 Measured against real S3 in `us-east-1`, from inside the region, with the pointer in the same bucket as the data: the median cold `intersect`
 of two 500,000-id segments sharing 100 of their 1,999 chunks made 204 GETs, **$81.60 per million**, requesting only
-the shared chunks, and took 492.69 ms from inside the region, by an engine whose combine window held 8 chunk keys (this release opens it 8 wide and widens it to 32, so fewer rounds are expected; not yet measured). A segment's first `store.load()`
+the shared chunks, and took 290.06 ms at the median from inside the region (run of 2026-10-04, whose client had 50 sockets; the client this release builds allows 128, and its effect is not measured). A segment's first `store.load()`
 is **$11.60 per million**, pointer included, from its measured requests at list prices. A cold `count()` is one pointer read: it reads no payload and no object.
 
 The trade is stated plainly. A membership check that misses the cache costs a ranged GET against object storage,

package/dist/bin/export-segments.js

@@ -449,6 +449,10 @@ var SafeBitmap = class _SafeBitmap {
   toArray() {
     return this.bitmap.toArray();
   }
+  /** The values as one fresh ascending `Uint32Array`, exported natively. */
+  toUint32Array() {
+    return this.bitmap.toUint32Array();
+  }
 };
 function bitmapAsLoadInput(input) {
   return input instanceof RoaringBitmap32 ? { bitmap: input } : input;
@@ -1668,9 +1672,14 @@ var CloudRoaring = class _CloudRoaring {
     return estimateCost(input);
   }
 };
-var failing = (err) => ({
-  [Symbol.asyncIterator]: () => ({ next: () => Promise.reject(err) })
-});
+var withBatches = (gen, batches) => Object.assign(gen, { batches });
+var failing = (err) => {
+  const rejecting = () => ({ next: () => Promise.reject(err) });
+  return {
+    [Symbol.asyncIterator]: rejecting,
+    batches: () => ({ [Symbol.asyncIterator]: rejecting })
+  };
+};
 var samePin = (a, b) => a === void 0 || b === void 0 ? a === b : a.generation === b.generation && a.fingerprint === b.fingerprint;
 var twoPins = (a, b) => {
   const one = (p) => p === void 0 ? "live" : `pinned at generation ${p.generation ?? "none"}`;
@@ -1689,6 +1698,8 @@ var readOptions = (options) => ({
 var NO_SEGMENTS = [];
 var EMPTY_IDS = {
   async *[Symbol.asyncIterator]() {
+  },
+  async *batches() {
   }
 };
 var KEEP_EVERY_GENERATION = Number.MAX_SAFE_INTEGER;
@@ -1944,7 +1955,9 @@ var Segment = class _Segment {
     if (this.expired()) return EMPTY_IDS;
     const range = options == null ? void 0 : rangeOf(options);
     const none = range === void 0 || range.after === void 0 && range.through === void 0;
-    return this.engine.iterate(this.ref, none ? void 0 : range);
+    const { engine, ref } = this;
+    const bounds = none ? void 0 : range;
+    return withBatches(engine.iterate(ref, bounds), () => engine.iterateBatches(ref, bounds));
   }
   /**
    * The options a combine hands the engine, read once, when it is called ({@link readOptions}), with the `exclude`
@@ -1994,7 +2007,9 @@ var Segment = class _Segment {
     } catch (err) {
       return failing(err);
     }
-    return engine.intersect([this.ref, ...others.map((o) => o.ref)], this.refsIn(options, exclude));
+    const refs = [this.ref, ...others.map((o) => o.ref)];
+    const opts = this.refsIn(options, exclude);
+    return withBatches(engine.intersect(refs, opts), () => engine.intersectBatches(refs, opts));
   }
   /**
    * Materialize `this ∩ others…` (minus `exclude`) as a **new generation of `dest`** — `dest`'s previous contents
@@ -2052,7 +2067,9 @@ var Segment = class _Segment {
     } catch (err) {
       return failing(err);
     }
-    return engine.union([this.ref, ...others.map((o) => o.ref)], this.refsIn(options, exclude));
+    const refs = [this.ref, ...others.map((o) => o.ref)];
+    const opts = this.refsIn(options, exclude);
+    return withBatches(engine.union(refs, opts), () => engine.unionBatches(refs, opts));
   }
   /** Materialize `this ∪ others…` (minus `exclude`) as a **new generation of `dest`** — see {@link intersectInto}. */
   async unionInto(dest, others, options) {
@@ -2091,10 +2108,12 @@ var Segment = class _Segment {
     } catch (err) {
       return failing(err);
     }
-    return engine.andNot(
-      this.ref,
-      excludes.map((o) => o.ref),
-      options == null ? void 0 : readOptions(options)
+    const base = this.ref;
+    const refs = excludes.map((o) => o.ref);
+    const opts = options == null ? void 0 : readOptions(options);
+    return withBatches(
+      engine.andNot(base, refs, opts),
+      () => engine.andNotBatches(base, refs, opts)
     );
   }
   /** Materialize `this \ (excludes…)` as a **new generation of `dest`** — see {@link intersectInto}. */