evlog 2.16.0 → 2.17.0

package/dist/{storage-BT-3fT1-.mjs.map → storage-Dwinmg8P.mjs.map}

@@ -1 +1 @@
-{"version":3,"file":"storage-BT-3fT1-.mjs","names":[],"sources":["../src/shared/storage.ts"],"sourcesContent":["import { AsyncLocalStorage } from 'node:async_hooks'\nimport type { RequestLogger } from '../types'\n\n/**\n * Create a request-scoped `AsyncLocalStorage` and matching `useLogger`\n * accessor. Every framework that exposes `useLogger()` (Express, Fastify,\n * NestJS, SvelteKit) calls this once at module level.\n *\n * @param contextHint - Appended to the error message when `useLogger()` is\n *   called outside of a request, e.g. `\"middleware context. Make sure\n *   app.use(evlog()) is registered before your routes.\"`.\n */\nexport function createLoggerStorage(contextHint: string) {\n  const storage = new AsyncLocalStorage<RequestLogger>()\n\n  function useLogger<T extends object = Record<string, unknown>>(): RequestLogger<T> {\n    const logger = storage.getStore()\n    if (!logger) {\n      throw new Error(\n        `[evlog] useLogger() was called outside of an evlog ${contextHint}`,\n      )\n    }\n    return logger as RequestLogger<T>\n  }\n\n  return { storage, useLogger }\n}\n"],"mappings":";;;;;;;;;;;AAYA,SAAgB,oBAAoB,aAAqB;CACvD,MAAM,UAAU,IAAI,mBAAkC;CAEtD,SAAS,YAA0E;EACjF,MAAM,SAAS,QAAQ,UAAU;AACjC,MAAI,CAAC,OACH,OAAM,IAAI,MACR,sDAAsD,cACvD;AAEH,SAAO;;AAGT,QAAO;EAAE;EAAS;EAAW"}
+{"version":3,"file":"storage-Dwinmg8P.mjs","names":[],"sources":["../src/shared/storage.ts"],"sourcesContent":["import { AsyncLocalStorage } from 'node:async_hooks'\nimport type { RequestLogger } from '../types'\n\n/**\n * Create a request-scoped `AsyncLocalStorage` and matching `useLogger`\n * accessor. Every framework that exposes `useLogger()` (Express, Fastify,\n * NestJS, SvelteKit) calls this once at module level.\n *\n * @param contextHint - Appended to the error message when `useLogger()` is\n *   called outside of a request, e.g. `\"middleware context. Make sure\n *   app.use(evlog()) is registered before your routes.\"`.\n */\nexport function createLoggerStorage(contextHint: string) {\n  const storage = new AsyncLocalStorage<RequestLogger>()\n\n  function useLogger<T extends object = Record<string, unknown>>(): RequestLogger<T> {\n    const logger = storage.getStore()\n    if (!logger) {\n      throw new Error(\n        `[evlog] useLogger() was called outside of an evlog ${contextHint}`,\n      )\n    }\n    return logger as RequestLogger<T>\n  }\n\n  return { storage, useLogger }\n}\n"],"mappings":";;;;;;;;;;;AAYA,SAAgB,oBAAoB,aAAqB;CACvD,MAAM,UAAU,IAAI,mBAAkC;CAEtD,SAAS,YAA0E;EACjF,MAAM,SAAS,QAAQ,UAAU;AACjC,MAAI,CAAC,OACH,OAAM,IAAI,MACR,sDAAsD,cACvD;AAEH,SAAO;;AAGT,QAAO;EAAE;EAAS;EAAW"}

package/dist/stream.d.mts

