@flareapp/electron 0.1.0

package/README.md

@@ -0,0 +1,173 @@
+# @flareapp/electron
+
+> ⚠️ **Experimental (`0.1.0`).** This package is new and its API may change in a minor release. Feedback and bug reports are very welcome at https://github.com/spatie/flare-client-js/issues.
+
+Electron SDK for [Flare](https://flareapp.io) error tracking. It captures JavaScript errors in **both** Electron processes and routes every report through the main process, so your API key lives in exactly one place.
+
+## What it captures
+
+- **Main process:** uncaught exceptions and unhandled promise rejections.
+- **Renderer process:** `window.onerror` and `unhandledrejection`, plus anything you report manually.
+- **Process crashes:** `render-process-gone` and `child-process-gone` (renderer/GPU/utility), reported as structured errors with the crash `reason` and `exitCode`.
+
+It does **not** capture native crashes (C++/Crashpad minidumps). Only JavaScript-level errors are sent to Flare.
+
+## Install
+
+```bash
+npm install @flareapp/electron
+```
+
+`electron` is a peer dependency; this package expects your app to provide it.
+
+## Setup
+
+Flare needs wiring in all three Electron contexts. The API key, `stage`, `version`, and sourcemap settings are configured **once, in the main process** — the renderer needs none of them.
+
+### 1. Main process
+
+```ts
+// main.ts
+import { app } from 'electron';
+import { flare } from '@flareapp/electron/main';
+
+flare.light('your-flare-api-key');
+
+// Optional: these are set ONCE here and applied to renderer reports too.
+flare.configure({ stage: 'production', version: app.getVersion() });
+
+// Optional: fatal-handler behavior and IPC trust policy.
+flare.configureElectron({
+    uncaughtExceptionMode: 'report-and-exit', // 'report' | 'report-and-exit' | 'off'
+    unhandledRejectionMode: 'report-and-exit',
+    captureRenderProcessGone: true,
+});
+```
+
+In `report-and-exit` mode, after a fatal error Flare reports it, flushes pending reports (up to `shutdownTimeoutMs`), then calls `app.exit(1)`.
+
+### 2. Preload script
+
+Because `contextIsolation` is on (the Electron default and the recommended setting), the renderer cannot reach `ipcRenderer` directly. The preload helper bridges reports over `contextBridge`. This step is **required** — without it, renderer reports are dropped.
+
+```ts
+// preload.ts
+import { exposeFlare } from '@flareapp/electron/preload';
+
+exposeFlare();
+```
+
+Make sure your `BrowserWindow` points at this preload script:
+
+```ts
+new BrowserWindow({
+    webPreferences: {
+        preload: path.join(__dirname, 'preload.js'),
+        contextIsolation: true,
+    },
+});
+```
+
+### 3. Renderer
+
+Import the renderer entry once, as early as possible, to install the global error listeners:
+
+```ts
+// renderer entry, e.g. main.tsx / index.ts
+import '@flareapp/electron/renderer';
+```
+
+For manual reporting, use the exported instance:
+
+```ts
+import { flare } from '@flareapp/electron/renderer';
+
+try {
+    doRiskyThing();
+} catch (error) {
+    flare.report(error as Error);
+}
+```
+
+The renderer builds the full report (stack trace + source snippets + browser context) in its own context, then forwards it to the main process. No API key lives in the renderer.
+
+## How reports flow
+
+```
+renderer error
+  → RendererFlare builds Report (stack + snippets + browser context)
+  → renderer beforeSubmit → serialize → size-check
+  → window.__flare.report(jsonString)    [contextBridge]
+  → ipcRenderer.invoke('flare:report')   [IPC]
+  → main: trust sender → size-check → parse → validate
+  → overlay stage/version/sourcemap + app metadata + user
+  → main beforeSubmit → sent to Flare
+
+main-process error
+  → process handlers → sent to Flare (app.exit on report-and-exit)
+
+renderer / GPU crash
+  → render-process-gone / child-process-gone → reported → sent to Flare
+```
+
+The API key is held only in the main process because that is the single egress point: every report, wherever it originates, is sent from main.
+
+## Filtering reports (`beforeSubmit`)
+
+`beforeSubmit` runs in **two stages**: once in the renderer (scrub close to the source) and once in main (the final gate before sending). Returning `null`/`false` from either drops the report.
+
+```ts
+// main
+flare.configure({
+    beforeSubmit: (report) => {
+        // final scrub before sending
+        return report;
+    },
+});
+
+// renderer
+import { flare } from '@flareapp/electron/renderer';
+flare.configure({
+    beforeSubmit: (report) => {
+        delete report.attributes['context.custom'];
+        return report;
+    },
+});
+```
+
+## Sender trust
+
+The main process only accepts reports from frames it trusts. By **default** it accepts:
+
+- `file:` URLs (packaged builds), and
+- `http(s)` on `localhost` / `127.0.0.1` (dev servers).
+
+It rejects everything else, including remote origins and custom protocols. If your app serves its renderer over a custom protocol or loads trusted remote content, opt in:
+
+```ts
+// Add a custom protocol scheme:
+flare.configureElectron({ trustedProtocols: ['app'] });
+
+// Or take full control:
+flare.configureElectron({
+    trustSender: (frame) => new URL(frame.url).origin === 'https://app.example.com',
+});
+```
+
+## Attaching the current user
+
+```ts
+import { flare } from '@flareapp/electron/main';
+
+flare.setUser({ id: 123, email: 'user@example.com', username: 'jane' });
+flare.setUser(null); // clear on logout
+```
+
+The user is attached to main-process reports and to forwarded renderer reports.
+
+## Not captured
+
+- Native crashes / Crashpad minidumps.
+- Errors that occur before `flare.light('your-key')` runs in the main process. The fatal process handlers are attached by `light()`, and no report is sent without a key, so call `light()` as early as possible in your main entry. Errors before that point (in any process) are not sent.
+
+This is an experimental release — see the note at the top.

package/dist/main.cjs

@@ -0,0 +1,486 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+//#region \0rolldown/runtime.js
+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 (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) {
+				__defProp(to, key, {
+					get: ((k) => from[k]).bind(null, key),
+					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+				});
+			}
+		}
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+let electron = require("electron");
+let _flareapp_core = require("@flareapp/core");
+let node_os = require("node:os");
+node_os = __toESM(node_os);
+let node_fs_promises = require("node:fs/promises");
+let node_url = require("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": node_os.default.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 (0, node_fs_promises.readFile)(/^file:\/\//i.test(url) ? (0, node_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 _flareapp_core.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 _flareapp_core.Api(), collector, new ElectronDiskFileReader(), new _flareapp_core.GlobalScopeProvider(), 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: electron.app,
+	ipcMain: electron.ipcMain
+});
+
+//#endregion
+Object.defineProperty(exports, 'DEFAULT_URL_DENYLIST', {
+  enumerable: true,
+  get: function () {
+    return _flareapp_core.DEFAULT_URL_DENYLIST;
+  }
+});
+exports.ElectronFlare = ElectronFlare;
+exports.FLARE_BRIDGE_KEY = FLARE_BRIDGE_KEY;
+exports.FLARE_IPC_CHANNEL = FLARE_IPC_CHANNEL;
+Object.defineProperty(exports, 'GlobalScopeProvider', {
+  enumerable: true,
+  get: function () {
+    return _flareapp_core.GlobalScopeProvider;
+  }
+});
+Object.defineProperty(exports, 'Logger', {
+  enumerable: true,
+  get: function () {
+    return _flareapp_core.Logger;
+  }
+});
+Object.defineProperty(exports, 'NullFileReader', {
+  enumerable: true,
+  get: function () {
+    return _flareapp_core.NullFileReader;
+  }
+});
+Object.defineProperty(exports, 'Scope', {
+  enumerable: true,
+  get: function () {
+    return _flareapp_core.Scope;
+  }
+});
+Object.defineProperty(exports, 'convertToError', {
+  enumerable: true,
+  get: function () {
+    return _flareapp_core.convertToError;
+  }
+});
+exports.flare = flare;
+Object.defineProperty(exports, 'redactUrlQuery', {
+  enumerable: true,
+  get: function () {
+    return _flareapp_core.redactUrlQuery;
+  }
+});
+Object.defineProperty(exports, 'resolveDenylist', {
+  enumerable: true,
+  get: function () {
+    return _flareapp_core.resolveDenylist;
+  }
+});