@cloudbitmaps/roaring 0.9.0 → 0.10.0

package/dist/moved-options.d.ts

@@ -0,0 +1,14 @@
+/**
+ * The 0.9.x option spellings this release no longer accepts, and what to tell someone who passes one.
+ *
+ * NOT part of the public API. It lives in its own module — rather than as an `export` from the barrel — so
+ * that the gates which must agree with it (the doc-fence scan, the harness scan, and the test that diffs this
+ * table against `CloudRoaringOptions` at the previous tag) can all read ONE copy, without the migration
+ * table becoming a permanent public export in the same release whose point was to shrink that surface.
+ *
+ * Retyping it was tried and is what this replaces: the hand-maintained copies had drifted to naming three
+ * spellings no release ever shipped while omitting the five that actually went away with the live tier.
+ */
+export type MovedOptionKind = 'group' | 'renamed' | 'gone';
+/** `[the 0.9.x key, what to do instead, which kind of answer that is]`. */
+export declare const MOVED_OPTIONS: ReadonlyArray<readonly [string, string, MovedOptionKind]>;

package/dist/portable/decode.d.ts

@@ -0,0 +1,54 @@
+/**
+ * A decoded portable-roaring bitmap that can be queried but not modified.
+ *
+ * Construction parses only the headers — container payloads are read on demand, so a membership test against a
+ * large bitmap touches one container rather than materializing the set.
+ */
+export declare class PortableRoaringReader {
+    private readonly bytes;
+    private readonly view;
+    private readonly containers;
+    private constructor();
+    /**
+     * Parse the headers of a portable-format bitmap.
+     *
+     * @throws {IntegrityError} if the cookie is unrecognized, or any header field runs past the buffer.
+     */
+    static decode(bytes: Uint8Array): PortableRoaringReader;
+    /**
+     * Total cardinality.
+     *
+     * Served entirely from the descriptive header — no container payload is read, so this is O(containers) and
+     * independent of how many values the bitmap holds.
+     */
+    count(): number;
+    /** Is `value` (a `u32`) in the set? */
+    has(value: number): boolean;
+    /** Binary search the descriptive header for the container owning `key`. */
+    private findContainer;
+    /**
+     * 1,024 little-endian `u64` words. Read as `u32` at `(low >> 5) * 4`: a LE `u64` is two LE `u32`s with the
+     * low word first, so the 32-bit view lands on the right half without any 64-bit arithmetic.
+     */
+    private bitmapHas;
+    /**
+     * Sorted `u16` values — binary search.
+     *
+     * The `at === low` early return means the `at < low` below is only ever evaluated when `at !== low`, so
+     * writing it `at <= low` would behave identically. That is recorded because mutation testing surfaced it as
+     * a surviving mutant: it is an *equivalent* one, unkillable by any test rather than a coverage gap — three
+     * non-equivalent mutations of these same lines (inverting the branches, never reporting a hit, dropping the
+     * last element) are all caught. Do not "fix" the survivor, and do not add a test chasing it.
+     */
+    private arrayHas;
+    /**
+     * `u16` run count, then that many `(start, length)` `u16` pairs sorted by start.
+     *
+     * `length` is the number of values **after** `start`, so a run covers the inclusive range
+     * `[start, start + length]` and a single-value run is stored with length 0. Getting this off by one is the
+     * easiest mistake in the format and is why the differential test drives runs specifically.
+     */
+    private runHas;
+}
+/** Convenience wrapper over {@link PortableRoaringReader.decode}. */
+export declare function decodePortableRoaring(bytes: Uint8Array): PortableRoaringReader;

package/dist/roaring-codec.d.ts

