@cloudbitmaps/core 0.1.0-rc.0

package/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/NOTICE

@@ -0,0 +1,12 @@
+CloudRoaring
+Copyright 2026 Sharvil Kadam
+
+This product includes software developed as an open-source project.
+Licensed under the Apache License, Version 2.0 (the "License"); see the LICENSE
+file. You may obtain a copy of the License at:
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+CloudRoaring builds on the Roaring Bitmap data structure and is designed to use
+the CRoaring engine (via the `roaring` Node.js binding) for in-memory bit math.
+Those projects are independent works under their own licenses.

package/README.md

@@ -0,0 +1,22 @@
+# @cloudbitmaps/core
+
+The **codec-agnostic cloud engine** behind the [CloudBitmaps](https://github.com/cloudbitmaps/cloudbitmaps) family:
+tiered storage (HOT RAM → WARM key/value deltas → COLD immutable `.crbm` objects), serverless chunk-skipping
+intersection, the segment registry, crash-safe 2-phase-commit compaction, encryption-at-rest + crypto-shred, and
+**every storage driver** (S3 · GCS · Azure Blob · DynamoDB · PostgreSQL · Redis · MongoDB · Cassandra/ScyllaDB ·
+MySQL/MariaDB, each on its own subpath with the backend SDK as an optional peer dependency).
+
+## You probably want a flavor, not this package
+
+This package holds no bitmap codec — that lives in a *flavor* package which depends on this one and supplies it
+through the `CodecInterface` seam. Install the flavor; `@cloudbitmaps/core` arrives **transitively**:
+
+```bash
+npm i @cloudbitmaps/roaring        # the roaring flavor (flagship)
+```
+
+Depend on `@cloudbitmaps/core` directly only to **author a flavor or a driver**. It has **zero runtime
+dependencies** of its own.
+
+Full docs, guides, and the design corpus live in the
+[repository](https://github.com/cloudbitmaps/cloudbitmaps). Licensed Apache-2.0.

package/dist/azure/index.cjs

@@ -0,0 +1,368 @@
+'use strict';
+
+var crypto = require('crypto');
+
+// src/drivers/azure/cold.ts
+
+// src/core/errors.ts
+var ERROR_BRAND = /* @__PURE__ */ Symbol.for("cloud-roaring.error");
+var TRANSIENT_BRAND = /* @__PURE__ */ Symbol.for("cloud-roaring.error.transient");
+var CloudRoaringError = class extends Error {
+  /** Cross-bundle brand — see the predicates ({@link isCloudRoaringError}, …). Non-enumerable-ish (symbol key ⇒ not in JSON). */
+  [ERROR_BRAND] = true;
+  constructor(message) {
+    super(message);
+    this.name = new.target.name;
+  }
+};
+var ValidationError = class extends CloudRoaringError {
+};
+var WriteConflictError = class extends CloudRoaringError {
+};
+var NotFoundError = class extends CloudRoaringError {
+};
+var TransientError = class extends CloudRoaringError {
+  /** A second brand so the whole transient subtree (incl. {@link TimeoutError}) is classifiable cross-bundle. */
+  [TRANSIENT_BRAND] = true;
+  constructor(message, options) {
+    super(message);
+    if (options && "cause" in options) this.cause = options.cause;
+  }
+};
+function hasBrand(err, brand) {
+  return typeof err === "object" && err !== null && err[brand] === true;
+}
+function isCloudRoaringError(err) {
+  return hasBrand(err, ERROR_BRAND);
+}
+function isWriteConflictError(err) {
+  return isCloudRoaringError(err) && err.name === "WriteConflictError";
+}
+function isNotFoundError(err) {
+  return isCloudRoaringError(err) && err.name === "NotFoundError";
+}
+function isValidationError(err) {
+  return isCloudRoaringError(err) && err.name === "ValidationError";
+}
+
+// src/core/validate.ts
+var NAME = /^[A-Za-z0-9][A-Za-z0-9._-]{0,255}$/;
+function validatePart(value, field) {
+  if (typeof value !== "string" || !NAME.test(value) || value.includes("..")) {
+    throw new ValidationError(
+      `${field} must match ${String(NAME)} and contain no "..": got ${JSON.stringify(value)}`
+    );
+  }
+}
+function validateSegmentRef(ref) {
+  validatePart(ref.segment, "segment");
+  if (ref.namespace !== void 0) validatePart(ref.namespace, "namespace");
+}
+
+// src/drivers/_shared/keys.ts
+var DEFAULT_NAMESPACE = "_default";
+function namespacePart(namespace) {
+  return namespace ?? DEFAULT_NAMESPACE;
+}
+
+// src/drivers/azure/keys.ts
+var SUFFIX = ".crbm";
+function prefixPart(prefix) {
+  if (prefix === void 0) return "";
+  const trimmed = prefix.replace(/^\/+|\/+$/g, "");
+  return trimmed === "" ? "" : `${trimmed}/`;
+}
+function normalizeAzurePrefix(prefix) {
+  if (prefix === void 0) return void 0;
+  for (const ch of prefix) {
+    if (ch.charCodeAt(0) < 32) {
+      throw new ValidationError("prefix must not contain control characters");
+    }
+  }
+  for (const segment of prefix.split("/")) {
+    if (segment === "." || segment === "..") {
+      throw new ValidationError(
+        `prefix must not contain "." or ".." path segments: ${JSON.stringify(prefix)}`
+      );
+    }
+  }
+  return prefix;
+}
+function segmentObjectPrefix(prefix, ref) {
+  validateSegmentRef(ref);
+  return `${prefixPart(prefix)}${namespacePart(ref.namespace)}/segments/${ref.segment}.`;
+}
+function coldObjectName(prefix, key) {
+  if (!Number.isInteger(key.generation) || key.generation < 0) {
+    throw new ValidationError(`generation must be a non-negative integer; got ${key.generation}`);
+  }
+  return `${segmentObjectPrefix(prefix, key)}${key.generation}${SUFFIX}`;
+}
+function parseGenerationFromName(segmentPrefix, objectName) {
+  if (!objectName.startsWith(segmentPrefix) || !objectName.endsWith(SUFFIX)) return null;
+  const middle = objectName.slice(segmentPrefix.length, objectName.length - SUFFIX.length);
+  if (!/^(0|[1-9]\d*)$/.test(middle)) return null;
+  const generation = Number(middle);
+  return Number.isSafeInteger(generation) ? generation : null;
+}
+
+// src/drivers/azure/azure-errors.ts
+function httpStatus(err) {
+  const code = err?.statusCode;
+  return typeof code === "number" ? code : void 0;
+}
+function azureCode(err) {
+  const e = err;
+  if (typeof e?.code === "string") return e.code;
+  if (typeof e?.details?.errorCode === "string") return e.details.errorCode;
+  return void 0;
+}
+function networkCode(err) {
+  const code = err?.code;
+  return typeof code === "string" ? code : void 0;
+}
+function isConditionalConflict(err) {
+  const status = httpStatus(err);
+  if (status === 409 || status === 412) return true;
+  const code = azureCode(err);
+  return code === "BlobAlreadyExists" || code === "ConditionNotMet";
+}
+function isNotFound(err) {
+  return httpStatus(err) === 404 || azureCode(err) === "BlobNotFound";
+}
+function isInvalidRange(err) {
+  return httpStatus(err) === 416 || azureCode(err) === "InvalidRange";
+}
+function isTransient(err) {
+  if (isConditionalConflict(err) || isNotFound(err) || isInvalidRange(err)) return false;
+  const status = httpStatus(err);
+  if (status === 429 || status !== void 0 && status >= 500 && status < 600) return true;
+  const code = azureCode(err);
+  if (code === "ServerBusy" || code === "OperationTimedOut" || code === "InternalError")
+    return true;
+  const net = networkCode(err);
+  return net === "ECONNRESET" || net === "ECONNABORTED" || net === "ETIMEDOUT" || net === "ESOCKETTIMEDOUT" || net === "ECONNREFUSED" || net === "EHOSTUNREACH" || net === "ENETUNREACH" || net === "EPIPE" || net === "EAI_AGAIN" || net === "ENOTFOUND";
+}
+
+// src/drivers/azure/cold.ts
+var AZURE_BLOCK_BYTES = 8 * 1024 * 1024;
+var AZURE_MAX_BLOCKS = 5e4;
+var OCTET_STREAM = { blobContentType: "application/octet-stream" };
+var IF_ABSENT = { conditions: { ifNoneMatch: "*" }, blobHTTPHeaders: OCTET_STREAM };
+var AzureBlobColdDriver = class {
+  container;
+  prefix;
+  maxObjectBytes;
+  blockBytes;
+  constructor(options) {
+    this.container = options.containerClient;
+    this.prefix = normalizeAzurePrefix(options.prefix);
+    const requestedBlock = options.blockBytes ?? AZURE_BLOCK_BYTES;
+    if (!Number.isSafeInteger(requestedBlock) || requestedBlock < 1) {
+      throw new ValidationError(
+        `blockBytes must be a positive safe integer; got ${requestedBlock}`
+      );
+    }
+    if (options.maxObjectBytes !== void 0 && (!Number.isSafeInteger(options.maxObjectBytes) || options.maxObjectBytes < 1)) {
+      throw new ValidationError(
+        `maxObjectBytes must be a positive safe integer; got ${options.maxObjectBytes}`
+      );
+    }
+    this.maxObjectBytes = options.maxObjectBytes ?? requestedBlock * AZURE_MAX_BLOCKS;
+    this.blockBytes = Math.max(requestedBlock, Math.ceil(this.maxObjectBytes / AZURE_MAX_BLOCKS));
+  }
+  capabilities() {
+    return { rangeRead: true, maxObjectBytes: this.maxObjectBytes, conditionalPut: true };
+  }
+  blob(name) {
+    return this.container.getBlockBlobClient(name);
+  }
+  async putImmutable(key, write) {
+    const objectName = coldObjectName(this.prefix, key);
+    const sink = new AzureBlockBlobSink(
+      this.blob(objectName),
+      this.blockBytes,
+      this.maxObjectBytes
+    );
+    try {
+      await write(sink);
+      return await sink.finish();
+    } catch (err) {
+      if (isConditionalConflict(err)) {
+        throw new WriteConflictError(
+          `generation already exists (write-once): ${key.segment}.${key.generation}`
+        );
+      }
+      if (isValidationError(err) || isWriteConflictError(err) || isNotFoundError(err)) throw err;
+      throw this.mapError(err);
+    }
+  }
+  async getRange(key, offset, length) {
+    if (!Number.isInteger(offset) || !Number.isInteger(length) || offset < 0 || length < 0) {
+      throw new ValidationError(`invalid range offset=${offset} length=${length}`);
+    }
+    if (length === 0) return new Uint8Array(0);
+    const objectName = coldObjectName(this.prefix, key);
+    try {
+      const res = await this.blob(objectName).download(offset, length);
+      const bytes = await collect(res.readableStreamBody);
+      if (bytes.length !== length) {
+        throw new ValidationError(
+          `range [${offset}, ${offset + length}) out of bounds (got ${bytes.length}B)`
+        );
+      }
+      return bytes;
+    } catch (err) {
+      throw this.mapReadError(err, key);
+    }
+  }
+  async getTail(key, maxBytes) {
+    const objectName = coldObjectName(this.prefix, key);
+    try {
+      const props = await this.blob(objectName).getProperties();
+      const size = props.contentLength ?? 0;
+      if (!Number.isSafeInteger(size) || size < 0) {
+        throw new ValidationError(`Azure returned an invalid blob size: ${String(size)}`);
+      }
+      if (maxBytes <= 0 || size === 0) return { bytes: new Uint8Array(0), size };
+      const take = Math.min(maxBytes, size);
+      const res = await this.blob(objectName).download(size - take, take);
+      return { bytes: await collect(res.readableStreamBody), size };
+    } catch (err) {
+      throw this.mapReadError(err, key);
+    }
+  }
+  async delete(key) {
+    try {
+      await this.blob(coldObjectName(this.prefix, key)).deleteIfExists();
+    } catch (err) {
+      throw this.mapError(err);
+    }
+  }
+  async *list(ref) {
+    const prefix = segmentObjectPrefix(this.prefix, ref);
+    try {
+      for await (const item of this.container.listBlobsFlat({ prefix })) {
+        const generation = parseGenerationFromName(prefix, item.name);
+        if (generation !== null) {
+          yield { namespace: ref.namespace, segment: ref.segment, generation };
+        }
+      }
+    } catch (err) {
+      throw this.mapError(err);
+    }
+  }
+  /** Map Azure read errors to the driver vocabulary; pass everything else through {@link mapError}. */
+  mapReadError(err, key) {
+    if (isValidationError(err)) return err;
+    if (isNotFound(err))
+      return new NotFoundError(`no such generation: ${key.segment}.${key.generation}`);
+    if (isInvalidRange(err)) {
+      return new ValidationError(`range out of bounds for ${key.segment}.${key.generation}`);
+    }
+    return this.mapError(err);
+  }
+  /**
+   * Reclassify a transient Azure fault (throttle/5xx/dropped connection) as a retryable {@link TransientError}
+   * so the retry decorator can ride it out; everything else propagates unchanged. The final fallback at every
+   * client-call site, so callers + the decorator only ever see typed errors.
+   */
+  mapError(err) {
+    if (isTransient(err)) {
+      return new TransientError(
+        `transient Azure fault: ${err?.code ?? "unknown"}`,
+        { cause: err }
+      );
+    }
+    return err;
+  }
+};
+function concatBytes(parts, total) {
+  const out = new Uint8Array(total);
+  let offset = 0;
+  for (const p of parts) {
+    out.set(p, offset);
+    offset += p.length;
+  }
+  return out;
+}
+var AzureBlockBlobSink = class {
+  constructor(blob, blockBytes, maxObjectBytes) {
+    this.blob = blob;
+    this.blockBytes = blockBytes;
+    this.maxObjectBytes = maxObjectBytes;
+  }
+  blob;
+  blockBytes;
+  maxObjectBytes;
+  hash = crypto.createHash("sha256");
+  pending = [];
+  pendingLen = 0;
+  total = 0;
+  blockIds = [];
+  /**
+   * A random per-sink nonce folded into every block id. Azure pools **uncommitted** blocks per *blob name*,
+   * keyed by id — so two writers racing the same generation key on the staged path MUST use disjoint id spaces,
+   * else one would overwrite the other's staged blocks and a commit could reference an interleaved mix of both
+   * writers' bytes (a corrupt blob whose committed content wouldn't match the returned SHA-256). A per-instance
+   * nonce makes each writer's ids unique, so the winner commits only its own blocks and the loser cleanly 409s.
+   * 6 random bytes → 12 fixed hex chars, keeping every id equal-length (Azure's within-blob id requirement).
+   */
+  uploadNonce = crypto.randomBytes(6).toString("hex");
+  /** Fixed-width (constant length within a blob) AND per-sink-unique block id: `<nonce>-<zero-padded index>`. */
+  blockId(n) {
+    return Buffer.from(`${this.uploadNonce}-${String(n).padStart(6, "0")}`).toString("base64");
+  }
+  async write(bytes) {
+    if (bytes.length === 0) return;
+    this.total += bytes.length;
+    if (this.total > this.maxObjectBytes) {
+      throw new ValidationError(`object exceeds maxObjectBytes ${this.maxObjectBytes}`);
+    }
+    this.hash.update(bytes);
+    this.pending.push(new Uint8Array(bytes));
+    this.pendingLen += bytes.length;
+    if (this.pendingLen >= this.blockBytes) await this.flushBlock();
+  }
+  /** Stage the buffered bytes (≥ one block) as a single block, freeing them. */
+  async flushBlock() {
+    if (this.blockIds.length >= AZURE_MAX_BLOCKS) {
+      throw new ValidationError(`upload exceeded the Azure ${AZURE_MAX_BLOCKS}-block limit`);
+    }
+    const body = concatBytes(this.pending, this.pendingLen);
+    this.pending.length = 0;
+    this.pendingLen = 0;
+    const id = this.blockId(this.blockIds.length);
+    await this.blob.stageBlock(id, body, body.length);
+    this.blockIds.push(id);
+  }
+  /** Commit the blob: a single conditional `upload` if it fit in one block, else commit the staged block list. */
+  async finish() {
+    const sha256 = this.hash.digest("hex");
+    if (this.blockIds.length === 0) {
+      const body = concatBytes(this.pending, this.pendingLen);
+      await this.blob.upload(body, body.length, IF_ABSENT);
+      return { size: this.total, sha256 };
+    }
+    if (this.pendingLen > 0) await this.flushBlock();
+    await this.blob.commitBlockList(this.blockIds, IF_ABSENT);
+    return { size: this.total, sha256 };
+  }
+};
+async function collect(body) {
+  if (body === void 0) {
+    throw new NotFoundError("Azure download returned no body");
+  }
+  const chunks = [];
+  let total = 0;
+  for await (const chunk of body) {
+    const u8 = typeof chunk === "string" ? new TextEncoder().encode(chunk) : new Uint8Array(chunk);
+    chunks.push(u8);
+    total += u8.length;
+  }
+  return concatBytes(chunks, total);
+}
+
+exports.AzureBlobColdDriver = AzureBlobColdDriver;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map