@flareapp/electron 0.1.0

package/dist/main.d.cts

@@ -0,0 +1,77 @@
+import { AttributeValue, Attributes, Config, Config as Config$1, DEFAULT_URL_DENYLIST, Flare, GlobalScopeProvider, Glow, Logger, MessageLevel, NullFileReader, Report, Scope, SdkInfo, StackFrame, convertToError, redactUrlQuery, resolveDenylist } from "@flareapp/core";
+import { App, IpcMain } from "electron";
+
+//#region src/types.d.ts
+type ElectronFatalMode = 'off' | 'report' | 'report-and-exit';
+type ElectronUser = {
+  id?: string | number;
+  email?: string;
+  username?: string;
+  ipAddress?: string;
+};
+/** A frame the IPC receiver evaluates for trust. Mirrors Electron's WebFrameMain shape we use. */
+type SenderFrame = {
+  url: string;
+};
+type ElectronOptions = {
+  uncaughtExceptionMode?: ElectronFatalMode;
+  unhandledRejectionMode?: ElectronFatalMode;
+  shutdownTimeoutMs?: number; /** Listen to app 'render-process-gone' / 'child-process-gone' and report them. */
+  captureRenderProcessGone?: boolean; /** Extra URL scheme names (no colon), e.g. 'app', trusted as report senders. */
+  trustedProtocols?: string[]; /** Full override of the sender-trust check. When set, replaces the default policy. */
+  trustSender?: (frame: SenderFrame) => boolean; /** Max serialized report size in bytes accepted over IPC. */
+  maxReportBytes?: number;
+};
+//#endregion
+//#region src/main/ElectronFlare.d.ts
+type AppLike = Pick<App, 'getName' | 'getVersion' | 'getLocale' | 'isReady' | 'exit' | 'on' | 'off'> & {
+  isPackaged: boolean;
+};
+type ElectronFlareDeps = {
+  app: AppLike;
+  ipcMain: IpcMain;
+};
+declare class ElectronFlare extends Flare {
+  private app;
+  private ipcMain;
+  private options;
+  private user;
+  private isLit;
+  private handlerManager;
+  private renderGoneHandler;
+  private childGoneHandler;
+  private forwardedInFlight;
+  private flushScheduler;
+  private mainStage;
+  private mainVersion;
+  private mainSourcemapVersionId;
+  constructor(deps: ElectronFlareDeps);
+  configure(config: Partial<Config$1>): this;
+  light(key?: string, debug?: boolean): this;
+  configureElectron(partial: ElectronOptions): this;
+  setUser(user: ElectronUser | null): void;
+  dispose(): void;
+  /** Attach or detach the process-gone listeners to match options.captureRenderProcessGone. Idempotent. */
+  private reconcileCrashListeners;
+  private detachCrashListeners;
+  private reportProcessGone;
+  /**
+   * Wait for both core's tracked reports AND forwarded renderer reports (which bypass core's
+   * private track()), bounded by timeoutMs. The timeout is cleared when all reports settle
+   * first, so the event loop is not kept alive unnecessarily.
+   */
+  flush(timeoutMs?: number): Promise<void>;
+  /** Overlay main-authoritative config + Electron metadata + user onto a forwarded report, then send. */
+  private receiveRendererReport;
+}
+//#endregion
+//#region src/constants.d.ts
+/** IPC channel renderer reports travel on. Shared by preload, renderer, and main. */
+declare const FLARE_IPC_CHANNEL = "flare:report";
+/** Global key the preload bridge exposes in the renderer's main world. */
+declare const FLARE_BRIDGE_KEY = "__flare";
+//#endregion
+//#region src/main.d.ts
+declare const flare: ElectronFlare;
+//#endregion
+export { type AttributeValue, type Attributes, type Config, DEFAULT_URL_DENYLIST, type ElectronFatalMode, ElectronFlare, type ElectronOptions, type ElectronUser, FLARE_BRIDGE_KEY, FLARE_IPC_CHANNEL, GlobalScopeProvider, type Glow, Logger, type MessageLevel, NullFileReader, type Report, Scope, type SdkInfo, type SenderFrame, type StackFrame, convertToError, flare, redactUrlQuery, resolveDenylist };