@@ -0,0 +1,61 @@
+import type { CodecBitmap, CodecInterface } from '@cloudbitmaps/core';
+export declare class SafeBitmap implements CodecBitmap {
+    private readonly bitmap;
+    private constructor();
+    static empty(): SafeBitmap;
+    static fromValues(values: Iterable<number>): SafeBitmap;
+    /**
+     * 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: Uint8Array, maxBytes: number): SafeBitmap;
+    serialize(): Uint8Array;
+    /**
+     * Convert containers to run-encoding where that is smaller. Representation only — membership is untouched, and
+     * the portable format still round-trips through {@link RoaringCodec.safeDeserialize}.
+     *
+     * Roaring's third container type is a RUN, and no implementation selects it on its own: it takes an explicit
+     * `runOptimize()` pass. Nothing here made that call, so run-shaped ids paid array or bitset prices — measured
+     * at **570×** for a contiguous 1M-id range (128.1 KiB → 0.2 KiB) and **63×** for a 2,000-run shape
+     * (536.5 KiB → 8.5 KiB). Sparse ids come out byte-identical, so this is never a losing trade; roaring keeps
+     * whichever encoding is smaller per container.
+     *
+     * Those two factors are THIS CALL's own before/after on the same ids. They are not the ones the site quotes
+     * (543× and 63×) — those compare the optimized encoding against the best *fixed* representation at its floor,
+     * a different baseline that happens to land near 63× on the run shape too. `pnpm bench:encoding` prints both
+     * columns; don't carry a figure between them without checking which denominator it had.
+     *
+     * Called only when writing an immutable objects generation — see {@link CodecBitmap.optimize} for why the read
+     * path deliberately does not.
+     */
+    optimize(): void;
+    /**
+     * Largest value, or `undefined` when empty. O(1) — roaring reads it off the container index, so the engine's
+     * per-chunk range assertion costs one call per chunk rather than a walk per id.
+     */
+    maximum(): number | undefined;
+    add(value: number): void;
+    addMany(values: Iterable<number>): void;
+    remove(value: number): void;
+    removeMany(values: Iterable<number>): void;
+    has(value: number): boolean;
+    get size(): number;
+    get isEmpty(): boolean;
+    clone(): SafeBitmap;
+    /** In-place union: `this = this ∪ other`. */
+    orInPlace(other: CodecBitmap): void;
+    /** In-place difference: `this = this \ other`. */
+    andNotInPlace(other: CodecBitmap): void;
+    /** In-place intersection: `this = this ∩ other`. */
+    andInPlace(other: CodecBitmap): void;
+    /** Ascending iterator over the set values. */
+    [Symbol.iterator](): IterableIterator<number>;
+    toArray(): number[];
+}
+/**
+ * The roaring {@link CodecInterface} — the flagship codec, delegating to {@link SafeBitmap}'s statics. This is
+ * the default the `CloudRoaring` facade injects into the engine; `core/` itself never hard-references it once a
+ * caller supplies a codec. Moves to `@cloudbitmaps/roaring` when the package split lands.
+ */
+export declare const roaringCodec: CodecInterface;

package/dist/system-clock.d.ts

@@ -0,0 +1,40 @@
+/**
+ * The default real-time {@link Clock} — the production half of the determinism seam.
+ *
+ * It lives outside `core/`, so `Date.now()`, `setTimeout` and `setImmediate` are allowed here; that separation is
+ * the whole point of the seam, and it is lint-enforced on the other side.
+ *
+ * It sits in its own module rather than in `index.ts` because two places need it — the facade, and
+ * `codec-bound.ts`, which pre-binds it into `bulkLoadCrbmGeneration`. Importing it from `index.ts` would put a
+ * cycle between the barrel and a module the barrel re-exports.
+ */
+import type { Clock } from '@cloudbitmaps/core';
+/** Default real-time clock — lives outside `core/`, so `Date.now()` + timers are allowed here. */
+export declare class SystemClock implements Clock {
+    now(): number;
+    sleep(ms: number): Promise<void>;
+    /**
+     * `setImmediate`, and it has to be — this is the one place where the choice of primitive is the whole feature.
+     *
+     * A long CPU-bound loop in `core/` (bulk-load is the one that matters) periodically hands the loop back so a
+     * co-resident HTTP server keeps answering. Measured on the **synthetic yield-primitive benchmark** — a
+     * 61,035-iteration loop yielding every 1,024, isolating the primitive rather than timing a real load (the
+     * end-to-end figures are 450 ms → 19 ms; see `cooperative.ts`, which lists all three experiments):
+     *
+     * ```text
+     *   no yield         568 ms wall   568.0 ms worst event-loop gap
+     *   sleep(0)         555 ms wall   555.2 ms   ← a microtask. Yields NOTHING.
+     *   setImmediate     569 ms wall    13.8 ms   ← free, and 41x less starvation
+     *   setTimeout(1)    625 ms wall    15.0 ms   ← +10% wall for no extra relief
+     * ```
+     *
+     * `sleep(0)` resolving on a microtask is correct for its own contract and useless for this: microtasks drain
+     * before the loop ever advances a phase, so `await sleep(0)` in a tight loop never lets a single pending I/O
+     * callback run. `setImmediate` fires in the check phase *after* pending I/O, which is exactly the ordering a
+     * server wants — inbound requests are serviced before the loop resumes chewing.
+     *
+     * A timer is not ref'd here (unlike {@link sleep}): a yield expresses "someone else may go first", never
+     * "there is outstanding work" — and `setImmediate` cannot outlive the turn that scheduled it anyway.
+     */
+    yieldNow(): Promise<void>;
+}