@@ -0,0 +1,185 @@
+import { I as DrainContext, ct as WideEvent } from "./audit-CC8nfazi.mjs";
+
+//#region src/stream.d.ts
+/** Configuration accepted by {@link createStreamDrain}. */
+interface StreamDrainOptions {
+  /**
+   * Number of recent events kept in the ring buffer and replayed to new
+   * subscribers via {@link StreamDrain.recent}. Set to `0` to disable
+   * replay.
+   * @default 500
+   */
+  buffer?: number;
+  /**
+   * Optional predicate run on each drained event — return `false` to skip
+   * the event entirely (it is neither buffered nor delivered).
+   */
+  filter?: (event: WideEvent) => boolean;
+  /**
+   * Per-subscriber queue size for the {@link StreamDrain.events} async
+   * iterator. When the consumer falls behind by more than this many events,
+   * the oldest queued events are dropped — the drain is never blocked.
+   * @default 1000
+   */
+  perSubscriberQueue?: number;
+}
+/** Live drain that exposes its events to in-process subscribers. */
+interface StreamDrain {
+  /**
+   * Drain callback. Pass to `nitroApp.hooks.hook('evlog:drain', stream.drain)`
+   * or to a plugin via `drainPlugin('stream', stream.drain)`.
+   */
+  drain: (ctx: DrainContext | DrainContext[]) => Promise<void>;
+  /**
+   * Register a synchronous listener. Errors thrown by the listener are
+   * caught and logged — they never affect other subscribers or the drain.
+   * @returns Unsubscribe function.
+   */
+  subscribe: (listener: (event: WideEvent) => void) => () => void;
+  /**
+   * Async iterator over live events. Each call returns a fresh iterator —
+   * past events from the ring buffer are NOT replayed. Combine with
+   * {@link StreamDrain.recent} to seed history.
+   *
+   * Calling `return()` (e.g. via `break`) cleanly unsubscribes.
+   */
+  events: () => AsyncIterableIterator<WideEvent>;
+  /**
+   * Snapshot of buffered events (oldest first, most recent last). Useful
+   * to seed a new connection / UI panel before switching to live updates.
+   */
+  recent: () => readonly WideEvent[];
+  /** Number of currently active subscribers (sync + async iterators). */
+  readonly subscriberCount: number;
+  /** Number of events dropped because the buffer was disabled or wrapped. */
+  readonly droppedCount: number;
+  /**
+   * Disconnect all subscribers and end any pending async iterators. The
+   * stream itself remains usable — new subscriptions still work.
+   */
+  close: () => void;
+}
+/**
+ * Create an in-process {@link StreamDrain}. Multiple stream drains can
+ * coexist in the same process — they are fully independent.
+ */
+declare function createStreamDrain(options?: StreamDrainOptions): StreamDrain;
+/**
+ * Lazily create / return the process-wide default {@link StreamDrain}.
+ *
+ * Used by built-in framework integrations (Nuxt SSE bridge, devtools panel)
+ * so they share a single buffer. Custom code can subscribe to this stream
+ * to observe everything draining through evlog without registering a new
+ * drain.
+ *
+ * @example
+ * ```ts
+ * import { getDefaultStream } from 'evlog/stream'
+ *
+ * getDefaultStream().subscribe((event) => console.log(event.action))
+ * ```
+ */
+declare function getDefaultStream(options?: StreamDrainOptions): StreamDrain;
+/**
+ * Replace or clear the default stream. Pass `null` to reset (mostly useful
+ * in tests).
+ */
+declare function setDefaultStream(stream: StreamDrain | null): void;
+/** Configuration accepted by {@link startStreamServer}. */
+interface StreamServerOptions {
+  /**
+   * TCP port to listen on. `0` (default) lets the OS pick an ephemeral port —
+   * the actual port is exposed on the returned `port` / `url` and printed in
+   * the startup banner.
+   * @default 0
+   */
+  port?: number;
+  /**
+   * Listen address. Default `127.0.0.1` — local-only, never exposed to the
+   * LAN. Override to `0.0.0.0` only if you understand the security
+   * implications.
+   * @default '127.0.0.1'
+   */
+  host?: string;
+  /**
+   * Bearer token. When set, the server requires `Authorization: Bearer
+   * <token>` on every request and 401s otherwise. When unset, only
+   * connections from `127.0.0.1` (and equivalent local hosts) are
+   * accepted — same-origin policy applies on non-local hosts.
+   */
+  token?: string;
+  /**
+   * Heartbeat interval (ms) sent as `event: ping` to keep the connection
+   * alive through proxies and detect disconnects.
+   * @default 15000
+   */
+  heartbeatMs?: number;
+  /**
+   * Ring buffer size kept on the underlying default stream — replayed for
+   * late-joining clients via `?since=<iso>`.
+   * @default 500
+   */
+  buffer?: number;
+  /**
+   * Print `[evlog] Stream → http://...` at startup.
+   * @default true
+   */
+  banner?: boolean;
+  /**
+   * Directory where `stream.url` is written so external tools can discover
+   * the server. Set to `false` to disable.
+   * @default '.evlog'
+   */
+  urlFileDir?: string | false;
+}
+/** Return value of {@link startStreamServer}. */
+interface StreamServer {
+  /** Listening URL, e.g. `http://127.0.0.1:51203`. */
+  readonly url: string;
+  /** Resolved TCP port (useful when `port: 0`). */
+  readonly port: number;
+  /**
+   * Drain function — register on `evlog:drain` (Nitro / Nuxt), pass to
+   * `initLogger({ drain })` (Next / standalone), or call directly.
+   *
+   * Equivalent to the underlying default stream's drain — events flow
+   * through and reach every connected SSE client.
+   */
+  readonly drain: (ctx: DrainContext | DrainContext[]) => Promise<void>;
+  /** The underlying in-process {@link StreamDrain}. */
+  readonly stream: StreamDrain;
+  /** Stop the server, remove the URL file, and unsubscribe all clients. */
+  close: () => Promise<void>;
+}
+/**
+ * Start a local HTTP server that exposes the default in-process stream over
+ * Server-Sent Events. Framework-agnostic: works in any Node / Bun process
+ * (Nuxt, Next.js, Hono, Express, Fastify, raw scripts).
+ *
+ * The server binds to `127.0.0.1` on an ephemeral port by default — local
+ * tools and browser tabs from the same machine can connect, but the LAN
+ * cannot reach it.
+ *
+ * Idempotent: subsequent calls return the same instance until `close()` is
+ * called.
+ *
+ * @example
+ * ```ts
+ * import { startStreamServer } from 'evlog/stream'
+ *
+ * const server = await startStreamServer()
+ * console.log(server.url) // → http://127.0.0.1:51203
+ *
+ * // Hook into your drain pipeline (Nitro example):
+ * nitroApp.hooks.hook('evlog:drain', server.drain)
+ *
+ * // Or for a standalone script with initLogger:
+ * initLogger({ drain: server.drain })
+ * ```
+ */
+declare function startStreamServer(options?: StreamServerOptions): Promise<StreamServer>;
+/** @internal Used by tests to reset state between specs. */
+declare function resetStreamServerForTests(): void;
+//#endregion
+export { StreamDrain, StreamDrainOptions, StreamServer, StreamServerOptions, createStreamDrain, getDefaultStream, resetStreamServerForTests, setDefaultStream, startStreamServer };
+//# sourceMappingURL=stream.d.mts.map

