@tillstack/electron 0.1.0

package/README.md

@@ -0,0 +1,48 @@
+# @tillstack/electron
+
+TillPulse observability for Electron desktop apps. Covers the surfaces a web
+error tracker can't reach: main-process crashes, native C++/V8 minidumps,
+renderer/GPU/child-process failures, and app hangs.
+
+```bash
+npm install @tillstack/electron
+```
+
+In your **main process**:
+
+```ts
+import { TillPulse } from '@tillstack/electron'
+
+TillPulse.init({
+  dsn: 'https://<public-key>@ingest.tilldev.dev/<project-id>',
+  release: app.getVersion(),
+  environment: 'production',
+})
+```
+
+In each **renderer**, use [`@tillstack/browser`](../sdk-browser) — the renderer
+is a Chromium page, so it gets the full web treatment (errors, Web Vitals,
+network, breadcrumbs) with the same DSN.
+
+The main-process SDK captures:
+
+| Signal | Source |
+|---|---|
+| Main-process crashes | `uncaughtException`, `unhandledRejection` (stack-parsed) |
+| Native crashes | Electron `crashReporter` minidumps (C++/V8 faults the JS layer can't catch) |
+| Renderer/GPU/child gone | `render-process-gone`, `child-process-gone` (reason → crashed/oom) |
+| App hangs | renderer `unresponsive`/`responsive` → duration-tagged hang events |
+| Crash-free sessions | `session` on ready, `crashed` on an uncaught exception, `exited` on quit |
+| Desktop context | OS + arch + RAM, Electron/Chrome/Node/V8 versions |
+
+Events are **PII-scrubbed on-device** and buffered in a **file-backed queue** in
+`userData` — so the report explaining a crash survives the restart after it.
+Native minidump upload is opt-in (`uploadMinidumps: true`); by default dumps are
+kept locally and a metadata event is sent.
+
+## Options
+
+`dsn`, `release` required. Toggles (default on): `enableNativeCrashReporter`,
+`enableProcessMonitoring`, `enableHangDetection`, `enableSessionTracking`. Also
+`uploadMinidumps`, `environment`, `dist`, `disableDefaultPiiScrubbing`,
+`beforeSend`, `initialTags`, `flushIntervalMs`, `debug`.

package/dist/index.d.mts

@@ -0,0 +1,77 @@
+import { TillPulseEvent, Severity, BreadcrumbType, Breadcrumb } from '@tillstack/types';
+export { TillPulseEvent } from '@tillstack/types';
+
+interface TillPulseElectronOptions {
+    dsn: string;
+    release: string;
+    environment?: string;
+    dist?: string;
+    /** Start Electron's native crashReporter (writes minidumps for C++/V8 crashes the JS layer can't catch). Default true. */
+    enableNativeCrashReporter?: boolean;
+    /** Upload native minidumps to `<dsn-host>/api/v1/minidump`. Default false (dumps kept locally + a metadata event is sent). */
+    uploadMinidumps?: boolean;
+    /** Capture renderer/GPU/child-process-gone as crashes. Default true. */
+    enableProcessMonitoring?: boolean;
+    /** Treat renderer `unresponsive` as an app-hang event. Default true. */
+    enableHangDetection?: boolean;
+    /** Emit session events for crash-free sessions. Default true. */
+    enableSessionTracking?: boolean;
+    /** Opt in to TillShield desktop threat detection (DevTools-open on renderers). Off by default. */
+    enableThreatDetection?: boolean;
+    disableDefaultPiiScrubbing?: boolean;
+    beforeSend?: (e: TillPulseEvent) => TillPulseEvent | null | Promise<TillPulseEvent | null>;
+    initialTags?: Record<string, string>;
+    flushIntervalMs?: number;
+    debug?: boolean;
+}
+declare class TillPulseElectronSDK {
+    private opts;
+    private queue;
+    private endpoint;
+    private sessionId;
+    private timer;
+    private initialized;
+    private crumbs;
+    private tags;
+    private user;
+    private sessionStartedAt;
+    private sessionEnded;
+    init(options: TillPulseElectronOptions): void;
+    captureException(error: unknown): void;
+    captureMessage(message: string, level?: Severity): void;
+    captureSecurityEvent(input: {
+        securityType: string;
+        severity?: Severity;
+        confidence?: number;
+        evidence?: Record<string, unknown>;
+        message?: string;
+    }): void;
+    addBreadcrumb(input: {
+        type: BreadcrumbType;
+        category: string;
+        message: string;
+        level?: Breadcrumb['level'];
+        data?: Record<string, unknown>;
+    }): void;
+    setUser(user: {
+        id?: string;
+        segment?: string;
+    } | null): void;
+    setTag(key: string, value: string): void;
+    getQueueStats(): {
+        size: number;
+    };
+    flush(useKeepalive?: boolean): Promise<boolean>;
+    close(): void;
+    private _device;
+    private _base;
+    private _captureError;
+    private _captureSynthetic;
+    private _startSession;
+    private _markSession;
+    private _emitSession;
+    private _enqueue;
+}
+declare const TillPulse: TillPulseElectronSDK;
+
+export { TillPulse, type TillPulseElectronOptions, TillPulse as default };

package/dist/index.d.ts

@@ -0,0 +1,77 @@
+import { TillPulseEvent, Severity, BreadcrumbType, Breadcrumb } from '@tillstack/types';
+export { TillPulseEvent } from '@tillstack/types';
+
+interface TillPulseElectronOptions {
+    dsn: string;
+    release: string;
+    environment?: string;
+    dist?: string;
+    /** Start Electron's native crashReporter (writes minidumps for C++/V8 crashes the JS layer can't catch). Default true. */
+    enableNativeCrashReporter?: boolean;
+    /** Upload native minidumps to `<dsn-host>/api/v1/minidump`. Default false (dumps kept locally + a metadata event is sent). */
+    uploadMinidumps?: boolean;
+    /** Capture renderer/GPU/child-process-gone as crashes. Default true. */
+    enableProcessMonitoring?: boolean;
+    /** Treat renderer `unresponsive` as an app-hang event. Default true. */
+    enableHangDetection?: boolean;
+    /** Emit session events for crash-free sessions. Default true. */
+    enableSessionTracking?: boolean;
+    /** Opt in to TillShield desktop threat detection (DevTools-open on renderers). Off by default. */
+    enableThreatDetection?: boolean;
+    disableDefaultPiiScrubbing?: boolean;
+    beforeSend?: (e: TillPulseEvent) => TillPulseEvent | null | Promise<TillPulseEvent | null>;
+    initialTags?: Record<string, string>;
+    flushIntervalMs?: number;
+    debug?: boolean;
+}
+declare class TillPulseElectronSDK {
+    private opts;
+    private queue;
+    private endpoint;
+    private sessionId;
+    private timer;
+    private initialized;
+    private crumbs;
+    private tags;
+    private user;
+    private sessionStartedAt;
+    private sessionEnded;
+    init(options: TillPulseElectronOptions): void;
+    captureException(error: unknown): void;
+    captureMessage(message: string, level?: Severity): void;
+    captureSecurityEvent(input: {
+        securityType: string;
+        severity?: Severity;
+        confidence?: number;
+        evidence?: Record<string, unknown>;
+        message?: string;
+    }): void;
+    addBreadcrumb(input: {
+        type: BreadcrumbType;
+        category: string;
+        message: string;
+        level?: Breadcrumb['level'];
+        data?: Record<string, unknown>;
+    }): void;
+    setUser(user: {
+        id?: string;
+        segment?: string;
+    } | null): void;
+    setTag(key: string, value: string): void;
+    getQueueStats(): {
+        size: number;
+    };
+    flush(useKeepalive?: boolean): Promise<boolean>;
+    close(): void;
+    private _device;
+    private _base;
+    private _captureError;
+    private _captureSynthetic;
+    private _startSession;
+    private _markSession;
+    private _emitSession;
+    private _enqueue;
+}
+declare const TillPulse: TillPulseElectronSDK;
+
+export { TillPulse, type TillPulseElectronOptions, TillPulse as default };

package/dist/index.js

@@ -0,0 +1,492 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var electron = require('electron');
+var os = require('os');
+var fs = require('fs');
+var path = require('path');
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var os__namespace = /*#__PURE__*/_interopNamespace(os);
+var fs__namespace = /*#__PURE__*/_interopNamespace(fs);
+var path__namespace = /*#__PURE__*/_interopNamespace(path);
+
+// src/index.ts
+
+// src/scrub.ts
+var SCRUB_RULES = [
+  { pattern: /\bAKIA[0-9A-Z]{16}\b/g, replacement: "[aws_key]" },
+  { pattern: /(?:aws_secret|secret_access_key|AWS_SECRET)[^A-Za-z0-9+/]*([A-Za-z0-9+/]{40})\b/gi, replacement: "[aws_secret]" },
+  { pattern: /\bAIza[0-9A-Za-z_-]{35}\b/g, replacement: "[gcp_key]" },
+  { pattern: /\b(?:ghp|gho|ghs|ghr)_[A-Za-z0-9]{36,}\b/g, replacement: "[github_token]" },
+  { pattern: /\bgithub_pat_[A-Za-z0-9_]{82}\b/g, replacement: "[github_token]" },
+  { pattern: /\bxox[baprs]-[A-Za-z0-9-]{10,}\b/g, replacement: "[slack_token]" },
+  { pattern: /\bxapp-\d-[A-Za-z0-9-]{10,}\b/g, replacement: "[slack_token]" },
+  { pattern: /\beyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+/g, replacement: "[jwt]" },
+  { pattern: /Bearer\s+[A-Za-z0-9\-._~+/]+=*/gi, replacement: "Bearer [token]" },
+  { pattern: /\b(?:sk|pk|ak|rk)_(?:live|test)_[A-Za-z0-9]{16,}\b/g, replacement: "[apikey]" },
+  { pattern: /\b[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}\b/g, replacement: "[email]" },
+  { pattern: /\b[A-Z0-9]{10}\b(?=\s*confirmed|\s*transaction|\s*M-?Pesa)/gi, replacement: "[mpesa_tx]" },
+  { pattern: /\b(?:\d[ -]*?){13,19}\b/g, replacement: "[card]" },
+  { pattern: /\b\d{13}\b/g, replacement: "[id_number]" },
+  { pattern: /\b\d{11}\b/g, replacement: "[id_number]" },
+  { pattern: /\+?\d{1,3}[\s.-]?\(?\d{2,4}\)?[\s.-]?\d{3,4}[\s.-]?\d{3,4}\b/g, replacement: "[phone]" },
+  { pattern: /\b(?:\d{1,3}\.){3}\d{1,3}\b/g, replacement: "[ip]" }
+];
+var SENSITIVE_KEY = /^(?:password|passwd|pwd|secret|client[_-]?secret|token|access[_-]?token|refresh[_-]?token|id[_-]?token|api[_-]?key|apikey|authorization|auth|session|cookie|set[_-]?cookie|private[_-]?key|credit[_-]?card|card[_-]?number|cvv|cvc|ssn|pin|otp|mfa|totp)$/i;
+var MAX_REDACT_DEPTH = 24;
+function redactByKey(value, depth = 0) {
+  if (depth > MAX_REDACT_DEPTH || value === null || typeof value !== "object") return value;
+  if (Array.isArray(value)) return value.map((v) => redactByKey(v, depth + 1));
+  const out = {};
+  for (const [k, v] of Object.entries(value)) {
+    out[k] = SENSITIVE_KEY.test(k) ? "[redacted]" : redactByKey(v, depth + 1);
+  }
+  return out;
+}
+function scrubEvent(event) {
+  try {
+    let json = JSON.stringify(redactByKey(event));
+    for (const { pattern, replacement } of SCRUB_RULES) json = json.replace(pattern, replacement);
+    return JSON.parse(json);
+  } catch {
+    return event;
+  }
+}
+
+// src/index.ts
+var SDK_NAME = "@tillstack/electron";
+var SDK_VERSION = "0.1.0";
+function parseDsn(dsn) {
+  const m = dsn.match(/^(https?):\/\/([^@]+)@([^/]+)\/(.+)$/);
+  if (!m) throw new Error(`TillPulse: invalid DSN: ${dsn}`);
+  const scheme = m[1];
+  const host = m[3];
+  const local = /^(localhost|127\.0\.0\.1|::1)(:\d+)?$/i.test(host);
+  if (scheme !== "https" && !local) {
+    throw new Error("TillPulse: DSN must use https:// (refusing to send telemetry over cleartext http)");
+  }
+  return { scheme, host };
+}
+function generateId() {
+  return `${Date.now().toString(36)}${Math.random().toString(36).slice(2, 12)}`;
+}
+var FileQueue = class {
+  constructor(dir) {
+    this.items = [];
+    this.max = 500;
+    this.file = path__namespace.join(dir, "tillpulse-queue.json");
+    try {
+      if (fs__namespace.existsSync(this.file)) {
+        const parsed = JSON.parse(fs__namespace.readFileSync(this.file, "utf8"));
+        if (Array.isArray(parsed)) this.items = parsed;
+      }
+    } catch {
+    }
+  }
+  persist() {
+    try {
+      fs__namespace.writeFileSync(this.file, JSON.stringify(this.items));
+    } catch {
+    }
+  }
+  enqueue(id, eventType, obj) {
+    let payload;
+    try {
+      payload = JSON.stringify(obj);
+    } catch {
+      return;
+    }
+    this.items.push({ id, event_type: eventType, payload, attempts: 0, next: 0 });
+    if (this.items.length > this.max) this.items = this.items.slice(this.items.length - this.max);
+    this.persist();
+  }
+  due(limit) {
+    const now = Date.now();
+    return this.items.filter((i) => i.next <= now).slice(0, limit);
+  }
+  ackOk(ids) {
+    const s = new Set(ids);
+    this.items = this.items.filter((i) => !s.has(i.id));
+    this.persist();
+  }
+  ackFail(ids) {
+    const s = new Set(ids);
+    const now = Date.now();
+    for (const i of this.items) {
+      if (!s.has(i.id)) continue;
+      i.attempts += 1;
+      i.next = now + Math.min(2e3 * 2 ** (i.attempts - 1), 5 * 6e4);
+    }
+    this.items = this.items.filter((i) => i.attempts <= 10);
+    this.persist();
+  }
+  size() {
+    return this.items.length;
+  }
+};
+function osName() {
+  if (process.platform === "darwin") return "macOS";
+  if (process.platform === "win32") return "Windows";
+  return "Linux";
+}
+var TillPulseElectronSDK = class {
+  constructor() {
+    this.opts = null;
+    this.queue = null;
+    this.endpoint = "";
+    this.sessionId = generateId();
+    this.timer = null;
+    this.initialized = false;
+    this.crumbs = [];
+    this.tags = {};
+    this.user = null;
+    this.sessionStartedAt = 0;
+    this.sessionEnded = false;
+  }
+  init(options) {
+    if (this.initialized) return;
+    let host;
+    let scheme;
+    try {
+      ;
+      ({ host, scheme } = parseDsn(options.dsn));
+    } catch (err) {
+      if (options.debug) console.error("[TillPulse]", err);
+      return;
+    }
+    this.initialized = true;
+    this.opts = options;
+    this.endpoint = `${scheme}://${host}/api/v1/envelope`;
+    this.tags = { ...options.initialTags };
+    let dir = ".";
+    try {
+      dir = electron.app.getPath("userData");
+    } catch {
+    }
+    this.queue = new FileQueue(dir);
+    if (options.enableNativeCrashReporter !== false) {
+      try {
+        electron.crashReporter.start({
+          productName: (() => {
+            try {
+              return electron.app.getName();
+            } catch {
+              return "app";
+            }
+          })(),
+          submitURL: options.uploadMinidumps ? `${scheme}://${host}/api/v1/minidump` : void 0,
+          uploadToServer: options.uploadMinidumps === true,
+          compress: true,
+          globalExtra: { tp_release: options.release, tp_env: options.environment ?? "production" }
+        });
+      } catch (err) {
+        if (options.debug) console.warn("[TillPulse] crashReporter.start failed:", err);
+      }
+    }
+    process.on("uncaughtException", (...args) => {
+      const err = args[0];
+      this._captureError(err, "critical", "uncaughtException");
+      this._markSession("crashed");
+      void this.flush(true);
+    });
+    process.on("unhandledRejection", (...args) => {
+      this._captureError(args[0], "high", "unhandledRejection");
+    });
+    if (options.enableProcessMonitoring !== false) {
+      electron.app.on("render-process-gone", (...a) => {
+        const details = a[2] ?? a[1];
+        const reason = details?.reason ?? "unknown";
+        const crashed = reason === "crashed" || reason === "oom" || reason === "abnormal-exit";
+        this._captureSynthetic("RenderProcessGone", `Renderer process gone: ${reason}`, crashed ? "critical" : "medium", {
+          reason,
+          exit_code: details?.exitCode
+        });
+        if (crashed) this._markSession("crashed");
+      });
+      electron.app.on("child-process-gone", (...a) => {
+        const d = a[1];
+        this._captureSynthetic("ChildProcessGone", `Child process (${d?.type}) gone: ${d?.reason}`, "medium", {
+          type: d?.type,
+          reason: d?.reason,
+          exit_code: d?.exitCode
+        });
+      });
+    }
+    if (options.enableHangDetection !== false) {
+      electron.app.on("web-contents-created", (...a) => {
+        const contents = a[1];
+        if (!contents || typeof contents.on !== "function") return;
+        let hangStart = 0;
+        contents.on("unresponsive", () => {
+          hangStart = Date.now();
+          this.addBreadcrumb({ type: "device", category: "app.hang", level: "warning", message: "renderer unresponsive" });
+        });
+        contents.on("responsive", () => {
+          const dur = hangStart ? Date.now() - hangStart : 0;
+          if (dur > 0) {
+            this._captureSynthetic("AppHang", `Renderer was unresponsive for ${dur}ms`, "medium", { duration_ms: dur });
+          }
+          hangStart = 0;
+        });
+      });
+    }
+    if (options.enableThreatDetection) {
+      electron.app.on("web-contents-created", (...a) => {
+        const contents = a[1];
+        if (!contents || typeof contents.on !== "function") return;
+        contents.on("devtools-opened", () => {
+          this.captureSecurityEvent({
+            securityType: "devtools_open",
+            severity: "low",
+            confidence: 0.7,
+            message: "DevTools opened on a renderer",
+            evidence: { url: typeof contents.getURL === "function" ? contents.getURL() : void 0 }
+          });
+        });
+      });
+    }
+    if (options.enableSessionTracking !== false) {
+      const start = () => this._startSession();
+      try {
+        if (electron.app.isReady()) start();
+        else void electron.app.whenReady().then(start);
+      } catch {
+        start();
+      }
+      electron.app.on("before-quit", () => {
+        this._markSession("exited");
+        void this.flush(true);
+      });
+      electron.app.on("window-all-closed", () => this._markSession("exited"));
+    }
+    const flushMs = options.flushIntervalMs ?? 1e4;
+    this.timer = setInterval(() => void this.flush(), flushMs);
+    if (this.timer.unref) this.timer.unref();
+    if (options.debug) console.log("[TillPulse] electron SDK initialized", { release: options.release });
+  }
+  // ── Public API ──
+  captureException(error) {
+    this._captureError(error, "high", "captureException");
+  }
+  captureMessage(message, level = "info") {
+    this._enqueue(this._base("error", level, { exception: { type: "Message", value: message } }));
+  }
+  // Report a security signal to TillShield (same shape as the other SDKs).
+  captureSecurityEvent(input) {
+    this._enqueue(
+      this._base("security", input.severity ?? "high", {
+        security_type: input.securityType,
+        security_confidence: input.confidence ?? 0.8,
+        security_evidence: input.evidence ?? {},
+        exception: { type: `security:${input.securityType}`, value: input.message ?? input.securityType }
+      })
+    );
+  }
+  addBreadcrumb(input) {
+    this.crumbs.push({
+      type: input.type,
+      category: input.category,
+      message: input.message,
+      level: input.level ?? "info",
+      data: input.data,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    if (this.crumbs.length > 100) this.crumbs = this.crumbs.slice(this.crumbs.length - 100);
+  }
+  setUser(user) {
+    this.user = user;
+  }
+  setTag(key, value) {
+    this.tags[key] = value;
+  }
+  getQueueStats() {
+    return { size: this.queue?.size() ?? 0 };
+  }
+  async flush(useKeepalive = false) {
+    if (!this.queue || !this.opts) return false;
+    const items = this.queue.due(50);
+    if (items.length === 0) return true;
+    const lines = [
+      JSON.stringify({ dsn: this.opts.dsn, sdk: { name: SDK_NAME, version: SDK_VERSION }, sent_at: (/* @__PURE__ */ new Date()).toISOString() })
+    ];
+    const ids = [];
+    for (const it of items) {
+      lines.push(JSON.stringify({ type: it.event_type, content_type: "application/json", length: it.payload.length }));
+      lines.push(it.payload);
+      ids.push(it.id);
+    }
+    try {
+      const res = await fetch(this.endpoint, {
+        method: "POST",
+        headers: { "Content-Type": "application/x-sentry-envelope", Authorization: `DSN ${this.opts.dsn}` },
+        body: lines.join("\n")
+      });
+      if (res.ok || res.status >= 400 && res.status < 500 && res.status !== 429) {
+        this.queue.ackOk(ids);
+        return true;
+      }
+      this.queue.ackFail(ids);
+      return false;
+    } catch {
+      this.queue.ackFail(ids);
+      return false;
+    }
+  }
+  close() {
+    this._markSession("exited");
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+    void this.flush(true);
+    this.initialized = false;
+  }
+  // ── Internals ──
+  _device() {
+    let total = 0;
+    let free = 0;
+    let release2 = "";
+    try {
+      total = os__namespace.totalmem();
+      free = os__namespace.freemem();
+      release2 = os__namespace.release();
+    } catch {
+    }
+    return {
+      device_model: `Electron ${process.versions["electron"] ?? ""}`.trim(),
+      device_manufacturer: process.platform,
+      device_family: "desktop",
+      os_name: osName(),
+      os_version: release2,
+      cpu_architecture: process.arch,
+      total_ram_mb: total ? Math.round(total / (1024 * 1024)) : void 0,
+      available_ram_mb: free ? Math.round(free / (1024 * 1024)) : void 0,
+      locale: process.env["LANG"]
+    };
+  }
+  _base(eventType, severity, extra) {
+    const o = this.opts;
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const event = {
+      event_id: generateId(),
+      project_id: "",
+      event_type: eventType,
+      severity,
+      environment: o.environment ?? "production",
+      release_version: o.release,
+      dist: o.dist,
+      timestamp: now,
+      client_timestamp: now,
+      breadcrumbs: this.crumbs.slice(),
+      device: this._device(),
+      network: { network_type: "unknown" },
+      app_state: { app_foreground: true },
+      user: { user_id: this.user?.id, user_segment: this.user?.segment, session_id: this.sessionId },
+      sdk: { name: SDK_NAME, version: SDK_VERSION },
+      ...extra
+    };
+    if (Object.keys(this.tags).length) {
+      event.tags = { ...this.tags };
+    }
+    event.extra = {
+      chrome: process.versions["chrome"],
+      node: process.versions["node"],
+      v8: process.versions["v8"]
+    };
+    return event;
+  }
+  _captureError(thrown, severity, mechanism) {
+    if (!this.opts) return;
+    const err = thrown instanceof Error ? thrown : null;
+    this._enqueue(
+      this._base("error", severity, {
+        exception: {
+          type: err?.name ?? "Error",
+          value: err?.message ?? String(thrown),
+          stacktrace: err?.stack ? { frames: parseNodeStack(err.stack) } : void 0
+        },
+        fingerprint: `electron:${mechanism}`
+      })
+    );
+  }
+  _captureSynthetic(type, message, severity, data) {
+    if (!this.opts) return;
+    const ev = this._base("error", severity, { exception: { type, value: message } });
+    ev.extra = {
+      ...ev.extra,
+      ...data
+    };
+    this._enqueue(ev);
+  }
+  _startSession() {
+    this.sessionStartedAt = Date.now();
+    this.sessionEnded = false;
+    this._emitSession("ok");
+  }
+  _markSession(status) {
+    if (this.sessionEnded || this.sessionStartedAt === 0) return;
+    this.sessionEnded = true;
+    this._emitSession(status, Date.now() - this.sessionStartedAt);
+  }
+  _emitSession(status, durationMs) {
+    if (!this.opts) return;
+    this._enqueue(this._base("session", "info", { session_status: status, ...durationMs !== void 0 ? { session_duration_ms: durationMs } : {} }));
+  }
+  async _enqueue(event) {
+    const o = this.opts;
+    if (!o || !this.queue) return;
+    let final = event;
+    if (o.beforeSend) {
+      try {
+        final = await o.beforeSend(event);
+      } catch {
+      }
+    }
+    if (!final) return;
+    if (!o.disableDefaultPiiScrubbing) final = scrubEvent(final);
+    this.queue.enqueue(final.event_id, final.event_type, final);
+  }
+};
+function parseNodeStack(stack) {
+  const frames = [];
+  for (const raw of stack.split("\n")) {
+    const line = raw.trim();
+    const m = line.match(/^at\s+(.+?)\s+\((.+?):(\d+):(\d+)\)$/) || line.match(/^at\s+()(.+?):(\d+):(\d+)$/);
+    if (!m) continue;
+    const file = m[2];
+    frames.push({
+      filename: file,
+      function: m[1] || "<anonymous>",
+      lineno: Number(m[3]),
+      colno: Number(m[4]),
+      in_app: !file.includes("node_modules") && !file.startsWith("node:")
+    });
+  }
+  return frames;
+}
+var TillPulse = new TillPulseElectronSDK();
+var src_default = TillPulse;
+
+exports.TillPulse = TillPulse;
+exports.default = src_default;
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map