package/dist/testing/conformance.d.ts

@@ -0,0 +1,34 @@
+import { SafeBitmap } from '../roaring-codec.js';
+import type { StorageChunkSource, IRegistryDriver } from '@cloudbitmaps/core';
+/**
+ * The segment every conformance seeder must write. Exported so a driver's own test file derives the name
+ * instead of restating it — a second copy that drifts makes the suite query a segment nobody seeded, which
+ * fails as an empty result rather than as the mismatch it actually is.
+ */
+export declare const CONFORMANCE_SEGMENT = "s:v1";
+/**
+ * Contract tests for a {@link StorageChunkSource}. `makeSource` MUST build a fresh source seeded with the
+ * given chunks (each an immutable Storage bitmap) and nothing else.
+ */
+export declare function storageChunkSourceConformance(label: string, makeSource: (chunks: Array<{
+    chunkKey: number;
+    bitmap: SafeBitmap;
+}>) => Promise<StorageChunkSource>): void;
+/**
+ * Contract tests for an {@link IRegistryDriver}. `makeDriver` MUST return a fresh, empty, isolated driver on
+ * each call. The OCC contract (create / token-fenced CAS / ABA) plus the registry's record semantics (forward
+ * currentGen, status, clearable keyId, discovery).
+ */
+export declare function registryConformance(label: string, makeDriver: () => IRegistryDriver): void;
+/**
+ * Contract tests for an {@link IRegistryDriver} under **concurrent writers** — `makeDrivers` MUST return two
+ * independent driver instances over the **same** backing store, as two processes would see it.
+ *
+ * This exists because {@link registryConformance} drives one driver sequentially, and `ObjectStoreRegistry`
+ * checks the OCC token in memory before it ever issues a conditional write. That in-process check answers
+ * every sequential case, so the store-level precondition — the only thing that fences writers *across*
+ * processes, and the entire reason these drivers are built on conditional writes — is never load-bearing
+ * there. A backend that accepted `If-Match` and ignored it passed the full suite; so did a GCS driver whose
+ * writes were not fenced at all. These cases are what make the fence testable.
+ */
+export declare function registryConcurrency(label: string, makeDrivers: () => readonly [IRegistryDriver, IRegistryDriver]): void;

