@cloudbitmaps/roaring 0.9.0 → 0.11.0

package/dist/open-charging-storage.d.ts

@@ -0,0 +1,34 @@
+/**
+ * A storage driver that charges every **generation open** to a per-op budget, for `eraseSubject`.
+ *
+ * The budget counts fan-out in units of one backend read. `eraseSubject`'s scan charges one unit per registered
+ * segment, but a segment whose current generation lacks the id is searched anyway: every other generation in its
+ * bucket is opened, one tail read each, and with the keep-everything default of the `*Into` verbs that is one per
+ * generation the segment ever had. Those opens are the work the scan's own count leaves out. They are counted here,
+ * at the storage port where they happen, so an open added to the erasure later is charged without anyone
+ * remembering to charge it, and no option of the public erasure call had to grow.
+ *
+ * Two opens are never charged, because the segment's unit already pays for them: the generation the row named when
+ * the scan listed it, which every erasure must read to decide membership, and an object this call wrote itself,
+ * which it reads back to verify. A refusal here comes from a read, and in an erasure the reads that can be refused
+ * come before the deletes.
+ */
+import type { GenKey, IStorageDriver, SegmentRef } from '@cloudbitmaps/core';
+export declare class OpenChargingStorage implements IStorageDriver {
+    private readonly inner;
+    private readonly charge;
+    private readonly free;
+    /**
+     * @param inner   the driver the erasure would otherwise use
+     * @param current the generation the segment's row named when it was listed, or `null` when it named none
+     * @param charge  called once per charged open; it throws to refuse
+     */
+    constructor(inner: IStorageDriver, current: number | null, charge: () => void);
+    capabilities(): ReturnType<IStorageDriver['capabilities']>;
+    putImmutable(key: GenKey, write: Parameters<IStorageDriver['putImmutable']>[1]): ReturnType<IStorageDriver['putImmutable']>;
+    getRange(key: GenKey, offset: number, length: number): Promise<Uint8Array>;
+    /** One `getTail` is one open: a reader takes the footer and the index from it, and reads chunks with `getRange`. */
+    getTail(key: GenKey, maxBytes: number): ReturnType<IStorageDriver['getTail']>;
+    delete(key: GenKey): Promise<void>;
+    list(ref: SegmentRef): AsyncIterable<GenKey>;
+}

package/dist/option-keys.d.ts

@@ -0,0 +1,19 @@
+/**
+ * The keys `new CloudRoaring(options)` takes: at the top level, and inside each group whose value is an object. The
+ * constructor refuses any other key by name, because an option it ignored would do nothing and look as if it had,
+ * and the gates that read the docs' samples and the harnesses' option bags hold them to the same table. A test
+ * holds the table to the option interfaces, in both directions.
+ *
+ * NOT part of the public API. It is its own module, rather than an `export` from the barrel, so the constructor
+ * and those gates read one copy.
+ */
+export declare const OPTION_KEYS: {
+    readonly top: readonly ["storage", "cache", "encryption", "retry", "metrics", "budget", "seams"];
+    readonly cache: readonly ["maxChunks", "ttlMs", "genTtlMs", "readerMax", "readerMaxBytes"];
+    readonly encryption: readonly ["keystore", "required"];
+    readonly retry: readonly ["maxAttempts", "baseDelayMs", "maxDelayMs", "backoffFactor", "jitter", "onRetry"];
+    readonly budget: readonly ["maxRequests"];
+    readonly seams: readonly ["clock", "rng"];
+};
+/** The groups: the top-level keys whose value, when it is an object, has keys of its own. */
+export type OptionGroup = Exclude<keyof typeof OPTION_KEYS, 'top'>;

package/dist/portable/decode.d.ts

