@cloudbitmaps/roaring 0.1.0-rc.0

package/dist/index.cjs

@@ -0,0 +1,561 @@
+'use strict';
+
+var core = require('@cloudbitmaps/core');
+var roaring = require('roaring');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var roaring__default = /*#__PURE__*/_interopDefault(roaring);
+
+// src/index.ts
+var { RoaringBitmap32, SerializationFormat, DeserializationFormat } = roaring__default.default;
+var SafeBitmap = class _SafeBitmap {
+  bitmap;
+  constructor(bitmap) {
+    this.bitmap = bitmap;
+  }
+  static empty() {
+    return new _SafeBitmap(new RoaringBitmap32());
+  }
+  static fromValues(values) {
+    return new _SafeBitmap(new RoaringBitmap32(values));
+  }
+  /**
+   * S1: validate size, then deserialize with the **portable** (validated) format.
+   * Throws `IntegrityError` if the input exceeds `maxBytes` or fails to decode — the
+   * native addon is never handed unbounded or unsafe-format input.
+   */
+  static safeDeserialize(bytes, maxBytes) {
+    if (bytes.length > maxBytes) {
+      throw new core.IntegrityError(`serialized bitmap is ${bytes.length}B, exceeds cap ${maxBytes}B`);
+    }
+    try {
+      return new _SafeBitmap(RoaringBitmap32.deserialize(bytes, DeserializationFormat.portable));
+    } catch (err) {
+      throw new core.IntegrityError(`failed to deserialize bitmap: ${err.message}`);
+    }
+  }
+  serialize() {
+    return this.bitmap.serialize(SerializationFormat.portable);
+  }
+  add(value) {
+    this.bitmap.add(value);
+  }
+  addMany(values) {
+    this.bitmap.addMany(values);
+  }
+  remove(value) {
+    this.bitmap.remove(value);
+  }
+  removeMany(values) {
+    this.bitmap.removeMany(values);
+  }
+  has(value) {
+    return this.bitmap.has(value);
+  }
+  get size() {
+    return this.bitmap.size;
+  }
+  get isEmpty() {
+    return this.bitmap.isEmpty;
+  }
+  clone() {
+    return new _SafeBitmap(this.bitmap.clone());
+  }
+  // The binary set ops take the `CodecBitmap` interface type (per the seam), but a single store is
+  // single-codec (homogeneity contract), so `other` is always a `SafeBitmap` here — reach its private
+  // `bitmap` (accessible on same-class instances) for the native op.
+  /** In-place union: `this = this ∪ other`. */
+  orInPlace(other) {
+    this.bitmap.orInPlace(other.bitmap);
+  }
+  /** In-place difference: `this = this \ other`. */
+  andNotInPlace(other) {
+    this.bitmap.andNotInPlace(other.bitmap);
+  }
+  /** In-place intersection: `this = this ∩ other`. */
+  andInPlace(other) {
+    this.bitmap.andInPlace(other.bitmap);
+  }
+  /** Ascending iterator over the set values. */
+  [Symbol.iterator]() {
+    return this.bitmap[Symbol.iterator]();
+  }
+  toArray() {
+    return this.bitmap.toArray();
+  }
+};
+var roaringCodec = {
+  empty: () => SafeBitmap.empty(),
+  fromValues: (values) => SafeBitmap.fromValues(values),
+  safeDeserialize: (bytes, maxBytes) => SafeBitmap.safeDeserialize(bytes, maxBytes)
+};
+var bulkLoadCrbmGeneration = (driver, key, ids, options = {}) => core.bulkLoadCrbmGeneration(driver, key, ids, { ...options, codec: options.codec ?? roaringCodec });
+var compactSegment = (ref, deps, options) => core.compactSegment(ref, { ...deps, codec: deps.codec ?? roaringCodec }, options);
+var runCompactionCycle = (deps, options) => core.runCompactionCycle({ ...deps, codec: deps.codec ?? roaringCodec }, options);
+var runExport = (reader, registry, sink, options = {}) => core.runExport(reader, registry, sink, { ...options, codec: options.codec ?? roaringCodec });
+
+// src/index.ts
+var SystemClock = class {
+  now() {
+    return Date.now();
+  }
+  sleep(ms) {
+    if (ms <= 0) return Promise.resolve();
+    return new Promise((resolve) => {
+      setTimeout(resolve, ms);
+    });
+  }
+};
+var SystemRng = class {
+  next() {
+    return Math.random();
+  }
+};
+var DEFAULT_CACHE_MAX_CHUNKS = 1024;
+var DEFAULT_ADMIN_CONCURRENCY = 8;
+function validateConcurrency(concurrency) {
+  if (concurrency !== void 0 && (!Number.isInteger(concurrency) || concurrency < 1)) {
+    throw new core.ValidationError(`concurrency must be a positive integer; got ${concurrency}`);
+  }
+}
+function requireScope(options, op) {
+  if (options.namespace === void 0 && options.allNamespaces !== true) {
+    throw new core.ValidationError(
+      `${op} scans the global id space across all namespaces \u2014 pass an explicit \`namespace\`, or \`{ allNamespaces: true }\` to intentionally sweep the whole fleet`
+    );
+  }
+}
+function resolveColdSource(options, clock) {
+  const cold = options.cold;
+  if (cold === null || typeof cold !== "object") {
+    throw new core.ValidationError("`cold` must be an IColdDriver or a ColdChunkSource");
+  }
+  const hasGetChunk = typeof cold.getChunk === "function";
+  const hasPutImmutable = typeof cold.putImmutable === "function";
+  if (hasGetChunk && hasPutImmutable) {
+    throw new core.ValidationError(
+      "`cold` exposes both `getChunk` and `putImmutable` \u2014 ambiguous; pass an IColdDriver or a ColdChunkSource, not a hybrid"
+    );
+  }
+  if (!hasGetChunk && !hasPutImmutable) {
+    throw new core.ValidationError("`cold` must be an IColdDriver or a ColdChunkSource");
+  }
+  if (hasGetChunk) {
+    if (options.registry !== void 0 || options.keystore !== void 0 || options.requireEncryption === true) {
+      throw new core.ValidationError(
+        "registry/keystore/requireEncryption apply only when `cold` is a raw IColdDriver; configure them on the ColdChunkSource you passed instead"
+      );
+    }
+    return { source: cold, driver: void 0 };
+  }
+  const driver = cold;
+  return {
+    source: new core.CrbmColdChunkSource(driver, {
+      registry: options.registry,
+      keystore: options.keystore,
+      requireEncryption: options.requireEncryption,
+      clock,
+      currentGenTtlMs: options.coldGenTtlMs,
+      maxOpenSegments: options.coldReaderCacheMax,
+      maxOpenIndexBytes: options.coldReaderCacheMaxBytes
+    }),
+    driver
+  };
+}
+var CloudRoaring = class {
+  engine;
+  clock;
+  metrics;
+  // The store's own drivers, kept so the in-process lifecycle helpers (`compact`/`eraseSubject`/`subjectReport`)
+  // reuse them instead of making you re-pass a CompactionDeps. `coldDriver` is set only when `cold` was a raw
+  // IColdDriver (a pre-built ColdChunkSource has no underlying driver to compact through).
+  coldDriver;
+  warmDriver;
+  registry;
+  keystore;
+  requireEncryption;
+  /** Resolved store-level per-op budget (null = disabled); the admin scans use it, with a per-op override. */
+  budget;
+  constructor(options) {
+    const clock = options.clock ?? new SystemClock();
+    const rng = options.rng ?? new SystemRng();
+    const metrics = core.safeMetrics(options.metrics ?? core.NOOP_METRICS);
+    const cache = new core.BoundedLru({
+      maxEntries: options.cacheMaxChunks ?? DEFAULT_CACHE_MAX_CHUNKS,
+      ttlMs: options.cacheTtlMs,
+      clock
+    });
+    const resolved = resolveColdSource(options, clock);
+    let cold = resolved.source;
+    let warm = options.warm;
+    if (options.retry !== false) {
+      const retryOpts = {
+        clock,
+        rng,
+        policy: options.retry,
+        // Bridge transient-fault retries into the metrics stream, then call the user's own hook.
+        onRetry: (info) => {
+          metrics.onEvent({
+            kind: "retry",
+            reason: "transient",
+            attempt: info.attempt,
+            delayMs: info.delayMs
+          });
+          options.onRetry?.(info);
+        }
+      };
+      warm = new core.RetryingWarmDriver(options.warm, retryOpts);
+      cold = new core.RetryingColdChunkSource(cold, retryOpts);
+    }
+    if (options.writeConcurrency !== void 0 && (!Number.isInteger(options.writeConcurrency) || options.writeConcurrency < 1)) {
+      throw new core.ValidationError(
+        `writeConcurrency must be a positive integer; got ${options.writeConcurrency}`
+      );
+    }
+    this.budget = core.resolveBudget(options.budget, core.DEFAULT_BUDGET);
+    const deps = {
+      warm,
+      cold,
+      cache,
+      codec: roaringCodec,
+      // the facade injects the flagship codec ([DECISIONS #58]); core stays codec-agnostic
+      clock,
+      rng,
+      occBackoff: options.occBackoff,
+      metrics,
+      warmReadConsistency: options.warmReadConsistency,
+      writeConcurrency: options.writeConcurrency,
+      budget: this.budget
+    };
+    this.engine = new core.SegmentEngine(deps);
+    this.clock = clock;
+    this.metrics = metrics;
+    this.coldDriver = resolved.driver;
+    this.warmDriver = options.warm;
+    this.registry = options.registry;
+    this.keystore = options.keystore;
+    this.requireEncryption = options.requireEncryption ?? false;
+  }
+  /**
+   * Build {@link CompactionDeps} from the store's own drivers, for the in-process lifecycle helpers
+   * ({@link compact} / {@link eraseSubject}). Requires the store to have been constructed with a **raw cold
+   * driver** (a pre-built `ColdChunkSource` has no underlying `IColdDriver` to compact through) and a `registry`
+   * (the authoritative `currentGen` pointer compaction swaps). Out-of-process callers use the `compactSegment`
+   * free function with explicit deps.
+   */
+  compactionDeps() {
+    if (this.coldDriver === void 0) {
+      throw new core.UnsupportedError(
+        "compact/eraseSubject/checkConsistency need the store built with a raw cold driver (IColdDriver), not a pre-built ColdChunkSource \u2014 or call the compactSegment/runConsistencyCheck free functions with explicit deps"
+      );
+    }
+    if (this.registry === void 0) {
+      throw new core.UnsupportedError(
+        "compact/eraseSubject/checkConsistency need a `registry` in the store config"
+      );
+    }
+    return {
+      cold: this.coldDriver,
+      warm: this.warmDriver,
+      registry: this.registry,
+      clock: this.clock,
+      codec: roaringCodec,
+      // facade injects the flagship codec ([DECISIONS #58])
+      keystore: this.keystore,
+      requireEncryption: this.requireEncryption,
+      metrics: this.metrics
+      // safe-wrapped sink → store.compact/eraseSubject emit `compaction` events (gap #2)
+    };
+  }
+  /** Get a handle to a segment. Validates the name/namespace grammar (finding S2). */
+  segment(name, options) {
+    const ref = { segment: name, namespace: options?.namespace };
+    core.validateSegmentRef(ref);
+    return new Segment(this.engine, ref, this.clock, this.metrics);
+  }
+  /**
+   * **Subject access (GDPR Art. 15 / CCPA right-to-know): which segments is this id a member of?** (Phase 6b.)
+   *
+   * Enumerates the **registered** segments (via the store's own `registry`) and does a tier-merging `has(id)` on
+   * each — no drivers to re-pass. Complete only over registered segments (register your segments if you claim
+   * SAR support). There is deliberately **no `id → segments` reverse index** — that would tax every write for a
+   * rare request; this admin scan is `O(registered segments)` and touches no hot path
+   * (phases/06). Requires a `registry` in the store config
+   * (throws {@link UnsupportedError} otherwise).
+   */
+  async subjectReport(id, options = {}) {
+    if (this.registry === void 0) {
+      throw new core.UnsupportedError("subjectReport needs a `registry` in the store config");
+    }
+    const registry = this.registry;
+    requireScope(options, "subjectReport");
+    validateConcurrency(options.concurrency);
+    const budget = core.resolvePerOpBudget(options.budget, this.budget);
+    core.splitId(id);
+    const recs = [];
+    for await (const rec of registry.list(options.namespace)) recs.push(rec);
+    core.checkBudget(budget, recs.length, "subjectReport");
+    const membership = await core.mapWithConcurrency(
+      recs,
+      options.concurrency ?? DEFAULT_ADMIN_CONCURRENCY,
+      async (rec) => {
+        if (rec.status === "destroyed") return null;
+        const ref = { segment: rec.segment, namespace: rec.namespace };
+        return await this.engine.has(ref, id, { consistent: true }) ? { segment: rec.segment, namespace: rec.namespace } : null;
+      }
+    );
+    const segments = membership.filter((m) => m !== null);
+    return { id, segments, scannedSegments: recs.length };
+  }
+  /**
+   * **Subject erasure (GDPR Art. 17): remove an id from every segment it's in, with a physical-deletion
+   * guarantee.** (Phase 6b.)
+   *
+   * For each **registered** segment the id is a member of: writes a logical `remove` tombstone (immediate) and
+   * then **force-compacts that segment now** — folding the tombstone into a fresh immutable generation so the
+   * bit is *physically* gone from Cold on return, even for an otherwise-idle/archival segment that organic
+   * compaction would never touch (the P13 fix). The returned per-segment record is your **erasure ledger** —
+   * persist it / route it to your audit sink as the proof of deletion; the physical-purge proof is
+   * compaction's own VERIFY step (a re-`has()` here would be unsound — a pinned cold source can still read the
+   * old generation; take a fresh generation view after erasing, exactly as with the compaction daemon).
+   *
+   * Uses the store's **own** drivers (raw cold + warm + registry), so the old integrator obligation to wire a
+   * matching `CompactionDeps` is gone — the `remove()` and the force-compaction provably run over the same tiers.
+   * Requires the store built with a **raw cold driver + registry** (throws {@link UnsupportedError} otherwise;
+   * a pre-built `ColdChunkSource` store has no `IColdDriver` to compact through — use the `compactSegment` free
+   * function there). **One contract remains** (an integrator obligation the library cannot check): **do not
+   * concurrently re-add the same id while erasing it.** A normal `add(id)` landing between the `remove` and the
+   * compaction clears the tombstone and folds the id back into the new generation
+   * (`effective = (cold ∪ adds) \ removes`); `physicallyPurged` attests only that compaction committed a
+   * generation with the tombstones applied at pin time — quiesce writes for the subject during erasure.
+   *
+   * **A `physicallyPurged:false` entry means the logical removal holds but the physical purge didn't run this
+   * call** — either a daemon held a live lease (`note:'leased-by-other'`; the daemon finishes it), or the
+   * force-compaction hit an isolated fault (`note:'error: …'`; per-segment faults are caught so one segment
+   * can't discard the whole ledger). `physicallyPurged:false` is **conservative** (a concurrent daemon may
+   * already have purged the bit — `'clean'`). **Recovery:** follow up any `physicallyPurged:false` entry with
+   * `store.compact(ref)` (or let the daemon do it) — **re-running `eraseSubject` will NOT re-purge it**, because
+   * `has()` now reads false (the tombstone) so the segment is skipped as a non-member. The physical-purge proof
+   * is compaction's own VERIFY step (a re-`has()` here would be unsound: a pinned cold source can still read the
+   * old generation — take a fresh generation view after erasing, as with the daemon). Admin-only path;
+   * `O(registered segments)`, no hot-path cost. Per-subject crypto-shred is infeasible (a subject's bit is
+   * co-mingled in a shared container), so this is the single-subject erasure route; whole-segment/tenant erasure
+   * is the `destroySegment`/`eraseNamespace` free functions.
+   */
+  async eraseSubject(id, options) {
+    const compaction = this.compactionDeps();
+    core.validateCompactionOptions({ owner: options.owner });
+    requireScope(options, "eraseSubject");
+    validateConcurrency(options.concurrency);
+    const budget = core.resolvePerOpBudget(options.budget, this.budget);
+    core.splitId(id);
+    const recs = [];
+    for await (const rec of compaction.registry.list(options.namespace)) recs.push(rec);
+    core.checkBudget(budget, recs.length, "eraseSubject");
+    const entries = await core.mapWithConcurrency(
+      recs,
+      options.concurrency ?? DEFAULT_ADMIN_CONCURRENCY,
+      async (rec) => {
+        if (rec.status === "destroyed") return null;
+        const ref = { segment: rec.segment, namespace: rec.namespace };
+        let removed = false;
+        try {
+          if (!await this.engine.has(ref, id, { consistent: true })) return null;
+          await this.engine.remove(ref, id);
+          removed = true;
+          const result = await core.compactSegment(ref, compaction, {
+            owner: options.owner,
+            audit: options.audit
+          });
+          return {
+            segment: rec.segment,
+            namespace: rec.namespace,
+            removed: true,
+            physicallyPurged: result.compacted,
+            toGen: result.toGen,
+            note: result.compacted ? void 0 : result.reason
+          };
+        } catch (err) {
+          return {
+            segment: rec.segment,
+            namespace: rec.namespace,
+            removed,
+            physicallyPurged: false,
+            note: `error: ${err instanceof Error ? err.message : String(err)}`
+          };
+        }
+      }
+    );
+    const erasedFrom = entries.filter((e) => e !== null);
+    return { id, erasedFrom, scannedSegments: recs.length };
+  }
+  /**
+   * **Compact one segment now**, in-process, using the store's own drivers — a convenience over the
+   * {@link compactSegment} free function. Merges `(cold ∪ adds) \ removes` into a fresh immutable generation,
+   * swaps `currentGen`, then version-fenced-purges the archived Warm rows. A no-op (`compacted:false`) when the
+   * segment has no dirty rows or a daemon holds a live lease — never throws on the normal contention/lease paths.
+   * Requires the store built with a **raw cold driver + registry** (throws {@link UnsupportedError} otherwise);
+   * like the daemon, it uses the raw drivers directly (a transient fault surfaces to you rather than retrying
+   * under the hood). **Not for the request/hot path** — it reads and rewrites a whole Cold generation (streaming,
+   * constant-memory, but full-segment I/O). Use the `compact-segments` daemon (`runCompactionCycle`) for routine
+   * background compaction; reach for `store.compact()` for occasional/manual one-shots — a maintenance endpoint,
+   * a small daemon-less deployment, or right after a targeted `remove`.
+   */
+  async compact(ref, options) {
+    core.validateSegmentRef(ref);
+    return core.compactSegment(ref, this.compactionDeps(), options);
+  }
+  /**
+   * **Cross-tier DR consistency check (audit gap #11).** After a restore/failover, verify every registered
+   * segment's `currentGen` actually has its `.crbm` present in Cold — catching a **torn restore** where the
+   * registry (`currentGen`) came back ahead of the object store, so a pointer references a generation that
+   * isn't there (reads would then throw). Read-only, bounded fan-out; run it at startup after a restore.
+   * Returns `{ checked, inconsistent }` — `inconsistent` empty ⇒ coherent; otherwise it names the segments to
+   * recover (restore the object store, or roll the registry back to a coherent point). Needs the store built
+   * with a **raw cold driver + a registry** (throws {@link UnsupportedError} otherwise). `destroyed`
+   * (crypto-shredded) segments are skipped. Pair it with the DR runbook (docs/guide/disaster-recovery.md).
+   */
+  async checkConsistency(options = {}) {
+    const deps = this.compactionDeps();
+    return core.runConsistencyCheck({ cold: deps.cold, registry: deps.registry }, options);
+  }
+  /**
+   * **Export ("eject") every registered segment's current effective set** through the injected `sink`, using
+   * only public read APIs — so your data is readable **without CloudRoaring** (the exit path; see the README's
+   * "Your data stays yours"). `format: 'roaring'` (default) writes one **portable RoaringBitmap32** per segment
+   * (loadable by any roaring library); `'ndjson'` writes newline-delimited ids (zero-dependency, streaming).
+   * Enumerates via the store's **own** registry (needs one — throws {@link UnsupportedError} otherwise) so the
+   * enumeration and the read path provably share one registry; an all-warm segment not yet in the registry can be
+   * named via `options.candidates`. Encrypted segments are decrypted transparently **iff** this store was wired
+   * with their keystore — the export is therefore **cleartext**; protect it. Crypto-shredded segments are skipped.
+   * A segment that can't be read is isolated into the manifest's `failed[]` (the run continues), so "a manifest
+   * exists" means the run finished — check `failed`. The `export-segments` CLI wraps this with a filesystem sink.
+   */
+  async exportSegments(sink, options = {}) {
+    if (this.registry === void 0) {
+      throw new core.UnsupportedError("exportSegments needs a `registry` in the store config");
+    }
+    return core.runExport(this, this.registry, sink, {
+      ...options,
+      codec: options.codec ?? roaringCodec
+    });
+  }
+  /**
+   * Planning cost estimate (Phase 5b) — 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}.
+   */
+  static estimateCost(input) {
+    return core.estimateCost(input);
+  }
+};
+var Segment = class {
+  constructor(engine, ref, clock, metrics) {
+    this.engine = engine;
+    this.ref = ref;
+    this.clock = clock;
+    this.metrics = metrics;
+    this.metricsOn = metrics !== core.NOOP_METRICS;
+  }
+  engine;
+  ref;
+  clock;
+  metrics;
+  metricsOn;
+  /**
+   * Time an op with the injected clock and emit an `op` metric on completion (success or throw). Skipped
+   * entirely when no sink is wired, so the default path pays nothing.
+   */
+  async timed(name, fn) {
+    if (!this.metricsOn) return fn();
+    const startedAt = this.clock.now();
+    try {
+      return await fn();
+    } finally {
+      this.metrics.onEvent({ kind: "op", name, ms: Math.max(0, this.clock.now() - startedAt) });
+    }
+  }
+  /** Add an id (integer in `[0, 2^32)`). Throws {@link ValidationError} on a bad id. */
+  add(id) {
+    return this.timed("add", () => this.engine.add(this.ref, id));
+  }
+  /** Add many ids. Not atomic across chunks — see the class note. */
+  addMany(ids) {
+    return this.timed("addMany", () => this.engine.addMany(this.ref, ids));
+  }
+  /** Remove an id (integer in `[0, 2^32)`). Throws {@link ValidationError} on a bad id. */
+  remove(id) {
+    return this.timed("remove", () => this.engine.remove(this.ref, id));
+  }
+  /** Remove many ids. Not atomic across chunks — see the class note. */
+  removeMany(ids) {
+    return this.timed("removeMany", () => this.engine.removeMany(this.ref, ids));
+  }
+  has(id) {
+    return this.timed("has", () => this.engine.has(this.ref, id));
+  }
+  count() {
+    return this.timed("count", () => this.engine.count(this.ref));
+  }
+  iterate() {
+    return this.engine.iterate(this.ref);
+  }
+  /**
+   * Chunk-skipping intersection: stream the ids in **this** segment AND every segment in `others`, ascending.
+   * Fetches only the Cold chunks present in *all* operands (a key absent from any operand contributes nothing
+   * and is never downloaded), streaming under a bounded in-flight window — so the Cold footprint stays small
+   * (Lambda-friendly) regardless of segment size. Pass `concurrency` to tune that window (a positive integer).
+   * AND is commutative, so `a.intersect([b])` and `b.intersect([a])` yield the same ids. (Warm state is read
+   * up front, so total memory also carries each operand's Warm size — negligible under Topology-A.) Pass
+   * `budget` to override the store's per-op denial-of-wallet budget for this call (or `false` to lift it).
+   */
+  intersect(others, options) {
+    return this.engine.intersect([this.ref, ...others.map((o) => o.ref)], options);
+  }
+  /**
+   * Materialize `this ∩ others…` **into** `dest` (added, not replaced). Streaming + bounded-memory, but
+   * **not atomic** across chunks — see {@link addMany}.
+   */
+  intersectInto(dest, others, options) {
+    return this.timed(
+      "intersectInto",
+      () => this.engine.intersectInto(dest.ref, [this.ref, ...others.map((o) => o.ref)], options)
+    );
+  }
+  /**
+   * Grounded cost report for this segment (Phase 5b): storage cost from its **real** `.crbm` size (exact,
+   * no payload reads); request cost from the supplied `workload` rates. A segment with no Cold generation
+   * reports zero storage. See {@link CostReport} — it always includes a verdict (incl. the lose-zone).
+   */
+  async costReport(options) {
+    const canMeasure = this.engine.supportsColdSize;
+    const size = canMeasure ? await this.engine.segmentSize(this.ref) : null;
+    return core.groundedReport({
+      coldBytes: size?.sizeBytes ?? 0,
+      grounded: canMeasure,
+      workload: options?.workload,
+      topology: options?.topology,
+      pricing: options?.pricing,
+      extraNotes: canMeasure ? void 0 : ["cold source has no sizeOf() \u2014 storage not measured, reported as $0."]
+    });
+  }
+};
+var VERSION = "0.1.0-rc.0";
+
+exports.CloudRoaring = CloudRoaring;
+exports.SafeBitmap = SafeBitmap;
+exports.Segment = Segment;
+exports.VERSION = VERSION;
+exports.bulkLoadCrbmGeneration = bulkLoadCrbmGeneration;
+exports.compactSegment = compactSegment;
+exports.roaringCodec = roaringCodec;
+exports.runCompactionCycle = runCompactionCycle;
+exports.runExport = runExport;
+Object.keys(core).forEach(function (k) {
+  if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+    enumerable: true,
+    get: function () { return core[k]; }
+  });
+});
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map