package/dist/testing/fuzz-codec.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Internal surface for the coverage-guided fuzz harness, CODEC half.
+ *
+ * Only the concrete bitmap codec lives here — the core half (`CrbmReader`, the non-public `parseIndex`,
+ * `BufferReader`, `CloudRoaringError`, `DEFAULT_MAX_PAYLOAD_BYTES`) is built from `@cloudbitmaps/core`'s own
+ * `src/testing/fuzz-core.ts` to `fuzz/build/fuzz-core.js`. Splitting it this way keeps the published entries
+ * of both packages free of test-only exports: neither widened its public API to feed the fuzzer.
+ */
+export { SafeBitmap } from '../roaring-codec.js';

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@cloudbitmaps/roaring",
-  "version": "0.9.0",
-  "description": "Distributed, cloud-native Roaring Bitmaps — query and intersect billion-scale integer sets over tiered cloud storage (RAM → NoSQL → object store), at a fraction of an always-on cache.",
+  "version": "0.10.0",
+  "description": "Distributed, cloud-native Roaring Bitmaps — query and intersect billion-scale integer sets straight out of object storage, from a bounded RAM cache over immutable objects in your own bucket, at a fraction of an always-on cache.",
   "keywords": [
     "roaring",
     "bitmap",
@@ -16,17 +16,10 @@
     "set",
     "set-intersection",
     "s3",
-    "dynamodb",
     "gcs",
     "azure",
-    "postgres",
-    "redis",
-    "mongodb",
-    "cassandra",
-    "mysql",
-    "mariadb",
     "serverless",
-    "tiered-storage",
+    "object-storage",
     "scale-to-zero",
     "segmentation",
     "audience",
@@ -38,7 +31,8 @@
   "author": "Sharvil Kadam",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/cloudbitmaps/cloudbitmaps.git"
+    "url": "git+https://github.com/cloudbitmaps/cloudbitmaps.git",
+    "directory": "packages/roaring"
   },
   "homepage": "https://github.com/cloudbitmaps/cloudbitmaps#readme",
   "bugs": {
@@ -46,62 +40,15 @@
   },
   "type": "module",
   "engines": {
-    "node": ">=22"
+    "node": ">=22.12"
   },
   "sideEffects": false,
-  "main": "./dist/index.cjs",
-  "module": "./dist/index.js",
+  "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
-      "import": "./dist/index.js",
-      "require": "./dist/index.cjs"
-    },
-    "./s3": {
-      "types": "./dist/s3/index.d.ts",
-      "import": "./dist/s3/index.js",
-      "require": "./dist/s3/index.cjs"
-    },
-    "./dynamodb": {
-      "types": "./dist/dynamodb/index.d.ts",
-      "import": "./dist/dynamodb/index.js",
-      "require": "./dist/dynamodb/index.cjs"
-    },
-    "./gcs": {
-      "types": "./dist/gcs/index.d.ts",
-      "import": "./dist/gcs/index.js",
-      "require": "./dist/gcs/index.cjs"
-    },
-    "./azure": {
-      "types": "./dist/azure/index.d.ts",
-      "import": "./dist/azure/index.js",
-      "require": "./dist/azure/index.cjs"
-    },
-    "./postgres": {
-      "types": "./dist/postgres/index.d.ts",
-      "import": "./dist/postgres/index.js",
-      "require": "./dist/postgres/index.cjs"
-    },
-    "./redis": {
-      "types": "./dist/redis/index.d.ts",
-      "import": "./dist/redis/index.js",
-      "require": "./dist/redis/index.cjs"
-    },
-    "./mongodb": {
-      "types": "./dist/mongodb/index.d.ts",
-      "import": "./dist/mongodb/index.js",
-      "require": "./dist/mongodb/index.cjs"
-    },
-    "./cassandra": {
-      "types": "./dist/cassandra/index.d.ts",
-      "import": "./dist/cassandra/index.js",
-      "require": "./dist/cassandra/index.cjs"
-    },
-    "./mysql": {
-      "types": "./dist/mysql/index.d.ts",
-      "import": "./dist/mysql/index.js",
-      "require": "./dist/mysql/index.cjs"
+      "default": "./dist/index.js"
     }
   },
   "files": [
@@ -115,69 +62,17 @@
     "access": "public"
   },
   "bin": {
-    "compact-segments": "./dist/bin/compact-segments.js",
     "export-segments": "./dist/bin/export-segments.js"
   },
   "dependencies": {
-    "roaring": "^2.7.0",
-    "@cloudbitmaps/core": "0.9.0"
-  },
-  "peerDependencies": {
-    "@aws-sdk/client-dynamodb": "^3",
-    "@aws-sdk/client-s3": "^3",
-    "@azure/storage-blob": "^12",
-    "@google-cloud/storage": "^7",
-    "cassandra-driver": "^4",
-    "ioredis": "^5",
-    "mongodb": "^6",
-    "mysql2": "^3",
-    "pg": "^8"
-  },
-  "peerDependenciesMeta": {
-    "@aws-sdk/client-dynamodb": {
-      "optional": true
-    },
-    "@aws-sdk/client-s3": {
-      "optional": true
-    },
-    "@azure/storage-blob": {
-      "optional": true
-    },
-    "@google-cloud/storage": {
-      "optional": true
-    },
-    "cassandra-driver": {
-      "optional": true
-    },
-    "ioredis": {
-      "optional": true
-    },
-    "mongodb": {
-      "optional": true
-    },
-    "mysql2": {
-      "optional": true
-    },
-    "pg": {
-      "optional": true
-    }
+    "roaring": "2.7.0",
+    "@cloudbitmaps/core": "^0.10.0"
   },
   "devDependencies": {
-    "@aws-sdk/client-dynamodb": "^3.1075.0",
-    "@aws-sdk/client-s3": "^3.1075.0",
-    "@azure/storage-blob": "^12",
-    "@google-cloud/storage": "^7.0.0",
-    "cassandra-driver": "^4",
-    "ioredis": "^5",
-    "mongodb": "^6",
-    "mysql2": "^3.23.1",
-    "pg": "^8",
-    "@types/pg": "^8",
     "@types/node": "^22.0.0",
-    "tsup": "^8.0.0",
     "typescript": "^5.5.0"
   },
   "scripts": {
-    "build": "tsup"
+    "build": "node ../../scripts/build.mjs"
   }
 }

