@fallow-cli/beacon 0.1.0

package/dist/browser.js

@@ -0,0 +1,302 @@
+import { createRequire } from "node:module";
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/transport.ts
+var DEFAULT_FLUSH_INTERVAL_MS = 30000;
+var DEFAULT_MAX_QUEUE_SIZE = 1000;
+var DEFAULT_MAX_BATCH_SIZE = 100;
+var MAX_RETRIES = 5;
+var BASE_BACKOFF_MS = 3000;
+var MAX_BACKOFF_MS = 30 * 60 * 1000;
+var SERVERLESS_ENV_VARS = ["AWS_LAMBDA_FUNCTION_NAME", "VERCEL", "NETLIFY", "K_SERVICE"];
+var isServerless = () => SERVERLESS_ENV_VARS.some((v) => typeof process !== "undefined" && process.env[v]);
+var generatePayloadId = () => {
+  if (typeof crypto !== "undefined" && crypto.randomUUID) {
+    return crypto.randomUUID();
+  }
+  return `${Date.now()}-${Math.random().toString(36).slice(2, 11)}`;
+};
+var jitter = (ms) => ms + Math.random() * ms * 0.5;
+var backoffMs = (attempt) => Math.min(jitter(BASE_BACKOFF_MS * 2 ** attempt), MAX_BACKOFF_MS);
+var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+var unrefTimer = (timer) => {
+  if (typeof timer === "object" && "unref" in timer) {
+    timer.unref();
+  }
+};
+var createTransport = (config) => {
+  const queue = [];
+  const droppedReports = [];
+  let flushTimer = null;
+  let state = "active";
+  let retryAfterUntil = 0;
+  let retryCount = 0;
+  let destroyed = false;
+  const flushIntervalMs = config.flushIntervalMs ?? (isServerless() ? 0 : DEFAULT_FLUSH_INTERVAL_MS);
+  const maxQueueSize = config.maxQueueSize ?? DEFAULT_MAX_QUEUE_SIZE;
+  const maxBatchSize = config.maxBatchSize ?? DEFAULT_MAX_BATCH_SIZE;
+  const trackDrop = (reason, count) => {
+    const existing = droppedReports.find((r) => r.reason === reason);
+    if (existing) {
+      existing.droppedCount += count;
+    } else {
+      droppedReports.push({
+        reason,
+        droppedCount: count,
+        timestamp: new Date().toISOString()
+      });
+    }
+  };
+  const handleAuthError = (batchSize) => {
+    state = "shutdown";
+    trackDrop("auth_failure", batchSize);
+    config.onFallback?.();
+    return false;
+  };
+  const handleRateLimit = (response, batchSize) => {
+    const retryAfter = response.headers.get("Retry-After");
+    const waitMs = retryAfter ? Number.parseInt(retryAfter, 10) * 1000 : backoffMs(retryCount);
+    retryAfterUntil = Date.now() + waitMs;
+    state = "backoff";
+    retryCount++;
+    trackDrop("ratelimit_backoff", batchSize);
+    if (retryCount <= MAX_RETRIES) {
+      const timer = setTimeout(() => {
+        state = "active";
+      }, waitMs);
+      unrefTimer(timer);
+    } else {
+      state = "shutdown";
+      config.onFallback?.();
+    }
+    return false;
+  };
+  const retryWithBackoff = async (fn, batchSize) => {
+    if (retryCount >= MAX_RETRIES) {
+      trackDrop("network_error", batchSize);
+      retryCount = 0;
+      return false;
+    }
+    const waitMs = backoffMs(retryCount);
+    retryCount++;
+    state = "backoff";
+    await sleep(waitMs);
+    state = "active";
+    return fn();
+  };
+  const sendBatch = async (batch) => {
+    if (state === "shutdown" || destroyed)
+      return false;
+    if (Date.now() < retryAfterUntil) {
+      trackDrop("ratelimit_backoff", batch.length);
+      return false;
+    }
+    const body = JSON.stringify({
+      batch,
+      ...droppedReports.length > 0 ? { clientReports: droppedReports.splice(0) } : {}
+    });
+    try {
+      const response = await fetch(`${config.endpoint}/v1/ingest`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${config.apiKey}`
+        },
+        body
+      });
+      if (response.ok) {
+        retryCount = 0;
+        return true;
+      }
+      if (response.status === 401 || response.status === 403)
+        return handleAuthError(batch.length);
+      if (response.status === 429)
+        return handleRateLimit(response, batch.length);
+      return retryWithBackoff(() => sendBatch(batch), batch.length);
+    } catch {
+      return retryWithBackoff(() => sendBatch(batch), batch.length);
+    }
+  };
+  const flush = async () => {
+    if (queue.length === 0 || state === "shutdown" || destroyed)
+      return;
+    while (queue.length > 0) {
+      const batch = queue.splice(0, maxBatchSize);
+      const ok = await sendBatch(batch);
+      if (!ok) {
+        queue.unshift(...batch);
+        break;
+      }
+    }
+  };
+  const scheduleFlush = () => {
+    if (flushTimer !== null || flushIntervalMs === 0 || destroyed)
+      return;
+    flushTimer = setTimeout(() => {
+      flushTimer = null;
+      flush();
+      scheduleFlush();
+    }, flushIntervalMs);
+    unrefTimer(flushTimer);
+  };
+  const enqueue = (payload) => {
+    if (state === "shutdown" || destroyed)
+      return;
+    if (config.beforeSend) {
+      const transformed = config.beforeSend(payload);
+      if (transformed === null)
+        return;
+      queue.push(transformed);
+    } else {
+      queue.push(payload);
+    }
+    if (queue.length > maxQueueSize) {
+      const dropped = queue.splice(0, queue.length - maxQueueSize);
+      trackDrop("queue_overflow", dropped.length);
+    }
+    if (queue.length >= maxBatchSize || flushIntervalMs === 0) {
+      flush();
+    } else {
+      scheduleFlush();
+    }
+  };
+  const destroy = () => {
+    destroyed = true;
+    if (flushTimer !== null) {
+      clearTimeout(flushTimer);
+      flushTimer = null;
+    }
+  };
+  if (flushIntervalMs > 0) {
+    const initialDelay = Math.random() * flushIntervalMs;
+    const startTimer = setTimeout(() => {
+      scheduleFlush();
+    }, initialDelay);
+    unrefTimer(startTimer);
+  }
+  return {
+    enqueue,
+    flush,
+    destroy,
+    state: () => state,
+    pendingCount: () => queue.length
+  };
+};
+var sendBeaconFallback = (endpoint, payload) => {
+  if (typeof navigator === "undefined" || !navigator.sendBeacon)
+    return false;
+  const body = JSON.stringify({ batch: [payload] });
+  return navigator.sendBeacon(`${endpoint}/v1/ingest`, new Blob([body], { type: "application/json" }));
+};
+
+// src/browser.ts
+var shouldSample = (rate) => Math.random() < rate;
+var extractFromIstanbul = (coverageMap, config) => {
+  const functions = [];
+  const denyPaths = config.denyPaths ?? [/node_modules/, /\.test\./];
+  for (const [filePath, fileCoverage] of Object.entries(coverageMap)) {
+    if (denyPaths.some((re) => re.test(filePath)))
+      continue;
+    for (const [fnId, fnMeta] of Object.entries(fileCoverage.fnMap)) {
+      const hitCount = fileCoverage.f[fnId] ?? 0;
+      functions.push({
+        filePath,
+        functionName: fnMeta.name || `(anonymous@${filePath}:${fnMeta.loc.start.line})`,
+        lineNumber: fnMeta.loc.start.line,
+        hitCount,
+        trackingState: hitCount > 0 ? "called" : "never_called"
+      });
+    }
+  }
+  return functions;
+};
+var getIstanbulCoverage = () => {
+  if (typeof window === "undefined")
+    return null;
+  const cov = window.__coverage__;
+  return cov ?? null;
+};
+var createBrowserBeacon = (config) => {
+  let transport = null;
+  let started = false;
+  let sampled = false;
+  const enabled = config.enabled ?? true;
+  const sampleRate = config.sampleRate ?? 1;
+  const collectAndSend = (useBeaconApi) => {
+    if (!started || !sampled)
+      return;
+    const coverageMap = getIstanbulCoverage();
+    if (!coverageMap)
+      return;
+    const functions = extractFromIstanbul(coverageMap, config);
+    if (functions.length === 0)
+      return;
+    const payload = {
+      payloadId: generatePayloadId(),
+      projectId: config.projectId,
+      environment: config.environment,
+      commitSha: config.commitSha,
+      timestamp: new Date().toISOString(),
+      functions
+    };
+    if (useBeaconApi) {
+      sendBeaconFallback(config.endpoint, payload);
+    } else {
+      transport?.enqueue(payload);
+    }
+  };
+  const onVisibilityChange = () => {
+    if (document.visibilityState === "hidden") {
+      collectAndSend(true);
+    }
+  };
+  const onBeforeUnload = () => {
+    collectAndSend(true);
+  };
+  const start = () => {
+    if (!enabled || started)
+      return;
+    if (typeof window === "undefined")
+      return;
+    sampled = shouldSample(sampleRate);
+    if (!sampled)
+      return;
+    started = true;
+    transport = createTransport(config);
+    document.addEventListener("visibilitychange", onVisibilityChange);
+    window.addEventListener("beforeunload", onBeforeUnload);
+  };
+  const stop = () => {
+    if (!started)
+      return;
+    started = false;
+    document.removeEventListener("visibilitychange", onVisibilityChange);
+    window.removeEventListener("beforeunload", onBeforeUnload);
+    transport?.destroy();
+    transport = null;
+  };
+  const flush = async () => {
+    collectAndSend(false);
+    await transport?.flush();
+  };
+  return { start, stop, flush };
+};
+export {
+  createBrowserBeacon
+};

package/dist/node.js

@@ -0,0 +1,384 @@
+import { createRequire } from "node:module";
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/transport.ts
+var DEFAULT_FLUSH_INTERVAL_MS = 30000;
+var DEFAULT_MAX_QUEUE_SIZE = 1000;
+var DEFAULT_MAX_BATCH_SIZE = 100;
+var MAX_RETRIES = 5;
+var BASE_BACKOFF_MS = 3000;
+var MAX_BACKOFF_MS = 30 * 60 * 1000;
+var SERVERLESS_ENV_VARS = ["AWS_LAMBDA_FUNCTION_NAME", "VERCEL", "NETLIFY", "K_SERVICE"];
+var isServerless = () => SERVERLESS_ENV_VARS.some((v) => typeof process !== "undefined" && process.env[v]);
+var generatePayloadId = () => {
+  if (typeof crypto !== "undefined" && crypto.randomUUID) {
+    return crypto.randomUUID();
+  }
+  return `${Date.now()}-${Math.random().toString(36).slice(2, 11)}`;
+};
+var jitter = (ms) => ms + Math.random() * ms * 0.5;
+var backoffMs = (attempt) => Math.min(jitter(BASE_BACKOFF_MS * 2 ** attempt), MAX_BACKOFF_MS);
+var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+var unrefTimer = (timer) => {
+  if (typeof timer === "object" && "unref" in timer) {
+    timer.unref();
+  }
+};
+var createTransport = (config) => {
+  const queue = [];
+  const droppedReports = [];
+  let flushTimer = null;
+  let state = "active";
+  let retryAfterUntil = 0;
+  let retryCount = 0;
+  let destroyed = false;
+  const flushIntervalMs = config.flushIntervalMs ?? (isServerless() ? 0 : DEFAULT_FLUSH_INTERVAL_MS);
+  const maxQueueSize = config.maxQueueSize ?? DEFAULT_MAX_QUEUE_SIZE;
+  const maxBatchSize = config.maxBatchSize ?? DEFAULT_MAX_BATCH_SIZE;
+  const trackDrop = (reason, count) => {
+    const existing = droppedReports.find((r) => r.reason === reason);
+    if (existing) {
+      existing.droppedCount += count;
+    } else {
+      droppedReports.push({
+        reason,
+        droppedCount: count,
+        timestamp: new Date().toISOString()
+      });
+    }
+  };
+  const handleAuthError = (batchSize) => {
+    state = "shutdown";
+    trackDrop("auth_failure", batchSize);
+    config.onFallback?.();
+    return false;
+  };
+  const handleRateLimit = (response, batchSize) => {
+    const retryAfter = response.headers.get("Retry-After");
+    const waitMs = retryAfter ? Number.parseInt(retryAfter, 10) * 1000 : backoffMs(retryCount);
+    retryAfterUntil = Date.now() + waitMs;
+    state = "backoff";
+    retryCount++;
+    trackDrop("ratelimit_backoff", batchSize);
+    if (retryCount <= MAX_RETRIES) {
+      const timer = setTimeout(() => {
+        state = "active";
+      }, waitMs);
+      unrefTimer(timer);
+    } else {
+      state = "shutdown";
+      config.onFallback?.();
+    }
+    return false;
+  };
+  const retryWithBackoff = async (fn, batchSize) => {
+    if (retryCount >= MAX_RETRIES) {
+      trackDrop("network_error", batchSize);
+      retryCount = 0;
+      return false;
+    }
+    const waitMs = backoffMs(retryCount);
+    retryCount++;
+    state = "backoff";
+    await sleep(waitMs);
+    state = "active";
+    return fn();
+  };
+  const sendBatch = async (batch) => {
+    if (state === "shutdown" || destroyed)
+      return false;
+    if (Date.now() < retryAfterUntil) {
+      trackDrop("ratelimit_backoff", batch.length);
+      return false;
+    }
+    const body = JSON.stringify({
+      batch,
+      ...droppedReports.length > 0 ? { clientReports: droppedReports.splice(0) } : {}
+    });
+    try {
+      const response = await fetch(`${config.endpoint}/v1/ingest`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${config.apiKey}`
+        },
+        body
+      });
+      if (response.ok) {
+        retryCount = 0;
+        return true;
+      }
+      if (response.status === 401 || response.status === 403)
+        return handleAuthError(batch.length);
+      if (response.status === 429)
+        return handleRateLimit(response, batch.length);
+      return retryWithBackoff(() => sendBatch(batch), batch.length);
+    } catch {
+      return retryWithBackoff(() => sendBatch(batch), batch.length);
+    }
+  };
+  const flush = async () => {
+    if (queue.length === 0 || state === "shutdown" || destroyed)
+      return;
+    while (queue.length > 0) {
+      const batch = queue.splice(0, maxBatchSize);
+      const ok = await sendBatch(batch);
+      if (!ok) {
+        queue.unshift(...batch);
+        break;
+      }
+    }
+  };
+  const scheduleFlush = () => {
+    if (flushTimer !== null || flushIntervalMs === 0 || destroyed)
+      return;
+    flushTimer = setTimeout(() => {
+      flushTimer = null;
+      flush();
+      scheduleFlush();
+    }, flushIntervalMs);
+    unrefTimer(flushTimer);
+  };
+  const enqueue = (payload) => {
+    if (state === "shutdown" || destroyed)
+      return;
+    if (config.beforeSend) {
+      const transformed = config.beforeSend(payload);
+      if (transformed === null)
+        return;
+      queue.push(transformed);
+    } else {
+      queue.push(payload);
+    }
+    if (queue.length > maxQueueSize) {
+      const dropped = queue.splice(0, queue.length - maxQueueSize);
+      trackDrop("queue_overflow", dropped.length);
+    }
+    if (queue.length >= maxBatchSize || flushIntervalMs === 0) {
+      flush();
+    } else {
+      scheduleFlush();
+    }
+  };
+  const destroy = () => {
+    destroyed = true;
+    if (flushTimer !== null) {
+      clearTimeout(flushTimer);
+      flushTimer = null;
+    }
+  };
+  if (flushIntervalMs > 0) {
+    const initialDelay = Math.random() * flushIntervalMs;
+    const startTimer = setTimeout(() => {
+      scheduleFlush();
+    }, initialDelay);
+    unrefTimer(startTimer);
+  }
+  return {
+    enqueue,
+    flush,
+    destroy,
+    state: () => state,
+    pendingCount: () => queue.length
+  };
+};
+var sendBeaconFallback = (endpoint, payload) => {
+  if (typeof navigator === "undefined" || !navigator.sendBeacon)
+    return false;
+  const body = JSON.stringify({ batch: [payload] });
+  return navigator.sendBeacon(`${endpoint}/v1/ingest`, new Blob([body], { type: "application/json" }));
+};
+
+// src/node.ts
+var isTopLevelScript = (fn) => fn.functionName === "" && fn.ranges.length === 1 && fn.ranges[0]?.startOffset === 0;
+var normalizeUrl = (url) => url.startsWith("file://") ? url.slice(7) : url;
+var toFunctionCoverage = (entry, fn, filePath) => {
+  const hitCount = fn.ranges[0]?.count ?? 0;
+  return {
+    filePath,
+    functionName: fn.functionName || `(anonymous@${entry.url})`,
+    lineNumber: null,
+    hitCount,
+    trackingState: hitCount > 0 ? "called" : "never_called"
+  };
+};
+var shouldSkipEntry = (entry, denyPaths) => !entry.url || entry.url.startsWith("node:") || denyPaths.some((re) => re.test(entry.url));
+var extractFunctions = (entries, config) => {
+  const denyPaths = config.denyPaths ?? [/node_modules/, /\.test\./];
+  return entries.filter((entry) => !shouldSkipEntry(entry, denyPaths)).flatMap((entry) => {
+    const filePath = normalizeUrl(entry.url);
+    return entry.functions.filter((fn) => !isTopLevelScript(fn)).map((fn) => toFunctionCoverage(entry, fn, filePath));
+  });
+};
+var diffSnapshots = (previous, current) => {
+  const snapshot = new Map;
+  const incremental = [];
+  for (const fn of current) {
+    const key = `${fn.filePath}::${fn.functionName}`;
+    const prevCount = previous.get(key) ?? 0;
+    snapshot.set(key, fn.hitCount);
+    const diff = fn.hitCount - prevCount;
+    if (diff > 0) {
+      incremental.push({
+        ...fn,
+        hitCount: diff,
+        trackingState: "called"
+      });
+    } else if (prevCount === 0 && fn.hitCount === 0) {
+      incremental.push(fn);
+    }
+  }
+  return { incremental, snapshot };
+};
+var createNodeBeacon = (config) => {
+  let transport = null;
+  let snapshotTimer = null;
+  let previousSnapshot = new Map;
+  let isBaseline = true;
+  let started = false;
+  let coverageDir = null;
+  let beforeExitHandler = null;
+  const schedule = config.snapshotSchedule ?? "idle";
+  const enabled = config.enabled ?? true;
+  const takeSnapshot = async () => {
+    if (!transport || !started)
+      return;
+    try {
+      const v8 = await import("node:v8");
+      const fs = await import("node:fs");
+      const path = await import("node:path");
+      v8.takeCoverage();
+      if (!coverageDir)
+        return;
+      const files = fs.readdirSync(coverageDir).filter((f) => f.endsWith(".json"));
+      const allEntries = [];
+      for (const file of files) {
+        try {
+          const content = fs.readFileSync(path.join(coverageDir, file), "utf-8");
+          const parsed = JSON.parse(content);
+          allEntries.push(...parsed.result);
+        } catch {}
+      }
+      const functions = extractFunctions(allEntries, config);
+      const { incremental, snapshot } = diffSnapshots(previousSnapshot, functions);
+      previousSnapshot = snapshot;
+      if (isBaseline) {
+        isBaseline = false;
+        return;
+      }
+      if (incremental.length === 0)
+        return;
+      const payload = {
+        payloadId: generatePayloadId(),
+        projectId: config.projectId,
+        environment: config.environment,
+        commitSha: config.commitSha,
+        timestamp: new Date().toISOString(),
+        functions: incremental
+      };
+      transport.enqueue(payload);
+    } catch {}
+  };
+  const scheduleSnapshot = () => {
+    if (!started)
+      return;
+    switch (schedule) {
+      case "idle": {
+        const scheduleNext = () => {
+          if (!started)
+            return;
+          snapshotTimer = setTimeout(() => {
+            takeSnapshot().then(() => {
+              if (started)
+                scheduleNext();
+            });
+          }, 60000);
+          if (typeof snapshotTimer === "object" && "unref" in snapshotTimer) {
+            snapshotTimer.unref();
+          }
+        };
+        scheduleNext();
+        break;
+      }
+      case "interval": {
+        const intervalMs = config.flushIntervalMs ?? 30000;
+        const loop = () => {
+          if (!started)
+            return;
+          snapshotTimer = setTimeout(() => {
+            takeSnapshot().then(loop);
+          }, intervalMs);
+          if (typeof snapshotTimer === "object" && "unref" in snapshotTimer) {
+            snapshotTimer.unref();
+          }
+        };
+        loop();
+        break;
+      }
+      case "manual":
+        break;
+    }
+  };
+  const start = () => {
+    if (!enabled || started)
+      return;
+    started = true;
+    coverageDir = process.env.NODE_V8_COVERAGE ?? null;
+    if (!coverageDir) {
+      (async () => {
+        const os = await import("node:os");
+        const path = await import("node:path");
+        const fs = await import("node:fs");
+        coverageDir = path.join(os.tmpdir(), `fallow-v8-cov-${process.pid}`);
+        fs.mkdirSync(coverageDir, { recursive: true });
+        process.env.NODE_V8_COVERAGE = coverageDir;
+      })();
+    }
+    transport = createTransport(config);
+    takeSnapshot();
+    scheduleSnapshot();
+    beforeExitHandler = () => {
+      takeSnapshot().then(() => transport?.flush());
+    };
+    process.on("beforeExit", beforeExitHandler);
+  };
+  const stop = async () => {
+    started = false;
+    if (snapshotTimer !== null) {
+      clearTimeout(snapshotTimer);
+      snapshotTimer = null;
+    }
+    if (beforeExitHandler) {
+      process.off("beforeExit", beforeExitHandler);
+      beforeExitHandler = null;
+    }
+    await takeSnapshot();
+    await transport?.flush();
+    transport?.destroy();
+    transport = null;
+  };
+  const flush = async () => {
+    await takeSnapshot();
+    await transport?.flush();
+  };
+  return { start, stop, flush };
+};
+export {
+  createNodeBeacon
+};

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@fallow-cli/beacon",
+  "version": "0.1.0",
+  "description": "Lightweight production coverage beacon for fallow cloud",
+  "keywords": [
+    "coverage",
+    "dead-code",
+    "fallow",
+    "istanbul",
+    "v8"
+  ],
+  "license": "MIT",
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "main": "./dist/node.js",
+  "browser": "./dist/browser.js",
+  "types": "./dist/node.d.ts",
+  "exports": {
+    ".": {
+      "bun": "./src/node.ts",
+      "import": "./dist/node.js",
+      "types": "./dist/node.d.ts"
+    },
+    "./browser": {
+      "import": "./dist/browser.js",
+      "types": "./dist/browser.d.ts"
+    }
+  },
+  "scripts": {
+    "build": "bun build src/node.ts src/browser.ts --outdir dist --target node",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit"
+  },
+  "devDependencies": {
+    "typescript": "5.7.3",
+    "vitest": "3.1.1"
+  },
+  "peerDependencies": {}
+}