package/dist/main.d.mts

@@ -0,0 +1,77 @@
+import { App, IpcMain } from "electron";
+import { AttributeValue, Attributes, Config, Config as Config$1, DEFAULT_URL_DENYLIST, Flare, GlobalScopeProvider, Glow, Logger, MessageLevel, NullFileReader, Report, Scope, SdkInfo, StackFrame, convertToError, redactUrlQuery, resolveDenylist } from "@flareapp/core";
+
+//#region src/types.d.ts
+type ElectronFatalMode = 'off' | 'report' | 'report-and-exit';
+type ElectronUser = {
+  id?: string | number;
+  email?: string;
+  username?: string;
+  ipAddress?: string;
+};
+/** A frame the IPC receiver evaluates for trust. Mirrors Electron's WebFrameMain shape we use. */
+type SenderFrame = {
+  url: string;
+};
+type ElectronOptions = {
+  uncaughtExceptionMode?: ElectronFatalMode;
+  unhandledRejectionMode?: ElectronFatalMode;
+  shutdownTimeoutMs?: number; /** Listen to app 'render-process-gone' / 'child-process-gone' and report them. */
+  captureRenderProcessGone?: boolean; /** Extra URL scheme names (no colon), e.g. 'app', trusted as report senders. */
+  trustedProtocols?: string[]; /** Full override of the sender-trust check. When set, replaces the default policy. */
+  trustSender?: (frame: SenderFrame) => boolean; /** Max serialized report size in bytes accepted over IPC. */
+  maxReportBytes?: number;
+};
+//#endregion
+//#region src/main/ElectronFlare.d.ts
+type AppLike = Pick<App, 'getName' | 'getVersion' | 'getLocale' | 'isReady' | 'exit' | 'on' | 'off'> & {
+  isPackaged: boolean;
+};
+type ElectronFlareDeps = {
+  app: AppLike;
+  ipcMain: IpcMain;
+};
+declare class ElectronFlare extends Flare {
+  private app;
+  private ipcMain;
+  private options;
+  private user;
+  private isLit;
+  private handlerManager;
+  private renderGoneHandler;
+  private childGoneHandler;
+  private forwardedInFlight;
+  private flushScheduler;
+  private mainStage;
+  private mainVersion;
+  private mainSourcemapVersionId;
+  constructor(deps: ElectronFlareDeps);
+  configure(config: Partial<Config$1>): this;
+  light(key?: string, debug?: boolean): this;
+  configureElectron(partial: ElectronOptions): this;
+  setUser(user: ElectronUser | null): void;
+  dispose(): void;
+  /** Attach or detach the process-gone listeners to match options.captureRenderProcessGone. Idempotent. */
+  private reconcileCrashListeners;
+  private detachCrashListeners;
+  private reportProcessGone;
+  /**
+   * Wait for both core's tracked reports AND forwarded renderer reports (which bypass core's
+   * private track()), bounded by timeoutMs. The timeout is cleared when all reports settle
+   * first, so the event loop is not kept alive unnecessarily.
+   */
+  flush(timeoutMs?: number): Promise<void>;
+  /** Overlay main-authoritative config + Electron metadata + user onto a forwarded report, then send. */
+  private receiveRendererReport;
+}
+//#endregion
+//#region src/constants.d.ts
+/** IPC channel renderer reports travel on. Shared by preload, renderer, and main. */
+declare const FLARE_IPC_CHANNEL = "flare:report";
+/** Global key the preload bridge exposes in the renderer's main world. */
+declare const FLARE_BRIDGE_KEY = "__flare";
+//#endregion
+//#region src/main.d.ts
+declare const flare: ElectronFlare;
+//#endregion
+export { type AttributeValue, type Attributes, type Config, DEFAULT_URL_DENYLIST, type ElectronFatalMode, ElectronFlare, type ElectronOptions, type ElectronUser, FLARE_BRIDGE_KEY, FLARE_IPC_CHANNEL, GlobalScopeProvider, type Glow, Logger, type MessageLevel, NullFileReader, type Report, Scope, type SdkInfo, type SenderFrame, type StackFrame, convertToError, flare, redactUrlQuery, resolveDenylist };

