@cloudbitmaps/core 0.3.0 → 0.4.1

package/dist/index.d.ts

@@ -166,6 +166,21 @@ interface Clock {
      * replayable. `ms <= 0` resolves on a microtask without scheduling a timer.
      */
     sleep(ms: number): Promise<void>;
+    /**
+     * Hand the event loop back once, without asking for any elapsed time.
+     *
+     * This is **not** `sleep(0)`, and the difference is the reason the member exists. `sleep(0)` resolves on a
+     * microtask, and microtasks drain before the loop advances a phase — so awaiting it inside a CPU-bound loop
+     * yields to nothing at all, and a co-resident server stays blocked for the loop's full duration. A real yield
+     * needs a macrotask. `sleep(1)` is one, but it buys the relief at ~1 ms of dead wall-clock per yield.
+     *
+     * **Optional**, so every `Clock` written before this member still satisfies the interface. Callers must
+     * therefore degrade rather than assume: `clock.yieldNow?.() ?? clock.sleep(1)` — correct on any clock, cheap
+     * on one that implements this. `core/` cannot supply it itself (it is timer-free, lint-enforced); production
+     * wiring backs it with `setImmediate`, and a simulator can make it a no-op so virtual time is not perturbed
+     * by what is purely a scheduling courtesy.
+     */
+    yieldNow?(): Promise<void>;
 }
 /** Injected randomness. `core/` must never call `Math.random()` directly. Seedable for simulation. */
 interface Rng {
@@ -253,7 +268,7 @@ declare class BoundedLru<K, V> {
  * "Observability" section.
  */
 /** The segment operations that emit an `op` latency event (timed with the injected clock, at the facade). */
-type MetricOpName = 'add' | 'remove' | 'addMany' | 'removeMany' | 'has' | 'count' | 'intersectInto';
+type MetricOpName = 'add' | 'remove' | 'addMany' | 'removeMany' | 'has' | 'count' | 'intersectInto' | 'unionInto' | 'andNotInto';
 /**
  * One observability event. A discriminated union on `kind` — new variants can be added over time without
  * breaking consumers (they switch on the kinds they care about). `namespace` is the segment's namespace
@@ -295,8 +310,26 @@ type MetricEvent = {
     readonly delayMs: number;
 } | {
     readonly kind: 'intersect';
+    /**
+     * Which chunk-aligned combine this was. **Optional for backward compatibility** — absent means
+     * `'intersect'`, which is all this event reported before `union`/`andNot` existed.
+     *
+     * For `'union'` over its *include* operands alone, `skippedChunks` is 0 by construction — union reads
+     * every chunk of every operand, so there is nothing to prune. It can still be non-zero when a union
+     * carries `exclude` operands, because a suppression list may hold keys no include does and those are
+     * legitimately never fetched. So: 0 is the expected shape for a plain union, not a guarantee.
+     */
+    readonly op?: 'intersect' | 'union' | 'andNot';
+    /** Operand count, including any `exclude` (suppression) operands. */
     readonly operands: number;
-    /** Shared **distinct** chunk-keys selected to fetch (present in every operand). */
+    /**
+     * Distinct chunk **keys** selected to fetch — for `'intersect'`, those present in every operand.
+     *
+     * **Keys, not requests.** The actual cold GETs are roughly `fetchedChunks × operands`, plus one per
+     * `exclude` that holds a given key, which is why this number is smaller than what the per-op budget
+     * charges for the same call. The two are different units by design; if you are reconciling a bill, the
+     * budget's accounting is the one that models requests.
+     */
     readonly fetchedChunks: number;
     /**
      * **Distinct** chunk-keys pruned — never fetched (the chunk-skipping saving). Counts distinct keys,
@@ -462,6 +495,37 @@ declare function withRetry<T>(op: () => Promise<T>, policy: RetryPolicy, deps: R
  * caller shows up.
  */
 declare const DEFAULT_MAX_WARM_SCAN_BYTES: number;
+/**
+ * Default number of Warm chunk writes in flight per `addMany`/`removeMany`: **4**.
+ *
+ * The flusher was serial by default, which meant a 100-chunk `addMany` against a backend with ~10 ms of
+ * round-trip latency spent a full second doing nothing but waiting — one round-trip at a time, on work that has
+ * no ordering requirement between chunks. Distinct chunks are independent OCC rows.
+ *
+ * **Why 4 and not more.** The number is chosen against the *backend's* tolerance, not the client's appetite. A
+ * write here is a read-modify-write, so 4 in flight is up to 8 concurrent requests per `addMany` call — and a
+ * server handling many concurrent calls multiplies that again. Provisioned-capacity backends answer a burst
+ * with throttling, which is free only while retries can absorb it (4 attempts, exponential backoff, full
+ * jitter). Swept against a **modelled** backend — an in-process fake that throttles on concurrent requests in
+ * flight, not a real DynamoDB — 64 chunks, 5 trials each, counting a lost id or a surfaced error as a failure:
+ *
+ * ```text
+ *   backend capacity:      1      2      4      8
+ *   writeConcurrency  4:  0/5    0/5    0/5    0/5
+ *   writeConcurrency  8:  0/5    0/5    0/5    0/5
+ *   writeConcurrency 16:  0/5    0/5    0/5    0/5
+ *   writeConcurrency 32:  3/5    0/5    0/5    0/5   ← retry budget exhausted
+ * ```
+ *
+ * So the retry machinery holds far past 4; 4 is deliberately conservative, sitting 8x below the first observed
+ * failure against the harshest backend modelled. The remaining headroom is spent on the multiplier this table
+ * does not capture — many concurrent `addMany` calls sharing one backend — rather than on more throughput per
+ * call. A caller who knows their capacity can raise it.
+ *
+ * Raise it if your backend is provisioned for it (on-demand DynamoDB, or a Postgres pool sized to match); set
+ * it to `1` for the previous strictly-serial behaviour.
+ */
+declare const DEFAULT_WRITE_CONCURRENCY = 4;
 interface EngineDeps {
     readonly warm: IWarmDriver;
     readonly cold: ColdChunkSource;
@@ -490,9 +554,16 @@ interface EngineDeps {
      */
     readonly warmReadConsistency?: 'strong' | 'eventual';
     /**
-     * Max Warm chunk writes in flight per `addMany`/`removeMany` (the bounded flusher). Default **1** (serial —
-     * unchanged behavior). Higher values fan out distinct-chunk writes for throughput; each chunk is its own OCC
-     * row, so bounded concurrency is safe (`addMany` is already non-atomic on partial failure).
+     * Max Warm chunk writes in flight per `addMany`/`removeMany` (the bounded flusher).
+     * Default {@link DEFAULT_WRITE_CONCURRENCY}.
+     *
+     * Each chunk is its own OCC row, so distinct chunks never conflict with each other and fanning them out is
+     * safe. Raise it for more throughput against a backend with capacity to spare; set it to `1` for strictly
+     * serial writes.
+     *
+     * As before, `addMany`/`removeMany` are **not atomic**: a mid-flush failure can leave a partial result. What
+     * concurrency changes is only *how much* of the batch may already have landed when the first error surfaces —
+     * the flusher stops scheduling on the first failure, but writes already in flight still settle.
      */
     readonly writeConcurrency?: number;
     /**
@@ -536,8 +607,8 @@ declare class SegmentEngine {
     constructor(deps: EngineDeps);
     add(seg: SegmentRef, id: number): Promise<void>;
     remove(seg: SegmentRef, id: number): Promise<void>;
-    addMany(seg: SegmentRef, ids: Iterable<number>): Promise<void>;
-    removeMany(seg: SegmentRef, ids: Iterable<number>): Promise<void>;
+    addMany(seg: SegmentRef, ids: Iterable<number> | AsyncIterable<number>): Promise<void>;
+    removeMany(seg: SegmentRef, ids: Iterable<number> | AsyncIterable<number>): Promise<void>;
     has(seg: SegmentRef, id: number, opts?: WarmReadOptions): Promise<boolean>;
     count(seg: SegmentRef): Promise<number>;
     /** Whether the Cold source can measure segment size (for grounded cost); false ⇒ storage isn't grounded. */
@@ -546,6 +617,17 @@ declare class SegmentEngine {
     segmentSize(seg: SegmentRef): Promise<SegmentSize | null>;
     iterate(seg: SegmentRef): AsyncGenerator<number>;
     /**
+     * `segs[0] ∩ segs[1] ∩ …`, minus every id in `options.exclude` — streamed ascending.
+     *
+     * The `exclude` operands are what make suppression **compose without materialising**. Applying suppression
+     * afterwards (intersect into a temp segment, then remove) writes an intermediate segment that nobody wants;
+     * applying it here folds it into the same chunk-aligned pass. It is also cheaper than it looks: an exclude
+     * operand is read **only at the keys that survived the intersection** — the cost is bounded by the
+     * audience's surviving key count and **never scales with the size of the suppression list**. Subtracting a
+     * 61,000-chunk global opt-out list costs at most one read per surviving key, not 61,000.
+     *
+     * ---
+     *
      * Chunk-skipping intersection. Computes
      * `seg[0] ∩ seg[1] ∩ …` and streams the result ids ascending. It aligns each segment's *effective*
      * chunk-key set (Warm ∪ Cold), keeps only keys present in **all** operands (a key missing from any
@@ -573,14 +655,39 @@ declare class SegmentEngine {
     intersect(segs: readonly SegmentRef[], options?: {
         concurrency?: number;
         budget?: BudgetOption;
+        exclude?: readonly SegmentRef[];
+    }): AsyncGenerator<number>;
+    /**
+     * `segs[0] ∪ segs[1] ∪ …`, minus every id in `options.exclude` — streamed ascending.
+     *
+     * **Union is the one composite read with no chunk-skipping**, and that is a property of the operation rather
+     * than of this implementation: an id in *any* operand belongs to the result, so every chunk of every operand
+     * has to be read. `intersect` can prune a key absent from any operand; union cannot prune anything. It is
+     * budgeted exactly like `intersect` so a wide union is refused rather than quietly billed.
+     */
+    union(segs: readonly SegmentRef[], options?: {
+        concurrency?: number;
+        budget?: BudgetOption;
+        exclude?: readonly SegmentRef[];
+    }): AsyncGenerator<number>;
+    /**
+     * `seg \ (excludes[0] ∪ excludes[1] ∪ …)` — streamed ascending. Suppression on its own.
+     *
+     * Reads every chunk of `seg` (any of them may survive) but each exclude **only where it overlaps `seg`**, so
+     * the cost scales with the segment being filtered rather than with the size of the suppression list.
+     */
+    andNot(seg: SegmentRef, excludes: readonly SegmentRef[], options?: {
+        concurrency?: number;
+        budget?: BudgetOption;
     }): AsyncGenerator<number>;
+    private combine;
     /**
      * The AND of one chunk key across all operands (tier-merged per operand), or `null` if empty. Operand
      * chunks are fetched **in parallel** (the spec's parallel byte-range reads). `acc` takes ownership of the
      * first operand's effective chunk and mutates it in place — safe because `effectiveChunk` always returns
      * a FRESH bitmap (never a cached/shared Cold instance), so this can't poison the HOT cache.
      */
-    private intersectChunk;
+    private combineChunk;
     /**
      * Materialize `seg[0] ∩ seg[1] ∩ …` into `dest` via batched `addMany` (streaming, bounded memory).
      * **Not atomic** — like `addMany`, ids land chunk-by-chunk; a failure mid-stream leaves a partial result.
@@ -589,7 +696,60 @@ declare class SegmentEngine {
     intersectInto(dest: SegmentRef, segs: readonly SegmentRef[], options?: {
         concurrency?: number;
         batchSize?: number;
+        budget?: BudgetOption;
+        exclude?: readonly SegmentRef[];
     }): Promise<void>;
+    /**
+     * Materialize `segs[0] ∪ segs[1] ∪ …` (minus `options.exclude`) into `dest`. **Not atomic**, like
+     * {@link intersectInto}. See {@link union} for why this one cannot skip any chunk.
+     */
+    unionInto(dest: SegmentRef, segs: readonly SegmentRef[], options?: {
+        concurrency?: number;
+        batchSize?: number;
+        budget?: BudgetOption;
+        exclude?: readonly SegmentRef[];
+    }): Promise<void>;
+    /** Materialize `seg \ (excludes…)` into `dest`. **Not atomic**, like {@link intersectInto}. */
+    andNotInto(dest: SegmentRef, seg: SegmentRef, excludes: readonly SegmentRef[], options?: {
+        concurrency?: number;
+        batchSize?: number;
+        budget?: BudgetOption;
+    }): Promise<void>;
+    /**
+     * Stream a combine's results into `dest` in bounded batches.
+     *
+     * `dest` is **added to, not replaced**, and this is **not atomic** — ids land chunk-by-chunk, so a failure
+     * mid-stream leaves a partial result, exactly as `addMany` does. Batching keeps memory bounded no matter how
+     * large the result is.
+     */
+    private drainInto;
+    /**
+     * Group ids by chunk, then apply each chunk's whole batch in a single OCC read-modify-write.
+     *
+     * Accepts a **sync or async** iterable, so an Athena/BigQuery cursor streams straight in without the caller
+     * hand-batching `page → addMany(page)`.
+     *
+     * **The pending ids are held as BITMAPS, not as JS numbers, and that is the load-bearing choice.** Streaming
+     * input is unbounded by definition, so something has to give. The obvious answer — buffer N ids, flush them to
+     * the backend, repeat — bounds memory and is quietly catastrophic on cost: with ids arriving in arbitrary
+     * order, every flush touches nearly every chunk again, so an 11M-id stream at a 1M-id buffer would issue
+     * **11x** the OCC round-trips of a single pass. In a library whose headline claim is honest cost, silently
+     * multiplying someone's write bill by the size of their input is not a bounded-memory strategy; it is a
+     * different bug.
+     *
+     * So the staging buffer is capped, but it folds into per-chunk **compressed bitmaps** rather than being
+     * written out. Peak memory is the roaring representation of the ids seen so far — which is what the segment
+     * itself costs, and the floor for any implementation that writes each chunk exactly once — while the backend
+     * still sees exactly one read-modify-write per distinct chunk regardless of stream length. Above the staging cap
+     * this holds less than the previous sync-only version, which kept every remainder as an uncompressed JS
+     * number; below it — the common `addMany` — nothing is compacted until the end and the two are comparable.
+     * The guarantee is that a stream of *any* length stays bounded, not that every call got smaller.
+     *
+     * There is no way to do better without a sorted stream: a chunk can only be written once it is known that no
+     * further ids for it will arrive, and unsorted input never gives that guarantee. Callers streaming *very*
+     * large sets want `bulkLoadCrbmGeneration` instead — it writes one immutable Cold object rather than tens of
+     * thousands of warm rows. The crossover is documented in the guide.
+     */
     private mutateMany;
     /** OCC read-modify-write on a chunk's Warm delta, retrying on conflict (bounded). */
     private readModifyWrite;
@@ -907,8 +1067,16 @@ interface CompactionDeps {
     readonly cold: IColdDriver;
     readonly warm: IWarmDriver;
     readonly registry: IRegistryDriver;
-    /** Injected time source for lease expiry (the determinism seam — `core/` never reads ambient time). */
-    readonly clock: Pick<Clock, 'now'>;
+    /**
+     * Injected time source for lease expiry (the determinism seam — `core/` never reads ambient time).
+     *
+     * `now` is required; `sleep`/`yieldNow` are **optional and used only for cooperative yielding** while writing
+     * a generation. Supplying a full {@link Clock} (the facade does) makes compaction hand the event loop back
+     * periodically instead of blocking it for the whole write; supplying a bare `{ now }` keeps the previous
+     * uninterrupted behaviour. Optional rather than required because every existing caller passes `{ now }`, and
+     * requiring more would be a breaking change — the reason the yield below shipped unreachable the first time.
+     */
+    readonly clock: Pick<Clock, 'now'> & Partial<Pick<Clock, 'sleep' | 'yieldNow'>>;
     readonly maxBitmapBytes?: number;
     /**
      * Bitmap codec — compaction only merges bitmaps through it. Optional in the type so this
@@ -1367,6 +1535,56 @@ declare class LocalFsRegistryDriver implements IRegistryDriver {
     private withRowLock;
 }
 
+/**
+ * Cooperative yielding for the long CPU-bound loops.
+ *
+ * Everything this library does on the hot read path is small. Bulk-load is the exception: it is the one place
+ * where a single call legitimately occupies the CPU for hundreds of milliseconds, and Node has exactly one thread
+ * to occupy. Measured on a 1M-id load, 62,455 chunks: **442 ms wall, and 450 ms during which the event loop did
+ * not turn at all**. Wire that to a request handler and every other in-flight request on the instance — health
+ * checks included — waits out the whole load.
+ *
+ * The fix is not to make the work asynchronous. That was measured too, and it is a 7x *regression*: handing each
+ * chunk's insert to the threadpool costs ~9 µs of dispatch against ~1.5 µs of actual work once ids are spread
+ * across ~62,000 chunks (636 ms versus 92 ms). The work is genuinely CPU-bound and genuinely small per chunk;
+ * the only thing wrong with it is that it never stops to let anyone else go. So the fix is to keep the work
+ * synchronous and periodically hand the loop back.
+ *
+ * TWO TRAPS, both of which make a plausible implementation measure as no change at all:
+ *
+ * 1. **`await Promise.resolve()` — and equally `Clock.sleep(0)` — do nothing.** Both resolve on a microtask, and
+ *    the microtask queue drains to empty before the event loop advances a single phase. A loop awaiting them
+ *    yields to other *microtasks* and to nothing else; no pending I/O callback runs. Measured: 555 ms of
+ *    starvation against a 568 ms unyielded baseline **on the synthetic yield-primitive benchmark below** —
+ *    a different, smaller workload than the 442 ms end-to-end load above, which is why the two baselines
+ *    differ. The yield must be a **macrotask** — hence
+ *    `Clock.yieldNow`, backed by `setImmediate` in production wiring.
+ * 2. **Yielding per unit of work costs more than the work.** The yield has to be periodic, and `everyN` has to be
+ *    large enough that its cost disappears into the batch it interrupts.
+ *
+ * At `everyN = 1024` over that same synthetic workload the trade is close to free: 569 ms wall against a 568 ms
+ * baseline, with the worst event-loop gap down from 568 ms to 13.8 ms.
+ *
+ * **Three experiments, three sets of numbers — do not mix them.** (a) The end-to-end 1M-id bulk load:
+ * 442 ms wall / 450 ms blocked before, 256 ms / 19 ms after. (b) This synthetic yield-primitive comparison:
+ * 568 ms / 568 ms unyielded, 569 ms / 13.8 ms with `setImmediate`. (c) A per-chunk insert microbenchmark:
+ * 92 ms sync versus 636 ms via the threadpool. Quoting a baseline from one against a result from another is
+ * how this file previously published a 92 ms operation with 819 ms of starvation inside it.
+ */
+/**
+ * The only part of a `Clock` that yielding actually needs.
+ *
+ * Deliberately looser than `Clock` so the compaction path can opt in: `CompactionDeps.clock` is declared as
+ * `Pick<Clock, 'now'>` plus optional yield members, because its callers (including the `compact-segments` CLI)
+ * have always supplied a bare `{ now }`. Requiring a full `Clock` there would have been a breaking change for
+ * every one of them — which is exactly why the compaction yield shipped as dead code: the type could not carry
+ * a clock capable of yielding.
+ */
+interface Yielder {
+    yieldNow?(): Promise<void>;
+    sleep?(ms: number): Promise<void>;
+}
+
 interface CrbmReaderOptions {
     /** Speculative tail size in bytes (default 256 KB; clamped up to at least the footer size). */
     readonly tailBytes?: number;
@@ -1556,6 +1774,7 @@ declare function writeCrbmGeneration(driver: IColdDriver, key: GenKey, chunks: I
     bitmap: CodecBitmap;
 }>, options?: {
     crypto?: CrbmCrypto;
+    clock?: Yielder;
 }): Promise<{
     size: number;
     sha256: string;
@@ -1610,6 +1829,16 @@ declare function bulkLoadCrbmGeneration(driver: IColdDriver, key: GenKey, ids: I
     audit?: IAuditSink;
     /** Bitmap codec. Optional in the type; a **flavor** package binds it ({@link requireCodec}). */
     codec?: CodecInterface;
+    /**
+     * Injected clock. Supplying one makes bulk-load **cooperative**: it yields the event loop periodically so a
+     * long load does not stall everything else on the process. Without it the load still completes, just
+     * without yielding — which is the pre-existing behaviour, kept so this is purely additive.
+     *
+     * `@cloudbitmaps/roaring` supplies a real clock by default, so flavor users get cooperative behaviour with
+     * no wiring. `core/` cannot default it: it is timer-free by lint, which is exactly why waiting goes through
+     * this seam rather than `setTimeout`.
+     */
+    clock?: Clock;
 }): Promise<BulkLoadResult>;
 
 /**
@@ -1938,6 +2167,26 @@ declare class RetryingWarmDriver implements IWarmDriver {
         token: Token;
     }>;
     deleteConditional(ref: ChunkRef, expected: Token): Promise<void>;
+    /**
+     * Stream the inner driver's rows, retrying only until the first one arrives.
+     *
+     * **This used to buffer the whole scan** — `for await (…) out.push(row)` inside `withRetry`, then
+     * `yield* out` — which made the retry trivially safe and quietly defeated every bound above it. The engine's
+     * `collectWarm` refuses *during* enumeration precisely so resident memory is `O(ceiling)` rather than
+     * `O(segment)`; with the buffering wrapper in place (and it is wired by default) it saw its first row only
+     * after the entire segment was already in memory. Measured on a 500-row segment under
+     * `budget: { maxRequests: 3 }`: **500 rows materialised with the default wiring, 4 with `retry: false`**.
+     * Both paths threw the same `BudgetExceededError`, which is why no test caught it — the error was never the
+     * distinguishing observable, the row count was.
+     *
+     * **The trade this makes.** A mid-stream fault now propagates instead of being retried. It cannot be retried
+     * honestly: rows have already been handed to the consumer, so restarting the iterator would re-yield them,
+     * and the driver interface exposes no resumption token to continue from. Retry is kept where it pays —
+     * establishing the scan, which is where transient connect/throttle failures actually land — and bounded
+     * memory wins the conflict, because invariant 6 ("bounded memory & cost, always") is a hard invariant and
+     * mid-scan retry is not. A caller who needs whole-scan retry can wrap the operation at their own level,
+     * where re-reading from the start is safe.
+     */
     listChunks(ref: SegmentRef, opts?: WarmReadOptions): AsyncIterable<{
         chunkKey: number;
     } & WarmRow>;
@@ -2024,4 +2273,4 @@ declare class CrbmWriter {
     private buildFooter;
 }
 
-export { AWS_US_EAST_1_ONDEMAND, Aead, AeadSealed, type AuditEvent, type AuditEventKind, BlobReader, BlobSink, BoundedLru, type Budget, BudgetExceededError, type BudgetOption, type BulkLoadResult, CapabilityError, ChunkRef, type Clock, CloudRoaringError, type CodecBitmap, type CodecInterface, ColdCaps, ColdChunkSource, type CompactionCandidate, type CompactionCycleResult, type CompactionDeps, type CompactionOptions, type CompactionResult, type ConsistencyErrorEntry, type ConsistencyIssue, type ConsistencyReport, type CostAdvisory, type CostReport, CountingMetricsSink, CrbmColdChunkSource, type CrbmColdChunkSourceOptions, CrbmCrypto, CrbmReader, type CrbmReaderOptions, CrbmWriter, type CrbmWriterOptions, DEFAULT_BUDGET, DEFAULT_MAX_SCAN_SEGMENTS, DEFAULT_MAX_WARM_SCAN_BYTES, DEFAULT_OCC_BACKOFF, DEFAULT_PRICING, DEFAULT_RETRY_POLICY, type DestroyResult, type DiscoveryOptions, type EngineDeps, type EraseDeps, type EstimateInput, type ExportFailure, type ExportFormat, type ExportManifest, type ExportOptions, type ExportSink, type ExportWriter, type ExportedSegment, GenKey, type IAuditSink, IColdDriver, IKeystore, type IMetricsSink, IRegistryDriver, IWarmDriver, InProcessKeystore, type InProcessKeystoreOptions, IntegrityError, KeyUnavailableError, LocalFsColdDriver, LocalFsRegistryDriver, type LocalFsRegistryDriverOptions, LocalFsWarmDriver, MemoryColdChunkSource, MemoryColdDriver, MemoryRegistryDriver, type MemoryRegistryDriverOptions, MemoryWarmDriver, type MetricEvent, type MetricOpName, type MetricsSnapshot, NOOP_AUDIT, NOOP_METRICS, NewRegistryRecord, NoRow, NodeAead, NotFoundError, type PricingProfile, RecordingAuditSink, RegCaps, RegistryPatch, RegistryRecord, type RetryDeps, type RetryPolicy, RetryingColdChunkSource, RetryingColdDriver, type RetryingOptions, RetryingRegistryDriver, RetryingWarmDriver, type Rng, SegmentEngine, SegmentRef, SegmentSize, type SegmentSizing, TimeoutError, Token, type Topology, TransientError, UnsupportedError, ValidationError, WarmReadOptions, WarmRow, type Workload, WrappedDek, WriteConflictError, bulkLoadCrbmGeneration, checkBudget, chunkRefKey, collectWithinBudget, compactSegment, destroySegment, eraseNamespace, estimateCost, findCompactable, gcOrphanGenerations, groundedReport, isCloudRoaringError, isIntegrityError, isNotFoundError, isTransient, isTransientError, isValidationError, isWriteConflictError, joinId, mapWithConcurrency, publishGeneration, resolveBudget, resolvePerOpBudget, runCompactionCycle, runConsistencyCheck, runExport, safeMetrics, segmentKey, splitId, validateCompactionOptions, validateSegmentRef, withRetry, writeCrbmGeneration };
+export { AWS_US_EAST_1_ONDEMAND, Aead, AeadSealed, type AuditEvent, type AuditEventKind, BlobReader, BlobSink, BoundedLru, type Budget, BudgetExceededError, type BudgetOption, type BulkLoadResult, CapabilityError, ChunkRef, type Clock, CloudRoaringError, type CodecBitmap, type CodecInterface, ColdCaps, ColdChunkSource, type CompactionCandidate, type CompactionCycleResult, type CompactionDeps, type CompactionOptions, type CompactionResult, type ConsistencyErrorEntry, type ConsistencyIssue, type ConsistencyReport, type CostAdvisory, type CostReport, CountingMetricsSink, CrbmColdChunkSource, type CrbmColdChunkSourceOptions, CrbmCrypto, CrbmReader, type CrbmReaderOptions, CrbmWriter, type CrbmWriterOptions, DEFAULT_BUDGET, DEFAULT_MAX_SCAN_SEGMENTS, DEFAULT_MAX_WARM_SCAN_BYTES, DEFAULT_OCC_BACKOFF, DEFAULT_PRICING, DEFAULT_RETRY_POLICY, DEFAULT_WRITE_CONCURRENCY, type DestroyResult, type DiscoveryOptions, type EngineDeps, type EraseDeps, type EstimateInput, type ExportFailure, type ExportFormat, type ExportManifest, type ExportOptions, type ExportSink, type ExportWriter, type ExportedSegment, GenKey, type IAuditSink, IColdDriver, IKeystore, type IMetricsSink, IRegistryDriver, IWarmDriver, InProcessKeystore, type InProcessKeystoreOptions, IntegrityError, KeyUnavailableError, LocalFsColdDriver, LocalFsRegistryDriver, type LocalFsRegistryDriverOptions, LocalFsWarmDriver, MemoryColdChunkSource, MemoryColdDriver, MemoryRegistryDriver, type MemoryRegistryDriverOptions, MemoryWarmDriver, type MetricEvent, type MetricOpName, type MetricsSnapshot, NOOP_AUDIT, NOOP_METRICS, NewRegistryRecord, NoRow, NodeAead, NotFoundError, type PricingProfile, RecordingAuditSink, RegCaps, RegistryPatch, RegistryRecord, type RetryDeps, type RetryPolicy, RetryingColdChunkSource, RetryingColdDriver, type RetryingOptions, RetryingRegistryDriver, RetryingWarmDriver, type Rng, SegmentEngine, SegmentRef, SegmentSize, type SegmentSizing, TimeoutError, Token, type Topology, TransientError, UnsupportedError, ValidationError, WarmReadOptions, WarmRow, type Workload, WrappedDek, WriteConflictError, bulkLoadCrbmGeneration, checkBudget, chunkRefKey, collectWithinBudget, compactSegment, destroySegment, eraseNamespace, estimateCost, findCompactable, gcOrphanGenerations, groundedReport, isCloudRoaringError, isIntegrityError, isNotFoundError, isTransient, isTransientError, isValidationError, isWriteConflictError, joinId, mapWithConcurrency, publishGeneration, resolveBudget, resolvePerOpBudget, runCompactionCycle, runConsistencyCheck, runExport, safeMetrics, segmentKey, splitId, validateCompactionOptions, validateSegmentRef, withRetry, writeCrbmGeneration };