@belvador/spool 0.0.0-stage → 0.6.0

package/LICENSE

@@ -0,0 +1,27 @@
+MIT License
+
+Copyright (c) 2026 Belvador
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+---
+
+This software depends on the Sentry JavaScript SDK (https://github.com/getsentry/sentry-javascript),
+which is distributed under its own MIT License (Copyright (c) Functional Software, Inc. dba Sentry)
+in each of its npm packages. Belvador is not affiliated with or endorsed by Sentry.

package/README.md

@@ -1,3 +1,42 @@
-# Temporary Holding Version
+# @belvador/spool
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Keeps errors on disk while Belvador cannot be reached — for Node.js, Bun and Deno servers that
+use the open-source Sentry SDK with a Belvador DSN. When the network is back they are sent again,
+oldest first, also by the next process if this one was restarted or killed.
+
+```ts
+// Node.js
+import * as Sentry from "@sentry/node";
+import { withSpool } from "@belvador/spool";
+
+Sentry.init({
+  dsn: process.env.BELVADOR_DSN,
+  transport: withSpool(Sentry.makeNodeTransport, { dir: "/var/lib/my-app/belvador" }),
+});
+```
+
+- **Bun:** `withSpool(Sentry.makeFetchTransport, { dir })` with `@sentry/bun`.
+- **Deno:** `@sentry/deno` keeps its transport private, so use the one in this package:
+  `withSpool(makeFetchTransport, { dir })` with `npm:@sentry/deno` and `npm:@belvador/spool`.
+  Permissions: `--allow-net=<DSN host> --allow-env --allow-read=<dir> --allow-write=<dir>`.
+- **Already using `makeOfflineTransport`?** Pass `createStore: makeFileStore({ dir })`.
+  `withSpool` is still better: it also keeps a burst larger than the engine's 64-send memory
+  buffer, and does not count an error it stored as lost.
+
+| Option | Default | |
+|---|---|---|
+| `dir` | — | one directory per app; created with mode `0700`, files `0600`. Several processes of the same app may share it |
+| `maxBytes` | 64 MiB | the oldest envelopes are dropped first and counted as `queue_overflow` |
+| `ttlHours` | 72 | older envelopes are dropped instead of sent |
+| `key` | — | 32 random bytes of your own: envelopes are encrypted with AES-256-GCM |
+
+Tested: 200 errors while the intake is down, the process killed with `SIGKILL`, a new process
+started once the intake is back — all 200 arrive, none twice (Node.js, Bun, Deno). A kill in the
+middle of a write leaves at most one half-written file, which the next start drops and counts.
+
+What it does not promise: delivery of every event. A full disk, a damaged file or an envelope
+older than `ttlHours` is dropped and counted in the SDK's client reports; your app never waits
+for the disk and never sees an error from it. Cloudflare Workers and other short-lived functions
+have no lasting disk — this package does not help there.
+
+License: MIT · https://belvador.dev/docs/sdk/offline

package/dist/index.d.ts

@@ -0,0 +1,21 @@
+import type { BaseTransportOptions, Transport } from "@sentry/core";
+import { type FileStoreOptions } from "./store.js";
+export { SPOOL_DEFAULTS, createFileStore, makeFileStore, type FileStoreOptions, type OfflineStore, type StoreTransportOptions, } from "./store.js";
+/**
+ * Wraps a Sentry SDK transport so failed sends wait on disk:
+ *
+ *   import * as Sentry from "@sentry/node";
+ *   import { withSpool } from "@belvador/spool";
+ *   Sentry.init({ dsn: process.env.BELVADOR_DSN, transport: withSpool(Sentry.makeNodeTransport, { dir: "/var/lib/my-app/belvador" }) });
+ *
+ * Same as `makeOfflineTransport(base)` with `createStore: makeFileStore(options)` and
+ * `flushAtStartup: true`, plus: a burst larger than the engine's memory buffer goes to disk
+ * instead of being dropped, and a request the spool kept is not counted as lost.
+ */
+export declare function withSpool<O extends object>(base: (options: O) => Transport, options: FileStoreOptions): (transportOptions: O) => Transport;
+/**
+ * A plain `fetch` transport for runtimes whose Sentry SDK does not export one (`@sentry/deno`
+ * keeps its own private): `withSpool(makeFetchTransport, { dir })`. Node.js and Bun can use
+ * their SDK's `makeNodeTransport` / `makeFetchTransport` instead.
+ */
+export declare function makeFetchTransport(options: BaseTransportOptions): Transport;

package/dist/index.js

@@ -0,0 +1,91 @@
+// @belvador/spool — keeps errors on disk while Belvador cannot be reached, for Node.js, Bun and
+// Deno servers using the open-source Sentry SDK with a Belvador DSN. Sent again when the network
+// is back, within a size cap and a time limit — never a promise that every event arrives.
+// Importing this module has no side effects.
+import { createTransport, makeOfflineTransport } from "@sentry/core";
+import { makeFileStore } from "./store.js";
+export { SPOOL_DEFAULTS, createFileStore, makeFileStore, } from "./store.js";
+/** The engine's default in-memory send buffer (`DEFAULT_TRANSPORT_BUFFER_SIZE` of `@sentry/core`). */
+const ENGINE_BUFFER = 64;
+/**
+ * The transport under the spool. Two engine behaviours would lose or miscount errors here:
+ * - a full in-memory buffer answers `{}` (counted as `queue_overflow`), so a burst while the
+ *   network is down would keep only the first 64 — instead, sends past the buffer are refused,
+ *   and the spool keeps them on disk;
+ * - every failed request is counted as `network_error`, though the spool kept it — the spool
+ *   counts its own losses (disk failure, cap, time limit), so the base does not count that one.
+ */
+function underSpool(base) {
+    return (options) => {
+        const o = options;
+        const record = o.recordDroppedEvent;
+        const limit = Math.max(1, Math.floor(Number(o.bufferSize) || ENGINE_BUFFER));
+        const transport = base({
+            ...o,
+            recordDroppedEvent: (reason, category, count) => {
+                if (reason !== "network_error")
+                    record?.(reason, category, count);
+            },
+        });
+        let inFlight = 0;
+        return {
+            send(envelope) {
+                if (inFlight >= limit)
+                    return Promise.reject(new Error("[belvador] spool: send buffer full, kept on disk"));
+                inFlight++;
+                return Promise.resolve(transport.send(envelope)).then((r) => {
+                    inFlight--;
+                    return r;
+                }, (e) => {
+                    inFlight--;
+                    throw e;
+                });
+            },
+            flush: (timeout) => transport.flush(timeout),
+        };
+    };
+}
+/**
+ * Wraps a Sentry SDK transport so failed sends wait on disk:
+ *
+ *   import * as Sentry from "@sentry/node";
+ *   import { withSpool } from "@belvador/spool";
+ *   Sentry.init({ dsn: process.env.BELVADOR_DSN, transport: withSpool(Sentry.makeNodeTransport, { dir: "/var/lib/my-app/belvador" }) });
+ *
+ * Same as `makeOfflineTransport(base)` with `createStore: makeFileStore(options)` and
+ * `flushAtStartup: true`, plus: a burst larger than the engine's memory buffer goes to disk
+ * instead of being dropped, and a request the spool kept is not counted as lost.
+ */
+export function withSpool(base, options) {
+    const offline = makeOfflineTransport(underSpool(base));
+    const createStore = makeFileStore(options);
+    return (transportOptions) => offline({
+        ...transportOptions,
+        createStore: createStore,
+        flushAtStartup: true,
+    });
+}
+/**
+ * A plain `fetch` transport for runtimes whose Sentry SDK does not export one (`@sentry/deno`
+ * keeps its own private): `withSpool(makeFetchTransport, { dir })`. Node.js and Bun can use
+ * their SDK's `makeNodeTransport` / `makeFetchTransport` instead.
+ */
+export function makeFetchTransport(options) {
+    return createTransport(options, async (request) => {
+        const res = await fetch(options.url, {
+            method: "POST",
+            body: request.body,
+            referrerPolicy: "strict-origin",
+            ...(options.headers ? { headers: options.headers } : {}),
+        });
+        // Read the answer so the connection is released (Deno warns about unread bodies).
+        await res.arrayBuffer().catch(() => undefined);
+        return {
+            statusCode: res.status,
+            headers: {
+                "x-sentry-rate-limits": res.headers.get("X-Sentry-Rate-Limits"),
+                "retry-after": res.headers.get("Retry-After"),
+            },
+        };
+    });
+}

package/dist/store.d.ts

@@ -0,0 +1,37 @@
+import type { DataCategory, Envelope, EventDropReason } from "@sentry/core";
+export declare const SPOOL_DEFAULTS: {
+    readonly maxBytes: number;
+    readonly ttlHours: 72;
+    /** A claim or temp file older than this is abandoned, whatever its process (pid reuse after reboot). */
+    readonly abandonMs: number;
+    /** The size estimate is re-read from disk at least this often (other processes write too). */
+    readonly rescanMs: 30000;
+};
+export type FileStoreOptions = {
+    /** Directory for this app's envelopes; created with mode 0700. Use one per app, not per process. */
+    dir: string;
+    /** Total size on disk; the oldest envelopes go first. Default 64 MiB. */
+    maxBytes?: number;
+    /** Envelopes older than this are dropped instead of sent. Default 72 h. */
+    ttlHours?: number;
+    /** 32 random bytes of your own: envelopes are encrypted with AES-256-GCM. A wrong key length disables the store. */
+    key?: Uint8Array;
+};
+/** What the engine hands a store factory (`OfflineTransportOptions`), the part we use. */
+export type StoreTransportOptions = {
+    recordDroppedEvent?: (reason: EventDropReason, category: DataCategory, count?: number) => void;
+};
+/** The engine's `OfflineStore` (`@sentry/core` `makeOfflineTransport`). */
+export type OfflineStore = {
+    push(env: Envelope): Promise<void>;
+    unshift(env: Envelope): Promise<void>;
+    shift(): Promise<Envelope | undefined>;
+};
+/**
+ * `createStore` for `makeOfflineTransport` of `@sentry/node`, `@sentry/bun` or `@sentry/deno`:
+ *
+ *   transport: makeOfflineTransport(makeNodeTransport),
+ *   transportOptions: { createStore: makeFileStore({ dir: "/var/lib/my-app/belvador" }), flushAtStartup: true }
+ */
+export declare function makeFileStore(options: FileStoreOptions): (transport?: StoreTransportOptions) => OfflineStore;
+export declare function createFileStore(options: FileStoreOptions, transport: StoreTransportOptions): OfflineStore;

package/dist/store.js

@@ -0,0 +1,352 @@
+// A file store for the engine's offline transport (build 3.0 spec 12 §3): envelopes that could
+// not be sent are kept on disk and sent again later, within a size cap and a time limit. One
+// directory may be shared by several processes of the same app: writes are atomic (temp file +
+// rename), an envelope is claimed by renaming it before it is sent, and claims of a dead process
+// return to the queue. Never throws and never blocks the app: every failure is counted as a drop.
+import { constants } from "node:fs";
+import { chmod, mkdir, open, readdir, readFile, rename, rm, stat } from "node:fs/promises";
+import { createCipheriv, createDecipheriv, randomBytes } from "node:crypto";
+import { join } from "node:path";
+import * as process from "node:process";
+import { envelopeItemTypeToDataCategory, forEachEnvelopeItem, parseEnvelope, serializeEnvelope } from "@sentry/core";
+export const SPOOL_DEFAULTS = {
+    maxBytes: 64 * 1024 * 1024,
+    ttlHours: 72,
+    /** A claim or temp file older than this is abandoned, whatever its process (pid reuse after reboot). */
+    abandonMs: 10 * 60000,
+    /** The size estimate is re-read from disk at least this often (other processes write too). */
+    rescanMs: 30000,
+};
+const QUEUED = /^q-(\d{16})-[0-9a-f]{8}\.bls$/;
+const CLAIMED = /^c-(\d+)-(\d{16})-([0-9a-f]{8})\.bls$/;
+const TEMP = /^t-(\d+)-[0-9a-f]{8}\.tmp$/;
+const HEADER_MAX = 4096;
+const IV = 12;
+const TAG = 16;
+const enc = new TextEncoder();
+const dec = new TextDecoder();
+const rand8 = () => randomBytes(4).toString("hex");
+const pad16 = (n) => String(Math.max(0, Math.floor(n))).padStart(16, "0");
+function alive(pid) {
+    if (pid === process.pid)
+        return true;
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (e) {
+        // EPERM: it exists under another user. Anything else (ESRCH, unsupported): treat as gone
+        // only on ESRCH; otherwise rely on the age limit.
+        return e.code !== "ESRCH";
+    }
+}
+function categoriesOf(env) {
+    const out = [];
+    forEachEnvelopeItem(env, (_item, type) => {
+        if (type !== "client_report")
+            out.push(envelopeItemTypeToDataCategory(type));
+    });
+    return out;
+}
+/**
+ * `createStore` for `makeOfflineTransport` of `@sentry/node`, `@sentry/bun` or `@sentry/deno`:
+ *
+ *   transport: makeOfflineTransport(makeNodeTransport),
+ *   transportOptions: { createStore: makeFileStore({ dir: "/var/lib/my-app/belvador" }), flushAtStartup: true }
+ */
+export function makeFileStore(options) {
+    return (transport) => createFileStore(options, transport ?? {});
+}
+export function createFileStore(options, transport) {
+    const dir = String(options?.dir ?? "");
+    const maxBytes = Number.isFinite(options?.maxBytes) && options.maxBytes > 0 ? Math.floor(options.maxBytes) : SPOOL_DEFAULTS.maxBytes;
+    const ttlMs = (Number.isFinite(options?.ttlHours) && options.ttlHours > 0 ? options.ttlHours : SPOOL_DEFAULTS.ttlHours) *
+        3600000;
+    const key = options?.key;
+    const keyOk = key === undefined || (key instanceof Uint8Array && key.length === 32);
+    const record = (reason, cats) => {
+        try {
+            const counts = new Map();
+            for (const c of cats.length ? cats : ["error"])
+                counts.set(c, (counts.get(c) ?? 0) + 1);
+            for (const [c, n] of counts)
+                transport.recordDroppedEvent?.(reason, c, n);
+        }
+        catch {
+            /* the count is best effort */
+        }
+    };
+    let total = 0;
+    let scannedAt = 0;
+    let lastKey = 0;
+    let claim = null;
+    const created = new WeakMap();
+    const nextKey = () => {
+        lastKey = Math.max(lastKey + 1, Date.now() * 1000);
+        return lastKey;
+    };
+    function encode(env, createdAt) {
+        const raw = serializeEnvelope(env);
+        const body = typeof raw === "string" ? enc.encode(raw) : raw;
+        const header = { v: 1, c: createdAt, k: categoriesOf(env), e: key ? 1 : 0 };
+        const head = enc.encode(`${JSON.stringify(header)}\n`);
+        let payload = body;
+        if (key) {
+            const iv = randomBytes(IV);
+            const cipher = createCipheriv("aes-256-gcm", key, iv);
+            cipher.setAAD(head);
+            const ct = Buffer.concat([cipher.update(body), cipher.final()]);
+            payload = Buffer.concat([iv, ct, cipher.getAuthTag()]);
+        }
+        const out = new Uint8Array(head.length + payload.length);
+        out.set(head, 0);
+        out.set(payload, head.length);
+        return out;
+    }
+    function readHeader(bytes) {
+        const nl = bytes.subarray(0, HEADER_MAX).indexOf(10);
+        if (nl < 0)
+            return null;
+        try {
+            const h = JSON.parse(dec.decode(bytes.subarray(0, nl)));
+            if (h?.v !== 1 || typeof h.c !== "number" || !Array.isArray(h.k))
+                return null;
+            return { header: h, at: nl + 1 };
+        }
+        catch {
+            return null;
+        }
+    }
+    function decode(bytes) {
+        const parsed = readHeader(bytes);
+        if (!parsed)
+            return { header: null };
+        const { header, at } = parsed;
+        try {
+            let body = bytes.subarray(at);
+            if (header.e === 1) {
+                if (!key || body.length < IV + TAG)
+                    return { header };
+                const decipher = createDecipheriv("aes-256-gcm", key, body.subarray(0, IV));
+                decipher.setAAD(bytes.subarray(0, at));
+                decipher.setAuthTag(body.subarray(body.length - TAG));
+                body = Buffer.concat([decipher.update(body.subarray(IV, body.length - TAG)), decipher.final()]);
+            }
+            const env = parseEnvelope(body);
+            if (!Array.isArray(env) || env.length !== 2)
+                return { header };
+            return { env, header };
+        }
+        catch {
+            return { header };
+        }
+    }
+    async function headerCats(path) {
+        try {
+            const fh = await open(path, "r");
+            try {
+                const buf = new Uint8Array(HEADER_MAX);
+                const { bytesRead } = await fh.read(buf, 0, HEADER_MAX, 0);
+                return readHeader(buf.subarray(0, bytesRead))?.header.k ?? [];
+            }
+            finally {
+                await fh.close();
+            }
+        }
+        catch {
+            return [];
+        }
+    }
+    async function sizeOf(path) {
+        try {
+            return (await stat(path)).size;
+        }
+        catch {
+            return 0;
+        }
+    }
+    /** Queued names, oldest first, and the bytes of everything queued or claimed. */
+    async function scan() {
+        const names = await readdir(dir);
+        const queued = [];
+        let bytes = 0;
+        for (const n of names) {
+            if (QUEUED.test(n)) {
+                queued.push(n);
+                bytes += await sizeOf(join(dir, n));
+            }
+            else if (CLAIMED.test(n))
+                bytes += await sizeOf(join(dir, n));
+        }
+        queued.sort();
+        total = bytes;
+        scannedAt = Date.now();
+        return { queued, bytes };
+    }
+    async function prepare() {
+        if (!dir || !keyOk) {
+            if (!keyOk)
+                console.warn("[belvador] spool disabled: `key` must be 32 bytes");
+            return false;
+        }
+        await mkdir(dir, { recursive: true, mode: 0o700 });
+        await chmod(dir, 0o700).catch(() => { });
+        const now = Date.now();
+        for (const n of await readdir(dir)) {
+            const path = join(dir, n);
+            const t = TEMP.exec(n);
+            const c = CLAIMED.exec(n);
+            if (!t && !c)
+                continue;
+            const pid = Number((t ?? c)[1]);
+            let old = false;
+            try {
+                old = now - (await stat(path)).mtimeMs > SPOOL_DEFAULTS.abandonMs;
+            }
+            catch {
+                continue;
+            }
+            if (pid === process.pid || (!old && alive(pid)))
+                continue;
+            if (t) {
+                // Written halfway when its process died: never readable, counted once.
+                await rm(path, { force: true });
+                record("internal_sdk_error", ["error"]);
+            }
+            else {
+                // Claimed by a process that died mid-send: back to the queue (the node drops duplicates).
+                await rename(path, join(dir, `q-${c[2]}-${c[3]}.bls`)).catch(() => { });
+            }
+        }
+        await scan();
+        return true;
+    }
+    const ready = prepare().catch(() => false);
+    async function write(env, orderKey, createdAt) {
+        const bytes = encode(env, createdAt);
+        if (bytes.length > maxBytes) {
+            record("queue_overflow", categoriesOf(env));
+            return;
+        }
+        if (total + bytes.length > maxBytes || Date.now() - scannedAt > SPOOL_DEFAULTS.rescanMs) {
+            const { queued } = await scan();
+            for (const n of queued) {
+                if (total + bytes.length <= maxBytes)
+                    break;
+                const path = join(dir, n);
+                const size = await sizeOf(path);
+                const cats = await headerCats(path);
+                try {
+                    await rm(path);
+                    total -= size;
+                    record("queue_overflow", cats);
+                }
+                catch {
+                    /* taken by another process meanwhile */
+                }
+            }
+            if (total + bytes.length > maxBytes) {
+                record("queue_overflow", categoriesOf(env));
+                return;
+            }
+        }
+        const tmp = join(dir, `t-${process.pid}-${rand8()}.tmp`);
+        const fh = await open(tmp, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL, 0o600);
+        try {
+            await fh.writeFile(bytes);
+            await fh.sync();
+        }
+        finally {
+            await fh.close();
+        }
+        await rename(tmp, join(dir, `q-${pad16(orderKey)}-${rand8()}.bls`));
+        total += bytes.length;
+    }
+    /** The previous claim was not handed back (unshift): it was sent, so it goes. */
+    async function settleClaim() {
+        if (!claim)
+            return;
+        const c = claim;
+        claim = null;
+        await rm(c.path, { force: true }).catch(() => { });
+        total = Math.max(0, total - c.size);
+    }
+    return {
+        async push(env) {
+            try {
+                if (!(await ready))
+                    return record("internal_sdk_error", categoriesOf(env));
+                await write(env, nextKey(), Date.now());
+            }
+            catch {
+                record("internal_sdk_error", categoriesOf(env));
+            }
+        },
+        async unshift(env) {
+            try {
+                if (!(await ready))
+                    return record("internal_sdk_error", categoriesOf(env));
+                if (claim && claim.env === env) {
+                    // Same envelope back after a failed retry: keep its file and its place at the front.
+                    const c = claim;
+                    claim = null;
+                    await rename(c.path, join(dir, c.name));
+                    return;
+                }
+                const { queued } = await scan();
+                const first = queued[0] ? Number(QUEUED.exec(queued[0])[1]) : Date.now() * 1000;
+                await write(env, first - 1, created.get(env) ?? Date.now());
+            }
+            catch {
+                record("internal_sdk_error", categoriesOf(env));
+            }
+        },
+        async shift() {
+            try {
+                if (!(await ready))
+                    return undefined;
+                await settleClaim();
+                const { queued } = await scan();
+                for (const n of queued) {
+                    const m = QUEUED.exec(n);
+                    const from = join(dir, n);
+                    const name = `c-${process.pid}-${m[1]}-${n.slice(19, 27)}.bls`;
+                    const path = join(dir, name);
+                    try {
+                        await rename(from, path);
+                    }
+                    catch {
+                        continue; // another process claimed it first
+                    }
+                    let bytes;
+                    try {
+                        bytes = await readFile(path);
+                    }
+                    catch {
+                        continue;
+                    }
+                    const out = decode(bytes);
+                    if (!("env" in out)) {
+                        await rm(path, { force: true }).catch(() => { });
+                        total = Math.max(0, total - bytes.length);
+                        record("internal_sdk_error", out.header?.k ?? []);
+                        continue;
+                    }
+                    if (Date.now() - out.header.c > ttlMs) {
+                        await rm(path, { force: true }).catch(() => { });
+                        total = Math.max(0, total - bytes.length);
+                        record("network_error", out.header.k);
+                        continue;
+                    }
+                    created.set(out.env, out.header.c);
+                    claim = { path, name: n, size: bytes.length, env: out.env };
+                    return out.env;
+                }
+                return undefined;
+            }
+            catch {
+                return undefined;
+            }
+        },
+    };
+}

package/package.json

@@ -1,6 +1,50 @@
 {
   "name": "@belvador/spool",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.6.0",
+  "description": "Keeps errors on disk while Belvador cannot be reached, for Node.js, Bun and Deno servers using the open-source Sentry SDK: sent again when the network is back, within a size cap and a time limit.",
+  "license": "MIT",
+  "author": "Belvador (https://belvador.dev)",
+  "homepage": "https://belvador.dev/docs/sdk/offline",
+  "keywords": [
+    "belvador",
+    "error-tracking",
+    "errors",
+    "monitoring",
+    "sentry-compatible",
+    "offline",
+    "spool",
+    "nodejs",
+    "bun",
+    "deno"
+  ],
+  "type": "module",
+  "sideEffects": false,
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {
+    "@sentry/core": "10.76.2"
+  },
+  "publishConfig": {
+    "access": "public",
+    "tag": "latest"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json"
+  }
+}