package/dist/main.mjs

@@ -0,0 +1,406 @@
+import { app, ipcMain } from "electron";
+import { Api, DEFAULT_URL_DENYLIST, Flare, GlobalScopeProvider, GlobalScopeProvider as GlobalScopeProvider$1, Logger, NullFileReader, Scope, convertToError, redactUrlQuery, resolveDenylist } from "@flareapp/core";
+import os from "node:os";
+import { readFile } from "node:fs/promises";
+import { fileURLToPath } from "node:url";
+
+//#region src/env.ts
+const CLIENT_VERSION = typeof process !== "undefined" && true ? "0.1.0" : "?";
+
+//#endregion
+//#region src/types.ts
+const DEFAULT_ELECTRON_OPTIONS = {
+	uncaughtExceptionMode: "report-and-exit",
+	unhandledRejectionMode: "report-and-exit",
+	shutdownTimeoutMs: 2e3,
+	captureRenderProcessGone: true,
+	trustedProtocols: [],
+	trustSender: null,
+	maxReportBytes: 1e6
+};
+
+//#endregion
+//#region src/main/collectElectron.ts
+/**
+* App + runtime attributes that are safe to overlay onto ANY report regardless of origin.
+* Reused by both the collector (main errors) and the IPC receiver (forwarded renderer reports).
+*
+* Intentionally does NOT include per-process fields like `flare.entry_point.type` or `process.type`
+* so that forwarded renderer reports keep their own `flare.entry_point.type: 'web'` intact.
+*/
+function collectElectronAppAttributes(app) {
+	const versions = process.versions;
+	const attrs = {
+		"service.name": app.getName(),
+		"app.version": app.getVersion(),
+		"app.packaged": app.isPackaged,
+		"process.runtime.name": "electron",
+		"process.runtime.version": versions.electron ?? "",
+		"process.versions.electron": versions.electron ?? "",
+		"process.versions.chrome": versions.chrome ?? "",
+		"process.versions.node": versions.node ?? process.version,
+		"host.arch": process.arch,
+		"os.type": os.type()
+	};
+	if (app.isReady()) try {
+		attrs["app.locale"] = app.getLocale();
+	} catch {}
+	return attrs;
+}
+/** Project a user into OTel enduser.* / client.address keys. */
+function projectUser(user) {
+	const attrs = {};
+	if (!user) return attrs;
+	if (user.id !== void 0) attrs["enduser.id"] = String(user.id);
+	if (user.email !== void 0) attrs["enduser.email"] = user.email;
+	if (user.username !== void 0) attrs["enduser.username"] = user.username;
+	if (user.ipAddress !== void 0) attrs["client.address"] = user.ipAddress;
+	return attrs;
+}
+/** Build the ContextCollector core calls on every main-process report. */
+function makeElectronContextCollector(app, getUser) {
+	return (_config) => ({
+		"flare.entry_point.type": "server",
+		"process.type": process.type ?? "browser",
+		...collectElectronAppAttributes(app),
+		...projectUser(getUser())
+	});
+}
+
+//#endregion
+//#region src/main/ElectronDiskFileReader.ts
+/** Reads source snippets for main-process stack frames from disk. Mirrors @flareapp/node's DiskFileReader. */
+var ElectronDiskFileReader = class {
+	async read(url) {
+		if (!isLocalFileUrl(url)) return null;
+		try {
+			return await readFile(/^file:\/\//i.test(url) ? fileURLToPath(url) : url, "utf-8");
+		} catch {
+			return null;
+		}
+	}
+};
+function isLocalFileUrl(url) {
+	return /^file:\/\//i.test(url) || url.startsWith("/") || /^[a-z]:[\\/]/i.test(url) || url.startsWith("\\\\");
+}
+
+//#endregion
+//#region src/main/ElectronFlushScheduler.ts
+/** Flushes pending logs/reports when the Electron app is quitting. App is injectable for tests. */
+var ElectronFlushScheduler = class {
+	listener = null;
+	constructor(app) {
+		this.app = app;
+	}
+	register(flush) {
+		if (this.listener) return;
+		this.listener = () => {
+			flush();
+		};
+		this.app.on("before-quit", this.listener);
+	}
+	/** Detach the before-quit listener so a disposed ElectronFlare leaves no flush handler on the shared app. */
+	dispose() {
+		if (this.listener) {
+			this.app.off("before-quit", this.listener);
+			this.listener = null;
+		}
+	}
+};
+
+//#endregion
+//#region src/constants.ts
+/** IPC channel renderer reports travel on. Shared by preload, renderer, and main. */
+const FLARE_IPC_CHANNEL = "flare:report";
+/** Global key the preload bridge exposes in the renderer's main world. */
+const FLARE_BRIDGE_KEY = "__flare";
+
+//#endregion
+//#region src/main/ipcReceiver.ts
+/** Module-level ownership token for the single flare:report channel. */
+let currentOwner = null;
+/** Default sender-trust check: accept file: and localhost/127.0.0.1 only, plus configured custom protocols. */
+function defaultTrustPolicy(frame, opts) {
+	let parsed;
+	try {
+		parsed = new URL(frame.url);
+	} catch {
+		return false;
+	}
+	const scheme = parsed.protocol.replace(/:$/, "");
+	if (scheme === "file") return parsed.hostname === "" || parsed.hostname === "localhost";
+	const isLoopback = parsed.hostname === "localhost" || parsed.hostname === "127.0.0.1" || parsed.hostname === "[::1]";
+	if ((scheme === "http" || scheme === "https") && isLoopback) return true;
+	if (opts.trustedProtocols.includes(scheme)) return true;
+	return false;
+}
+function isTrusted(frame, opts) {
+	if (!frame || typeof frame.url !== "string") return false;
+	if (opts.trustSender) return opts.trustSender(frame);
+	return defaultTrustPolicy(frame, opts);
+}
+/**
+* Minimal top-level structural guard for a parsed report. This is intentionally NOT an exhaustive
+* validator of every StackFrame / SpanEvent: the renderer builds the report with our own Flare code,
+* and a compromised renderer could forge any valid-looking shape anyway. The real security boundary
+* is the sender-trust check plus the byte-size cap; this guard only rejects obviously-wrong payloads.
+*/
+function isReportShape(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const r = value;
+	return typeof r.seenAtUnixNano === "number" && Array.isArray(r.stacktrace) && Array.isArray(r.events) && typeof r.attributes === "object" && r.attributes !== null && !Array.isArray(r.attributes);
+}
+function registerIpcReceiver(ipcMain, owner, deps) {
+	if (currentOwner === owner) return;
+	if (currentOwner !== null) ipcMain.removeHandler(FLARE_IPC_CHANNEL);
+	currentOwner = owner;
+	ipcMain.handle(FLARE_IPC_CHANNEL, (async (event, payload) => {
+		const opts = deps.getOptions();
+		if (!isTrusted(event.senderFrame, opts)) return;
+		if (typeof payload !== "string") return;
+		if (Buffer.byteLength(payload, "utf8") > opts.maxReportBytes) return;
+		let parsed;
+		try {
+			parsed = JSON.parse(payload);
+		} catch {
+			return;
+		}
+		if (!isReportShape(parsed)) return;
+		await deps.onReport(parsed);
+	}));
+}
+function disposeIpcReceiver(ipcMain, owner) {
+	if (currentOwner !== owner) return;
+	ipcMain.removeHandler(FLARE_IPC_CHANNEL);
+	currentOwner = null;
+}
+
+//#endregion
+//#region src/main/processHandlers.ts
+/**
+* Fatal callbacks for Electron main. Mirrors @flareapp/node's buildFatalCallbacks but exits via
+* the injected `exit` (defaulting to app.exit at the call site), which is immediate and skips
+* before-quit/will-quit, correct after an uncaught exception.
+*/
+function buildFatalCallbacks(flare, getOpts, exit) {
+	return {
+		async onUncaught(err, origin) {
+			const opts = getOpts();
+			if (opts.uncaughtExceptionMode === "report-and-exit") process.exitCode = 1;
+			const error = err instanceof Error ? err : new Error(String(err));
+			try {
+				await flare.report(error, { "process.uncaught_exception.origin": origin });
+			} catch {}
+			if (opts.uncaughtExceptionMode === "report-and-exit") {
+				await flare.flush(opts.shutdownTimeoutMs);
+				exit(1);
+			}
+		},
+		async onRejection(reason) {
+			const opts = getOpts();
+			if (opts.unhandledRejectionMode === "report-and-exit") process.exitCode = 1;
+			const error = reason instanceof Error ? reason : new Error(String(reason));
+			try {
+				await flare.report(error);
+			} catch {}
+			if (opts.unhandledRejectionMode === "report-and-exit") {
+				await flare.flush(opts.shutdownTimeoutMs);
+				exit(1);
+			}
+		}
+	};
+}
+/**
+* Owns the lifecycle of the two process-level error listeners for the Electron main process.
+* Mirrors node's ProcessHandlerManager. Attach/detach the two process listeners, reconciling
+* against the desired modes.
+*/
+var ProcessHandlerManager = class {
+	uncaughtHandler = null;
+	rejectionHandler = null;
+	constructor(cbs) {
+		this.cbs = cbs;
+	}
+	reconcile(opts) {
+		this.reconcileOne("uncaughtException", opts.uncaughtExceptionMode, () => this.uncaughtHandler, (h) => {
+			this.uncaughtHandler = h;
+		}, (err, origin) => this.cbs.onUncaught(err, origin));
+		this.reconcileOne("unhandledRejection", opts.unhandledRejectionMode, () => this.rejectionHandler, (h) => {
+			this.rejectionHandler = h;
+		}, (reason) => this.cbs.onRejection(reason));
+	}
+	detach() {
+		if (this.uncaughtHandler) {
+			process.off("uncaughtException", this.uncaughtHandler);
+			this.uncaughtHandler = null;
+		}
+		if (this.rejectionHandler) {
+			process.off("unhandledRejection", this.rejectionHandler);
+			this.rejectionHandler = null;
+		}
+	}
+	reconcileOne(event, mode, get, set, impl) {
+		const current = get();
+		const wants = mode !== "off";
+		if (wants && !current) {
+			set(impl);
+			process.on(event, impl);
+		} else if (!wants && current) {
+			process.off(event, current);
+			set(null);
+		}
+	}
+};
+
+//#endregion
+//#region src/main/ElectronFlare.ts
+const SDK_NAME = "@flareapp/electron";
+/** Write `value` under `key` when non-empty, otherwise remove any renderer-supplied value. */
+function overlayOrDelete(attributes, key, value) {
+	if (value) attributes[key] = value;
+	else delete attributes[key];
+}
+var ElectronFlare = class extends Flare {
+	app;
+	ipcMain;
+	options = { ...DEFAULT_ELECTRON_OPTIONS };
+	user = null;
+	isLit = false;
+	handlerManager;
+	renderGoneHandler = null;
+	childGoneHandler = null;
+	forwardedInFlight = /* @__PURE__ */ new Set();
+	flushScheduler;
+	mainStage = "";
+	mainVersion = "";
+	mainSourcemapVersionId = "";
+	constructor(deps) {
+		const app = deps.app;
+		const collector = makeElectronContextCollector(app, () => this.user);
+		const flushScheduler = new ElectronFlushScheduler(app);
+		super(new Api(), collector, new ElectronDiskFileReader(), new GlobalScopeProvider$1(), flushScheduler);
+		this.app = app;
+		this.ipcMain = deps.ipcMain;
+		this.flushScheduler = flushScheduler;
+		this.setSdkInfo({
+			name: SDK_NAME,
+			version: CLIENT_VERSION
+		});
+		this.handlerManager = new ProcessHandlerManager(buildFatalCallbacks(this, () => this.options, (code) => this.app.exit(code)));
+		registerIpcReceiver(this.ipcMain, this, {
+			getOptions: () => this.options,
+			onReport: (report) => this.receiveRendererReport(report)
+		});
+		this.reconcileCrashListeners();
+	}
+	configure(config) {
+		if (config.stage !== void 0) this.mainStage = config.stage;
+		if (config.version !== void 0) this.mainVersion = config.version;
+		if (config.sourcemapVersionId !== void 0) this.mainSourcemapVersionId = config.sourcemapVersionId;
+		return super.configure(config);
+	}
+	light(key, debug) {
+		super.light(key, debug);
+		this.isLit = true;
+		this.handlerManager.reconcile(this.options);
+		return this;
+	}
+	configureElectron(partial) {
+		if (partial.uncaughtExceptionMode !== void 0) this.options.uncaughtExceptionMode = partial.uncaughtExceptionMode;
+		if (partial.unhandledRejectionMode !== void 0) this.options.unhandledRejectionMode = partial.unhandledRejectionMode;
+		if (partial.shutdownTimeoutMs !== void 0) this.options.shutdownTimeoutMs = partial.shutdownTimeoutMs;
+		if (partial.captureRenderProcessGone !== void 0) this.options.captureRenderProcessGone = partial.captureRenderProcessGone;
+		if (partial.trustedProtocols !== void 0) this.options.trustedProtocols = Array.isArray(partial.trustedProtocols) ? partial.trustedProtocols : [];
+		if (partial.trustSender !== void 0) this.options.trustSender = partial.trustSender;
+		if (partial.maxReportBytes !== void 0 && Number.isFinite(partial.maxReportBytes)) this.options.maxReportBytes = partial.maxReportBytes;
+		if (this.isLit) this.handlerManager.reconcile(this.options);
+		this.reconcileCrashListeners();
+		return this;
+	}
+	setUser(user) {
+		this.user = user;
+	}
+	dispose() {
+		this.handlerManager.detach();
+		this.detachCrashListeners();
+		disposeIpcReceiver(this.ipcMain, this);
+		this.flushScheduler.dispose();
+	}
+	/** Attach or detach the process-gone listeners to match options.captureRenderProcessGone. Idempotent. */
+	reconcileCrashListeners() {
+		const want = this.options.captureRenderProcessGone;
+		const attached = this.renderGoneHandler !== null;
+		if (want && !attached) {
+			this.renderGoneHandler = (_event, webContents, details) => {
+				return this.reportProcessGone("renderer", details, webContents?.id);
+			};
+			this.childGoneHandler = (_event, details) => {
+				return this.reportProcessGone("child", details);
+			};
+			this.app.on("render-process-gone", this.renderGoneHandler);
+			this.app.on("child-process-gone", this.childGoneHandler);
+		} else if (!want && attached) this.detachCrashListeners();
+	}
+	detachCrashListeners() {
+		if (this.renderGoneHandler) {
+			this.app.off("render-process-gone", this.renderGoneHandler);
+			this.renderGoneHandler = null;
+		}
+		if (this.childGoneHandler) {
+			this.app.off("child-process-gone", this.childGoneHandler);
+			this.childGoneHandler = null;
+		}
+	}
+	reportProcessGone(kind, details, webContentsId) {
+		const reason = details.reason ?? "unknown";
+		const label = kind === "renderer" ? "Renderer process gone" : "Child process gone";
+		const error = /* @__PURE__ */ new Error(`${label}: ${reason}`);
+		const attrs = {
+			"electron.process_gone.kind": kind,
+			"electron.process_gone.reason": reason
+		};
+		if (details.exitCode !== void 0) attrs["electron.process_gone.exit_code"] = details.exitCode;
+		if (details.type !== void 0) attrs["electron.process_gone.type"] = details.type;
+		if (details.serviceName !== void 0) attrs["electron.process_gone.service_name"] = details.serviceName;
+		if (webContentsId !== void 0) attrs["electron.process_gone.web_contents_id"] = webContentsId;
+		return this.report(error, attrs);
+	}
+	/**
+	* Wait for both core's tracked reports AND forwarded renderer reports (which bypass core's
+	* private track()), bounded by timeoutMs. The timeout is cleared when all reports settle
+	* first, so the event loop is not kept alive unnecessarily.
+	*/
+	flush(timeoutMs = 2e3) {
+		const settled = Promise.allSettled([super.flush(timeoutMs), ...this.forwardedInFlight]);
+		return new Promise((resolve) => {
+			const timer = setTimeout(resolve, timeoutMs);
+			settled.then(() => {
+				clearTimeout(timer);
+				resolve();
+			});
+		});
+	}
+	/** Overlay main-authoritative config + Electron metadata + user onto a forwarded report, then send. */
+	receiveRendererReport(report) {
+		Object.assign(report.attributes, collectElectronAppAttributes(this.app), projectUser(this.user));
+		overlayOrDelete(report.attributes, "service.stage", this.mainStage);
+		overlayOrDelete(report.attributes, "service.version", this.mainVersion);
+		if (this.mainSourcemapVersionId) report.sourcemapVersionId = this.mainSourcemapVersionId;
+		else delete report.sourcemapVersionId;
+		const sent = this.sendReport(report).finally(() => {
+			this.forwardedInFlight.delete(sent);
+		});
+		this.forwardedInFlight.add(sent);
+		return sent;
+	}
+};
+
+//#endregion
+//#region src/main.ts
+const flare = new ElectronFlare({
+	app,
+	ipcMain
+});
+
+//#endregion
+export { DEFAULT_URL_DENYLIST, ElectronFlare, FLARE_BRIDGE_KEY, FLARE_IPC_CHANNEL, GlobalScopeProvider, Logger, NullFileReader, Scope, convertToError, flare, redactUrlQuery, resolveDenylist };

package/dist/preload.cjs

@@ -0,0 +1,21 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+let electron = require("electron");
+
+//#region src/constants.ts
+/** IPC channel renderer reports travel on. Shared by preload, renderer, and main. */
+const FLARE_IPC_CHANNEL = "flare:report";
+/** Global key the preload bridge exposes in the renderer's main world. */
+const FLARE_BRIDGE_KEY = "__flare";
+
+//#endregion
+//#region src/preload.ts
+/**
+* Call once in your preload script. Bridges renderer error reports to the main process over a
+* single contextBridge method. Respects contextIsolation; does not require nodeIntegration.
+*/
+function exposeFlare() {
+	electron.contextBridge.exposeInMainWorld(FLARE_BRIDGE_KEY, { report: (payload) => electron.ipcRenderer.invoke(FLARE_IPC_CHANNEL, payload) });
+}
+
+//#endregion
+exports.exposeFlare = exposeFlare;

package/dist/preload.d.cts

@@ -0,0 +1,8 @@
+//#region src/preload.d.ts
+/**
+ * Call once in your preload script. Bridges renderer error reports to the main process over a
+ * single contextBridge method. Respects contextIsolation; does not require nodeIntegration.
+ */
+declare function exposeFlare(): void;
+//#endregion
+export { exposeFlare };

package/dist/preload.d.mts

@@ -0,0 +1,8 @@
+//#region src/preload.d.ts
+/**
+ * Call once in your preload script. Bridges renderer error reports to the main process over a
+ * single contextBridge method. Respects contextIsolation; does not require nodeIntegration.
+ */
+declare function exposeFlare(): void;
+//#endregion
+export { exposeFlare };

package/dist/preload.mjs

@@ -0,0 +1,20 @@
+import { contextBridge, ipcRenderer } from "electron";
+
+//#region src/constants.ts
+/** IPC channel renderer reports travel on. Shared by preload, renderer, and main. */
+const FLARE_IPC_CHANNEL = "flare:report";
+/** Global key the preload bridge exposes in the renderer's main world. */
+const FLARE_BRIDGE_KEY = "__flare";
+
+//#endregion
+//#region src/preload.ts
+/**
+* Call once in your preload script. Bridges renderer error reports to the main process over a
+* single contextBridge method. Respects contextIsolation; does not require nodeIntegration.
+*/
+function exposeFlare() {
+	contextBridge.exposeInMainWorld(FLARE_BRIDGE_KEY, { report: (payload) => ipcRenderer.invoke(FLARE_IPC_CHANNEL, payload) });
+}
+
+//#endregion
+export { exposeFlare };