package/dist/stream.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stream.d.mts","names":[],"sources":["../src/stream.ts"],"mappings":";;;;UA0BiB,kBAAA;EA+CiB;;;;;;EAxChC,MAAA;EA2BA;;;;EAtBA,MAAA,IAAU,KAAA,EAAO,SAAA;EA8BH;;;;;;EAvBd,kBAAA;AAAA;;UAIe,WAAA;EAgDgB;;;;EA3C/B,KAAA,GAAQ,GAAA,EAAK,YAAA,GAAe,YAAA,OAAmB,OAAA;EA2CoB;;;AAsJrE;;EA3LE,SAAA,GAAY,QAAA,GAAW,KAAA,EAAO,SAAA;EA2L2C;;;;;;AAS3E;EA5LE,MAAA,QAAc,qBAAA,CAAsB,SAAA;;;;AAkMtC;EA7LE,MAAA,iBAAuB,SAAA;;WAEd,eAAA;EAkMT;EAAA,SAhMS,YAAA;EA8MT;;;;EAzMA,KAAA;AAAA;;AAoOF;;;iBArNgB,iBAAA,CAAkB,OAAA,GAAS,kBAAA,GAA0B,WAAA;;;;;;;;;;;;;;;;iBAsJrD,gBAAA,CAAiB,OAAA,GAAU,kBAAA,GAAqB,WAAA;;;;AA6HhE;iBApHgB,gBAAA,CAAiB,MAAA,EAAQ,WAAA;;UAMxB,mBAAA;EA8GmE;;;;;;EAvGlF,IAAA;EAuGkF;;;AAyMpF;;;EAzSE,IAAA;EAySuC;;;;;;EAlSvC,KAAA;;;;;;EAMA,WAAA;;;;;;EAMA,MAAA;;;;;EAKA,MAAA;;;;;;EAMA,UAAA;AAAA;;UAIe,YAAA;;WAEN,GAAA;;WAEA,IAAA;;;;;;;;WAQA,KAAA,GAAQ,GAAA,EAAK,YAAA,GAAe,YAAA,OAAmB,OAAA;;WAE/C,MAAA,EAAQ,WAAA;;EAEjB,KAAA,QAAa,OAAA;AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA8CO,iBAAA,CAAkB,OAAA,GAAS,mBAAA,GAA2B,OAAA,CAAQ,YAAA;;iBAyMpE,yBAAA,CAAA"}

package/dist/stream.mjs

