@burn0/burn0 0.1.0

package/dist/register.js

@@ -0,0 +1,864 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/config/env.ts
+function getApiKey() {
+  const key = process.env.BURN0_API_KEY;
+  return key && key.length > 0 ? key : void 0;
+}
+function detectMode(opts) {
+  const isTest = process.env.NODE_ENV === "test";
+  if (isTest) {
+    return process.env.BURN0_ENABLE_TEST === "1" ? "test-enabled" : "test-disabled";
+  }
+  if (opts.apiKey) {
+    return opts.isTTY ? "dev-cloud" : "prod-cloud";
+  }
+  return opts.isTTY ? "dev-local" : "prod-local";
+}
+function isTTY() {
+  return Boolean(process.stdout.isTTY);
+}
+function isDebug() {
+  return process.env.BURN0_DEBUG === "1" || process.env.BURN0_DEBUG === "true";
+}
+
+// src/interceptor/guard.ts
+var patched = false;
+function canPatch() {
+  return !patched;
+}
+function markPatched() {
+  patched = true;
+}
+function resetGuard() {
+  patched = false;
+}
+var KNOWN_SDK_MODULES = [
+  "openai",
+  "@anthropic-ai/sdk",
+  "@google/generative-ai",
+  "@mistralai/mistralai",
+  "cohere-ai",
+  "stripe",
+  "@sendgrid/mail",
+  "twilio",
+  "resend",
+  "@supabase/supabase-js"
+];
+function checkImportOrder() {
+  const preloaded2 = [];
+  if (typeof require !== "undefined" && require.cache) {
+    for (const sdk of KNOWN_SDK_MODULES) {
+      if (Object.keys(require.cache).some((k) => k.includes(`/node_modules/${sdk}/`))) {
+        preloaded2.push(sdk);
+      }
+    }
+  }
+  return preloaded2;
+}
+
+// src/services/map.ts
+var BUILT_IN_MAP = {
+  // LLMs
+  "api.openai.com": "openai",
+  "api.anthropic.com": "anthropic",
+  "generativelanguage.googleapis.com": "google-gemini",
+  "api.mistral.ai": "mistral",
+  "api.cohere.com": "cohere",
+  "api.groq.com": "groq",
+  "api.together.xyz": "together-ai",
+  "api.perplexity.ai": "perplexity",
+  "api.fireworks.ai": "fireworks-ai",
+  "api.deepseek.com": "deepseek",
+  "api.replicate.com": "replicate",
+  "api.ai21.com": "ai21",
+  // APIs
+  "api.stripe.com": "stripe",
+  "api.paypal.com": "paypal",
+  "api.sendgrid.com": "sendgrid",
+  "api.resend.com": "resend",
+  "api.postmarkapp.com": "postmark",
+  "api.mailgun.net": "mailgun",
+  "api.twilio.com": "twilio",
+  "api.vonage.com": "vonage",
+  "api.clerk.com": "clerk",
+  "api.cloudinary.com": "cloudinary",
+  "upload.uploadcare.com": "uploadcare",
+  "maps.googleapis.com": "google-maps",
+  "api.mapbox.com": "mapbox",
+  "api.segment.io": "segment",
+  "api.mixpanel.com": "mixpanel",
+  "api.github.com": "github-api",
+  "api.plaid.com": "plaid",
+  "api.pinecone.io": "pinecone",
+  "supabase.co": "supabase"
+};
+var IGNORED_PATTERNS = ["localhost", "127.0.0.1", "0.0.0.0", "[::1]"];
+var serviceMap = { ...BUILT_IN_MAP };
+function identifyService(hostname) {
+  if (IGNORED_PATTERNS.includes(hostname) || hostname.startsWith("localhost:")) {
+    return null;
+  }
+  if (serviceMap[hostname]) return serviceMap[hostname];
+  for (const [mapHost, service] of Object.entries(serviceMap)) {
+    if (hostname.endsWith("." + mapHost)) return service;
+  }
+  return `unknown:${hostname}`;
+}
+
+// src/types.ts
+var SCHEMA_VERSION = 1;
+
+// src/interceptor/stream.ts
+function teeReadableStream(stream) {
+  return stream.tee();
+}
+function extractUsageFromSSE(raw) {
+  const lines = raw.split("\n");
+  for (let i = lines.length - 1; i >= 0; i--) {
+    const line = lines[i];
+    if (!line.startsWith("data: ") || line === "data: [DONE]") continue;
+    try {
+      const parsed = JSON.parse(line.slice(6));
+      if (parsed.usage) return parsed.usage;
+    } catch {
+    }
+  }
+  return null;
+}
+async function collectStream(stream, timeoutMs = 3e4) {
+  const reader = stream.getReader();
+  const chunks = [];
+  const decoder = new TextDecoder();
+  const timeout = new Promise((_, reject) => {
+    setTimeout(() => reject(new Error("stream timeout")), timeoutMs);
+  });
+  try {
+    while (true) {
+      const result = await Promise.race([reader.read(), timeout]);
+      if (result.done) break;
+      chunks.push(decoder.decode(result.value, { stream: true }));
+    }
+  } catch {
+  } finally {
+    try {
+      reader.releaseLock();
+    } catch {
+    }
+  }
+  return chunks.join("");
+}
+
+// src/interceptor/fetch.ts
+var originalFetch = null;
+function patchFetch(onEvent) {
+  originalFetch = globalThis.fetch;
+  globalThis.fetch = async function burn0Fetch(input, init) {
+    const startTime = Date.now();
+    const url = new URL(typeof input === "string" ? input : input instanceof URL ? input.href : input.url);
+    const hostname = url.hostname;
+    const service = identifyService(hostname);
+    if (!service) {
+      return originalFetch(input, init);
+    }
+    let model;
+    if (init?.body && typeof init.body === "string") {
+      try {
+        const parsed = JSON.parse(init.body);
+        if (parsed.model) model = parsed.model;
+      } catch {
+      }
+    }
+    if (!model) {
+      const modelMatch = url.pathname.match(/\/models\/([^/:]+)/);
+      if (modelMatch) model = modelMatch[1];
+    }
+    const response = await originalFetch(input, init);
+    const duration = Date.now() - startTime;
+    let tokensIn;
+    let tokensOut;
+    if (response.headers.get("content-type")?.includes("text/event-stream") && response.body) {
+      const [forCaller, forBurn0] = teeReadableStream(response.body);
+      collectStream(forBurn0).then((raw) => {
+        const usage = extractUsageFromSSE(raw);
+        let sseTokensIn = usage?.prompt_tokens ?? usage?.input_tokens;
+        let sseTokensOut = usage?.completion_tokens ?? usage?.output_tokens;
+        if (sseTokensIn !== void 0 && sseTokensIn < 0) sseTokensIn = void 0;
+        if (sseTokensOut !== void 0 && sseTokensOut < 0) sseTokensOut = void 0;
+        const sseEvent = {
+          schema_version: SCHEMA_VERSION,
+          service,
+          endpoint: url.pathname,
+          model,
+          tokens_in: sseTokensIn,
+          tokens_out: sseTokensOut,
+          status_code: response.status,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          duration_ms: duration,
+          estimated: !usage
+        };
+        try {
+          onEvent(sseEvent);
+        } catch {
+        }
+      }).catch(() => {
+        const sseEvent = {
+          schema_version: SCHEMA_VERSION,
+          service,
+          endpoint: url.pathname,
+          model,
+          status_code: response.status,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          duration_ms: duration,
+          estimated: true
+        };
+        try {
+          onEvent(sseEvent);
+        } catch {
+        }
+      });
+      return new Response(forCaller, {
+        status: response.status,
+        statusText: response.statusText,
+        headers: response.headers
+      });
+    }
+    if (response.headers.get("content-type")?.includes("application/json")) {
+      try {
+        const cloned = response.clone();
+        const body = await cloned.json();
+        if (body.usage) {
+          tokensIn = body.usage.prompt_tokens ?? body.usage.input_tokens;
+          tokensOut = body.usage.completion_tokens ?? body.usage.output_tokens;
+        }
+        if (body.usageMetadata) {
+          tokensIn = body.usageMetadata.promptTokenCount;
+          tokensOut = body.usageMetadata.candidatesTokenCount;
+        }
+        if (body.model) model = body.model;
+      } catch {
+      }
+    }
+    if (tokensIn !== void 0 && tokensIn < 0) tokensIn = void 0;
+    if (tokensOut !== void 0 && tokensOut < 0) tokensOut = void 0;
+    const event = {
+      schema_version: SCHEMA_VERSION,
+      service,
+      endpoint: url.pathname,
+      model,
+      tokens_in: tokensIn,
+      tokens_out: tokensOut,
+      status_code: response.status,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      duration_ms: duration,
+      estimated: false
+    };
+    try {
+      onEvent(event);
+    } catch {
+    }
+    return response;
+  };
+}
+function unpatchFetch() {
+  if (originalFetch) {
+    globalThis.fetch = originalFetch;
+    originalFetch = null;
+  }
+}
+
+// src/interceptor/http.ts
+var import_node_http = __toESM(require("http"));
+var import_node_https = __toESM(require("https"));
+var originalHttpRequest = null;
+var originalHttpsRequest = null;
+var originalHttpGet = null;
+var originalHttpsGet = null;
+function wrapRequest(original, onEvent) {
+  return function burn0Request(...args) {
+    const req = original.apply(this, args);
+    const startTime = Date.now();
+    const firstArg = args[0];
+    let hostname = "";
+    let endpoint = "/";
+    if (typeof firstArg === "string") {
+      try {
+        const parsed = new URL(firstArg);
+        hostname = parsed.hostname;
+        endpoint = parsed.pathname;
+      } catch {
+      }
+    } else if (firstArg instanceof URL) {
+      hostname = firstArg.hostname;
+      endpoint = firstArg.pathname;
+    } else if (firstArg && typeof firstArg === "object") {
+      hostname = firstArg.hostname ?? firstArg.host ?? "";
+      endpoint = firstArg.path ?? "/";
+    }
+    const cleanHostname = hostname.replace(/:\d+$/, "");
+    const service = identifyService(cleanHostname);
+    if (!service) return req;
+    req.on("response", (res) => {
+      const isJson = res.headers["content-type"]?.includes("application/json");
+      const chunks = [];
+      const MAX_RESPONSE_SIZE = 5 * 1024 * 1024;
+      let totalSize = 0;
+      let tooLarge = false;
+      if (isJson) {
+        res.on("data", (chunk) => {
+          totalSize += chunk.length;
+          if (totalSize > MAX_RESPONSE_SIZE) {
+            tooLarge = true;
+            return;
+          }
+          chunks.push(chunk);
+        });
+      }
+      res.on("end", () => {
+        const duration = Date.now() - startTime;
+        let tokensIn;
+        let tokensOut;
+        let model;
+        if (isJson && chunks.length > 0 && !tooLarge) {
+          try {
+            const body = JSON.parse(Buffer.concat(chunks).toString());
+            if (body.usage) {
+              tokensIn = body.usage.prompt_tokens ?? body.usage.input_tokens;
+              tokensOut = body.usage.completion_tokens ?? body.usage.output_tokens;
+            }
+            if (body.model) model = body.model;
+          } catch {
+          }
+        }
+        if (tokensIn !== void 0 && tokensIn < 0) tokensIn = void 0;
+        if (tokensOut !== void 0 && tokensOut < 0) tokensOut = void 0;
+        const event = {
+          schema_version: SCHEMA_VERSION,
+          service,
+          endpoint: endpoint.toString(),
+          model,
+          tokens_in: tokensIn,
+          tokens_out: tokensOut,
+          status_code: res.statusCode ?? 0,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          duration_ms: duration,
+          estimated: false
+        };
+        try {
+          onEvent(event);
+        } catch {
+        }
+      });
+    });
+    return req;
+  };
+}
+function patchHttp(onEvent) {
+  originalHttpRequest = import_node_http.default.request;
+  originalHttpsRequest = import_node_https.default.request;
+  originalHttpGet = import_node_http.default.get;
+  originalHttpsGet = import_node_https.default.get;
+  import_node_http.default.request = wrapRequest(originalHttpRequest, onEvent);
+  import_node_https.default.request = wrapRequest(originalHttpsRequest, onEvent);
+  import_node_http.default.get = wrapRequest(originalHttpGet, onEvent);
+  import_node_https.default.get = wrapRequest(originalHttpsGet, onEvent);
+}
+function unpatchHttp() {
+  if (originalHttpRequest) {
+    import_node_http.default.request = originalHttpRequest;
+    originalHttpRequest = null;
+  }
+  if (originalHttpsRequest) {
+    import_node_https.default.request = originalHttpsRequest;
+    originalHttpsRequest = null;
+  }
+  if (originalHttpGet) {
+    import_node_http.default.get = originalHttpGet;
+    originalHttpGet = null;
+  }
+  if (originalHttpsGet) {
+    import_node_https.default.get = originalHttpsGet;
+    originalHttpsGet = null;
+  }
+}
+
+// src/track.ts
+var import_node_async_hooks = require("async_hooks");
+var storage = new import_node_async_hooks.AsyncLocalStorage();
+var activeSpan = null;
+function createTracker() {
+  async function track2(feature, metadata, fn) {
+    await storage.run({ feature, metadata }, fn);
+  }
+  function startSpan2(feature, metadata) {
+    activeSpan = { feature, metadata };
+    return {
+      end() {
+        activeSpan = null;
+      }
+    };
+  }
+  function enrichEvent2(event) {
+    const ctx = storage.getStore() ?? activeSpan;
+    if (!ctx) return event;
+    return {
+      ...event,
+      feature: ctx.feature,
+      metadata: ctx.metadata && Object.keys(ctx.metadata).length > 0 ? ctx.metadata : void 0
+    };
+  }
+  return { track: track2, startSpan: startSpan2, enrichEvent: enrichEvent2 };
+}
+
+// src/restore.ts
+function createRestorer(deps) {
+  return () => {
+    deps.unpatchFetch();
+    deps.unpatchHttp();
+    deps.resetGuard();
+  };
+}
+
+// src/transport/dispatcher.ts
+function createDispatcher(mode2, deps) {
+  return (event) => {
+    switch (mode2) {
+      case "dev-local":
+        deps.logEvent?.(event);
+        deps.writeLedger?.(event);
+        break;
+      case "dev-cloud":
+        deps.logEvent?.(event);
+        deps.addToBatch?.(event);
+        break;
+      case "prod-cloud":
+        deps.addToBatch?.(event);
+        break;
+      case "prod-local":
+        deps.accumulate?.(event);
+        break;
+      case "test-enabled":
+        deps.logEvent?.(event);
+        deps.writeLedger?.(event);
+        deps.addToBatch?.(event);
+        break;
+      case "test-disabled":
+        break;
+    }
+  };
+}
+
+// src/transport/batch.ts
+var BatchBuffer = class {
+  events = [];
+  timer = null;
+  options;
+  constructor(options) {
+    this.options = options;
+    this.timer = setInterval(() => {
+      if (this.events.length > 0) this.flush();
+    }, options.timeThresholdMs);
+    if (this.timer && typeof this.timer === "object" && "unref" in this.timer) {
+      this.timer.unref();
+    }
+  }
+  add(event) {
+    this.events.push(event);
+    if (this.events.length > this.options.maxSize) {
+      this.events = this.events.slice(-this.options.maxSize);
+    }
+    if (this.events.length >= this.options.sizeThreshold) {
+      this.flush();
+    }
+  }
+  flush() {
+    if (this.events.length === 0) return;
+    const batch2 = [...this.events];
+    this.events = [];
+    this.options.onFlush(batch2);
+  }
+  destroy() {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+  }
+};
+
+// src/transport/local.ts
+var import_node_fs = __toESM(require("fs"));
+var import_node_path = __toESM(require("path"));
+var BURN0_DIR = ".burn0";
+var LEDGER_FILE = "costs.jsonl";
+var MAX_FILE_SIZE = 10 * 1024 * 1024;
+var MAX_AGE_MS = 7 * 24 * 60 * 60 * 1e3;
+var LocalLedger = class {
+  filePath;
+  dirPath;
+  constructor(projectRoot) {
+    this.dirPath = import_node_path.default.join(projectRoot, BURN0_DIR);
+    this.filePath = import_node_path.default.join(this.dirPath, LEDGER_FILE);
+  }
+  write(event) {
+    this.ensureDir();
+    this.rotateIfNeeded();
+    import_node_fs.default.appendFileSync(this.filePath, JSON.stringify(event) + "\n");
+  }
+  read() {
+    try {
+      const content = import_node_fs.default.readFileSync(this.filePath, "utf-8").trim();
+      if (!content) return [];
+      return content.split("\n").map((line) => JSON.parse(line));
+    } catch {
+      return [];
+    }
+  }
+  ensureDir() {
+    if (!import_node_fs.default.existsSync(this.dirPath)) import_node_fs.default.mkdirSync(this.dirPath, { recursive: true });
+  }
+  rotateIfNeeded() {
+    try {
+      const stat = import_node_fs.default.statSync(this.filePath);
+      if (stat.size > MAX_FILE_SIZE) {
+        this.pruneOldEntries();
+        return;
+      }
+    } catch {
+      return;
+    }
+    const events = this.read();
+    if (events.length > 0) {
+      const oldest = new Date(events[0].timestamp).getTime();
+      if (Date.now() - oldest > MAX_AGE_MS) this.pruneOldEntries();
+    }
+  }
+  pruneOldEntries() {
+    const cutoff = Date.now() - MAX_AGE_MS;
+    const events = this.read().filter((e) => new Date(e.timestamp).getTime() > cutoff);
+    const content = events.map((e) => JSON.stringify(e)).join("\n") + (events.length ? "\n" : "");
+    import_node_fs.default.writeFileSync(this.filePath, content);
+  }
+};
+
+// src/transport/api.ts
+var SDK_VERSION = "0.1.0";
+async function shipEvents(events, apiKey2, baseUrl, fetchFn = globalThis.fetch) {
+  const maxAttempts = 3;
+  const baseDelayMs = 1e3;
+  const maxDelayMs = 5e3;
+  for (let attempt = 0; attempt < maxAttempts; attempt++) {
+    try {
+      const response = await fetchFn(`${baseUrl}/v1/events`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "Authorization": `Bearer ${apiKey2}`,
+          "X-Burn0-SDK-Version": SDK_VERSION
+        },
+        body: JSON.stringify({ events, sdk_version: SDK_VERSION })
+      });
+      if (response.ok) return true;
+    } catch (err) {
+      if (isDebug()) {
+        console.warn("[burn0] Event shipping failed:", err.message);
+      }
+    }
+    if (attempt < maxAttempts - 1) {
+      const delay = Math.min(baseDelayMs * Math.pow(2, attempt), maxDelayMs);
+      await new Promise((resolve) => setTimeout(resolve, delay));
+    }
+  }
+  return false;
+}
+
+// src/transport/local-pricing.ts
+var import_node_fs2 = __toESM(require("fs"));
+var import_node_path2 = __toESM(require("path"));
+var pricingData = null;
+var CACHE_FILE = ".burn0/pricing-cache.json";
+var CACHE_TTL_MS = 24 * 60 * 60 * 1e3;
+var FREE_SERVICES = /* @__PURE__ */ new Set([
+  "github-api",
+  "slack-api",
+  "discord-api"
+]);
+async function fetchPricing(apiUrl, fetchFn) {
+  try {
+    const cachePath = import_node_path2.default.join(process.cwd(), CACHE_FILE);
+    if (import_node_fs2.default.existsSync(cachePath)) {
+      const raw = import_node_fs2.default.readFileSync(cachePath, "utf-8");
+      const cached = JSON.parse(raw);
+      if (Date.now() - cached.cached_at < CACHE_TTL_MS) {
+        pricingData = cached;
+        return;
+      }
+    }
+  } catch {
+  }
+  try {
+    const response = await fetchFn(`${apiUrl}/v1/pricing`, {
+      headers: { "Accept": "application/json" }
+    });
+    if (response.ok) {
+      const data = await response.json();
+      pricingData = data;
+      try {
+        const dir = import_node_path2.default.join(process.cwd(), ".burn0");
+        if (!import_node_fs2.default.existsSync(dir)) import_node_fs2.default.mkdirSync(dir, { recursive: true });
+        import_node_fs2.default.writeFileSync(
+          import_node_path2.default.join(process.cwd(), CACHE_FILE),
+          JSON.stringify({ ...data, cached_at: Date.now() }, null, 2)
+        );
+      } catch {
+      }
+    }
+  } catch {
+  }
+}
+function estimateLocalCost(event) {
+  if (FREE_SERVICES.has(event.service)) {
+    return { type: "free" };
+  }
+  if (event.service.startsWith("unknown:")) {
+    return { type: "unknown" };
+  }
+  if (!pricingData) {
+    return { type: "loading" };
+  }
+  const svc = pricingData.services[event.service];
+  if (!svc) {
+    return { type: "unknown" };
+  }
+  if (svc.type === "llm") {
+    if (!event.model) return { type: "unknown" };
+    if (event.tokens_in === void 0 || event.tokens_out === void 0) {
+      return { type: "no-tokens" };
+    }
+    let prices = svc.models[event.model];
+    if (!prices) {
+      const match = Object.keys(svc.models).find((m) => event.model.startsWith(m));
+      if (match) prices = svc.models[match];
+    }
+    if (prices) {
+      const inputCost = event.tokens_in / 1e6 * prices[0];
+      const outputCost = event.tokens_out / 1e6 * prices[1];
+      return { type: "priced", cost: inputCost + outputCost };
+    }
+    return { type: "unknown" };
+  }
+  if (svc.type === "api") {
+    const endpoint = event.endpoint ?? "";
+    for (const [prefix, cost] of Object.entries(svc.endpoints)) {
+      if (prefix !== "*" && endpoint.startsWith(prefix)) {
+        return cost === 0 ? { type: "free" } : { type: "priced", cost };
+      }
+    }
+    const defaultCost = svc.endpoints["*"];
+    if (defaultCost !== void 0) {
+      return defaultCost === 0 ? { type: "free" } : { type: "priced", cost: defaultCost };
+    }
+    return { type: "unknown" };
+  }
+  if (svc.type === "fixed") {
+    return { type: "fixed-tier" };
+  }
+  return { type: "unknown" };
+}
+
+// src/transport/logger.ts
+var DIM = "\x1B[2m";
+var RESET = "\x1B[0m";
+var CYAN = "\x1B[36m";
+var GREEN = "\x1B[32m";
+var YELLOW = "\x1B[33m";
+var WHITE = "\x1B[37m";
+var BOLD = "\x1B[1m";
+var ORANGE = "\x1B[38;2;250;93;25m";
+var GRAY = "\x1B[90m";
+var headerPrinted = false;
+var sessionTotal = 0;
+var eventCount = 0;
+function formatTokens(count) {
+  if (count >= 1e6) return `${(count / 1e6).toFixed(1)}M`;
+  if (count >= 1e3) return `${(count / 1e3).toFixed(1)}K`;
+  return count.toString();
+}
+function formatCost(cost) {
+  if (cost >= 1) return `$${cost.toFixed(2)}`;
+  if (cost >= 0.01) return `$${cost.toFixed(4)}`;
+  return `$${cost.toFixed(6)}`;
+}
+function formatCostEstimate(estimate) {
+  switch (estimate.type) {
+    case "priced":
+      return `${GREEN}${formatCost(estimate.cost)}${RESET}`;
+    case "free":
+      return `${GRAY}free${RESET}`;
+    case "no-tokens":
+      return `${YELLOW}no usage${RESET}`;
+    case "fixed-tier":
+      return `${YELLOW}plan?${RESET}`;
+    case "unknown":
+      return `${GRAY}untracked${RESET}`;
+    case "loading":
+      return `${GRAY}...${RESET}`;
+  }
+}
+function printHeader() {
+  if (headerPrinted) return;
+  headerPrinted = true;
+  process.stdout.write(`
+`);
+  process.stdout.write(`  ${ORANGE}${BOLD} burn0 ${RESET} ${DIM}live cost tracking${RESET}
+`);
+  process.stdout.write(`
+`);
+  process.stdout.write(`  ${GRAY}SERVICE          ENDPOINT / MODEL              USAGE          COST${RESET}
+`);
+  process.stdout.write(`  ${GRAY}${"\u2500".repeat(68)}${RESET}
+`);
+}
+function printSessionTotal() {
+  process.stdout.write(`  ${GRAY}${"\u2500".repeat(68)}${RESET}
+`);
+  if (sessionTotal > 0) {
+    process.stdout.write(`  ${GRAY}${eventCount} calls${RESET}                                              ${ORANGE}${BOLD}${formatCost(sessionTotal)}${RESET}
+`);
+  } else {
+    process.stdout.write(`  ${GRAY}${eventCount} calls${RESET}                                              ${GRAY}$0${RESET}
+`);
+  }
+  process.stdout.write(`  ${GRAY}${"\u2500".repeat(68)}${RESET}
+`);
+}
+function formatEventLine(event) {
+  const service = event.service.length > 15 ? event.service.substring(0, 14) + "." : event.service;
+  const modelOrEndpoint = event.model ? event.model.length > 29 ? event.model.substring(0, 28) + "." : event.model : event.endpoint.length > 29 ? event.endpoint.substring(0, 28) + "." : event.endpoint;
+  let usage = "";
+  if (event.tokens_in !== void 0 && event.tokens_out !== void 0) {
+    usage = `${formatTokens(event.tokens_in)} \u2192 ${formatTokens(event.tokens_out)}`;
+  }
+  const estimate = estimateLocalCost(event);
+  const costStr = formatCostEstimate(estimate);
+  return `  ${CYAN}${service.padEnd(16)}${RESET} ${WHITE}${modelOrEndpoint.padEnd(30)}${RESET}${GRAY}${usage.padEnd(15)}${RESET}${costStr}`;
+}
+function formatProcessSummary(events, uptimeSeconds) {
+  const services = {};
+  for (const event of events) {
+    if (!services[event.service]) services[event.service] = { calls: 0 };
+    services[event.service].calls++;
+    if (event.tokens_in !== void 0) services[event.service].tokens_in = (services[event.service].tokens_in ?? 0) + event.tokens_in;
+    if (event.tokens_out !== void 0) services[event.service].tokens_out = (services[event.service].tokens_out ?? 0) + event.tokens_out;
+  }
+  for (const svc of Object.values(services)) {
+    if (svc.tokens_in === void 0) delete svc.tokens_in;
+    if (svc.tokens_out === void 0) delete svc.tokens_out;
+  }
+  return JSON.stringify({
+    burn0: "process-summary",
+    uptime_hours: +(uptimeSeconds / 3600).toFixed(1),
+    total_calls: events.length,
+    services,
+    message: "Add BURN0_API_KEY to see cost breakdowns \u2192 burn0.dev"
+  });
+}
+function logEvent(event) {
+  printHeader();
+  const estimate = estimateLocalCost(event);
+  if (estimate.type === "priced" && estimate.cost > 0) {
+    sessionTotal += estimate.cost;
+  }
+  eventCount++;
+  process.stdout.write(`${formatEventLine(event)}
+`);
+  if (eventCount % 5 === 0) {
+    printSessionTotal();
+  }
+}
+
+// src/index.ts
+var BURN0_API_URL = process.env.BURN0_API_URL ?? "https://api.burn0.dev";
+var apiKey = getApiKey();
+var mode = detectMode({ isTTY: isTTY(), apiKey });
+var { track, startSpan, enrichEvent } = createTracker();
+var originalFetch2 = globalThis.fetch;
+if (mode !== "test-disabled") {
+  fetchPricing(BURN0_API_URL, originalFetch2).catch(() => {
+  });
+}
+var accumulatedEvents = [];
+var ledger = mode === "dev-local" || mode === "test-enabled" ? new LocalLedger(process.cwd()) : null;
+var batch = null;
+if ((mode === "dev-cloud" || mode === "prod-cloud") && apiKey) {
+  batch = new BatchBuffer({
+    sizeThreshold: 50,
+    timeThresholdMs: 1e4,
+    maxSize: 500,
+    onFlush: (events) => {
+      shipEvents(events, apiKey, BURN0_API_URL, originalFetch2).catch(() => {
+      });
+    }
+  });
+}
+var dispatch = createDispatcher(mode, {
+  logEvent,
+  writeLedger: ledger ? (e) => ledger.write(e) : void 0,
+  addToBatch: batch ? (e) => batch.add(e) : void 0,
+  accumulate: (e) => accumulatedEvents.push(e)
+});
+var preloaded = checkImportOrder();
+if (preloaded.length > 0) {
+  console.warn(`[burn0] Warning: These SDKs were imported before burn0 and may not be tracked: ${preloaded.join(", ")}. Move \`import 'burn0'\` to the top of your entry file.`);
+}
+if (canPatch() && mode !== "test-disabled") {
+  const onEvent = (event) => {
+    const enriched = enrichEvent(event);
+    dispatch(enriched);
+  };
+  patchFetch(onEvent);
+  patchHttp(onEvent);
+  markPatched();
+}
+if (mode === "prod-local") {
+  const startTime = Date.now();
+  process.on("beforeExit", () => {
+    if (accumulatedEvents.length > 0) {
+      const uptimeSeconds = (Date.now() - startTime) / 1e3;
+      console.log(formatProcessSummary(accumulatedEvents, uptimeSeconds));
+    }
+  });
+}
+if (batch) {
+  const exitFlush = () => {
+    batch.flush();
+    batch.destroy();
+  };
+  process.on("beforeExit", exitFlush);
+  process.on("SIGTERM", exitFlush);
+  process.on("SIGINT", exitFlush);
+  process.on("SIGHUP", exitFlush);
+}
+var restore = createRestorer({ unpatchFetch, unpatchHttp, resetGuard });
+//# sourceMappingURL=register.js.map