@cloudbitmaps/roaring 0.19.0 → 0.19.1

package/dist/index.d.ts

@@ -542,10 +542,9 @@ export declare 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
@@ -572,9 +571,10 @@ export declare 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.

package/dist/index.js

@@ -661,6 +661,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}`);
@@ -1176,10 +1181,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
@@ -1206,9 +1210,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.
@@ -1240,7 +1245,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 {
@@ -1602,7 +1607,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;
       }