@@ -0,0 +1,374 @@
+import { n as EVLOG_VERSION } from "./http-6umVAKDW.mjs";
+//#region src/stream.ts
+const DEFAULT_BUFFER = 500;
+const DEFAULT_QUEUE = 1e3;
+/**
+* Create an in-process {@link StreamDrain}. Multiple stream drains can
+* coexist in the same process — they are fully independent.
+*/
+function createStreamDrain(options = {}) {
+	const bufferSize = Math.max(0, Math.floor(options.buffer ?? DEFAULT_BUFFER));
+	const queueLimit = Math.max(1, Math.floor(options.perSubscriberQueue ?? DEFAULT_QUEUE));
+	const { filter } = options;
+	const buffer = [];
+	const syncListeners = /* @__PURE__ */ new Set();
+	const asyncSubscribers = /* @__PURE__ */ new Set();
+	let dropped = 0;
+	function publish(event) {
+		if (filter && !filter(event)) return;
+		if (bufferSize > 0) {
+			buffer.push(event);
+			while (buffer.length > bufferSize) {
+				buffer.shift();
+				dropped++;
+			}
+		}
+		for (const listener of syncListeners) try {
+			listener(event);
+		} catch (err) {
+			console.error("[evlog/stream] subscriber threw:", err);
+		}
+		for (const sub of asyncSubscribers) sub.push(event);
+	}
+	const drain = (ctx) => {
+		const contexts = Array.isArray(ctx) ? ctx : [ctx];
+		for (const c of contexts) if (c?.event) publish(c.event);
+		return Promise.resolve();
+	};
+	const subscribe = (listener) => {
+		syncListeners.add(listener);
+		return () => {
+			syncListeners.delete(listener);
+		};
+	};
+	function createAsyncIterator() {
+		const queue = [];
+		let pendingResolve = null;
+		let closed = false;
+		const subscriber = {
+			push(event) {
+				if (closed) return;
+				if (pendingResolve) {
+					const resolve = pendingResolve;
+					pendingResolve = null;
+					resolve({
+						value: event,
+						done: false
+					});
+					return;
+				}
+				queue.push(event);
+				while (queue.length > queueLimit) {
+					queue.shift();
+					dropped++;
+				}
+			},
+			end() {
+				if (closed) return;
+				closed = true;
+				if (pendingResolve) {
+					const resolve = pendingResolve;
+					pendingResolve = null;
+					resolve({
+						value: void 0,
+						done: true
+					});
+				}
+			}
+		};
+		asyncSubscribers.add(subscriber);
+		const iterator = {
+			[Symbol.asyncIterator]() {
+				return iterator;
+			},
+			next() {
+				if (queue.length > 0) return Promise.resolve({
+					value: queue.shift(),
+					done: false
+				});
+				if (closed) return Promise.resolve({
+					value: void 0,
+					done: true
+				});
+				return new Promise((resolve) => {
+					pendingResolve = resolve;
+				});
+			},
+			return() {
+				closed = true;
+				asyncSubscribers.delete(subscriber);
+				if (pendingResolve) {
+					const resolve = pendingResolve;
+					pendingResolve = null;
+					resolve({
+						value: void 0,
+						done: true
+					});
+				}
+				return Promise.resolve({
+					value: void 0,
+					done: true
+				});
+			}
+		};
+		return iterator;
+	}
+	return {
+		drain,
+		subscribe,
+		events: createAsyncIterator,
+		recent: () => buffer.slice(),
+		get subscriberCount() {
+			return syncListeners.size + asyncSubscribers.size;
+		},
+		get droppedCount() {
+			return dropped;
+		},
+		close() {
+			syncListeners.clear();
+			for (const sub of asyncSubscribers) sub.end();
+			asyncSubscribers.clear();
+		}
+	};
+}
+let defaultStream = null;
+/**
+* Lazily create / return the process-wide default {@link StreamDrain}.
+*
+* Used by built-in framework integrations (Nuxt SSE bridge, devtools panel)
+* so they share a single buffer. Custom code can subscribe to this stream
+* to observe everything draining through evlog without registering a new
+* drain.
+*
+* @example
+* ```ts
+* import { getDefaultStream } from 'evlog/stream'
+*
+* getDefaultStream().subscribe((event) => console.log(event.action))
+* ```
+*/
+function getDefaultStream(options) {
+	if (!defaultStream) defaultStream = createStreamDrain(options);
+	return defaultStream;
+}
+/**
+* Replace or clear the default stream. Pass `null` to reset (mostly useful
+* in tests).
+*/
+function setDefaultStream(stream) {
+	defaultStream?.close();
+	defaultStream = stream;
+}
+const STREAM_DEFAULTS = {
+	port: 0,
+	host: "127.0.0.1",
+	heartbeatMs: 15e3,
+	buffer: 500,
+	banner: true,
+	urlFileDir: ".evlog"
+};
+let activeStreamServer = null;
+function isLocalHost(host) {
+	if (!host) return false;
+	const lower = host.toLowerCase();
+	return lower.startsWith("localhost") || lower.startsWith("127.0.0.1") || lower.startsWith("[::1]");
+}
+/**
+* Start a local HTTP server that exposes the default in-process stream over
+* Server-Sent Events. Framework-agnostic: works in any Node / Bun process
+* (Nuxt, Next.js, Hono, Express, Fastify, raw scripts).
+*
+* The server binds to `127.0.0.1` on an ephemeral port by default — local
+* tools and browser tabs from the same machine can connect, but the LAN
+* cannot reach it.
+*
+* Idempotent: subsequent calls return the same instance until `close()` is
+* called.
+*
+* @example
+* ```ts
+* import { startStreamServer } from 'evlog/stream'
+*
+* const server = await startStreamServer()
+* console.log(server.url) // → http://127.0.0.1:51203
+*
+* // Hook into your drain pipeline (Nitro example):
+* nitroApp.hooks.hook('evlog:drain', server.drain)
+*
+* // Or for a standalone script with initLogger:
+* initLogger({ drain: server.drain })
+* ```
+*/
+async function startStreamServer(options = {}) {
+	if (activeStreamServer) return activeStreamServer;
+	const opts = {
+		...STREAM_DEFAULTS,
+		...options
+	};
+	const stream = getDefaultStream({ buffer: opts.buffer });
+	const { createServer } = await import("node:http");
+	const { writeFile, unlink, mkdir } = await import("node:fs/promises");
+	const { unlinkSync } = await import("node:fs");
+	const { join } = await import("node:path");
+	function envelopeFrame(type, data) {
+		return `data: ${JSON.stringify({
+			evlog: "1",
+			type,
+			data
+		})}\n\n`;
+	}
+	function writeCors(res) {
+		res.setHeader("Access-Control-Allow-Origin", "*");
+		res.setHeader("Access-Control-Allow-Methods", "GET, OPTIONS");
+		res.setHeader("Access-Control-Allow-Headers", "Authorization, Accept");
+	}
+	const server = createServer((req, res) => {
+		if (req.method === "OPTIONS") {
+			writeCors(res);
+			res.writeHead(204);
+			res.end();
+			return;
+		}
+		if (req.method !== "GET") {
+			res.writeHead(405);
+			res.end("method not allowed");
+			return;
+		}
+		if (opts.token) {
+			if (req.headers.authorization !== `Bearer ${opts.token}`) {
+				writeCors(res);
+				res.writeHead(401);
+				res.end("unauthorized");
+				return;
+			}
+		} else {
+			const origin = typeof req.headers.origin === "string" ? req.headers.origin : null;
+			if (origin) {
+				let originHost = null;
+				try {
+					originHost = new URL(origin).host;
+				} catch {
+					originHost = null;
+				}
+				if (!isLocalHost(originHost ?? void 0)) {
+					writeCors(res);
+					res.writeHead(403);
+					res.end("forbidden");
+					return;
+				}
+			}
+		}
+		const url = new URL(req.url ?? "/", "http://localhost");
+		if (url.pathname === "/info") {
+			writeCors(res);
+			res.writeHead(200, { "Content-Type": "application/json" });
+			res.end(JSON.stringify({
+				evlogVersion: EVLOG_VERSION,
+				bufferSize: opts.buffer,
+				heartbeatMs: opts.heartbeatMs
+			}));
+			return;
+		}
+		writeCors(res);
+		res.writeHead(200, {
+			"Content-Type": "text/event-stream; charset=utf-8",
+			"Cache-Control": "no-cache, no-transform",
+			"Connection": "keep-alive",
+			"X-Accel-Buffering": "no",
+			"X-Evlog-Version": EVLOG_VERSION
+		});
+		res.write(envelopeFrame("hello", {
+			evlogVersion: EVLOG_VERSION,
+			bufferSize: opts.buffer,
+			heartbeatMs: opts.heartbeatMs
+		}));
+		const since = url.searchParams.get("since");
+		const sinceMs = since ? Date.parse(since) : NaN;
+		if (Number.isFinite(sinceMs)) for (const past of stream.recent()) {
+			const ts = typeof past.timestamp === "string" ? Date.parse(past.timestamp) : NaN;
+			if (Number.isFinite(ts) && ts >= sinceMs) res.write(envelopeFrame("replay", past));
+		}
+		let closed = false;
+		const unsubscribe = stream.subscribe((event) => {
+			if (closed) return;
+			res.write(envelopeFrame("event", event));
+		});
+		const heartbeat = setInterval(() => {
+			if (closed) return;
+			res.write(`event: ping\ndata: ${JSON.stringify({
+				evlog: "1",
+				type: "ping",
+				data: { t: Date.now() }
+			})}\n\n`);
+		}, opts.heartbeatMs);
+		const cleanup = () => {
+			if (closed) return;
+			closed = true;
+			clearInterval(heartbeat);
+			unsubscribe();
+			try {
+				res.end();
+			} catch {}
+		};
+		req.on("close", cleanup);
+		req.on("error", cleanup);
+		res.on("close", cleanup);
+		res.on("error", cleanup);
+	});
+	const port = await new Promise((resolve, reject) => {
+		server.once("error", reject);
+		server.listen(opts.port, opts.host, () => {
+			const addr = server.address();
+			if (addr && typeof addr === "object") resolve(addr.port);
+			else reject(/* @__PURE__ */ new Error("[evlog/stream] failed to determine listening port"));
+		});
+	});
+	const url = `http://${opts.host}:${port}`;
+	let urlFile;
+	if (opts.urlFileDir !== false) try {
+		await mkdir(opts.urlFileDir, { recursive: true });
+		urlFile = join(opts.urlFileDir, "stream.url");
+		await writeFile(urlFile, url, "utf-8");
+	} catch (err) {
+		console.warn("[evlog/stream] failed to write stream.url:", err);
+	}
+	if (opts.banner) console.info(`\n  [evlog] Stream → ${url}\n`);
+	const exitHandler = () => {
+		if (urlFile) try {
+			unlinkSync(urlFile);
+		} catch {}
+		server.close();
+	};
+	process.once("SIGINT", exitHandler);
+	process.once("SIGTERM", exitHandler);
+	process.once("exit", exitHandler);
+	const close = async () => {
+		process.off("SIGINT", exitHandler);
+		process.off("SIGTERM", exitHandler);
+		process.off("exit", exitHandler);
+		if (urlFile) try {
+			await unlink(urlFile);
+		} catch {}
+		await new Promise((resolve, reject) => {
+			server.close((err) => err ? reject(err) : resolve());
+		});
+		if (activeStreamServer === result) activeStreamServer = null;
+	};
+	const result = {
+		url,
+		port,
+		drain: (ctx) => stream.drain(ctx),
+		stream,
+		close
+	};
+	activeStreamServer = result;
+	return result;
+}
+/** @internal Used by tests to reset state between specs. */
+function resetStreamServerForTests() {
+	activeStreamServer = null;
+}
+//#endregion
+export { createStreamDrain, getDefaultStream, resetStreamServerForTests, setDefaultStream, startStreamServer };
+
+//# sourceMappingURL=stream.mjs.map

