@cloudbitmaps/roaring 0.19.1 → 0.20.0

package/dist/index.d.ts

@@ -23,7 +23,7 @@
  * `checkConsistency`, `exportSegments` — reuse the store's own drivers, so you never re-pass them (they need the
  * store built with a backend). See the README and the getting-started guide.
  */
-import type { BudgetOption, GenerationEntry, GenerationMetadata, LoadGuard, LoadInput, LoadOptions, LoadRefusal, LoadResult, RollbackResult, Clock, StorageChunkSource, ConsistencyReport, CostReport, DropResult, EstimateInput, ExportManifest, ExportOptions, ExportSink, IAuditSink, IStorageDriver, IKeystore, IMetricsSink, StorageBackend, PricingProfile, RetentionPolicy, RetireExpiredOptions, RetireExpiredResult, RetryPolicy, Rng, SetRetentionResult, PinnedAt, IdRange, SegmentRef, Workload } from '@cloudbitmaps/core';
+import type { BudgetOption, GenerationEntry, GenerationMetadata, LoadGuard, LoadInput, LoadOptions, LoadRefusal, LoadResult, RollbackResult, Clock, StorageChunkSource, ConsistencyReport, DropResult, ExportManifest, ExportOptions, ExportSink, IAuditSink, IStorageDriver, IKeystore, IMetricsSink, StorageBackend, RetentionPolicy, RetireExpiredOptions, RetireExpiredResult, RetryPolicy, Rng, SetRetentionResult, PinnedAt, IdRange, SegmentRef } from '@cloudbitmaps/core';
 import type { SegmentInfo } from '@cloudbitmaps/core';
 import type { CombineExpr, CombineManyFeedRecord, CombineManyOperandStats, CombineManyOutputStats, CombineManyStats } from '@cloudbitmaps/core';
 import { deserializePortable } from './roaring-codec.js';
