@mugenlabs/logtape-devtools 0.2.1 → 0.4.0

package/README.md

@@ -4,13 +4,17 @@ A [TanStack DevTools](https://tanstack.com/devtools) plugin for inspecting [LogT
 
 Filter, search, and inspect structured logs in real time — without leaving the browser DevTools overlay.
 
+![The LogTape DevTools panel](./assets/panel.png)
+
 ## Features
 
 - **Live log streaming** — see logs as they happen
 - **Level filtering** — toggle trace, debug, info, warning, error, fatal
 - **Category search** — filter by logger category
-- **Structured inspection** — expand logs to view properties and stack traces
+- **Structured inspection** — expand logs to view properties and source location
 - **Pause & resume** — freeze the log stream to inspect entries
+- **Bounded memory** — a ring buffer keeps a fixed number of records
+- **Cheap when closed** — notifications are batched, the list is virtualized, and stack capture is skipped while no panel is subscribed
 
 ## Installation
 
@@ -20,63 +24,232 @@ pnpm add @mugenlabs/logtape-devtools @logtape/logtape @tanstack/react-devtools
 
 ## Quick Start
 
-### 1. Configure the LogTape sink
+`createLogTapeDevtools()` returns a sink and a panel plugin already wired to the same store. This is the recommended path.
+
+```tsx
+import { configure, getLogger } from "@logtape/logtape";
+import { createLogTapeDevtools } from "@mugenlabs/logtape-devtools";
+import { TanStackDevtools } from "@tanstack/react-devtools";
+
+const { sink, plugin } = createLogTapeDevtools();
+
+await configure({
+  sinks: { devtools: sink },
+  loggers: [{ category: [], lowestLevel: "trace", sinks: ["devtools"] }],
+});
+
+getLogger(["app", "auth"]).info("User {username} logged in", { username: "john_doe" });
+
+function App() {
+  return (
+    <>
+      <YourApp />
+      <TanStackDevtools plugins={[plugin]} />
+    </>
+  );
+}
+```
+
+### Advanced: two factories with an explicit store
+
+Use the individual factories when you need to hold on to the store — for example to clear it from a test, to run several isolated stores, or to configure LogTape in a file that must not import React.
 
 ```ts
+// logging.ts
 import { configure } from "@logtape/logtape";
-import { createDevtoolsSink } from "@mugenlabs/logtape-devtools";
+import { createDevtoolsSink, createLogStore } from "@mugenlabs/logtape-devtools";
+
+export const logStore = createLogStore({ maxRecords: 5000 });
 
 await configure({
-  sinks: { devtools: createDevtoolsSink() },
-  loggers: [{ category: ["app"], sinks: ["devtools"], lowestLevel: "debug" }],
+  sinks: { devtools: createDevtoolsSink({ store: logStore }) },
+  loggers: [{ category: ["app"], lowestLevel: "debug", sinks: ["devtools"] }],
 });
 ```
 
-### 2. Add the DevTools plugin
-
 ```tsx
-import { TanStackDevtools } from "@tanstack/react-devtools";
+// app.tsx
 import { createLogTapeDevtoolsPlugin } from "@mugenlabs/logtape-devtools";
+import { TanStackDevtools } from "@tanstack/react-devtools";
+import { logStore } from "./logging";
 
-const logtapePlugin = createLogTapeDevtoolsPlugin();
+const plugin = createLogTapeDevtoolsPlugin({ store: logStore });
 
-function App() {
+export function App() {
+  return <TanStackDevtools plugins={[plugin]} />;
+}
+```
+
+The sink and the plugin must be given **the same** store instance, otherwise the panel stays empty.
+
+### React-free subpath: `@mugenlabs/logtape-devtools/sink`
+
+The package root pulls in React (the panel is a React component). If your LogTape configuration is shared with a server entry point, a worker, or any non-React bundle, import from `@mugenlabs/logtape-devtools/sink` instead — it exports the sink, the store, and the types with no React dependency.
+
+```ts
+import { createDevtoolsSink, createLogStore } from "@mugenlabs/logtape-devtools/sink";
+```
+
+Exported from `/sink`: `createDevtoolsSink`, `createLogStore`, `defaultLogStore`, `LOG_LEVELS`, and the types `DevtoolsSink`, `DevtoolsSinkOptions`, `LogStore`, `LogStoreOptions`, `DevtoolsLogRecord`, `LogLevel`.
+
+## Production
+
+The panel is a development tool. Guard the mount so bundlers can tree-shake it — and `@tanstack/react-devtools` along with it — out of production builds:
+
+```tsx
+import { lazy, Suspense } from "react";
+
+const Devtools = import.meta.env.DEV
+  ? lazy(() => import("./devtools"))
+  : () => null;
+
+export function App() {
   return (
     <>
-      {/* your app */}
-      <TanStackDevtools plugins={[logtapePlugin]} />
+      <YourApp />
+      <Suspense fallback={null}>
+        <Devtools />
+      </Suspense>
     </>
   );
 }
 ```
 
+```tsx
+// devtools.tsx — only ever imported in development
+import { createLogTapeDevtoolsPlugin } from "@mugenlabs/logtape-devtools";
+import { TanStackDevtools } from "@tanstack/react-devtools";
+import { logStore } from "./logging";
+
+// Create the plugin once, outside the component, so it is not re-created on every render.
+const plugin = createLogTapeDevtoolsPlugin({ store: logStore });
+
+export default function Devtools() {
+  return <TanStackDevtools plugins={[plugin]} />;
+}
+```
+
+With webpack or other bundlers, `process.env.NODE_ENV !== "production"` works the same way — the important part is that the `import()` sits behind a statically analyzable flag.
+
+Two related behaviours make the sink itself cheap to leave in place:
+
+- **Stack capture auto-disables in production.** When `process.env.NODE_ENV === "production"`, `captureStackTrace` is ignored (minified bundles produce meaningless file and line references, and browsers do not apply source maps to `Error.stack`). Set `forceStackTrace: true` to override.
+- **Stack capture is skipped while no panel is open.** The sink checks `store.hasListeners()` on every record and does no stack work while nothing is subscribed. Message text is rendered lazily, so an unmounted panel costs one property clone per record.
+
+Records are still buffered in memory when no panel is mounted. If you do not want that in production either, keep the sink out of your production LogTape configuration, or pass `createLogStore({ maxRecords: 0 })` — the sink then returns before doing any work at all.
+
 ## API
 
+### `createLogTapeDevtools(options?)`
+
+Creates a LogTape sink and its matching DevTools plugin, both wired to the same store. Returns `{ sink, plugin }`.
+
+| Option | Type | Default | Description |
+| --- | --- | --- | --- |
+| `sink` | `Omit<DevtoolsSinkOptions, "store">` | `{}` | Sink options; the shared store is wired automatically |
+| `plugin` | `Omit<LogTapeDevtoolsPluginOptions, "store">` | `{}` | Plugin options; the shared store is wired automatically |
+| `store` | `LogStore` | `defaultLogStore` | Store shared by the sink and the plugin |
+
+```ts
+const { sink, plugin } = createLogTapeDevtools({
+  sink: { captureStackTrace: true },
+  plugin: { defaultOpen: false, name: "Logs" },
+});
+```
+
 ### `createDevtoolsSink(options?)`
 
-Creates a LogTape sink that forwards log records to the devtools store.
+Creates a LogTape sink that forwards log records to the devtools store. Returns a `DevtoolsSink` — a LogTape `Sink` that is also `Disposable`, so LogTape can dispose it when its configuration is reset (a disposed sink stops writing).
 
 | Option | Type | Default | Description |
 | --- | --- | --- | --- |
-| `store` | `LogStore` | `defaultLogStore` | Custom log store instance |
-| `captureStackTrace` | `boolean` | `true` (dev only) | Capture stack traces |
-| `stackTraceDepth` | `number` | `20` | Max stack trace frames |
+| `captureStackTrace` | `boolean` | `true` | Capture the source location (`file:line:col`) of each log call by parsing `new Error().stack`. Experimental and engine-dependent. Ignored in production builds and skipped while no panel is subscribed, unless `forceStackTrace` is set |
+| `forceStackTrace` | `boolean` | `false` | Capture stack traces even in production builds and while the panel is closed. Only has an effect when `captureStackTrace` is `true` |
+| `store` | `LogStore` | `defaultLogStore` | Store to write records into. Must match the store given to the plugin |
 
 ### `createLogTapeDevtoolsPlugin(options?)`
 
-Creates the TanStack DevTools plugin component.
+Creates a TanStack DevTools plugin (`TanStackDevtoolsReactPlugin` from `@tanstack/react-devtools`) to pass to `<TanStackDevtools plugins={[...]} />`. Create it once at module scope rather than inside a component.
 
 | Option | Type | Default | Description |
 | --- | --- | --- | --- |
-| `store` | `LogStore` | `defaultLogStore` | Custom log store instance |
+| `defaultOpen` | `boolean` | `true` | Whether the LogTape panel starts expanded |
+| `name` | `string` | `"LogTape"` | Display name shown in the DevTools tab bar |
+| `store` | `LogStore` | `defaultLogStore` | Store to read records from. Must match the store given to the sink |
 
 ### `createLogStore(options?)`
 
-Creates a standalone log store for advanced use cases.
+Creates an isolated log store. Records live in a fixed-capacity ring buffer, so appending is O(1) and the oldest record is evicted once the buffer is full. Listener notifications are coalesced into a microtask, so a synchronous burst of log calls triggers a single re-render.
 
 | Option | Type | Default | Description |
 | --- | --- | --- | --- |
-| `maxRecords` | `number` | `1000` | Maximum records to retain |
+| `maxRecords` | `number` | `1000` | Maximum number of records to retain. `0` disables buffering entirely |
+
+The returned `LogStore` exposes:
+
+| Member | Signature | Description |
+| --- | --- | --- |
+| `addRecord` | `(record: DevtoolsLogRecord) => void` | Appends a record, evicting the oldest when full |
+| `clear` | `() => void` | Removes every record and notifies subscribers |
+| `getSnapshot` | `() => DevtoolsLogRecord[]` | Current records, oldest first. Reference is stable between mutations (safe for `useSyncExternalStore`) |
+| `getMaxRecords` | `() => number` | Current retention limit. Optional for custom stores; when it returns `0` the sink skips all work |
+| `hasListeners` | `() => boolean` | Whether anything is currently subscribed |
+| `setMaxSize` | `(size: number) => void` | Updates the retention limit, trimming if needed |
+| `subscribe` | `(listener: () => void) => () => void` | Registers a change listener; returns an unsubscribe function |
+
+> **Breaking change in 0.2:** custom `LogStore` implementations must now provide `hasListeners()`.
+
+### `defaultLogStore`
+
+The shared `LogStore` instance (created with the default `maxRecords: 1000`) used whenever no explicit store is passed.
+
+### Types
+
+`DevtoolsLogRecord` — a LogTape record normalized for display:
+
+| Field | Type | Description |
+| --- | --- | --- |
+| `id` | `string` | Unique identifier, stable for the record's lifetime |
+| `timestamp` | `number` | Creation time in ms since the Unix epoch |
+| `level` | `LogLevel` | Severity of the record |
+| `category` | `string[]` | Logger category path, e.g. `["app", "auth"]` |
+| `message` | `unknown[]` | Raw message parts, alternating literals and interpolated values |
+| `messageText` | `string` | Message parts rendered into one searchable string (computed lazily on first access) |
+| `properties` | `Record<string, unknown>` | Structured properties, deep-cloned for safety |
+| `caller` | `string \| undefined` | Source location, present only when stack capture ran |
+
+`LogLevel` — `"trace" | "debug" | "info" | "warning" | "error" | "fatal"`, also available as the ordered array `LOG_LEVELS`.
+
+## Troubleshooting
+
+**No logs appear in the panel.**
+
+- Check that the sink is actually referenced by a logger. Registering it under `sinks` is not enough — every logger you care about needs it in its own `sinks` array. `{ category: [], lowestLevel: "trace", sinks: ["devtools"] }` catches everything.
+- Check `lowestLevel`. LogTape filters below it before the sink ever runs, so `lowestLevel: "info"` means `logger.debug(...)` never reaches the panel.
+- Check for a store mismatch. If you pass a custom store, the *same instance* must go to both `createDevtoolsSink` and `createLogTapeDevtoolsPlugin`. Passing it to only one of them leaves the panel reading an empty store. `createLogTapeDevtools()` avoids this by wiring both for you.
+- Watch out for duplicate module instances (two copies of the package in the dependency tree, or a dev server that re-evaluates the module) — `defaultLogStore` is per module instance.
+
+**Source locations (`caller`) are missing.**
+
+- In production builds stack capture is disabled by design. Pass `forceStackTrace: true` if your build is unminified and you want it anyway.
+- With the panel closed, capture is skipped because nothing is subscribed. Open the panel and log again, or pass `forceStackTrace: true`.
+- Stack parsing depends on the JS engine's `Error.stack` format. Frames matching `logtape` are skipped; if your own wrapper module has "logtape" in its path, its frames are skipped too and you may see the wrong location.
+
+**Several sinks writing into one store.**
+
+- This is supported. Each sink generates ids with its own random discriminator, so two sinks sharing a store cannot collide even on identical timestamps.
+- Records from all sinks interleave in one list. Give the loggers distinct categories if you need to tell them apart, and remember `maxRecords` is a budget for the store as a whole.
+
+## Compatibility
+
+| Peer dependency | Range | Notes |
+| --- | --- | --- |
+| `@logtape/logtape` | `>=2.0.0` | **Optional** — only types are imported; you need it to configure LogTape anyway |
+| `react` | `^18.0.0 \|\| ^19.0.0` | Required for the panel |
+| `react-dom` | `^18.0.0 \|\| ^19.0.0` | Required for the panel |
+| `@tanstack/react-devtools` | `>=0.9.0` | **Optional** — only needed to host the panel |
+
+Node `>=18`. The package is published as ESM only (`import` condition, no `require()`). `@tanstack/react-devtools` being optional means you can depend on this package purely for the sink (via `@mugenlabs/logtape-devtools/sink`) without installing the DevTools shell.
 
 ## Demo
 

package/dist/chunk-FDWUISCJ.mjs

@@ -0,0 +1,300 @@
+// src/store.ts
+var DEFAULT_MAX_RECORDS = 1e3;
+function normalizeMaxRecords(value) {
+  const numeric = Math.floor(Number(value ?? DEFAULT_MAX_RECORDS));
+  return Number.isFinite(numeric) && numeric > 0 ? numeric : 0;
+}
+function schedule(callback) {
+  if (typeof queueMicrotask === "function") {
+    queueMicrotask(callback);
+    return;
+  }
+  Promise.resolve().then(callback);
+}
+function createLogStore(options) {
+  let max = normalizeMaxRecords(options?.maxRecords);
+  let buffer = [];
+  let start = 0;
+  let size = 0;
+  let snapshot = [];
+  let snapshotDirty = false;
+  const listeners = /* @__PURE__ */ new Set();
+  let notifyScheduled = false;
+  function emit() {
+    for (const listener of listeners) {
+      listener();
+    }
+  }
+  function notify() {
+    if (notifyScheduled) {
+      return;
+    }
+    notifyScheduled = true;
+    schedule(() => {
+      notifyScheduled = false;
+      emit();
+    });
+  }
+  function toArray() {
+    const result = new Array(size);
+    for (let i = 0; i < size; i += 1) {
+      result[i] = buffer[(start + i) % buffer.length];
+    }
+    return result;
+  }
+  function normalize() {
+    const trimmed = size > max;
+    const kept = trimmed ? toArray().slice(size - max) : toArray();
+    buffer = kept;
+    start = 0;
+    size = kept.length;
+    return trimmed;
+  }
+  return {
+    addRecord: (record) => {
+      if (max === 0) {
+        return;
+      }
+      if (size < max) {
+        buffer.push(record);
+        size += 1;
+      } else {
+        buffer[start] = record;
+        start = (start + 1) % buffer.length;
+      }
+      snapshotDirty = true;
+      notify();
+    },
+    clear: () => {
+      buffer = [];
+      start = 0;
+      size = 0;
+      snapshotDirty = true;
+      notify();
+    },
+    getMaxRecords: () => max,
+    getSnapshot: () => {
+      if (snapshotDirty) {
+        snapshot = toArray();
+        snapshotDirty = false;
+      }
+      return snapshot;
+    },
+    hasListeners: () => listeners.size > 0,
+    setMaxSize: (nextMax) => {
+      max = normalizeMaxRecords(nextMax);
+      if (normalize()) {
+        snapshotDirty = true;
+        notify();
+      }
+    },
+    subscribe: (listener) => {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    }
+  };
+}
+var defaultLogStore = createLogStore();
+
+// src/types.ts
+var LOG_LEVELS = ["trace", "debug", "info", "warning", "error", "fatal"];
+
+// src/safe-json.ts
+function toSerializable(value) {
+  switch (typeof value) {
+    case "bigint":
+      return `${value}n`;
+    case "symbol":
+      return value.toString();
+    case "function":
+      return `[Function ${value.name || "anonymous"}]`;
+    default:
+      break;
+  }
+  if (value instanceof Error) {
+    const error = { message: value.message, name: value.name };
+    if (value.stack) {
+      error.stack = value.stack;
+    }
+    if ("cause" in value && value.cause !== void 0) {
+      error.cause = value.cause;
+    }
+    return error;
+  }
+  if (value instanceof Map) {
+    return [...value.entries()];
+  }
+  if (value instanceof Set) {
+    return [...value];
+  }
+  return value;
+}
+function createReplacer() {
+  const ancestors = [];
+  return function replace(_key, value) {
+    while (ancestors.length > 0 && ancestors.at(-1)?.serialized !== this) {
+      ancestors.pop();
+    }
+    if (typeof value === "object" && value !== null) {
+      if (ancestors.some((ancestor) => ancestor.original === value)) {
+        return "[Circular]";
+      }
+      const serialized = toSerializable(value);
+      if (typeof serialized === "object" && serialized !== null) {
+        ancestors.push({ original: value, serialized });
+      }
+      return serialized;
+    }
+    return toSerializable(value);
+  };
+}
+function safeStringify(value, indent) {
+  try {
+    const json = JSON.stringify(value, createReplacer(), indent);
+    if (json !== void 0) {
+      return json;
+    }
+  } catch {
+  }
+  return String(value);
+}
+function jsonClone(value) {
+  return JSON.parse(safeStringify(value));
+}
+function safeCloneProperties(properties) {
+  if (typeof structuredClone === "function") {
+    try {
+      return structuredClone(properties);
+    } catch {
+    }
+  }
+  try {
+    return jsonClone(properties);
+  } catch {
+  }
+  const result = {};
+  for (const [key, entry] of Object.entries(properties)) {
+    try {
+      result[key] = jsonClone(entry);
+    } catch {
+      result[key] = String(entry);
+    }
+  }
+  return result;
+}
+
+// src/sink.ts
+function renderMessage(message) {
+  return message.map((part) => {
+    if (typeof part === "string") {
+      return part;
+    }
+    if (part === null || part === void 0) {
+      return String(part);
+    }
+    return safeStringify(part);
+  }).join("");
+}
+var v8FrameRe = /at\s+(?:.*?\s+\()?(.+?):(\d+):(\d+)\)?$/;
+var smFrameRe = /(?:^|@)(.+?):(\d+):(\d+)$/;
+function captureCallerInfo() {
+  const { stack } = new Error();
+  if (!stack) {
+    return void 0;
+  }
+  const lines = stack.split("\n");
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed === "Error") {
+      continue;
+    }
+    if (/logtape/i.test(trimmed)) {
+      continue;
+    }
+    const match = v8FrameRe.exec(trimmed) ?? smFrameRe.exec(trimmed);
+    if (!match) {
+      continue;
+    }
+    const [, filePath, lineNo, colNo] = match;
+    const fileName = filePath.replace(/[?#].*$/, "").split("/").pop() ?? filePath;
+    return `${fileName}:${lineNo}:${colNo}`;
+  }
+  return void 0;
+}
+function normalizeRecord(record, captureStack, id) {
+  const message = [...record.message];
+  const normalized = {
+    category: [...record.category],
+    id,
+    level: record.level,
+    message,
+    properties: safeCloneProperties(record.properties),
+    timestamp: record.timestamp
+  };
+  let messageText;
+  Object.defineProperty(normalized, "messageText", {
+    configurable: true,
+    enumerable: true,
+    get: () => {
+      messageText ??= renderMessage(message);
+      return messageText;
+    }
+  });
+  if (captureStack) {
+    const caller = captureCallerInfo();
+    if (caller) {
+      normalized.caller = caller;
+    }
+  }
+  return normalized;
+}
+function isProductionEnv() {
+  try {
+    if (typeof process !== "undefined" && process.env?.NODE_ENV === "production") {
+      return true;
+    }
+  } catch {
+  }
+  return false;
+}
+function createDevtoolsSink(options) {
+  const store = options?.store ?? defaultLogStore;
+  const wantsStack = options?.captureStackTrace ?? true;
+  const forceStack = options?.forceStackTrace ?? false;
+  const captureStack = wantsStack && (forceStack || !isProductionEnv());
+  const sinkId = Math.random().toString(36).slice(2, 8);
+  let counter = 0;
+  let disposed = false;
+  const sink = (record) => {
+    if (disposed || store.getMaxRecords?.() === 0) {
+      return;
+    }
+    try {
+      const shouldCaptureStack = captureStack && (forceStack || store.hasListeners());
+      counter += 1;
+      const normalized = normalizeRecord(
+        record,
+        shouldCaptureStack,
+        `log-${sinkId}-${counter}-${record.timestamp}`
+      );
+      store.addRecord(normalized);
+    } catch {
+    }
+  };
+  return Object.assign(sink, {
+    [Symbol.dispose]: () => {
+      disposed = true;
+    }
+  });
+}
+
+export {
+  createLogStore,
+  defaultLogStore,
+  safeStringify,
+  LOG_LEVELS,
+  createDevtoolsSink
+};
+//# sourceMappingURL=chunk-FDWUISCJ.mjs.map

package/dist/chunk-FDWUISCJ.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/store.ts","../src/types.ts","../src/safe-json.ts","../src/sink.ts"],"sourcesContent":["import type { DevtoolsLogRecord } from \"./types\";\n\ntype Listener = () => void;\n\n/**\n * Reactive log record container backing the devtools panel.\n *\n * Records are kept in a fixed-capacity ring buffer so appending is O(1); the\n * array returned by {@link LogStore.getSnapshot} is rebuilt lazily at most once\n * per mutation batch. Listener notifications are coalesced into a microtask, so\n * a synchronous burst of {@link LogStore.addRecord} calls results in a single\n * notification.\n */\nexport interface LogStore {\n  /** Appends a record, evicting the oldest one when the max size is reached. */\n  addRecord: (record: DevtoolsLogRecord) => void;\n  /** Removes every record and notifies subscribers. */\n  clear: () => void;\n  /**\n   * The current retention limit. `0` means the store discards everything, which\n   * lets the sink skip normalisation entirely. Optional for custom stores.\n   */\n  getMaxRecords?: () => number;\n  /**\n   * Returns the current records, oldest first.\n   *\n   * The reference is stable until the store changes, which makes it safe to use\n   * with `useSyncExternalStore`.\n   */\n  getSnapshot: () => DevtoolsLogRecord[];\n  /**\n   * Whether anything is currently subscribed to the store.\n   *\n   * Used by the sink to skip expensive work (such as stack trace capture) while\n   * no devtools panel is mounted.\n   */\n  hasListeners: () => boolean;\n  /** Updates the maximum number of retained records, trimming if needed. */\n  setMaxSize: (size: number) => void;\n  /** Registers a change listener. Returns an unsubscribe function. */\n  subscribe: (listener: Listener) => () => void;\n}\n\n/** Options for {@link createLogStore}. */\nexport interface LogStoreOptions {\n  /**\n   * Maximum number of log records to retain. Older records are evicted first.\n   *\n   * @default 1000\n   */\n  maxRecords?: number;\n}\n\nconst DEFAULT_MAX_RECORDS = 1000;\n\n/**\n * Coerce a user-supplied capacity into a non-negative integer. Fractions would\n * defeat the `size < max` capacity check and NaN would wedge the ring buffer.\n */\nfunction normalizeMaxRecords(value: number | undefined): number {\n  const numeric = Math.floor(Number(value ?? DEFAULT_MAX_RECORDS));\n  return Number.isFinite(numeric) && numeric > 0 ? numeric : 0;\n}\n\nfunction schedule(callback: () => void): void {\n  if (typeof queueMicrotask === \"function\") {\n    queueMicrotask(callback);\n    return;\n  }\n  Promise.resolve().then(callback);\n}\n\n/**\n * Creates an isolated log store.\n *\n * Pass the same instance to `createDevtoolsSink` and\n * `createLogTapeDevtoolsPlugin` to keep the sink and the panel in sync.\n *\n * ```ts\n * const store = createLogStore({ maxRecords: 5000 });\n * ```\n */\nexport function createLogStore(options?: LogStoreOptions): LogStore {\n  let max = normalizeMaxRecords(options?.maxRecords);\n\n  // Ring buffer: `start` is the index of the oldest record, `size` the number\n  // of live entries. Appending is O(1) — no per-record array copy.\n  let buffer: DevtoolsLogRecord[] = [];\n  let start = 0;\n  let size = 0;\n\n  let snapshot: DevtoolsLogRecord[] = [];\n  let snapshotDirty = false;\n\n  const listeners = new Set<Listener>();\n  let notifyScheduled = false;\n\n  function emit() {\n    for (const listener of listeners) {\n      listener();\n    }\n  }\n\n  function notify() {\n    if (notifyScheduled) {\n      return;\n    }\n    notifyScheduled = true;\n    schedule(() => {\n      notifyScheduled = false;\n      emit();\n    });\n  }\n\n  /** Materializes the ring buffer into a plain, oldest-first array. */\n  function toArray(): DevtoolsLogRecord[] {\n    const result: DevtoolsLogRecord[] = new Array(size);\n    for (let i = 0; i < size; i += 1) {\n      result[i] = buffer[(start + i) % buffer.length];\n    }\n    return result;\n  }\n\n  /**\n   * Rewrites the buffer in logical order, dropping records beyond `max`.\n   * Keeps the invariant that a below-capacity buffer is linear (`start === 0`).\n   */\n  function normalize(): boolean {\n    const trimmed = size > max;\n    const kept = trimmed ? toArray().slice(size - max) : toArray();\n    buffer = kept;\n    start = 0;\n    size = kept.length;\n    return trimmed;\n  }\n\n  return {\n    addRecord: (record) => {\n      if (max === 0) {\n        return;\n      }\n      if (size < max) {\n        // Below capacity — the buffer is linear, so a plain append is enough.\n        buffer.push(record);\n        size += 1;\n      } else {\n        // At capacity — overwrite the oldest slot.\n        buffer[start] = record;\n        start = (start + 1) % buffer.length;\n      }\n      snapshotDirty = true;\n      notify();\n    },\n    clear: () => {\n      buffer = [];\n      start = 0;\n      size = 0;\n      snapshotDirty = true;\n      notify();\n    },\n    getMaxRecords: () => max,\n    getSnapshot: () => {\n      if (snapshotDirty) {\n        snapshot = toArray();\n        snapshotDirty = false;\n      }\n      return snapshot;\n    },\n    hasListeners: () => listeners.size > 0,\n    setMaxSize: (nextMax) => {\n      max = normalizeMaxRecords(nextMax);\n      if (normalize()) {\n        snapshotDirty = true;\n        notify();\n      }\n    },\n    subscribe: (listener) => {\n      listeners.add(listener);\n      return () => {\n        listeners.delete(listener);\n      };\n    },\n  };\n}\n\n/** Default shared store instance used when no custom store is provided */\nexport const defaultLogStore = createLogStore();\n","/** Severity levels supported by LogTape, ordered from least to most severe. */\nexport type LogLevel = \"trace\" | \"debug\" | \"info\" | \"warning\" | \"error\" | \"fatal\";\n\n/** Every {@link LogLevel}, ordered from least to most severe. */\nexport const LOG_LEVELS: LogLevel[] = [\"trace\", \"debug\", \"info\", \"warning\", \"error\", \"fatal\"];\n\n/** A LogTape record normalized for display in the devtools panel. */\nexport interface DevtoolsLogRecord {\n  /** Source location of the log call (only present when `captureStackTrace` is enabled). */\n  caller?: string;\n  /** Logger category path, e.g. `[\"app\", \"auth\"]`. */\n  category: string[];\n  /** Unique identifier, stable for the lifetime of the record. */\n  id: string;\n  /** Severity of the record. */\n  level: LogLevel;\n  /** Raw message parts, alternating literals and interpolated values. */\n  message: unknown[];\n  /** Message parts rendered into a single searchable string. */\n  messageText: string;\n  /** Structured properties attached to the log call, deep-cloned for safety. */\n  properties: Record<string, unknown>;\n  /** Creation time in milliseconds since the Unix epoch. */\n  timestamp: number;\n}\n","/**\n * JSON helpers shared by the sink and the panel.\n *\n * This module is intentionally React-free so that it can be pulled into the\n * `@mugenlabs/logtape-devtools/sink` entry point.\n */\n\n/**\n * Map values JSON cannot represent (or would silently flatten to `{}`) onto a\n * readable equivalent. Anything else is returned untouched.\n */\nfunction toSerializable(value: unknown): unknown {\n  switch (typeof value) {\n    case \"bigint\":\n      return `${value}n`;\n    case \"symbol\":\n      return value.toString();\n    case \"function\":\n      return `[Function ${value.name || \"anonymous\"}]`;\n    default:\n      break;\n  }\n  if (value instanceof Error) {\n    const error: Record<string, unknown> = { message: value.message, name: value.name };\n    if (value.stack) {\n      error.stack = value.stack;\n    }\n    if (\"cause\" in value && value.cause !== undefined) {\n      error.cause = value.cause;\n    }\n    return error;\n  }\n  if (value instanceof Map) {\n    return [...value.entries()];\n  }\n  if (value instanceof Set) {\n    return [...value];\n  }\n  return value;\n}\n\ninterface Ancestor {\n  /** The value as it appeared in the source graph — used for cycle detection. */\n  original: object;\n  /** What JSON.stringify actually recursed into — used to unwind the stack. */\n  serialized: object;\n}\n\n/**\n * Replacer that marks true cycles as `\"[Circular]\"` while leaving shared\n * (non-circular) references intact, and converts unrepresentable values via\n * {@link toSerializable}.\n */\nfunction createReplacer(): (this: unknown, key: string, value: unknown) => unknown {\n  const ancestors: Ancestor[] = [];\n  return function replace(this: unknown, _key, value) {\n    // `this` is the object holding `key`; unwind to the current branch.\n    while (ancestors.length > 0 && ancestors.at(-1)?.serialized !== this) {\n      ancestors.pop();\n    }\n    if (typeof value === \"object\" && value !== null) {\n      if (ancestors.some((ancestor) => ancestor.original === value)) {\n        return \"[Circular]\";\n      }\n      const serialized = toSerializable(value);\n      if (typeof serialized === \"object\" && serialized !== null) {\n        ancestors.push({ original: value, serialized });\n      }\n      return serialized;\n    }\n    return toSerializable(value);\n  };\n}\n\n/**\n * Serializes any value to JSON, never throwing.\n *\n * Errors, Maps, Sets, BigInts, symbols and functions are rendered in a readable\n * form instead of being dropped, circular references become `\"[Circular]\"`,\n * and anything still unserializable falls back to `String(value)`.\n */\nexport function safeStringify(value: unknown, indent?: number): string {\n  try {\n    const json = JSON.stringify(value, createReplacer(), indent);\n    if (json !== undefined) {\n      return json;\n    }\n  } catch {\n    // A throwing `toJSON` or getter — fall through.\n  }\n  return String(value);\n}\n\nfunction jsonClone(value: unknown): unknown {\n  return JSON.parse(safeStringify(value));\n}\n\n/**\n * Deep-clones a properties bag, never throwing.\n *\n * Uses `structuredClone` when available and degrades per entry (via a JSON\n * round trip, then `String(value)`) so that a single unclonable value cannot\n * drop the whole object.\n */\nexport function safeCloneProperties(properties: Record<string, unknown>): Record<string, unknown> {\n  if (typeof structuredClone === \"function\") {\n    try {\n      return structuredClone(properties);\n    } catch {\n      // Functions, DOM nodes, proxies… fall through to the JSON path.\n    }\n  }\n\n  try {\n    return jsonClone(properties) as Record<string, unknown>;\n  } catch {\n    // Fall through to the per-entry path.\n  }\n\n  const result: Record<string, unknown> = {};\n  for (const [key, entry] of Object.entries(properties)) {\n    try {\n      result[key] = jsonClone(entry);\n    } catch {\n      result[key] = String(entry);\n    }\n  }\n  return result;\n}\n","import type { LogRecord, Sink } from \"@logtape/logtape\";\nimport { safeCloneProperties, safeStringify } from \"./safe-json\";\nimport { defaultLogStore, type LogStore } from \"./store\";\nimport type { DevtoolsLogRecord, LogLevel } from \"./types\";\n\nfunction renderMessage(message: readonly unknown[]): string {\n  return message\n    .map((part) => {\n      if (typeof part === \"string\") {\n        return part;\n      }\n      if (part === null || part === undefined) {\n        return String(part);\n      }\n      return safeStringify(part);\n    })\n    .join(\"\");\n}\n\n// ---------------------------------------------------------------------------\n// Stack trace parser — extracts the caller frame from `new Error().stack`\n// ---------------------------------------------------------------------------\n\n// V8 (Chrome/Node/Edge): \"    at functionName (file:line:col)\"\nconst v8FrameRe = /at\\s+(?:.*?\\s+\\()?(.+?):(\\d+):(\\d+)\\)?$/;\n// SpiderMonkey (Firefox) / JSC (Safari): \"functionName@file:line:col\"\nconst smFrameRe = /(?:^|@)(.+?):(\\d+):(\\d+)$/;\n\nfunction captureCallerInfo(): string | undefined {\n  // biome-ignore lint/suspicious/useErrorMessage: we only need the stack trace, not the message\n  const { stack } = new Error();\n  if (!stack) {\n    return undefined;\n  }\n\n  const lines = stack.split(\"\\n\");\n\n  for (const line of lines) {\n    const trimmed = line.trim();\n\n    // Skip empty lines and the \"Error\" header\n    if (!trimmed || trimmed === \"Error\") {\n      continue;\n    }\n\n    // Skip frames from logtape internals (both @logtape/logtape and @mugenlabs/logtape-devtools)\n    if (/logtape/i.test(trimmed)) {\n      continue;\n    }\n\n    // Try V8 format first, then SpiderMonkey/JSC\n    const match = v8FrameRe.exec(trimmed) ?? smFrameRe.exec(trimmed);\n    if (!match) {\n      continue;\n    }\n\n    const [, filePath, lineNo, colNo] = match;\n\n    // Extract just the filename from the full path/URL\n    const fileName =\n      filePath\n        .replace(/[?#].*$/, \"\")\n        .split(\"/\")\n        .pop() ?? filePath;\n\n    return `${fileName}:${lineNo}:${colNo}`;\n  }\n\n  return undefined;\n}\n\nfunction normalizeRecord(record: LogRecord, captureStack: boolean, id: string): DevtoolsLogRecord {\n  const message = [...record.message];\n  const normalized = {\n    category: [...record.category],\n    id,\n    level: record.level as LogLevel,\n    message,\n    properties: safeCloneProperties(record.properties),\n    timestamp: record.timestamp,\n  } as DevtoolsLogRecord;\n\n  // Rendering the message serialises every interpolated value, so defer it to\n  // the first read (search or display) instead of paying for it on every log.\n  let messageText: string | undefined;\n  Object.defineProperty(normalized, \"messageText\", {\n    configurable: true,\n    enumerable: true,\n    get: () => {\n      messageText ??= renderMessage(message);\n      return messageText;\n    },\n  });\n\n  if (captureStack) {\n    const caller = captureCallerInfo();\n    if (caller) {\n      normalized.caller = caller;\n    }\n  }\n\n  return normalized;\n}\n\nfunction isProductionEnv(): boolean {\n  try {\n    // Bundlers (Vite, webpack, etc.) statically replace this at build time\n    if (typeof process !== \"undefined\" && process.env?.NODE_ENV === \"production\") {\n      return true;\n    }\n  } catch {\n    // process may not exist in browser environments\n  }\n  return false;\n}\n\n/** Options for {@link createDevtoolsSink}. */\nexport interface DevtoolsSinkOptions {\n  /**\n   * Capture the source location of each log call via stack trace parsing.\n   *\n   * Relies on `new Error().stack`, which is engine-dependent. Automatically\n   * disabled in production builds (when `process.env.NODE_ENV === \"production\"`)\n   * because minified bundles produce meaningless file/line references. Note that\n   * source maps do not help here — browsers do not apply source maps to\n   * `Error.stack`.\n   *\n   * Also skipped while no devtools panel is mounted (the store has no\n   * subscribers), unless `forceStackTrace` is `true`.\n   *\n   * @experimental\n   * @default true\n   */\n  captureStackTrace?: boolean;\n  /**\n   * Force stack trace capture even in production builds and while the panel is\n   * closed. Only has an effect when `captureStackTrace` is `true`.\n   *\n   * @default false\n   */\n  forceStackTrace?: boolean;\n  /** Custom log store instance. Defaults to the shared store. */\n  store?: LogStore;\n}\n\n/**\n * A LogTape sink that is also disposable. LogTape disposes sinks when the\n * configuration is reset; a disposed sink stops writing to its store.\n */\nexport type DevtoolsSink = Sink & Disposable;\n\n/**\n * Creates a LogTape sink that forwards log records to the devtools panel.\n *\n * Usage:\n * ```ts\n * import { configure } from \"@logtape/logtape\";\n * import { createDevtoolsSink } from \"@mugenlabs/logtape-devtools\";\n *\n * await configure({\n *   sinks: { devtools: createDevtoolsSink() },\n *   loggers: [\n *     { category: [\"app\"], lowestLevel: \"debug\", sinks: [\"devtools\"] },\n *   ],\n * });\n * ```\n */\nexport function createDevtoolsSink(options?: DevtoolsSinkOptions): DevtoolsSink {\n  const store = options?.store ?? defaultLogStore;\n  const wantsStack = options?.captureStackTrace ?? true;\n  const forceStack = options?.forceStackTrace ?? false;\n  const captureStack = wantsStack && (forceStack || !isProductionEnv());\n\n  // Per-sink counter, plus a random discriminator so that two sinks sharing a\n  // single store cannot emit the same id for records with equal timestamps.\n  const sinkId = Math.random().toString(36).slice(2, 8);\n  let counter = 0;\n  let disposed = false;\n\n  const sink = (record: LogRecord): void => {\n    // A store with no capacity drops every record, so skip normalisation too.\n    if (disposed || store.getMaxRecords?.() === 0) {\n      return;\n    }\n    try {\n      // Stack capture is the most expensive part of normalization — skip it\n      // while nothing is watching the store (i.e. no panel is mounted).\n      const shouldCaptureStack = captureStack && (forceStack || store.hasListeners());\n      counter += 1;\n      const normalized = normalizeRecord(\n        record,\n        shouldCaptureStack,\n        `log-${sinkId}-${counter}-${record.timestamp}`\n      );\n      store.addRecord(normalized);\n    } catch {\n      // Fail silently — devtools should never break the application\n    }\n  };\n\n  return Object.assign(sink, {\n    [Symbol.dispose]: () => {\n      disposed = true;\n    },\n  });\n}\n"],"mappings":"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","names":[]}