package/dist/stream.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"stream.mjs","names":[],"sources":["../src/stream.ts"],"sourcesContent":["/**\n * In-process event stream — the foundation for any local consumer (devtools,\n * dashboards, CLIs, SSE/WebSocket bridges) to observe events flowing through\n * the drain pipeline without re-implementing one.\n *\n * @example\n * ```ts\n * import { createStreamDrain } from 'evlog/stream'\n *\n * const stream = createStreamDrain({ buffer: 200 })\n * nitroApp.hooks.hook('evlog:drain', stream.drain)\n *\n * stream.subscribe((event) => {\n *   if (event.level === 'error') notifyOps(event)\n * })\n *\n * for await (const event of stream.events()) {\n *   console.log(event.timestamp, event.action ?? event.message)\n * }\n * ```\n */\n\nimport type { DrainContext, WideEvent } from './types'\nimport { EVLOG_VERSION } from './shared/http'\n\n/** Configuration accepted by {@link createStreamDrain}. */\nexport interface StreamDrainOptions {\n  /**\n   * Number of recent events kept in the ring buffer and replayed to new\n   * subscribers via {@link StreamDrain.recent}. Set to `0` to disable\n   * replay.\n   * @default 500\n   */\n  buffer?: number\n  /**\n   * Optional predicate run on each drained event — return `false` to skip\n   * the event entirely (it is neither buffered nor delivered).\n   */\n  filter?: (event: WideEvent) => boolean\n  /**\n   * Per-subscriber queue size for the {@link StreamDrain.events} async\n   * iterator. When the consumer falls behind by more than this many events,\n   * the oldest queued events are dropped — the drain is never blocked.\n   * @default 1000\n   */\n  perSubscriberQueue?: number\n}\n\n/** Live drain that exposes its events to in-process subscribers. */\nexport interface StreamDrain {\n  /**\n   * Drain callback. Pass to `nitroApp.hooks.hook('evlog:drain', stream.drain)`\n   * or to a plugin via `drainPlugin('stream', stream.drain)`.\n   */\n  drain: (ctx: DrainContext | DrainContext[]) => Promise<void>\n  /**\n   * Register a synchronous listener. Errors thrown by the listener are\n   * caught and logged — they never affect other subscribers or the drain.\n   * @returns Unsubscribe function.\n   */\n  subscribe: (listener: (event: WideEvent) => void) => () => void\n  /**\n   * Async iterator over live events. Each call returns a fresh iterator —\n   * past events from the ring buffer are NOT replayed. Combine with\n   * {@link StreamDrain.recent} to seed history.\n   *\n   * Calling `return()` (e.g. via `break`) cleanly unsubscribes.\n   */\n  events: () => AsyncIterableIterator<WideEvent>\n  /**\n   * Snapshot of buffered events (oldest first, most recent last). Useful\n   * to seed a new connection / UI panel before switching to live updates.\n   */\n  recent: () => readonly WideEvent[]\n  /** Number of currently active subscribers (sync + async iterators). */\n  readonly subscriberCount: number\n  /** Number of events dropped because the buffer was disabled or wrapped. */\n  readonly droppedCount: number\n  /**\n   * Disconnect all subscribers and end any pending async iterators. The\n   * stream itself remains usable — new subscriptions still work.\n   */\n  close: () => void\n}\n\nconst DEFAULT_BUFFER = 500\nconst DEFAULT_QUEUE = 1000\n\ninterface AsyncSubscriber {\n  push: (event: WideEvent) => void\n  end: () => void\n}\n\n/**\n * Create an in-process {@link StreamDrain}. Multiple stream drains can\n * coexist in the same process — they are fully independent.\n */\nexport function createStreamDrain(options: StreamDrainOptions = {}): StreamDrain {\n  const bufferSize = Math.max(0, Math.floor(options.buffer ?? DEFAULT_BUFFER))\n  const queueLimit = Math.max(1, Math.floor(options.perSubscriberQueue ?? DEFAULT_QUEUE))\n  const { filter } = options\n\n  const buffer: WideEvent[] = []\n  const syncListeners = new Set<(event: WideEvent) => void>()\n  const asyncSubscribers = new Set<AsyncSubscriber>()\n  let dropped = 0\n\n  function publish(event: WideEvent): void {\n    if (filter && !filter(event)) return\n\n    if (bufferSize > 0) {\n      buffer.push(event)\n      while (buffer.length > bufferSize) {\n        buffer.shift()\n        dropped++\n      }\n    }\n\n    for (const listener of syncListeners) {\n      try {\n        listener(event)\n      } catch (err) {\n        console.error('[evlog/stream] subscriber threw:', err)\n      }\n    }\n\n    for (const sub of asyncSubscribers) {\n      sub.push(event)\n    }\n  }\n\n  const drain: StreamDrain['drain'] = (ctx) => {\n    const contexts = Array.isArray(ctx) ? ctx : [ctx]\n    for (const c of contexts) {\n      if (c?.event) publish(c.event)\n    }\n    return Promise.resolve()\n  }\n\n  const subscribe: StreamDrain['subscribe'] = (listener) => {\n    syncListeners.add(listener)\n    return () => {\n      syncListeners.delete(listener)\n    }\n  }\n\n  function createAsyncIterator(): AsyncIterableIterator<WideEvent> {\n    const queue: WideEvent[] = []\n    let pendingResolve: ((result: IteratorResult<WideEvent>) => void) | null = null\n    let closed = false\n\n    const subscriber: AsyncSubscriber = {\n      push(event) {\n        if (closed) return\n        if (pendingResolve) {\n          const resolve = pendingResolve\n          pendingResolve = null\n          resolve({ value: event, done: false })\n          return\n        }\n        queue.push(event)\n        while (queue.length > queueLimit) {\n          queue.shift()\n          dropped++\n        }\n      },\n      end() {\n        if (closed) return\n        closed = true\n        if (pendingResolve) {\n          const resolve = pendingResolve\n          pendingResolve = null\n          resolve({ value: undefined, done: true })\n        }\n      },\n    }\n\n    asyncSubscribers.add(subscriber)\n\n    const iterator: AsyncIterableIterator<WideEvent> = {\n      [Symbol.asyncIterator]() {\n        return iterator\n      },\n      next(): Promise<IteratorResult<WideEvent>> {\n        if (queue.length > 0) {\n          return Promise.resolve({ value: queue.shift()!, done: false })\n        }\n        if (closed) {\n          return Promise.resolve({ value: undefined, done: true })\n        }\n        return new Promise((resolve) => {\n          pendingResolve = resolve\n        })\n      },\n      return(): Promise<IteratorResult<WideEvent>> {\n        closed = true\n        asyncSubscribers.delete(subscriber)\n        if (pendingResolve) {\n          const resolve = pendingResolve\n          pendingResolve = null\n          resolve({ value: undefined, done: true })\n        }\n        return Promise.resolve({ value: undefined, done: true })\n      },\n    }\n\n    return iterator\n  }\n\n  return {\n    drain,\n    subscribe,\n    events: createAsyncIterator,\n    recent: () => buffer.slice(),\n    get subscriberCount() {\n      return syncListeners.size + asyncSubscribers.size\n    },\n    get droppedCount() {\n      return dropped\n    },\n    close() {\n      syncListeners.clear()\n      for (const sub of asyncSubscribers) {\n        sub.end()\n      }\n      asyncSubscribers.clear()\n    },\n  }\n}\n\nlet defaultStream: StreamDrain | null = null\n\n/**\n * Lazily create / return the process-wide default {@link StreamDrain}.\n *\n * Used by built-in framework integrations (Nuxt SSE bridge, devtools panel)\n * so they share a single buffer. Custom code can subscribe to this stream\n * to observe everything draining through evlog without registering a new\n * drain.\n *\n * @example\n * ```ts\n * import { getDefaultStream } from 'evlog/stream'\n *\n * getDefaultStream().subscribe((event) => console.log(event.action))\n * ```\n */\nexport function getDefaultStream(options?: StreamDrainOptions): StreamDrain {\n  if (!defaultStream) defaultStream = createStreamDrain(options)\n  return defaultStream\n}\n\n/**\n * Replace or clear the default stream. Pass `null` to reset (mostly useful\n * in tests).\n */\nexport function setDefaultStream(stream: StreamDrain | null): void {\n  defaultStream?.close()\n  defaultStream = stream\n}\n\n/** Configuration accepted by {@link startStreamServer}. */\nexport interface StreamServerOptions {\n  /**\n   * TCP port to listen on. `0` (default) lets the OS pick an ephemeral port —\n   * the actual port is exposed on the returned `port` / `url` and printed in\n   * the startup banner.\n   * @default 0\n   */\n  port?: number\n  /**\n   * Listen address. Default `127.0.0.1` — local-only, never exposed to the\n   * LAN. Override to `0.0.0.0` only if you understand the security\n   * implications.\n   * @default '127.0.0.1'\n   */\n  host?: string\n  /**\n   * Bearer token. When set, the server requires `Authorization: Bearer\n   * <token>` on every request and 401s otherwise. When unset, only\n   * connections from `127.0.0.1` (and equivalent local hosts) are\n   * accepted — same-origin policy applies on non-local hosts.\n   */\n  token?: string\n  /**\n   * Heartbeat interval (ms) sent as `event: ping` to keep the connection\n   * alive through proxies and detect disconnects.\n   * @default 15000\n   */\n  heartbeatMs?: number\n  /**\n   * Ring buffer size kept on the underlying default stream — replayed for\n   * late-joining clients via `?since=<iso>`.\n   * @default 500\n   */\n  buffer?: number\n  /**\n   * Print `[evlog] Stream → http://...` at startup.\n   * @default true\n   */\n  banner?: boolean\n  /**\n   * Directory where `stream.url` is written so external tools can discover\n   * the server. Set to `false` to disable.\n   * @default '.evlog'\n   */\n  urlFileDir?: string | false\n}\n\n/** Return value of {@link startStreamServer}. */\nexport interface StreamServer {\n  /** Listening URL, e.g. `http://127.0.0.1:51203`. */\n  readonly url: string\n  /** Resolved TCP port (useful when `port: 0`). */\n  readonly port: number\n  /**\n   * Drain function — register on `evlog:drain` (Nitro / Nuxt), pass to\n   * `initLogger({ drain })` (Next / standalone), or call directly.\n   *\n   * Equivalent to the underlying default stream's drain — events flow\n   * through and reach every connected SSE client.\n   */\n  readonly drain: (ctx: DrainContext | DrainContext[]) => Promise<void>\n  /** The underlying in-process {@link StreamDrain}. */\n  readonly stream: StreamDrain\n  /** Stop the server, remove the URL file, and unsubscribe all clients. */\n  close: () => Promise<void>\n}\n\nconst STREAM_DEFAULTS = {\n  port: 0,\n  host: '127.0.0.1',\n  heartbeatMs: 15_000,\n  buffer: 500,\n  banner: true,\n  urlFileDir: '.evlog' as string | false,\n}\n\nlet activeStreamServer: StreamServer | null = null\n\nfunction isLocalHost(host: string | undefined): boolean {\n  if (!host) return false\n  const lower = host.toLowerCase()\n  return lower.startsWith('localhost') || lower.startsWith('127.0.0.1') || lower.startsWith('[::1]')\n}\n\n/**\n * Start a local HTTP server that exposes the default in-process stream over\n * Server-Sent Events. Framework-agnostic: works in any Node / Bun process\n * (Nuxt, Next.js, Hono, Express, Fastify, raw scripts).\n *\n * The server binds to `127.0.0.1` on an ephemeral port by default — local\n * tools and browser tabs from the same machine can connect, but the LAN\n * cannot reach it.\n *\n * Idempotent: subsequent calls return the same instance until `close()` is\n * called.\n *\n * @example\n * ```ts\n * import { startStreamServer } from 'evlog/stream'\n *\n * const server = await startStreamServer()\n * console.log(server.url) // → http://127.0.0.1:51203\n *\n * // Hook into your drain pipeline (Nitro example):\n * nitroApp.hooks.hook('evlog:drain', server.drain)\n *\n * // Or for a standalone script with initLogger:\n * initLogger({ drain: server.drain })\n * ```\n */\nexport async function startStreamServer(options: StreamServerOptions = {}): Promise<StreamServer> {\n  if (activeStreamServer) return activeStreamServer\n\n  const opts = { ...STREAM_DEFAULTS, ...options }\n  const stream = getDefaultStream({ buffer: opts.buffer })\n\n  const { createServer } = await import('node:http')\n  const { writeFile, unlink, mkdir } = await import('node:fs/promises')\n  const { unlinkSync } = await import('node:fs')\n  const { join } = await import('node:path')\n\n  function envelopeFrame(type: 'event' | 'replay' | 'hello', data: unknown): string {\n    return `data: ${JSON.stringify({ evlog: '1', type, data })}\\n\\n`\n  }\n\n  function writeCors(res: import('node:http').ServerResponse): void {\n    res.setHeader('Access-Control-Allow-Origin', '*')\n    res.setHeader('Access-Control-Allow-Methods', 'GET, OPTIONS')\n    res.setHeader('Access-Control-Allow-Headers', 'Authorization, Accept')\n  }\n\n  const server = createServer((req, res) => {\n    if (req.method === 'OPTIONS') {\n      writeCors(res)\n      res.writeHead(204)\n      res.end()\n      return\n    }\n\n    if (req.method !== 'GET') {\n      res.writeHead(405)\n      res.end('method not allowed')\n      return\n    }\n\n    if (opts.token) {\n      if (req.headers.authorization !== `Bearer ${opts.token}`) {\n        writeCors(res)\n        res.writeHead(401)\n        res.end('unauthorized')\n        return\n      }\n    } else {\n      const origin = typeof req.headers.origin === 'string' ? req.headers.origin : null\n      if (origin) {\n        let originHost: string | null = null\n        try {\n          originHost = new URL(origin).host\n        } catch {\n          originHost = null\n        }\n        if (!isLocalHost(originHost ?? undefined)) {\n          writeCors(res)\n          res.writeHead(403)\n          res.end('forbidden')\n          return\n        }\n      }\n    }\n\n    const url = new URL(req.url ?? '/', 'http://localhost')\n\n    if (url.pathname === '/info') {\n      writeCors(res)\n      res.writeHead(200, { 'Content-Type': 'application/json' })\n      res.end(JSON.stringify({\n        evlogVersion: EVLOG_VERSION,\n        bufferSize: opts.buffer,\n        heartbeatMs: opts.heartbeatMs,\n      }))\n      return\n    }\n\n    writeCors(res)\n    res.writeHead(200, {\n      'Content-Type': 'text/event-stream; charset=utf-8',\n      'Cache-Control': 'no-cache, no-transform',\n      'Connection': 'keep-alive',\n      'X-Accel-Buffering': 'no',\n      'X-Evlog-Version': EVLOG_VERSION,\n    })\n\n    res.write(envelopeFrame('hello', {\n      evlogVersion: EVLOG_VERSION,\n      bufferSize: opts.buffer,\n      heartbeatMs: opts.heartbeatMs,\n    }))\n\n    const since = url.searchParams.get('since')\n    const sinceMs = since ? Date.parse(since) : Number.NaN\n    if (Number.isFinite(sinceMs)) {\n      for (const past of stream.recent()) {\n        const ts = typeof past.timestamp === 'string' ? Date.parse(past.timestamp) : Number.NaN\n        if (Number.isFinite(ts) && ts >= sinceMs) {\n          res.write(envelopeFrame('replay', past))\n        }\n      }\n    }\n\n    let closed = false\n    const unsubscribe = stream.subscribe((event) => {\n      if (closed) return\n      res.write(envelopeFrame('event', event))\n    })\n\n    const heartbeat = setInterval(() => {\n      if (closed) return\n      res.write(`event: ping\\ndata: ${JSON.stringify({ evlog: '1', type: 'ping', data: { t: Date.now() } })}\\n\\n`)\n    }, opts.heartbeatMs)\n\n    const cleanup = () => {\n      if (closed) return\n      closed = true\n      clearInterval(heartbeat)\n      unsubscribe()\n      try {\n        res.end()\n      } catch {\n        // noop\n      }\n    }\n\n    req.on('close', cleanup)\n    req.on('error', cleanup)\n    res.on('close', cleanup)\n    res.on('error', cleanup)\n  })\n\n  const port: number = await new Promise((resolve, reject) => {\n    server.once('error', reject)\n    server.listen(opts.port, opts.host, () => {\n      const addr = server.address()\n      if (addr && typeof addr === 'object') {\n        resolve(addr.port)\n      } else {\n        reject(new Error('[evlog/stream] failed to determine listening port'))\n      }\n    })\n  })\n\n  const url = `http://${opts.host}:${port}`\n\n  let urlFile: string | undefined\n  if (opts.urlFileDir !== false) {\n    try {\n      await mkdir(opts.urlFileDir, { recursive: true })\n      urlFile = join(opts.urlFileDir, 'stream.url')\n      await writeFile(urlFile, url, 'utf-8')\n    } catch (err) {\n      console.warn('[evlog/stream] failed to write stream.url:', err)\n    }\n  }\n\n  if (opts.banner) {\n    console.info(`\\n  [evlog] Stream → ${url}\\n`)\n  }\n\n  const exitHandler = () => {\n    if (urlFile) {\n      try {\n        unlinkSync(urlFile)\n      } catch {\n        // noop\n      }\n    }\n    server.close()\n  }\n  process.once('SIGINT', exitHandler)\n  process.once('SIGTERM', exitHandler)\n  process.once('exit', exitHandler)\n\n  const close = async (): Promise<void> => {\n    process.off('SIGINT', exitHandler)\n    process.off('SIGTERM', exitHandler)\n    process.off('exit', exitHandler)\n    if (urlFile) {\n      try {\n        await unlink(urlFile)\n      } catch {\n        // noop\n      }\n    }\n    await new Promise<void>((resolve, reject) => {\n      server.close(err => err ? reject(err) : resolve())\n    })\n    if (activeStreamServer === result) activeStreamServer = null\n  }\n\n  const result: StreamServer = {\n    url,\n    port,\n    drain: ctx => stream.drain(ctx),\n    stream,\n    close,\n  }\n\n  activeStreamServer = result\n  return result\n}\n\n/** @internal Used by tests to reset state between specs. */\nexport function resetStreamServerForTests(): void {\n  activeStreamServer = null\n}\n"],"mappings":"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"}