@@ -121,9 +121,11 @@ export interface CacheOptions {
      * advanced.
      *
      * **While the registry cannot be read, the bound stretches.** A refresh that fails with a
-     * {@link TransientError} keeps serving the generation the reader holds, and the key it unwrapped, and is tried
-     * again 500 ms later (or after this TTL, if shorter), so the store converges within one retry of the registry
-     * answering. A refresh that fails with anything else, an access denial or a row that will not parse, is not
+     * {@link TransientError} keeps serving the generation of a segment still in the reader cache, and the key its reader
+     * unwrapped (a read that needs the key, where none was unwrapped before it, unwraps it from that segment's row as
+     * resolved before the outage), and is tried again 500 ms later (or after this TTL, if shorter), so the store converges
+     * within one retry of the registry answering. A segment the reader cache has let go is not served past its resolution's TTL: once that
+     * lapses, a read of it fails with the fault, as a cold read does. A refresh that fails with anything else, an access denial or a row that will not parse, is not
      * ridden out: the read that meets it throws that error, and the reader is dropped.
      *
      * `0` turns this timed refresh off, and so does wiring a bare `IStorageDriver`, which has no registry. That is
@@ -138,7 +140,13 @@ export interface CacheOptions {
     /**
      * Ceiling on how many segments' `.crbm` readers (each holding a parsed index) the store keeps open at once
      * (default 1024) — the steady-state memory bound for a long-running server that reads across many segments.
-     * Past it the least-recently-used segment's reader is evicted; re-opening it later is one cheap tail GET. A reader of a small generation, one whose whole object came with its tail read,
+     * Past it the least-recently-used segment's reader is evicted; re-opening it later is one cheap tail GET. With a
+     * timed refresh ({@link CacheOptions.genTtlMs} above 0, and a backend) the store also keeps up to 8 times this many
+     * segments' resolutions (what it read of each segment's row: never an unwrapped key, though the wrapped keys are in
+     * it) for `genTtlMs`, apart from their readers. An evicted segment is then reopened with no registry read, on the
+     * generation it had resolved, when a read needs its index or a chunk the chunk cache does not hold: `iterate` and the
+     * combines always do, and a `has()` of a cached chunk, a `count()` and a `stat()` do not, where the row has a summary
+     * the store can use. A reader of a small generation, one whose whole object came with its tail read,
      * also holds its chunk bytes, so a read of it makes no chunk request until the reader is evicted or the pointer refresh
      * moves it on; a store with no timed refresh (`genTtlMs: 0`, or no registry) keeps none.
      * Applies whenever the store builds its own read path — a backend or a bare `IStorageDriver`. A pre-built
@@ -152,7 +160,8 @@ export interface CacheOptions {
      * of the memory bound, complementing the {@link CacheOptions.readerMax} *count* bound. A wide/dense segment's
      * parsed index can reach about 1.3 MB, so a count-only bound could let the open readers pin over a GB and blow a small
      * heap (e.g. a 128 MB Lambda); this evicts the least-recently-used reader once the summed index footprint
-     * would exceed the ceiling — whichever of the count/byte bounds binds first. Lower it for memory-tight
+     * would exceed the ceiling — whichever of the count/byte bounds binds first. A sixteenth of it (4 MiB by default)
+     * bounds the segments' resolutions a store with a timed refresh keeps besides. Lower it for memory-tight
      * deployments that read across wide segments. Applies whenever the store builds its own read path.
      */
     readonly readerMaxBytes?: number;
@@ -242,8 +251,9 @@ export interface SubjectErasureEntry {
     /** The generation written without the id (present whenever one was written). */
     readonly generation?: number;
     /**
-     * Why the id was NOT erased from this segment, when `erased` is false. `'superseded'` — the pointer moved while
-     * the call was in flight, by a load, another erasure or a rollback, so **this call** did not erase the id;
+     * Why the id was NOT erased from this segment, when `erased` is false. `'superseded'` — another writer (a load,
+     * another erasure or a rollback) moved the pointer, or replaced an object the call meant to delete, while the call
+     * was in flight, so **this call** did not erase the id;
      * re-run against the new generation, which erases it if it is still there and reports nothing for the segment
      * if the racing writer already removed it. `` `error: <message>` `` — an isolated per-segment fault
      * (per-segment faults are recorded so one segment can't discard the whole ledger); re-run after fixing the
@@ -474,8 +484,9 @@ export interface MaterializeResult {
      * What the destination held when the guard judged it — `null` when it had no current generation, **or when
      * no bound needed it**. It is taken only when a bound will use it: `allowEmpty: true` with neither
      * `guard.minRetained` nor `guard.maxGrowth` skips it, and this is `null` even though `dest` was non-empty. When the destination's row
-     * carries a summary of its current generation the count comes from the row and the object is not read; a row
-     * written before rows carried a summary costs one object-header fetch.
+     * carries a summary of its current generation the count comes from the row and the object is not read; a row with
+     * none (one a rollback left when it could not open the key, one a registry of your own stores without one, or one this store cannot use) costs
+     * one object-header fetch.
      */
     readonly cardinalityBefore: number | null;
     /** Non-empty chunks in the generation. */
@@ -533,10 +544,11 @@ export declare class CloudRoaring {
     private lifecycleDeps;
     /**
      * Get a handle to a segment. Validates the name (non-empty, well-formed, within the encoded-length cap). The options
-     * are `{ namespace }` and nothing else: anything else is refused with {@link ValidationError}, by name, since a
-     * misspelt `namespace` would otherwise address the default namespace. An `expiresAt` among them is refused with its own
-     * message: a handle carries no deadline, and one left unread would serve the data past it. A key whose value is
-     * `undefined` is read as absent, so a spread of options keeps working.
+     * are a plain object holding `{ namespace }` and nothing else: any other own key, enumerable or not, is refused with
+     * {@link ValidationError}, by name, since a misspelt `namespace` would otherwise address the default namespace, and a
+     * deadline such as `expiresAt` would be left unread. A class instance, or an object built on another, is refused too,
+     * since it can carry an option no scan of its own keys sees. A key whose value is `undefined` is read as absent, so a
+     * spread of options keeps working.
      */
     segment(name: string, options?: SegmentOptions): Segment;
     /**
@@ -551,13 +563,20 @@ export declare class CloudRoaring {
      * of it. A materialisation is a load whose ids happen to come from a combine instead of from upstream, so
      * everything `load()` learned the hard way applies unchanged: the generation is written UNPUBLISHED, the
      * guard runs while the old generation is still authoritative, the publish is fenced as above, and a refused
-     * object is reclaimed only when a re-read finds the row unchanged (the same token) or gone (hard invariant 1:
-     * deleting it after a purge-and-recreate would put a live row over a missing generation).
-     *
-     * That last check narrows the window rather than closing it: the row read and the delete are two round
-     * trips, and `IStorageDriver` has no conditional delete to make them one. the collection a load runs carries
-     * the same residual. The failure it leaves is an orphan object, which costs storage until
-     * something collects it — deliberately the cheaper side of the trade.
+     * object is reclaimed only when a re-read finds the row unchanged (the same token, or one that differs only in
+     * its leases), `destroyed`, or gone, or finds key material on it when the load wrote cleartext; under any other
+     * row it is kept (hard invariant 1: deleting it after a purge-and-recreate would put a live row over a missing
+     * generation).
+     *
+     * Where the row is gone, or keyed over a cleartext write, the object is proved the load's own by its footer, and
+     * the delete passes the version that read reported, so on a storage driver that reports `conditionalDelete` an
+     * object put under the number since is kept. Where the row is unchanged or `destroyed`, the check narrows the
+     * window rather than closing it: the row read and the delete are two round trips, and the delete is by number,
+     * since the write reports no version of the object it made. The other deletes a load leads to are by number too: its
+     * collection deletes what a listing, or the row's list of kept generations, names below the pointer, and a drop's
+     * sweep and a tombstoned segment's collection delete what a listing names under a `destroyed` row. The failure the
+     * checks leave when they refuse is an orphan object, which costs storage until something collects it —
+     * deliberately the cheaper side of the trade.
      *
      * Written and published in one step, with no guard, an empty combine — a typo'd operand, an `exclude` that
      * swallowed everything, an operand that had not loaded yet — would silently replace `dest` with an empty
@@ -746,10 +765,14 @@ export declare class CloudRoaring {
      * can still hold it, and so can one above the pointer after a {@link CloudRoaring.rollback}, which the rollback
      * could make current again. Each holder is deleted — below the pointer by a `keep: 0` collection, above it one
      * by one, re-proved against the row first — and the generations above the pointer that never held the id stay
-     * as rollback targets. An entry says `erased: true` only once the call has listed the bucket and read what is
-     * left: **no generation of the segment holds the id**. The returned per-segment record is your **erasure ledger** —
-     * persist it / route it to your audit sink as the proof of deletion (a `segment.rewrite` audit event is also
-     * emitted per rewrite when you pass `audit`).
+     * as rollback targets, but for any object no read of the segment can open, which goes whatever the id. An entry
+     * says `erased: true` only once the call has listed the bucket and read what is left: **no generation of the
+     * segment holds the id**. The returned per-segment record is your **erasure ledger** —
+     * persist it / route it to your audit sink as the proof of deletion (when you pass `audit`, an audit event is also
+     * emitted per segment erased: `segment.rewrite` for a rewrite, `segment.collect` where only other generations held
+     * the id and nothing was rewritten). A segment where the erasure deleted only objects no read of it can open (a first
+     * load's sealed under a key no row holds) found the id in none, so the ledger does not list it; the audit sink gets
+     * `segment.collect` for it with no `fromGeneration`, which is the only record of that deletion.
      *
      * Uses the backend's **own** two halves, so the membership check and the rewrite provably run
      * over the same generation. Requires the store built with a **backend** (throws
@@ -771,13 +794,21 @@ export declare class CloudRoaring {
      * an error, read off the row: a moved pointer is a `'superseded'` entry, which a re-run settles, and a segment
      * that a concurrent `dropSegment` tombstoned or a retention sweep purged is left out of the ledger. A tombstoned
      * segment is still searched: a cleartext object left under it that holds the id is deleted, with everything under
-     * the tombstone, and the entry reads `erased: true`.
+     * the tombstone, and the entry reads `erased: true`. So is a segment whose row names no generation yet (a retention
+     * policy set before its first load): a first load's object that holds the id is deleted, once the row's `pointerId`
+     * is renewed so that the load, if still running, is refused at its publish, and the entry reads `erased: true`. An
+     * encrypted first load's object there cannot be searched, so it is deleted whatever the id: on an encrypted store,
+     * an erasure of any id refuses an encrypted first load in flight that has written its object onto a segment made
+     * ahead of its data. Each such delete, and each of a holder above the pointer, names the object the erasure read:
+     * on a storage driver that reports `conditionalDelete`, another erasure of the id that deletes it first, followed by
+     * a load that takes the number freed and publishes, does not lose that load's generation to this erasure's delete,
+     * which is refused, and the entry says what the row says; on one that does not, it can.
      *
      * **Read `note` on any `erased: false` entry — the two reasons mean different things.** `'superseded'` means
-     * another writer (a load, another erasure, or a rollback) moved the pointer mid-call, so **this call** did not
-     * erase the id. Re-run: it erases the id if it is still there, and lists nothing for the segment if a racing
-     * erasure of the same id already removed it. Do not read `'superseded'` as "the id is still present" —
-     * read it as "not done by this call, and the re-run settles it".
+     * another writer (a load, another erasure, or a rollback) moved the pointer, or replaced an object the call meant to
+     * delete, mid-call, so **this call** did not erase the id. Re-run: it erases the id if it is still there, and lists
+     * nothing for the segment if a racing erasure of the same id already removed it. Do not read `'superseded'` as
+     * "the id is still present" — read it as "not done by this call, and the re-run settles it".
      * `` `error: …` `` is a per-segment fault (caught so one segment can't discard the whole ledger) and it can land
      * on either side of the publish: if the rewrite had not published, the id is still there and a re-run erases
      * it; if the publish succeeded and only the **collection** of the old generation failed, the id is already
@@ -899,8 +930,9 @@ export declare class CloudRoaring {
      * and are then *above* `currentGen`, where collection never looks. They remain until loads pass them (the first
      * load whose number one of them holds numbers above them all, and collection then keeps the newest `keep` of what is
      * below its pointer), {@link CloudRoaring.dropSegment}
-     * deletes them, or {@link CloudRoaring.eraseSubject} does: all of those present when it rewrites, and only those holding
-     * the id when the current generation does not. An operator who has just undone a bad load should not have the
+     * deletes them, or {@link CloudRoaring.eraseSubject} does: all of those present when it rewrites, and, when the
+     * current generation does not hold the id, only those holding it and any no read of the segment can open, whatever
+     * the id. An operator who has just undone a bad load should not have the
      * evidence collected out from under them, while a rollback target that still holds erased data would make the
      * erasure undoable.
      *
@@ -962,10 +994,12 @@ export declare class CloudRoaring {
      * published, a retention change, a rollback or an erasure wrote the row, or the row was deleted.
      *
      * A refused load deletes the object it wrote before returning — it sits above `currentGen`, where generation
-     * collection deliberately never looks — but only while the segment's registry row is unchanged or gone. Once
-     * another write has changed the row, the generation number it holds may name another incarnation's live object,
-     * so it leaves the orphan rather than risk deleting live data. No row's list names it, so it takes no place in a
-     * window, and a listing deletes it once a later generation is current above it.
+     * collection deliberately never looks — but only while the segment's registry row is unchanged (or differs only
+     * in its leases), `destroyed` or gone, or has key material when the load wrote cleartext, which has no place in an
+     * encrypted segment's bucket. Under a row that is gone or keyed, a read of the object's footer must prove it the
+     * load's own first. Once another write has otherwise changed the row, the generation number it holds may name
+     * another incarnation's live object, so it leaves the orphan rather than risk deleting live data. No row's list
+     * names it, so it takes no place in a window, and a listing deletes it once a later generation is current above it.
      *
      * **Collection is by name at any `keep` up to 64.** The segment's row records the generations a load keeps, so a load
      * that found nothing above the pointer deletes the generations its publish pushed out of the window and lists
@@ -1139,8 +1173,8 @@ export declare class CloudRoaring {
      * Pass `purgeTombstones: false` to keep every tombstone, that row included. On a backend whose registry reports
      * `conditionalDelete` (AWS S3, Azure Blob, the local filesystem and memory, by default; GCS when you set `conditionalDelete: true`)
      * the purge removes the row from the bucket for good, by a delete the store applies only to the version it judged,
-     * so a full sweep reads what is live or inside its grace rather than every name a namespace ever held; elsewhere,
-     * and for a row a release before 0.12 wrote, it leaves a tombstone. Each retirement files a pointer in the due index
+     * so a full sweep reads what is live or inside its grace rather than every name a namespace ever held; elsewhere it
+     * leaves a tombstone. Each retirement files a pointer in the due index
      * under the day its tombstone's grace ends, so `scan: 'index'` purges as well as retires.
      *
      * Needs the store built with a **backend** (throws {@link UnsupportedError} otherwise),
@@ -1232,7 +1266,8 @@ export declare class CloudRoaring {
      * A segment whose pointer names a missing object is the torn restore this reports; a cold `count()` of it still
      * answers the number its row records, while a read of the object throws, so the count alone never shows it. With
      * `summaries: true` it also opens each segment's current object (one tail read each) and reports a segment whose
-     * row's summary says another id count or metadata than the object holds as `summary-mismatch`, which is what a
+     * row's summary names another object by its fingerprint, or says another id count or metadata than the object holds,
+     * as `summary-mismatch`, which is what a
      * restore of the registry from another point than the bucket leaves a count to answer. A sealed summary is held
      * against its object when this store has the key, and counted in `summariesUnchecked` when it does not.
      *
@@ -1259,13 +1294,6 @@ export declare class CloudRoaring {
      * CLI wraps this with a filesystem sink.
      */
     exportSegments(sink: ExportSink, options?: ExportOptions): Promise<ExportManifest>;
-    /**
-     * Planning cost estimate — pure, no instance/data needed: sizing, sales, what-if. For a real, grounded report
-     * from live segment sizes, use `store.segment(name).costReport()`. See {@link CostReport}.
-     * @deprecated Moves to `@cloudbitmaps/tools`, a package of its own, with a `size` on `stat()` so a grounded report
-     * needs nothing internal. It is a planning tool, and its price list is as old as the release that ships it.
-     */
-    static estimateCost(input: EstimateInput): CostReport;
 }
 /**
  * Options common to every chunk-aligned combine (`intersect` / `union` / `andNot`), and the `*Into` verbs.
@@ -1432,13 +1460,22 @@ export interface PinAt {
     /** The fingerprint of that generation's object, from the earlier pin's `pinnedAt.fingerprint`. */
     readonly fingerprint: string;
 }
-/** What {@link Segment.stat} answers: the generation a handle reads, its id count and its metadata. */
+/**
+ * What {@link Segment.stat} answers: the generation a handle reads, its id count, its metadata and the size of its
+ * object.
+ */
 export interface SegmentStat {
     /** The generation read, or `null` when the segment has none. */
     readonly generation: number | null;
     readonly cardinality: number;
     /** The metadata the generation was loaded with; absent when it has none. */
     readonly metadata?: GenerationMetadata;
+    /**
+     * The generation's object in storage, in bytes: what the segment stores. From the registry row's summary, which
+     * records the object's size with its checksum, or from the object's footer when the row has no summary to use.
+     * `null` when the segment has no generation, or when the store's source cannot report a size.
+     */
+    readonly sizeBytes: number | null;
 }
 /**
  * A handle bound to one segment — the read verbs, plus the three `*Into` verbs that write a **new generation**
@@ -1639,8 +1676,8 @@ export declare class Segment {
      * Cardinality of the generation this handle reads: **one registry read when cold, none when warm, and no read of the
      * object**, with **zero payload reads**. The registry row records the id count of the generation it names, written
      * by the write that made it current, and a count answers from that. A row with no summary it can use (one written
-     * before rows carried it, one that names another generation, a sealed one that does not open) sends the count to the
-     * `.crbm` index, summed with a tail read of the object. A segment whose pointer names a missing object (a torn
+     * without it, as a registry of your own may, one that names another generation, a sealed one that does not open)
+     * sends the count to the `.crbm` index, summed with a tail read of the object. A segment whose pointer names a missing object (a torn
      * restore) still counts the row's number, while a read of the object throws; `checkConsistency` is what finds it.
      *
      * What this trusts: the row's summary, or the index's sum, and no payload is decoded to confirm it. The summary is
@@ -1655,17 +1692,30 @@ export declare class Segment {
      */
     count(): Promise<number>;
     /**
-     * What the generation this handle reads is, from one resolution: its number, its id count and the metadata it
-     * was loaded with (absent when it has none). It is what answers {@link Segment.count}, so the three describe one
-     * generation and cannot straddle a publish. One registry read when cold, none while warm, and none on a pinned
-     * handle, which answers for the generation it pinned. A segment with no generation answers
-     * `{ generation: null, cardinality: 0 }`.
-     *
-     * Trust is as for `count()`: the registry row's word, not confirmed against the object until the object is
-     * opened, when a disagreement makes this process stop using that row's summary.
+     * What the generation this handle reads is, from one resolution: its number, its id count, the metadata it was
+     * loaded with (absent when it has none), and `sizeBytes`, its object's bytes in storage. All four come from the
+     * registry row when it has a summary this store can use, as `count()`'s do: the summary records the object's
+     * fingerprint, its size with its checksum. That is **one registry read when cold, none when warm, and no read of the
+     * object**. With no summary it can use, they come from the generation's object, opened once: its footer and index,
+     * with no payload read, which is a tail read of the object more when cold (and a range read for an index longer than
+     * the tail) and keeps the generation in the reader cache as a read does. On a pinned handle it answers for the
+     * generation it pinned, from the pinned object. A segment with no generation answers
+     * `{ generation: null, cardinality: 0, sizeBytes: null }`, and a store whose source cannot report a size answers
+     * `sizeBytes: null`. A pointer that names a missing object (a torn restore) still answers from the row's summary, as
+     * `count()` does, while a read of the object throws `NotFoundError`; with no summary to use, `stat()` throws it too.
+     * `checkConsistency` is what finds such a row.
+     *
+     * Trust is as for `count()`: what the row's summary says is believed until the object is next opened. Every open of
+     * the generation holds the object to the fingerprint the summary records, so another object under the number is
+     * refused when it is opened, and holds its count against the summary's; a disagreement in count makes this process
+     * stop using that summary, so `stat()` then answers from the object, whose index is checked for internal consistency
+     * and whose count is the index's sum. A reader already open is not checked again until the row changes, it is
+     * evicted or it is invalidated.
+     *
+     * `sizeBytes` is what `groundedReport` in `@cloudbitmaps/tools` prices storage from.
      *
      * ```ts
-     * const { generation, cardinality, metadata } = await store.segment('active-30d').stat();
+     * const { generation, cardinality, metadata, sizeBytes } = await store.segment('active-30d').stat();
      * ```
      */
     stat(): Promise<SegmentStat>;
@@ -1792,20 +1842,7 @@ export declare class Segment {
     private andNotAs;
     /** Materialize `this \ (excludes…)` as a **new generation of `dest`** — see {@link intersectInto}. */
     andNotInto(dest: Segment, excludes: Segment[], options?: AndNotIntoOptions): Promise<MaterializeResult>;
-    /**
-     * Grounded cost report for this segment: storage cost from its **real** `.crbm` size (exact, no payload
-     * reads); request cost from the supplied `workload` rates. A segment with no Storage generation reports zero
-     * storage. The pointer refresh is priced at the store's own `cache.genTtlMs`, or at none when the store never
-     * refreshes, unless the workload sets `genTtlMs`. See {@link CostReport} — it always includes a verdict (incl.
-     * the lose-zone).
-     * @deprecated Moves to `@cloudbitmaps/tools`, a package of its own, with a `size` on `stat()` so a grounded report
-     * needs nothing internal. It is a planning tool, and its price list is as old as the release that ships it.
-     */
-    costReport(options?: {
-        pricing?: PricingProfile;
-        workload?: Workload;
-    }): Promise<CostReport>;
 }
 export { deserializePortable };
-export { MemoryStorage, LocalFsStorage, CrbmStorageChunkSource, destroySegment, eraseNamespace, excludingReservedRows, readRetentionPolicy, MIN_EXPIRES_AT_MS, LEASE_SKEW_MS, MAX_LEASE_MS, MAX_LEASES_PER_SEGMENT, InProcessKeystore, NodeAead, aadFor, CloudRoaringError, ValidationError, WriteConflictError, IntegrityError, NotFoundError, UnsupportedError, CapabilityError, TransientError, KeyUnavailableError, BudgetExceededError, LeaseExpiredError, LeaseLimitError, StaleOperandError, isCloudRoaringError, isWriteConflictError, isTransientError, isNotFoundError, isIntegrityError, isValidationError, isLeaseExpiredError, isLeaseLimitError, isStaleOperandError, isUnsupportedError, isCapabilityError, isBudgetExceededError, isKeyUnavailableError, CrbmReader, BufferReader, CountingMetricsSink, RecordingAuditSink, DEFAULT_RETRY_POLICY, AWS_US_EAST_1_ONDEMAND, ELASTICACHE_REDIS_US_EAST_1_ONDEMAND, ONE_REDIS_HA_CLUSTER, } from '@cloudbitmaps/core';
-export type { Aead, AeadSealed, AuditEvent, BlobReader, BlobSink, Budget, BudgetOption, ChunkRef, Clock, CodecBitmap, CodecInterface, ConsistencyErrorEntry, ConsistencyIssue, ConsistencyReport, CostReport, CrbmCrypto, CrbmReaderOptions, CrbmStorageChunkSourceOptions, DestroyResult, ClearRegistrySummary, DropResult, EncodedChunk, EraseDeps, EstimateInput, ExportFailure, ExportFormat, ExportManifest, ExportOptions, ExportSink, ExportWriter, ExportedSegment, GenKey, GenerationEntry, GenerationMetadata, GovernanceMeta, IAuditSink, IKeystore, IMetricsSink, IRegistryDriver, IStorageDriver, IdRange, InProcessKeystoreOptions, LoadGuard, LoadInput, LoadOptions, LoadRefusal, LoadResult, LocalFsStorageOptions, MemoryStorageOptions, MetricEvent, MetricOpName, MetricsSnapshot, NewRegistryRecord, PinnedAt, PinnedObject, PortableBitmap, PricingProfile, RedisNodeType, RedisSizing, RegCaps, RegistryPatch, RegistryRecord, RegistryStatus, RegistrySummary, RegistryWriteOptions, LeaseEntry, RetentionPolicy, RetireEntry, RetireExpiredOptions, RetireExpiredResult, RetryPolicy, Rng, RollbackResult, SealedRegistrySummary, SegmentInfo, SegmentRef, SegmentSize, SegmentSizing, SetRetentionResult, StorageBackend, StorageCaps, StorageChunkSource, Token, Workload, WrappedDek, } from '@cloudbitmaps/core';
+export { MemoryStorage, LocalFsStorage, CrbmStorageChunkSource, destroySegment, eraseNamespace, excludingReservedRows, readRetentionPolicy, MIN_EXPIRES_AT_MS, LEASE_SKEW_MS, MAX_LEASE_MS, MAX_LEASES_PER_SEGMENT, InProcessKeystore, NodeAead, aadFor, CloudRoaringError, ValidationError, WriteConflictError, IntegrityError, NotFoundError, UnsupportedError, CapabilityError, TransientError, KeyUnavailableError, BudgetExceededError, LeaseExpiredError, LeaseLimitError, StaleOperandError, isCloudRoaringError, isWriteConflictError, isTransientError, isNotFoundError, isIntegrityError, isValidationError, isLeaseExpiredError, isLeaseLimitError, isStaleOperandError, isUnsupportedError, isCapabilityError, isBudgetExceededError, isKeyUnavailableError, CrbmReader, BufferReader, CountingMetricsSink, RecordingAuditSink, DEFAULT_RETRY_POLICY, } from '@cloudbitmaps/core';
+export type { Aead, AeadSealed, AuditEvent, BlobReader, BlobSink, Budget, BudgetOption, ChunkRef, Clock, CodecBitmap, CodecInterface, ConsistencyErrorEntry, ConsistencyIssue, ConsistencyReport, CrbmCrypto, CrbmReaderOptions, CrbmStorageChunkSourceOptions, DestroyResult, ClearRegistrySummary, DropResult, EncodedChunk, EraseDeps, ExportFailure, ExportFormat, ExportManifest, ExportOptions, ExportSink, ExportSkipped, ExportWriter, ExportedSegment, GenKey, GenerationEntry, GenerationMetadata, GovernanceMeta, IAuditSink, IKeystore, IMetricsSink, IRegistryDriver, IStorageDriver, IdRange, InProcessKeystoreOptions, LoadGuard, LoadInput, LoadOptions, LoadRefusal, LoadResult, LocalFsStorageOptions, MemoryStorageOptions, MetricEvent, MetricOpName, MetricsSnapshot, NewRegistryRecord, PinnedAt, PinnedObject, PortableBitmap, RegCaps, RegistryPatch, RegistryRecord, RegistryStatus, RegistrySummary, RegistryWriteOptions, LeaseEntry, RetentionPolicy, RetireEntry, RetireExpiredOptions, RetireExpiredResult, RetryPolicy, Rng, RollbackResult, SealedRegistrySummary, SegmentInfo, SegmentRef, SegmentSize, SetRetentionResult, StorageBackend, StorageCaps, StorageChunkSource, StorageDeleteOptions, TailRead, Token, WrappedDek, } from '@cloudbitmaps/core';