package/dist/azure/index.cjs

@@ -1,14 +0,0 @@
-'use strict';
-
-var azure = require('@cloudbitmaps/core/azure');
-
-
-
-Object.keys(azure).forEach(function (k) {
-	if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
-		enumerable: true,
-		get: function () { return azure[k]; }
-	});
-});
-//# sourceMappingURL=index.cjs.map
-//# sourceMappingURL=index.cjs.map

package/dist/azure/index.cjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":[],"names":[],"mappings":"","file":"index.cjs","sourcesContent":[]}

package/dist/azure/index.d.cts

@@ -1,9 +0,0 @@
-export * from '@cloudbitmaps/core/azure';
-import '@cloudbitmaps/core/cassandra';
-import '@cloudbitmaps/core/dynamodb';
-import '@cloudbitmaps/core/gcs';
-import '@cloudbitmaps/core/mongodb';
-import '@cloudbitmaps/core/mysql';
-import '@cloudbitmaps/core/postgres';
-import '@cloudbitmaps/core/redis';
-import '@cloudbitmaps/core/s3';

package/dist/azure/index.d.ts

@@ -1,9 +0,0 @@
-export * from '@cloudbitmaps/core/azure';
-import '@cloudbitmaps/core/cassandra';
-import '@cloudbitmaps/core/dynamodb';
-import '@cloudbitmaps/core/gcs';
-import '@cloudbitmaps/core/mongodb';
-import '@cloudbitmaps/core/mysql';
-import '@cloudbitmaps/core/postgres';
-import '@cloudbitmaps/core/redis';
-import '@cloudbitmaps/core/s3';

package/dist/azure/index.js

@@ -1,3 +0,0 @@
-export * from '@cloudbitmaps/core/azure';
-//# sourceMappingURL=index.js.map
-//# sourceMappingURL=index.js.map

package/dist/azure/index.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":[],"names":[],"mappings":"","file":"index.js","sourcesContent":[]}

package/dist/bin/compact-segments.js