package/dist/sveltekit/index.d.mts

@@ -1,5 +1,5 @@
-import { Y as RequestLogger } from "../audit-X1uUukm3.mjs";
-import { t as BaseEvlogOptions } from "../middleware-CAQHJRN1.mjs";
+import { $ as RequestLogger } from "../audit-CC8nfazi.mjs";
+import { t as BaseEvlogOptions } from "../middleware-U-lIAzHg.mjs";
 
 //#region src/sveltekit/index.d.ts
 declare const useLogger: <T extends object = Record<string, unknown>>() => RequestLogger<T>;

package/dist/sveltekit/index.mjs

@@ -1,9 +1,9 @@
 import { t as extractSafeHeaders } from "../headers-CU-QqnYg.mjs";
 import { EvlogError } from "../error.mjs";
 import { t as extractErrorStatus } from "../errors-BQgyQ9xe.mjs";
-import { n as serializeEvlogErrorResponse, t as resolveEvlogError } from "../nitro-DavLelNz.mjs";
-import { r as createMiddlewareLogger, t as attachForkToLogger } from "../fork-DPN8aL8O.mjs";
-import { t as createLoggerStorage } from "../storage-BT-3fT1-.mjs";
+import { n as serializeEvlogErrorResponse, t as resolveEvlogError } from "../nitro-DErMq_Zj.mjs";
+import { r as createMiddlewareLogger, t as attachForkToLogger } from "../fork-8u_zFOJq.mjs";
+import { t as createLoggerStorage } from "../storage-Dwinmg8P.mjs";
 //#region src/sveltekit/index.ts
 const { storage, useLogger } = createLoggerStorage("handle context. Make sure evlog() handle is added to your hooks.server.ts.");
 /**