@@ -0,0 +1,53 @@
+/**
+ * A decoded portable-roaring bitmap that can be queried but not modified.
+ *
+ * Construction checks every container once, in {@link parsePortableLayout}, which is the same check the native
+ * path runs; after that a membership test reads one container rather than materializing the set.
+ */
+export declare class PortableRoaringReader {
+    private readonly view;
+    private readonly containers;
+    private constructor();
+    /**
+     * Parse and check a portable-format bitmap.
+     *
+     * @throws {IntegrityError} if the bytes are not a well-formed portable bitmap: see {@link parsePortableLayout}.
+     */
+    static decode(bytes: Uint8Array): PortableRoaringReader;
+    /**
+     * Total cardinality.
+     *
+     * Served entirely from the descriptive header, which {@link parsePortableLayout} has checked against every
+     * container's payload, 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/portable/layout.d.ts

@@ -0,0 +1,32 @@
+/** A container of sorted `u16` values. */
+export declare const ARRAY = 0;
+/** A container of 65,536 bits. */
+export declare const BITMAP = 1;
+/** A container of `(start, length)` runs. */
+export declare const RUN = 2;
+export type ContainerKind = typeof ARRAY | typeof BITMAP | typeof RUN;
+export interface PortableContainer {
+    /** High 16 bits of every value in this container. */
+    readonly key: number;
+    /** Number of values. Stored as `cardinality - 1` on the wire, normalized here. */
+    readonly cardinality: number;
+    readonly kind: ContainerKind;
+    /** Absolute byte offset of this container's payload within the source buffer; a run container's run count. */
+    readonly offset: number;
+}
+/**
+ * Parse the portable-format bitmap in `bytes`, and check its structure.
+ *
+ * An empty buffer is the empty bitmap, as it is to the native addon, which returns one without reading a byte.
+ *
+ * @throws {IntegrityError} if the cookie is unrecognized, any field runs past the buffer, or the structure is not
+ * one a writer produces (see the module header for the list).
+ */
+export declare function parsePortableLayout(bytes: Uint8Array): PortableContainer[];
+/**
+ * {@link parsePortableLayout}'s check alone, for a caller that hands the bytes to another decoder afterwards and
+ * so has no use for the layout: it allocates nothing per container.
+ *
+ * @throws {IntegrityError} exactly where {@link parsePortableLayout} does.
+ */
+export declare function checkPortableLayout(bytes: Uint8Array): void;

package/dist/reserved-namespace.d.ts

@@ -0,0 +1,3 @@
+export declare const RESERVED_NAMESPACE_PREFIX = "cbm.due.";
+/** Throw `ValidationError` for a namespace in the reserved prefix; `undefined` and every look-alike pass. */
+export declare function refuseReservedNamespace(namespace: string | undefined): void;

package/dist/roaring-codec.d.ts

@@ -0,0 +1,68 @@
+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;
+    /**
+     * Cap the size, check the structure, then deserialize with the **portable** format.
+     * Throws `IntegrityError` if the input exceeds `maxBytes`, is not a well-formed portable bitmap, or fails to
+     * decode — the native addon is never handed unbounded, malformed or unsafe-format input.
+     *
+     * The structural check is what makes the decoded bitmap's answers mean anything. The native deserializer
+     * bounds its reads and checks nothing else, so bytes of the right length and the wrong shape (containers or
+     * values out of order, overlapping runs, a cardinality that disagrees with the bits) decode into a bitmap
+     * whose `maximum()`, `has()` and `size` are wrong, and some of those shapes crash the process when used.
+     */
+    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 last container, so the engine's
+     * per-chunk range assertion costs one call per chunk rather than a walk per id. The last container holds the
+     * largest value only because {@link SafeBitmap.safeDeserialize} refuses bytes whose containers or values are
+     * out of order.
+     */
+    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.
+ */
+export declare const roaringCodec: CodecInterface;

package/dist/system-clock.d.ts

@@ -0,0 +1,39 @@
+/**
+ * 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` so the facade, the tests and anything else that needs a real
+ * clock can import it without importing the whole barrel.
+ */
+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 519 ms → 24 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,54 @@
+import { SafeBitmap } from '../roaring-codec.js';
+import type { StorageChunkSource, IRegistryDriver, IStorageDriver } 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;
+/** The storage-driver cases {@link storageDriverConformance} runs; an emulator that cannot model one skips it by name. */
+export type StorageDriverCase = 'write-once round trip' | 'collision' | 'collision on a large upload' | 'missing object' | 'out-of-range read' | 'tail size' | 'idempotent delete' | 'list read-after-delete';
+/**
+ * Contract tests for an {@link IStorageDriver} — the contract its doc comment lists: write-once with
+ * `WriteConflictError` on a collision, `NotFoundError` for a missing object, `ValidationError` for an out-of-range
+ * read, `getTail`'s true total size, idempotent `delete`, and a `list` that is read-after-delete. `makeDriver` MUST
+ * return a driver over an empty, isolated keyspace on each call.
+ *
+ * `skip` names the cases a backend cannot exercise (a local emulator that does not model a contract), so each
+ * skip is visible at the call site, with the reason beside it, rather than hidden in a weakened assertion.
+ */
+export declare function storageDriverConformance(label: string, makeDriver: () => IStorageDriver, options?: {
+    readonly skip?: readonly StorageDriverCase[];
+    /**
+     * Size of the object the `collision on a large upload` case writes. Pass one above the driver's single-request
+     * upload threshold to exercise its multipart or resumable path, where the write-once precondition is
+     * sent on a different request than a small object's. Omitted, the case does not run.
+     */
+    readonly largeBytes?: number;
+}): 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,23 @@
+/**
+ * Internal surface for the coverage-guided fuzz harness, CODEC half.
+ *
+ * The concrete bitmap codec, and the one property the harness holds every decode it accepts to. 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.
+ */
+import { SafeBitmap } from '../roaring-codec.js';
+export { SafeBitmap };
+/**
+ * What an accepted decode must be: it iterates strictly ascending, `size` is the number of values it iterates, and
+ * `has` confirms what it iterates. Throws a plain `Error` otherwise, which the fuzz targets and the corpus replay
+ * report as a finding.
+ *
+ * Memory safety alone does not see a structurally broken bitmap. Bytes with containers or values out of order, or
+ * a cardinality that disagrees with the bits, decode into memory that behaves until an operation trusts one of the
+ * broken invariants, so a contract of "no crash" passes them. This fails them. It is bounded like the
+ * materialization it replaces, because a valid run-heavy bitmap is tiny on disk and can hold billions of ids, and it
+ * asks `has` of the first 4,096 values only, which is enough to reach every container a small input can hold.
+ */
+export declare function assertConsistentDecode(bm: SafeBitmap): void;

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.11.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,29 +16,22 @@
     "set",
     "set-intersection",
     "s3",
-    "dynamodb",
     "gcs",
     "azure",
-    "postgres",
-    "redis",
-    "mongodb",
-    "cassandra",
-    "mysql",
-    "mariadb",
     "serverless",
-    "tiered-storage",
+    "object-storage",
     "scale-to-zero",
     "segmentation",
     "audience",
     "cloud",
-    "cloud-roaring",
     "cloudbitmaps"
   ],
   "license": "Apache-2.0",
   "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 +39,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 +61,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.11.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":[]}