@@ -1,201 +0,0 @@
-#!/usr/bin/env node
-import { SystemClock, src_exports, runCompactionCycle } from '../chunk-D6LIJSGF.js';
-import { hostname } from 'os';
-import { join } from 'path';
-import { pathToFileURL } from 'url';
-
-function parseConfig(env) {
-  const root = env.CR_COMPACT_ROOT;
-  if (root === void 0 || root === "") {
-    throw new Error("CR_COMPACT_ROOT is required (the local-filesystem storage root)");
-  }
-  const mode = env.CR_COMPACT_MODE ?? "once";
-  if (mode !== "once" && mode !== "loop") {
-    throw new Error(`CR_COMPACT_MODE must be "once" or "loop"; got ${mode}`);
-  }
-  const num = (name, def) => {
-    const raw = env[name];
-    if (raw === void 0 || raw === "") return def;
-    const v = Number(raw);
-    if (!Number.isFinite(v) || v < 0)
-      throw new Error(`${name} must be a non-negative number; got ${raw}`);
-    return v;
-  };
-  const intOpt = (name, min = 0) => {
-    const raw = env[name];
-    if (raw === void 0 || raw === "") return void 0;
-    const v = Number(raw);
-    if (!Number.isInteger(v) || v < min)
-      throw new Error(`${name} must be an integer >= ${min}; got ${raw}`);
-    return v;
-  };
-  const shard = intOpt("CR_COMPACT_SHARD");
-  const totalShards = intOpt("CR_COMPACT_TOTAL_SHARDS");
-  if (shard === void 0 !== (totalShards === void 0)) {
-    throw new Error("set both CR_COMPACT_SHARD and CR_COMPACT_TOTAL_SHARDS, or neither");
-  }
-  return {
-    root,
-    mode,
-    intervalMs: num("CR_COMPACT_INTERVAL_MS", 3e4),
-    namespace: env.CR_COMPACT_NAMESPACE,
-    threshold: num("CR_COMPACT_THRESHOLD", 1),
-    keep: num("CR_COMPACT_KEEP", 1),
-    owner: env.CR_COMPACT_OWNER ?? `${hostname()}:${process.pid}`,
-    shard,
-    totalShards,
-    maxSegments: intOpt("CR_COMPACT_MAX_SEGMENTS", 1),
-    retire: env.CR_RETIRE === "1" ? parseRetireConfig(env, num, intOpt) : void 0
-  };
-}
-function parseRetireConfig(env, num, intOpt) {
-  return {
-    // `intOpt(name, 1)`, not `num`: `num` accepts 0 and 1.5, and `retireExpired` then throws a ValidationError
-    // from *inside* the cycle — swallowed into a generic `{"event":"error"}` line every 30 s in loop mode, so
-    // compaction keeps reporting healthy cycles while retention silently never runs. `parseConfig` promises to
-    // throw a clear error on misconfiguration; this is what keeps that promise. (CR_COMPACT_MAX_SEGMENTS, the
-    // identical concept, already used `intOpt`.)
-    limit: intOpt("CR_RETIRE_LIMIT", 1) ?? src_exports.DEFAULT_RETIRE_LIMIT,
-    dryRun: env.CR_RETIRE_DRY_RUN === "1",
-    intervalMs: num("CR_RETIRE_INTERVAL_MS", src_exports.DEFAULT_TOMBSTONE_GRACE_MS),
-    purgeTombstones: env.CR_RETIRE_KEEP_TOMBSTONES !== "1",
-    tombstoneGraceMs: num("CR_RETIRE_TOMBSTONE_GRACE_MS", src_exports.DEFAULT_TOMBSTONE_GRACE_MS)
-  };
-}
-function localFsDeps(root, metrics) {
-  return {
-    cold: new src_exports.LocalFsColdDriver(join(root, "cold")),
-    warm: new src_exports.LocalFsWarmDriver(join(root, "warm")),
-    registry: new src_exports.LocalFsRegistryDriver(join(root, "registry")),
-    // A real clock, not `{ now }`: outside `core/` ambient time is allowed, and a full clock is what lets
-    // the generation write hand the event loop back instead of blocking the daemon for its whole duration.
-    clock: new SystemClock(),
-    ...metrics ? { metrics } : {}
-  };
-}
-async function runOnce(deps, config) {
-  return runCompactionCycle(deps, {
-    owner: config.owner,
-    namespace: config.namespace,
-    threshold: config.threshold,
-    keep: config.keep,
-    shard: config.shard,
-    totalShards: config.totalShards,
-    maxSegments: config.maxSegments
-  });
-}
-async function retireOnce(deps, config, lastSweptAt) {
-  const retire = config.retire;
-  if (retire === void 0) return void 0;
-  if (lastSweptAt !== void 0 && deps.clock.now() - lastSweptAt < retire.intervalMs) {
-    return void 0;
-  }
-  return (0, src_exports.retireExpired)(
-    { registry: deps.registry, warm: deps.warm, cold: deps.cold },
-    {
-      namespace: config.namespace,
-      now: deps.clock.now(),
-      limit: retire.limit,
-      dryRun: retire.dryRun,
-      purgeTombstones: retire.purgeTombstones,
-      tombstoneGraceMs: retire.tombstoneGraceMs
-    }
-  );
-}
-var LOG_SKIPPED_SAMPLE = 20;
-function logRetire(result) {
-  const skipped = result.entries.filter((e) => e.action === "skipped");
-  const byReason = {};
-  for (const e of skipped) {
-    const key = e.reason.startsWith("failed:") ? "failed" : e.reason;
-    byReason[key] = (byReason[key] ?? 0) + 1;
-  }
-  const notReclaimed = result.entries.filter(
-    (e) => e.action === "retired" && e.result.generationsRemaining.length > 0
-  );
-  log({
-    event: "retire",
-    dryRun: result.dryRun,
-    scanned: result.scanned,
-    eligible: result.eligible,
-    retired: result.retired,
-    wouldRetire: result.wouldRetire,
-    tombstonesPurged: result.tombstonesPurged,
-    limited: result.limited,
-    skippedByReason: byReason,
-    skippedSample: skipped.slice(0, LOG_SKIPPED_SAMPLE).map((e) => ({ segment: e.segment, namespace: e.namespace, reason: e.reason })),
-    notFullyReclaimed: notReclaimed.slice(0, LOG_SKIPPED_SAMPLE).map((e) => e.segment),
-    notFullyReclaimedCount: notReclaimed.length
-  });
-}
-var sleep = (ms) => new Promise((r) => setTimeout(r, ms));
-var log = (obj) => {
-  process.stdout.write(`${JSON.stringify(obj)}
-`);
-};
-function stdoutMetricsSink() {
-  return {
-    onEvent: (event) => log({ event: "metric", ...event })
-  };
-}
-async function main(env = process.env) {
-  const config = parseConfig(env);
-  const deps = localFsDeps(
-    config.root,
-    env.CR_COMPACT_METRICS === "1" ? stdoutMetricsSink() : void 0
-  );
-  if (config.mode === "once") {
-    const cycle = await runOnce(deps, config);
-    log({
-      event: "cycle",
-      mode: "once",
-      candidates: cycle.candidates,
-      compacted: cycle.compacted,
-      deferred: cycle.deferred,
-      results: cycle.results
-    });
-    const swept = await retireOnce(deps, config);
-    if (swept !== void 0) logRetire(swept);
-    return;
-  }
-  let stop = false;
-  const onSignal = () => {
-    stop = true;
-  };
-  process.on("SIGINT", onSignal);
-  process.on("SIGTERM", onSignal);
-  log({ event: "start", mode: "loop", intervalMs: config.intervalMs, owner: config.owner });
-  let lastSweptAt;
-  while (!stop) {
-    try {
-      const cycle = await runOnce(deps, config);
-      log({
-        event: "cycle",
-        candidates: cycle.candidates,
-        compacted: cycle.compacted,
-        deferred: cycle.deferred,
-        results: cycle.results
-      });
-      const swept = await retireOnce(deps, config, lastSweptAt);
-      if (swept !== void 0) {
-        lastSweptAt = deps.clock.now();
-        logRetire(swept);
-      }
-    } catch (err) {
-      log({ event: "error", message: err.message });
-    }
-    if (!stop) await sleep(config.intervalMs);
-  }
-  log({ event: "stopped" });
-}
-if (process.argv[1] !== void 0 && import.meta.url === pathToFileURL(process.argv[1]).href) {
-  main().catch((err) => {
-    process.stderr.write(`${err.message}
-`);
-    process.exit(1);
-  });
-}
-
-export { localFsDeps, main, parseConfig, retireOnce, runOnce };
-//# sourceMappingURL=compact-segments.js.map
-//# sourceMappingURL=compact-segments.js.map