@cloudbitmaps/roaring 0.19.0 → 0.19.1

package/PRIVACY.md

@@ -119,9 +119,9 @@ ledger is not by itself proof the id is gone. A tombstoned segment is searched t
 cleartext object left under it that holds the id is deleted with everything under the tombstone, and the entry reads
 `erased: true`. A segment whose row names no generation yet (a retention policy set before its first load) is
 searched too: an object a first load wrote and never published that holds the id, or on an encrypted store cannot
-be searched until its load publishes the key, is reported as an `error: …` note and not deleted, because that load may
-still publish it. Load the segment, which makes the object collectable, or drop
-it, and re-run.
+be searched until its load publishes the key, is reported as an `error: …` note and not deleted: the erasure writes
+nothing to such a row, so the load that wrote the object may still publish it. Load the segment, which makes the
+object collectable, or drop it, and re-run.
 
 **Do not roll a segment back while erasing from it.** A rollback that lands mid-erasure can move the pointer onto a
 generation the erasure did not rewrite, so the id can be current again. Roll back before the erasure starts or

package/dist/bin/export-segments.js

@@ -668,6 +668,11 @@ var SystemRng = class {
 };
 var DEFAULT_CACHE_MAX_CHUNKS = 1024;
 var DEFAULT_ADMIN_CONCURRENCY = 8;
+function rowVersionOfLive(version) {
+  if (version === null) return null;
+  const cut = version.lastIndexOf("#");
+  return cut < 0 ? version : version.slice(0, cut);
+}
 function validateConcurrency(concurrency) {
   if (concurrency !== void 0 && (!Number.isInteger(concurrency) || concurrency < 1)) {
     throw new ValidationError2(`concurrency must be a positive integer; got ${concurrency}`);
@@ -1183,10 +1188,9 @@ var CloudRoaring = class _CloudRoaring {
   /**
    * Write `ids` as a **new generation of `dest`** and publish it — the shared body of the `*Into` verbs. An `*Into`
    * materialisation is a load, and publishes the same way (hard invariant 1): every load that finds a row fences its
-   * publish on the row's token; a guarded load (the default, since the empty refusal needs the size of the current generation)
-   * also fences on the pointer it judged (`expectFrom`), and one that found no row fences on that absence instead.
-   * Only an unguarded load (`allowEmpty: true`, with neither `guard.minRetained` nor `guard.maxGrowth`) onto a segment with no row publishes bare
-   * forward-only. The destination's previous generation stays readable until the publish lands (readers re-resolve
+   * publish on the row's token, and every load that finds none on that absence, guarded or not; a guarded load (the
+   * default, since the empty refusal needs the size of the current generation) also fences on the pointer it judged
+   * (`expectFrom`). The destination's previous generation stays readable until the publish lands (readers re-resolve
    * within `cache.genTtlMs`).
    *
    * This routes through `loadSegment` rather than writing the generation itself, and that is the whole point
@@ -1213,9 +1217,10 @@ var CloudRoaring = class _CloudRoaring {
    * **A `WriteConflictError` does not by itself mean nothing was published**, and that is worth knowing
    * before you write the retry. `'superseded'` covers five different causes — the write-once PUT collided,
    * the pointer moved, a row appeared where the load found none, the row's token changed, the row was purged —
-   * and only the first three are the "somebody beat us" the name suggests. A token can also change on a write
-   * that is not a supersession at all, such as a `setRetention` on the destination. On top of that, the collection pass that runs AFTER a
-   * successful publish can raise the same error. So: treat it as "re-read the destination and decide",
+   * and only the first two are always the "somebody beat us" the name suggests. A row can appear, and a token can
+   * change, on a write that is not a supersession at all: a `setRetention` on the destination creates its row when it
+   * has none, and rewrites it when it has one. On top of that, the collection pass that runs AFTER a successful
+   * publish can raise the same error. So: treat it as "re-read the destination and decide",
    * never as "the write did not happen".
    *
    * **And by default it collects nothing**, unlike `load()`. See the `keep` default below.
@@ -1247,7 +1252,7 @@ var CloudRoaring = class _CloudRoaring {
     if (reason === "superseded") {
       const wrote = result.size > 0 ? `generation ${result.generation} was written and is not current` : `nothing was written \u2014 another writer took generation ${result.generation} first`;
       throw new WriteConflictError(
-        `${op}: the destination "${dest.segment}" changed while this materialisation was in flight, so its result is not the destination's current generation: ${wrote}. The pointer may have moved, the row may have been rewritten (a retention policy does this), dropped or purged. Re-read the destination and re-run.`
+        `${op}: the destination "${dest.segment}" changed while this materialisation was in flight, so its result is not the destination's current generation: ${wrote}. The pointer may have moved, the row may have been created or rewritten (a retention policy does either), dropped or purged. Re-read the destination and re-run.`
       );
     }
     return {
@@ -1609,7 +1614,7 @@ var CloudRoaring = class _CloudRoaring {
         if (this.crbmSource !== void 0) {
           const held = await this.crbmSource.currentVersion(ref);
           const listed = rec.currentGen === null ? null : `${rec.currentGen}:${String(rec.token)}`;
-          if (held !== listed) this.engine.invalidate(ref);
+          if (rowVersionOfLive(held) !== listed) this.engine.invalidate(ref);
         }
         return await this.engine.has(ref, id) ? { segment: rec.segment, namespace: rec.namespace } : null;
       }