@cloudbitmaps/core 0.23.0 → 0.25.0

package/dist/index.js

@@ -1,7 +1,7 @@
 import {
   boundedAll,
   mapWithConcurrency
-} from "./chunk-CGILDXGP.js";
+} from "./chunk-BUDAVGBI.js";
 import {
   BufferReader,
   KeptSegmentKeys,
@@ -9,7 +9,7 @@ import {
   segmentKey,
   segmentPrefix,
   shardOf
-} from "./chunk-GKHERVVQ.js";
+} from "./chunk-WPER7R2R.js";
 import {
   BudgetExceededError,
   CHUNK_COUNT,
@@ -99,6 +99,7 @@ import {
   rollbackKnown,
   sameIncarnation,
   sameKeys,
+  sameKnownGens,
   sizeOfFingerprint,
   sizePart,
   splitId,
@@ -115,7 +116,7 @@ import {
   validateUserRef,
   windowOf,
   withRetry
-} from "./chunk-MVUD4R72.js";
+} from "./chunk-2B2QF4FU.js";
 
 // src/core/budget.ts
 var DEFAULT_BUDGET = { maxRequests: 1e6 };
@@ -182,7 +183,7 @@ async function refuseAbsent(op, candidates, limit, exists, nameOf) {
 // src/core/chunk-checks.ts
 function assertChunkKeyInRange(k) {
   if (!Number.isInteger(k) || k < 0 || k >= CHUNK_COUNT) {
-    throw new IntegrityError(`chunk key from a tier is out of range: ${k}`);
+    throw new IntegrityError("a chunk key from a tier is out of range");
   }
 }
 function assertChunkCardinalityInRange(c) {
@@ -205,22 +206,22 @@ function checkedChunkKeys(listed2) {
   keys.sort((a, b) => a - b);
   for (let i = 1; i < keys.length; i++) {
     if (keys[i] === keys[i - 1]) {
-      throw new IntegrityError(`chunk key from a tier is listed twice: ${keys[i]}`);
+      throw new IntegrityError("a chunk key from a tier is listed twice");
     }
   }
   return keys;
 }
-function assertChunkPayloadInRange(bitmap, chunkKey) {
+function assertChunkPayloadInRange(bitmap) {
   const max = bitmap.maximum?.();
   if (max !== void 0 && max > MAX_REMAINDER) {
     throw new IntegrityError(
-      `chunk ${chunkKey} payload holds value ${max}, outside the 16-bit remainder range [0, ${MAX_REMAINDER}] \u2014 the stored object is corrupt or was not written by this codec`
+      `a chunk payload holds a value outside the 16-bit remainder range [0, ${MAX_REMAINDER}] (a container key other than 0) \u2014 the stored object is corrupt or was not written by this codec`
     );
   }
 }
-function decodeChunkBytes(codec, bytes, chunkKey, maxBitmapBytes) {
+function decodeChunkBytes(codec, bytes, maxBitmapBytes) {
   const bitmap = codec.safeDeserialize(bytes, maxBitmapBytes);
-  assertChunkPayloadInRange(bitmap, chunkKey);
+  assertChunkPayloadInRange(bitmap);
   return bitmap;
 }
 
@@ -237,12 +238,10 @@ var ChunkStream = class {
     return this.iterator.next().then(
       (step) => {
         if (step.done === true) {
-          throw this.failure?.error ?? new IntegrityError(`chunk stream ended before chunk ${key}`);
+          throw this.failure?.error ?? new IntegrityError("chunk stream ended before a chunk it was opened over");
         }
         if (step.value.key !== key) {
-          throw new IntegrityError(
-            `chunk stream answered chunk ${step.value.key} where ${key} was due`
-          );
+          throw new IntegrityError("chunk stream answered a chunk other than the one due");
         }
         return step.value;
       },
@@ -758,6 +757,23 @@ function chunkIds(chunk, chunkKey, w) {
   for (let i = 0; i < rem.length; i++) rem[i] = base + (rem[i] & MAX_REMAINDER);
   return rem;
 }
+function smallestFirst(chunks) {
+  const out = chunks.slice();
+  const sizes = out.map((c) => c.size);
+  for (let i = 1; i < out.length; i++) {
+    const c = out[i];
+    const size = sizes[i];
+    let j = i - 1;
+    while (j >= 0 && sizes[j] > size) {
+      out[j + 1] = out[j];
+      sizes[j + 1] = sizes[j];
+      j--;
+    }
+    out[j + 1] = c;
+    sizes[j + 1] = size;
+  }
+  return out;
+}
 function alignKeys(operands, mode) {
   const candidates = [];
   if (mode === "all") {
@@ -1183,9 +1199,7 @@ var SegmentEngine = class _SegmentEngine {
     const expected = counts.get(chunkKey);
     if (chunk === null || chunk.size !== expected) {
       const got = chunk === null ? "no bytes" : `${chunk.size} ids`;
-      throw new IntegrityError(
-        `chunk ${chunkKey} holds ${got}, but the object's index says ${expected}`
-      );
+      throw new IntegrityError(`a chunk holds ${got}, but the object's index says ${expected}`);
     }
     return chunk.toUint32Array ? chunk.toUint32Array() : Uint32Array.from(chunk);
   }
@@ -1504,7 +1518,7 @@ var SegmentEngine = class _SegmentEngine {
    * 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).
    *
-   * The accumulator is a **clone** of the first operand's chunk, and that clone is load-bearing: every other
+   * The accumulator is a **clone** of one operand's chunk (the first, or for a codec that asks the one with the fewest values), and that clone is load-bearing: every other
    * bitmap here is the cached, shared Storage instance and must never be mutated, or the cache is poisoned for
    * every later reader. The remaining operands and the excludes are only *read* by the in-place ops, so they are
    * used as-is — one clone per key, not one per operand.
@@ -1518,10 +1532,11 @@ var SegmentEngine = class _SegmentEngine {
     const fetched = await Promise.all(reads.map((op) => this.operandChunk(op, chunkKey, moves)));
     const chunks = together ? fetched.slice(0, present.length) : fetched;
     if (mode === "all" && chunks.some((c) => c === null)) return null;
-    const first = chunks[0];
+    const ordered = mode === "all" && chunks.length > 2 && this.codec.intersectSmallestFirst === true ? smallestFirst(chunks) : chunks;
+    const first = ordered[0];
     const acc = first ? first.clone() : this.codec.empty();
-    for (let i = 1; i < chunks.length; i++) {
-      const other = chunks[i];
+    for (let i = 1; i < ordered.length; i++) {
+      const other = ordered[i];
       if (other === null || other === void 0) continue;
       if (mode === "all") {
         acc.andInPlace(other);
@@ -1852,7 +1867,7 @@ var SegmentEngine = class _SegmentEngine {
         streamed.moves.moved = true;
       }
       if (read.bytes === null) return null;
-      const bitmap = decodeChunkBytes(this.codec, read.bytes, chunkKey, this.maxBitmapBytes);
+      const bitmap = decodeChunkBytes(this.codec, read.bytes, this.maxBitmapBytes);
       if (this.cache && !streamed.invalidated && !this.scope.invalidatedSince(streamed.prefix, streamed.openedAt)) {
         const version = this.streamedVersion(streamed.gen, read.version);
         if (version !== null) {
@@ -2065,7 +2080,7 @@ var SegmentEngine = class _SegmentEngine {
       }
     }
     if (!bytes) return null;
-    const bitmap = decodeChunkBytes(this.codec, bytes, ref.chunkKey, this.maxBitmapBytes);
+    const bitmap = decodeChunkBytes(this.codec, bytes, this.maxBitmapBytes);
     if (key !== "" && this.scope.isOpen(cacheKey, token)) this.cache?.set(key, bitmap);
     return bitmap;
   }
@@ -2301,6 +2316,22 @@ function requireCodec(codec, api) {
 // src/export/index.ts
 var UTF8 = new TextEncoder();
 var DEFAULT_NDJSON_BATCH_BYTES = 64 * 1024;
+var EXPORT_BATCH = 1 << 16;
+async function addAll(bitmap, ids) {
+  const batch = new Uint32Array(EXPORT_BATCH);
+  let held = 0;
+  let count = 0;
+  for await (const id of ids) {
+    batch[held++] = id;
+    count += 1;
+    if (held === EXPORT_BATCH) {
+      bitmap.addMany(batch);
+      held = 0;
+    }
+  }
+  if (held > 0) bitmap.addMany(batch.subarray(0, held));
+  return count;
+}
 var errMessage = (err) => err instanceof Error ? err.message : String(err);
 async function runExport(reader, registry, sink, options = {}) {
   if (sink === null || typeof sink !== "object" || typeof sink.open !== "function") {
@@ -2360,10 +2391,7 @@ async function runExport(reader, registry, sink, options = {}) {
       writer = await sink.open(ref, ext);
       if (format === "roaring") {
         const bm = requireCodec(options.codec, "runExport({ format: 'roaring' })").empty();
-        for await (const id of ids) {
-          bm.add(id);
-          count += 1;
-        }
+        count = await addAll(bm, ids);
         if (count === 0 && await rowIsGone(ref)) return await skipGone(ref, writer);
         const out = bm.serialize();
         await writer.write(out);
@@ -2513,7 +2541,7 @@ function* planChunkReads(extents, region) {
   for (const extent of extents) {
     const extentEnd = extent.offset + extent.length;
     if (!(Number.isSafeInteger(extent.offset) && Number.isSafeInteger(extent.length) && extent.length >= 1 && extent.offset >= previousEnd && extentEnd <= region.end)) {
-      throw crbmIntegrity(`chunk ${extent.key} is not inside the chunk region, in order`);
+      throw crbmIntegrity("a chunk is not inside the chunk region, in order");
     }
     previousEnd = extentEnd;
     if (chunks.length > 0 && extent.offset - end <= MAX_COALESCE_GAP_BYTES && extentEnd - start <= MAX_COALESCED_READ_BYTES) {
@@ -2537,7 +2565,7 @@ function* planChunkReads(extents, region) {
 var U32_CEIL = U32_MAX + 1;
 function varintLength(value) {
   if (!Number.isInteger(value) || value < 0 || value >= U32_CEIL) {
-    throw new RangeError(`varint value must be a u32; got ${value}`);
+    throw new RangeError("varint value must be a u32");
   }
   if (value < 128) return 1;
   if (value < 16384) return 2;
@@ -2974,7 +3002,7 @@ var CrbmReader = class _CrbmReader {
   }
   /**
    * Range-GET one chunk's payload, verifying its CRC32C before returning. Returns `null` if the chunk is
-   * absent. Throws `IntegrityError` on a CRC mismatch (the bytes must never reach the native
+   * absent. Throws `IntegrityError` on a CRC mismatch (the bytes must never reach the codec's
    * deserializer). The returned bytes may be shared (a small generation's chunks are kept by the reader and handed out
    * again), so callers must not change them.
    */
@@ -2984,7 +3012,7 @@ var CrbmReader = class _CrbmReader {
     const offset = this.index.offsets[slot];
     const length = this.index.lengths[slot];
     if (offset < PAYLOAD_START || offset + length > this.objectSize - FOOTER_BYTES) {
-      throw crbmIntegrity(`chunk ${chunkKey} payload out of bounds`);
+      throw crbmIntegrity(`chunk at position ${slot} payload out of bounds`);
     }
     const held = this.keptRange(offset, length);
     return this.openChunk(slot, chunkKey, held ?? await this.blob.getRange(offset, length));
@@ -3011,11 +3039,11 @@ var CrbmReader = class _CrbmReader {
    */
   openChunk(slot, chunkKey, bytes) {
     if (crc32c(bytes) !== this.index.crcs[slot]) {
-      throw crbmIntegrity(`chunk ${chunkKey} payload CRC mismatch`);
+      throw crbmIntegrity(`chunk at position ${slot} payload CRC mismatch`);
     }
     if (this.crypto === void 0) return bytes;
     if (bytes.length < AEAD_NONCE_BYTES + AEAD_TAG_BYTES) {
-      throw crbmIntegrity(`chunk ${chunkKey} encrypted payload too short`);
+      throw crbmIntegrity(`chunk at position ${slot} encrypted payload too short`);
     }
     return this.crypto.aead.open(
       {
@@ -3261,19 +3289,20 @@ function parseIndex(indexBytes, payloadEnd, maxPayloadBytes, minPayloadBytes = 1
     const chunkKey = prevKey + keyDelta;
     const offset = prevEnd + offDelta;
     if (i > 0 && keyDelta === 0) {
-      throw crbmIntegrity(`.crbm index has a duplicate chunkKey ${chunkKey}`);
+      throw crbmIntegrity(`.crbm index entry ${i} repeats a chunk key`);
     }
-    if (chunkKey > 65535) throw crbmIntegrity(`.crbm chunkKey ${chunkKey} out of range`);
+    if (chunkKey > 65535)
+      throw crbmIntegrity(`.crbm index entry ${i} has a chunk key out of range`);
     if (len < minPayloadBytes || len > maxPayloadBytes) {
       throw crbmIntegrity(
-        `.crbm chunk ${chunkKey} length ${len} invalid (most is ${maxPayloadBytes})`
+        `.crbm index entry ${i} has a payload length ${len} invalid (most is ${maxPayloadBytes})`
       );
     }
     if (card < 1 || card > MAX_CHUNK_CARDINALITY) {
-      throw crbmIntegrity(`.crbm chunk ${chunkKey} cardinality ${card} invalid`);
+      throw crbmIntegrity(`.crbm index entry ${i} has a cardinality ${card} invalid`);
     }
     if (offset + len > payloadEnd) {
-      throw crbmIntegrity(`.crbm chunk ${chunkKey} payload out of bounds`);
+      throw crbmIntegrity(`.crbm index entry ${i} has a payload out of bounds`);
     }
     keys[count] = chunkKey;
     cardinalityMinusOne[count] = card - 1;
@@ -3357,8 +3386,9 @@ async function provenObject(storage, key, fingerprint) {
       version ??= tail.version;
     });
     return await CrbmReader.sameObject(blob, fingerprint) ? { version } : null;
-  } catch {
-    return null;
+  } catch (err) {
+    if (isNotFoundError(err)) return null;
+    throw err;
   }
 }
 function sameObjectUnder(storage, key, fingerprint) {
@@ -3409,12 +3439,7 @@ async function footerCrcUnder(storage, key) {
   return (await readFooter(storageBlobReader(storage, key))).footerCrc;
 }
 async function provesOwnObject(storage, key, fingerprint) {
-  try {
-    return await CrbmReader.sameObject(storageBlobReader(storage, key), fingerprint);
-  } catch (err) {
-    if (isNotFoundError(err)) return false;
-    throw err;
-  }
+  return await provenObject(storage, key, fingerprint) !== null;
 }
 var openedVersions = /* @__PURE__ */ new WeakMap();
 function openGenerationReader(storage, key, crypto, options = {}, named) {
@@ -5042,11 +5067,11 @@ var PinnedStorageChunkSource = class {
   constructor(inner, pins) {
     this.inner = inner;
     this.pins = pins;
-    for (const [key, pin] of pins) {
+    for (const [pinKey, pin] of pins) {
       const held = pin;
       if (held.generation !== null && (typeof held.version !== "string" || typeof held.fingerprint !== "string"))
         throw new ValidationError(
-          `pin for "${key}" names generation ${held.generation} without its version and object fingerprint`
+          `pin for "${pinKey}" names generation ${held.generation} without its version and object fingerprint`
         );
     }
   }
@@ -5247,14 +5272,15 @@ function plainView(bytes, what) {
   }
   return length === 0 ? new Uint8Array(0) : new Uint8Array(buffer, offset, length);
 }
-var sharedByteLength = typeof SharedArrayBuffer === "function" ? Object.getOwnPropertyDescriptor(SharedArrayBuffer.prototype, "byteLength")?.get : void 0;
+var plainByteLength = Object.getOwnPropertyDescriptor(ArrayBuffer.prototype, "byteLength")?.get;
+var hasSharedMemory = typeof SharedArrayBuffer === "function";
 function isShared(buffer) {
-  if (sharedByteLength === void 0) return false;
+  if (!hasSharedMemory) return false;
   try {
-    sharedByteLength.call(buffer);
-    return true;
-  } catch {
+    plainByteLength.call(buffer);
     return false;
+  } catch {
+    return true;
   }
 }
 function overCap(what, length) {
@@ -5295,11 +5321,22 @@ function prepareLoadInput(input, codec) {
     `a load takes ids (an iterable of integers), { serialized } or { bitmap }, as the only key; got an object with keys [${keys.join(", ")}]. Load options go in the next argument.`
   );
 }
-function decodeSerialized(bytes, codec, what = "the buffer") {
+function decodeSerialized(bytes, codec, what = "the buffer", options = {}) {
   if (typeof bytes !== "object" || bytes === null || tagOf(bytes) !== "Uint8Array") {
     throw new ValidationError(`${what} must be a Uint8Array of portable Roaring bytes`);
   }
   const view = plainView(bytes, what);
+  if (view.byteLength === 0 && options.refuseEmpty === true) {
+    throw new ValidationError(
+      `${what} is empty or detached: an empty buffer is not a bitmap, and an empty bitmap is built without bytes`
+    );
+  }
+  const { maxBytes } = options;
+  if (maxBytes !== void 0 && maxBytes < MAX_SERIALIZED_LOAD_BYTES && view.byteLength > maxBytes) {
+    throw new ValidationError(
+      `${what} is ${view.byteLength} bytes, more than the ${maxBytes} this call allows (maxBytes)`
+    );
+  }
   if (view.byteLength > MAX_SERIALIZED_LOAD_BYTES) throw overCap(what, view.byteLength);
   const own = isShared(view.buffer) ? new Uint8Array(view) : view;
   try {
@@ -5437,12 +5474,10 @@ var CrbmWriter = class {
   async addChunk(chunkKey, payload, cardinality) {
     if (this.finished) throw new ValidationError("CrbmWriter already finished");
     if (!Number.isInteger(chunkKey) || chunkKey < 0 || chunkKey > 65535) {
-      throw new ValidationError(`chunkKey must be a u16; got ${chunkKey}`);
+      throw new ValidationError("chunkKey must be a u16");
     }
     if (chunkKey <= this.lastKey) {
-      throw new ValidationError(
-        `chunkKey ${chunkKey} not strictly ascending (last ${this.lastKey})`
-      );
+      throw new ValidationError("chunkKey is not strictly ascending");
     }
     if (!Number.isInteger(cardinality) || cardinality < 1 || cardinality > MAX_CHUNK_CARDINALITY) {
       throw new ValidationError(
@@ -6252,7 +6287,7 @@ async function collectChunks(input, codec, clock) {
       throw new ValidationError("a chunk's key must be an integer in [0, 65535]");
     }
     if (chunkKey <= last) {
-      throw new ValidationError(`chunk ${chunkKey} does not ascend: the last was ${last}`);
+      throw new ValidationError("a chunk's key does not ascend past the previous chunk's");
     }
     last = chunkKey;
     const max = bitmap.maximum?.();
@@ -7271,7 +7306,7 @@ var KeyBits = class {
 };
 
 // src/core/combine-ledger.ts
-var RESIDENT_BITMAP_OVERHEAD = 512;
+var RESIDENT_BITMAP_OVERHEAD = 832;
 var MAX_CHUNK_SERIALIZED = 8208;
 function serializedBound(cardinality) {
   return Math.min(2 * cardinality + 16, MAX_CHUNK_SERIALIZED);
@@ -7279,7 +7314,7 @@ function serializedBound(cardinality) {
 var MAX_RESIDENT_DATA = 8800;
 function residentBytes(serialized) {
   return Math.ceil(
-    RESIDENT_BITMAP_OVERHEAD + Math.min(1.6 * serialized, serialized + 2e3, MAX_RESIDENT_DATA)
+    RESIDENT_BITMAP_OVERHEAD + Math.min(1.6 * serialized, serialized + 2200, MAX_RESIDENT_DATA)
   );
 }
 function residentBound(cardinality) {
@@ -8643,7 +8678,7 @@ var Run = class {
                 failOperand(
                   c,
                   new IntegrityError(
-                    `operand "${c.op.spec.name}" lists chunk ${key} but its generation holds no bytes for it`
+                    `operand "${c.op.spec.name}" lists a chunk its generation holds no bytes for`
                   ),
                   victims ?? wanting(c)
                 );
@@ -8652,13 +8687,10 @@ var Run = class {
               try {
                 const resident = residentBytes(bytes.length);
                 if (!this.ledger.reserve(resident, makeRoom)) {
-                  throw this.refuse(resident, `operand "${c.op.spec.name}" at chunk ${key}`);
+                  throw this.refuse(resident, `operand "${c.op.spec.name}" at one of its chunks`);
                 }
                 held += resident;
-                decoded.set(
-                  c.op.index,
-                  decodeChunkBytes(this.codec, bytes, key, this.maxBitmapBytes)
-                );
+                decoded.set(c.op.index, decodeChunkBytes(this.codec, bytes, this.maxBitmapBytes));
               } catch (error) {
                 failOperand(c, error, victims ?? wanting(c));
               }
@@ -9565,7 +9597,7 @@ async function holds(c, generation) {
       }
       throw err;
     }
-    return bytes !== null && codec.safeDeserialize(bytes, maxBytes).has(remainder);
+    return bytes !== null && decodeChunkBytes(codec, bytes, maxBytes).has(remainder);
   } catch (err) {
     if (isNotFoundError(err)) return null;
     throw err;
@@ -9681,7 +9713,8 @@ async function fence(c, plan) {
     const ledger = usableKnownGens(row);
     const doomed = doomedGenerations(c, plan, byName, ledger, pointer);
     const named = ledger !== void 0 && ledger.some((e) => doomed.has(e.generation));
-    const renew = byName.length > 0;
+    const sweepOwes = plan.sweeps && !named && row.pointerId === record.pointerId && sameKnownGens(row.knownGens, record.knownGens);
+    const renew = byName.length > 0 || sweepOwes;
     const renewedAfter = held && row.pointerId !== first.pointerId;
     if (!named && (!renew || renewedAfter)) {
       c.premise = row;
@@ -9975,8 +10008,7 @@ async function stage(c) {
     c.fromFingerprint = reader.fingerprint;
     const bytes = await read(() => reader.getChunk(chunkKey));
     if (bytes === null) return await notInCurrent(c);
-    const target = codec.safeDeserialize(bytes, maxBytes);
-    assertRemaindersInRange(target, chunkKey);
+    const target = decodeChunkBytes(codec, bytes, maxBytes);
     if (!target.has(remainder)) return await notInCurrent(c);
     target.remove(remainder);
     assertRegistryCanWrite(deps.registry, "eraseIdFromSegment");
@@ -10039,6 +10071,34 @@ async function stage(c) {
     throw err;
   }
 }
+async function provenOwn(c, key, fingerprint) {
+  const { deps } = c;
+  const retry = deps.readRetry;
+  const base = retry?.isRetryable ?? isTransientError;
+  let fault;
+  try {
+    return await retryRead(
+      async () => {
+        try {
+          return await provenObject(deps.storage, key, fingerprint);
+        } catch (err) {
+          if (!isIntegrityError(err)) fault = err;
+          throw err;
+        }
+      },
+      retry === void 0 ? void 0 : {
+        ...retry,
+        isRetryable: (err) => isIntegrityError(err) || base(err),
+        onRetry: (info) => {
+          if (!isIntegrityError(info.err)) retry.onRetry?.(info);
+        }
+      }
+    );
+  } catch (err) {
+    if (isIntegrityError(err) && fault === void 0) return null;
+    throw fault ?? err;
+  }
+}
 async function discardRefused(c, own) {
   const { ref, deps, base, from } = c;
   const key = { ...base, generation: own.generation };
@@ -10055,7 +10115,7 @@ async function discardRefused(c, own) {
     }
     if (row === null || row.status !== "active" || row.currentGen === null) return row;
     if (row.currentGen <= from || row.currentGen >= own.generation) return row;
-    const proven = await provenObject(deps.storage, key, own.fingerprint);
+    const proven = await provenOwn(c, key, own.fingerprint);
     if (proven === null) return row;
     const renewed = await renewal.renew(row);
     if ("row" in renewed) {
@@ -10234,26 +10294,17 @@ async function* rewrite(reader, chunkKey, replacement, codec, maxBytes, read) {
       }
       const item = await stream.next();
       if (item.done === true || item.value.key !== k) {
-        throw new IntegrityError(`the chunk stream ended before chunk ${k}`);
+        throw new IntegrityError("the chunk stream ended before a chunk the rewrite needs");
       }
       const bytes = item.value.bytes;
       if (bytes === null) continue;
-      const bitmap = codec.safeDeserialize(bytes, maxBytes);
-      assertRemaindersInRange(bitmap, k);
+      const bitmap = decodeChunkBytes(codec, bytes, maxBytes);
       yield { chunkKey: k, bitmap };
     }
   } finally {
     await stream.return(void 0);
   }
 }
-function assertRemaindersInRange(bitmap, chunkKey) {
-  const max = bitmap.maximum?.();
-  if (max !== void 0 && max > MAX_REMAINDER) {
-    throw new IntegrityError(
-      `chunk ${chunkKey} payload holds value ${max}, outside the 16-bit remainder range [0, ${MAX_REMAINDER}] \u2014 the stored object is corrupt or was not written by this codec; refusing to carry it into a new generation`
-    );
-  }
-}
 
 // src/core/cas-retry.ts
 async function casRetry(deps, ref, plan, step) {
@@ -12047,6 +12098,7 @@ export {
   LeaseLimitError,
   MAX_LEASES_PER_SEGMENT,
   MAX_LEASE_MS,
+  MAX_SERIALIZED_LOAD_BYTES,
   MIN_EXPIRES_AT_MS,
   NOOP_METRICS,
   NotFoundError,
@@ -12082,6 +12134,7 @@ export {
   mapWithConcurrency,
   readRetentionPolicy,
   rebindCombineMany,
+  refusalOfId,
   refuseUnknownRefKeys,
   releaseLease,
   resolveBudget,