@cloudbitmaps/roaring 0.12.0 → 0.14.0

package/PRIVACY.md

@@ -125,8 +125,8 @@ after it returns, and re-run any erasure a rollback interrupted.
 
 Erasure and crypto-shred are **immediate in storage and immediate in the store whose verb performed them**, for
 every read that starts after the verb returns. A read already in progress in that store can still yield an erased id
-from a chunk it had requested before the verb ran: up to 8 chunks for `iterate` and `count`, and up to `concurrency`
-keys for a combine. They are not immediate in any *other* store, in the same process or another, and this library ships nothing that could
+from a chunk it had requested before the verb ran: up to 32 chunks for `iterate` and `count`, and up to `concurrency`
+keys (32 by default) for a combine. They are not immediate in any *other* store, in the same process or another, and this library ships nothing that could
 make them so — there is no daemon, no bus, and no connection between two stores that happen to point at the same
 bucket.
 

package/README.md

@@ -69,10 +69,10 @@ name.
 
 ## What it costs
 
-Measured against real S3 in `us-east-1`, 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 206 GETs, **$82.40 per million**, requesting only
-the shared chunks. Inside the region it is expected at 204 GETs, $81.60 per million. Writing and publishing a segment
-is **$11.20 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.
+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 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,
 where an in-process store costs a memory read. If you need sub-millisecond answers on a working set that fits a

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`
@@ -1981,7 +1994,7 @@ var Segment = class _Segment {
    * Chunk-skipping intersection: stream the ids in **this** segment AND every segment in `others`, ascending.
    * Fetches only the Storage chunks present in *all* operands (a key absent from any operand contributes nothing
    * and is never downloaded), streaming under a bounded in-flight window — so the Storage footprint stays small
-   * (Lambda-friendly) regardless of segment size. Pass `concurrency` to tune that window (a positive integer).
+   * (Lambda-friendly) regardless of segment size. Pass `concurrency` to tune that window (a positive integer, 32 by default).
    * AND is commutative, so `a.intersect([b])` and `b.intersect([a])` yield the same ids. Pass `budget` to
    * override the store's per-op denial-of-wallet budget for this call (or `false` to lift it).
    */
@@ -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}. */