@buoy-gg/console 7.0.41 → 7.0.42

package/lib/module/store/consoleLogStore.js

@@ -1,577 +1,8 @@
-"use strict";
+"use strict";import{getAccountAccess as F,hasAccountAccess as c}from"@buoy-gg/shared-ui";import*as L from"react";import{createToolStore as U,persistentStorage as u}from"@buoy-gg/shared-ui";import{sanitizeArgs as M}from"./sanitize";import{parseOrigin as P}from"../devtools/origin";const A=["log","info","warn","error","debug","trace","dir","table","assert","group","groupCollapsed","groupEnd"];const H=new Set(["error","warn","trace","assert"]);const G={error:"error",assert:"error",warn:"warning",debug:"verbose",log:"info",info:"info",trace:"info",dir:"info",table:"info",group:"info",groupCollapsed:"info",groupEnd:"info"};const B=1e3;const s=U({id:"console",max:B,order:"append",coalesce:"frame"});let m=false;let E=false;let d=false;const h={};function R(e){if(typeof e==="string")return e;if(e instanceof Error)return e.stack??`${e.name}: ${e.message}`;if(e===void 0)return"undefined";if(e===null)return"null";if(typeof e==="function")return`\u0192 ${e.name||"(anonymous)"}`;try{return JSON.stringify(e)}catch{return String(e)}}function K(e){return e.map(R).join(" ")}function j(e){if(!e)return void 0;return e.split("\n").slice(3).join("\n")||void 0}function J(){try{const e=Reflect.get(L,"captureOwnerStack");return typeof e==="function"?e()??void 0:void 0}catch{return void 0}}const V=8;function C(e){const t=e.split("\n").map(o=>o.trim()).filter(Boolean).map(o=>o.replace(/\s*\((?:https?:|\/).*$/,""));const n=t.slice(0,V);const r=t.length-n.length;return n.map(o=>`    ${o}`).join("\n")+(r>0?`
+    \u2026+${r} more frames`:"")}function z(e){if(!(e instanceof Error))return null;const t=e;return t.isComponentError||typeof t.componentStack==="string"?t:null}function W(e,t){const n=new Error().stack;const r=P(n,J());const o=e==="error"?z(t[0]):null;if(o){const k=y(o.name,o.message);const I=o.componentStack?`
 
-import { getAccountAccess, hasAccountAccess } from "@buoy-gg/shared-ui";
-/**
- * consoleLogStore
- *
- * Intercepts the global `console` methods and keeps a bounded ring buffer of
- * captured entries, modeled after Chrome DevTools' ConsoleMessage. Direct
- * console patching is the capture path (works identically on Expo, RN CLI, and
- * web). The DevTools-style view layer (filtering, formatting, grouping) is built
- * on top of these raw entries.
- *
- * By default the buffer is in-memory only, so a JS reload starts fresh — just
- * like the Metro/Chrome console. A "Preserve log" toggle persists the buffer to
- * storage and restores it on the next launch (Chrome's "Preserve log").
- */
+This error is located at:
+${C(o.componentStack)}`:"";b({id:s.allocId(),method:"error",level:"error",args:["[RENDER ERROR]",o],message:`[RENDER ERROR] ${k}${I}`,timestamp:Date.now(),stack:o.stack,origin:r},S(`[RENDER ERROR] ${k}`));return}const a={id:s.allocId(),method:e,level:G[e],args:t,message:K(t),timestamp:Date.now(),stack:H.has(e)?j(n):void 0,origin:r};s.add(a);x();if(a.level==="error")s.flushSync()}const Y=2e3;let T="";let N=0;function y(e,t){const n=t.trim();if(e&&n.startsWith(`${e}: `))return n;return e?`${e}: ${n}`:n}function S(e){const t=Date.now();if(e===T&&t-N<Y)return true;T=e;N=t;return false}function b(e,t=false){s.add(e);x();if(!t)s.flushSync(true)}function X(e,t){const n=e instanceof Error?e:void 0;const r=t===false?"[UNCAUGHT]":"[FATAL]";const o=n?y(n.name,n.message):R(e);const a=S(`${r} ${o}`);b({id:s.allocId(),method:"error",level:"error",args:[r,e],message:`${r} ${o}`,timestamp:Date.now(),stack:n?.stack,fatal:true},a)}function q(e){const t=e.extraData?.rawStack;if(typeof t==="string"&&t.length>0)return t;if(!Array.isArray(e.stack)||e.stack.length===0)return void 0;return e.stack.map(n=>{const r=n.lineNumber!=null?`${n.file??"?"}:${n.lineNumber}:${n.column??0}`:n.file??"?";return`    at ${n.methodName||"<anonymous>"} (${r})`}).join("\n")}function Q(e){const t=e.isFatal===false?"[UNCAUGHT]":"[FATAL]";const n=y(e.name??void 0,e.originalMessage??e.message??"Unknown error");const r=S(`${t} ${n}`);const o=typeof e.componentStack==="string"&&e.componentStack.trim()?`
 
-import * as React from "react";
-import { createToolStore, persistentStorage } from "@buoy-gg/shared-ui";
-import { sanitizeArgs } from "./sanitize";
-import { parseOrigin } from "../devtools/origin";
-
-/** The console method that produced an entry. */
-
-/** DevTools log levels (Protocol.Log.LogEntryLevel). */
-
-/** Methods we intercept, in the order we install them. */
-const METHODS = ["log", "info", "warn", "error", "debug", "trace", "dir", "table", "assert", "group", "groupCollapsed", "groupEnd"];
-
-/** Methods whose call site we capture a stack for. */
-const STACK_METHODS = new Set(["error", "warn", "trace", "assert"]);
-
-/** method → DevTools level. */
-const METHOD_LEVEL = {
-  error: "error",
-  assert: "error",
-  warn: "warning",
-  debug: "verbose",
-  log: "info",
-  info: "info",
-  trace: "info",
-  dir: "info",
-  table: "info",
-  group: "info",
-  groupCollapsed: "info",
-  groupEnd: "info"
-};
-
-/** Max entries retained before the oldest are dropped. */
-const MAX_ENTRIES = 1000;
-// Frame-coalesced emit: console traffic is inherently bursty (loops,
-// per-frame logs), and uncoalesced each entry was its own React commit —
-// the console tool measured 41 JS FPS / 84% CPU / 7 jank during a bench
-// dwell (tool-bench 2026-07-06) largely from its own live churn. The buffer,
-// listeners, clear-forwarding and the "push to the dashboard NOW" hook are
-// the shared `createToolStore`; this module adds capture + persistence.
-const store = createToolStore({
-  id: "console",
-  max: MAX_ENTRIES,
-  order: "append",
-  coalesce: "frame"
-});
-let installed = false;
-let fatalInstalled = false;
-/**
- * Raised by an explicit `uninstallConsoleCapture()`. The fatal-error hook can't
- * be safely unwound once chained (another library may have chained on top of
- * ours since), so an explicit user OFF mutes fatal recording instead.
- */
-let captureDisabledByUser = false;
-
-/** Saved originals so we can restore on uninstall and still print through. */
-const originals = {};
-
-/** Best-effort, single-line serialization of a single console argument. */
-function formatArg(arg) {
-  if (typeof arg === "string") return arg;
-  if (arg instanceof Error) return arg.stack ?? `${arg.name}: ${arg.message}`;
-  if (arg === undefined) return "undefined";
-  if (arg === null) return "null";
-  if (typeof arg === "function") return `ƒ ${arg.name || "(anonymous)"}`;
-  try {
-    return JSON.stringify(arg);
-  } catch {
-    return String(arg);
-  }
-}
-function formatArgs(args) {
-  return args.map(formatArg).join(" ");
-}
-
-/** Drop the "Error" header + the interceptor's own frames from a raw stack. */
-function cleanStack(raw) {
-  if (!raw) return undefined;
-  return raw.split("\n").slice(3).join("\n") || undefined;
-}
-
-/** Nearest owning React component stack (dev only; empty off-render). */
-function captureOwnerStack() {
-  try {
-    // React only exposes this API in some development builds. Keep the lookup
-    // dynamic so browser bundlers do not require a production named export.
-    const fn = Reflect.get(React, 'captureOwnerStack');
-    return typeof fn === "function" ? fn() ?? undefined : undefined;
-  } catch {
-    return undefined;
-  }
-}
-
-/**
- * An error React Native decorated on its way through ExceptionsManager: a
- * render/lifecycle crash carrying the component stack. `isComponentError` is
- * set by RN's `getExtendedError`, so this identifies a REAL crash rather than
- * an ordinary `console.error("...")` call.
- */
-
-/** Frames to keep from a component stack — the crash site plus its context. */
-const COMPONENT_STACK_FRAMES = 8;
-
-/**
- * Squeeze a React component stack down to the part a human (or an agent
- * reading this over a wire) actually uses: the component names nearest the
- * crash.
- *
- * Raw component stacks in a Metro dev bundle append the full bundle URL with
- * every query param to EVERY frame — one crash is ~15 KB of near-identical
- * `http://192.168.x.x:8830/…&transform.routerRoot=src/app…` noise wrapped
- * around the handful of names that matter. The complete error, componentStack
- * included, is still on the entry's `args` for anyone who wants it.
- */
-function compactComponentStack(stack) {
-  const frames = stack.split("\n").map(line => line.trim()).filter(Boolean)
-  // Drop the "(url)" tail; keep a "Name(./file.tsx)" hint when RN provides one.
-  .map(line => line.replace(/\s*\((?:https?:|\/).*$/, ""));
-  const shown = frames.slice(0, COMPONENT_STACK_FRAMES);
-  const rest = frames.length - shown.length;
-  return shown.map(f => `    ${f}`).join("\n") + (rest > 0 ? `\n    …+${rest} more frames` : "");
-}
-function asComponentError(arg) {
-  if (!(arg instanceof Error)) return null;
-  const e = arg;
-  return e.isComponentError || typeof e.componentStack === "string" ? e : null;
-}
-function record(method, args) {
-  // Capture the call site for every log so we can attribute its origin.
-  const rawStack = new Error().stack;
-  const origin = parseOrigin(rawStack, captureOwnerStack());
-
-  // React Native funnels an uncaught render error back through console.error
-  // (ExceptionsManager.reportException) so console monkey-patches still see it.
-  // That arrives as an ordinary error row, which badly under-sells it: the app
-  // is dead. Promote it to a tagged [FATAL] entry carrying the component stack.
-  const crash = method === "error" ? asComponentError(args[0]) : null;
-  if (crash) {
-    // Tagged [RENDER ERROR], not [FATAL]: React reports an error an
-    // ErrorBoundary CAUGHT and recovered from through this same path, with the
-    // same componentStack, and nothing here distinguishes the two. Claiming a
-    // healthy app "most likely CRASHED" is worse than under-claiming — the
-    // component stack, which is the useful part, is reported either way.
-    const headline = fatalKey(crash.name, crash.message);
-    const located = crash.componentStack ? `\n\nThis error is located at:\n${compactComponentStack(crash.componentStack)}` : "";
-    pushFatal({
-      id: store.allocId(),
-      method: "error",
-      level: "error",
-      args: ["[RENDER ERROR]", crash],
-      message: `[RENDER ERROR] ${headline}${located}`,
-      timestamp: Date.now(),
-      stack: crash.stack,
-      origin
-    }, isDuplicateFatal(`[RENDER ERROR] ${headline}`));
-    return;
-  }
-  const entry = {
-    id: store.allocId(),
-    method,
-    level: METHOD_LEVEL[method],
-    args,
-    message: formatArgs(args),
-    timestamp: Date.now(),
-    stack: STACK_METHODS.has(method) ? cleanStack(rawStack) : undefined,
-    origin
-  };
-  store.add(entry);
-  scheduleSave();
-  // Errors are the entries most likely to be the last thing an app ever logs,
-  // so they get pushed to any dashboard immediately instead of waiting on the
-  // throttle that a dying tree will never run. Rate-limited; ordinary logs
-  // still ride the normal throttled path.
-  if (entry.level === "error") store.flushSync();
-}
-
-/** Minimal shape of React Native's global `ErrorUtils`. */
-
-/**
- * Two independent seams report the same crash on some setups (the C++ handler
- * can also feed `console.error`). Suppress a repeat of the same headline within
- * this window so a crash reads as ONE entry.
- */
-const FATAL_DEDUPE_MS = 2000;
-let lastFatalKey = "";
-let lastFatalAt = 0;
-
-/**
- * Normalize a crash headline so the same error reported through two different
- * seams produces the same key. React Native often sets `error.message` to the
- * ALREADY-prefixed string ("TypeError: x is not a function"), so one path
- * builds "TypeError: TypeError: x…" and the other "TypeError: x…" — which
- * defeats the de-duplication entirely.
- */
-function fatalKey(name, message) {
-  const body = message.trim();
-  if (name && body.startsWith(`${name}: `)) return body;
-  return name ? `${name}: ${body}` : body;
-}
-
-/**
- * Has this crash already been recorded moments ago?
- *
- * Only ever used to suppress a duplicate PUSH to the dashboard — never to drop
- * an entry. Two different components crashing with the same message inside the
- * window are two crashes, and a tool whose pitch is "the app's last words"
- * must not silently throw one away.
- */
-function isDuplicateFatal(key) {
-  const now = Date.now();
-  if (key === lastFatalKey && now - lastFatalAt < FATAL_DEDUPE_MS) return true;
-  lastFatalKey = key;
-  lastFatalAt = now;
-  return false;
-}
-
-/**
- * The device sync bridge's "push this tool NOW" escape hatch
- * (@buoy-gg/external-sync `crashFlush`). Reached through the global rather than
- * an import because console deliberately has no dependency on external-sync.
- */
-// The flush itself lives on the shared store (`store.flushSync`): rate-limited
-// unless forced — a fatal is the app's last word and always goes out.
-
-/**
- * Append a pre-built fatal entry to the ring buffer, then push it to any
- * connected dashboard IMMEDIATELY.
- *
- * A fatal render error unmounts the React tree microseconds later, taking the
- * sync bridge — and the normal 200 ms throttled snapshot — with it. Flushing
- * synchronously here is what makes a crashed app's last words readable from
- * the desktop app and the MCP server instead of the app just going silent.
- */
-function pushFatal(entry, duplicate = false) {
-  store.add(entry);
-  scheduleSave();
-  // A repeat within the dedupe window is still RECORDED (two crashes are two
-  // crashes); it just doesn't earn another forced push to the dashboard.
-  if (!duplicate) store.flushSync(true);
-}
-
-/** Record an uncaught JS error from the global handler as an error entry. */
-function recordFatalError(error, isFatal) {
-  const err = error instanceof Error ? error : undefined;
-  // RN passes isFatal:false for non-fatal uncaught errors (e.g. errors thrown
-  // in event handlers on some setups); anything else is treated as fatal.
-  const label = isFatal === false ? "[UNCAUGHT]" : "[FATAL]";
-  const headline = err ? fatalKey(err.name, err.message) : formatArg(error);
-  const duplicate = isDuplicateFatal(`${label} ${headline}`);
-  // The label leads the args (not just the pre-rendered message): the
-  // DevTools-style row renders from args, so this is what makes the tag
-  // visible in the UI — exactly like `console.error("[FATAL]", err)`.
-  pushFatal({
-    id: store.allocId(),
-    method: "error",
-    level: "error",
-    args: [label, error],
-    message: `${label} ${headline}`,
-    timestamp: Date.now(),
-    // The error's OWN stack — the crash site, not this handler's call site.
-    stack: err?.stack,
-    fatal: true
-  }, duplicate);
-}
-
-/**
- * The exception payload React Native's C++ error handler hands to listeners
- * registered via `global.RN$registerExceptionListener` (JsErrorHandler.cpp).
- */
-
-/** Render the C++ handler's parsed frames back into a normal stack string. */
-function formatNativeStack(data) {
-  const raw = data.extraData?.rawStack;
-  if (typeof raw === "string" && raw.length > 0) return raw;
-  if (!Array.isArray(data.stack) || data.stack.length === 0) return undefined;
-  return data.stack.map(f => {
-    const where = f.lineNumber != null ? `${f.file ?? "?"}:${f.lineNumber}:${f.column ?? 0}` : f.file ?? "?";
-    return `    at ${f.methodName || "<anonymous>"} (${where})`;
-  }).join("\n");
-}
-
-/** Record a crash reported by React Native's native (C++) error handler. */
-function recordNativeException(data) {
-  const label = data.isFatal === false ? "[UNCAUGHT]" : "[FATAL]";
-  const headline = fatalKey(data.name ?? undefined, data.originalMessage ?? data.message ?? "Unknown error");
-  const duplicate = isDuplicateFatal(`${label} ${headline}`);
-  // The component stack is the single most useful line for "which component
-  // crashed" — RN puts it in the redbox, so put it in the console entry too.
-  const componentStack = typeof data.componentStack === "string" && data.componentStack.trim() ? `\n\nThis error is located at:\n${compactComponentStack(data.componentStack)}` : "";
-  const message = `${label} ${headline}${componentStack}`;
-  pushFatal({
-    id: store.allocId(),
-    method: "error",
-    level: "error",
-    args: [label, headline, ...(componentStack ? [componentStack.trim()] : [])],
-    message,
-    timestamp: Date.now(),
-    stack: formatNativeStack(data),
-    fatal: true
-  }, duplicate);
-}
-
-/**
- * Register with React Native's native (C++) exception handler — the seam a
- * RENDER crash actually travels through on the New Architecture.
- *
- * React 19 routes an uncaught render error to `onUncaughtError` →
- * `ExceptionsManager.handleException`, which NEVER reaches
- * `ErrorUtils.setGlobalHandler`. Where it goes from there depends on the build:
- *
- * - `useAlwaysAvailableJSErrorHandling` on: the C++ handler
- *   (`global.RN$handleException`) reports it and JS sees nothing — this
- *   listener is the only seam.
- * - otherwise: JS `reportException` re-feeds `console.error(e)` "so any methods
- *   monkey patched on top of console.error are called", which the console patch
- *   catches and promotes to `[FATAL]` (see `record`).
- *
- * Both are covered, and a crash reported through both de-duplicates to one
- * entry. `RN$registerExceptionListener` keeps a LIST of listeners (LogBox
- * registers one too), so this is purely additive. We never call the payload's
- * `preventDefault()`: suppressing RN's own redbox is not our call to make.
- */
-function installNativeExceptionCapture() {
-  const register = globalThis.RN$registerExceptionListener;
-  if (typeof register !== "function") return false;
-  register(data => {
-    try {
-      if (!captureDisabledByUser) recordNativeException(data);
-    } catch {
-      // Capture must never interfere with error reporting.
-    }
-  });
-  return true;
-}
-
-/**
- * Hook React Native's error paths so FATAL/uncaught JS errors land in the
- * console store: the classic `ErrorUtils.setGlobalHandler` (old architecture,
- * native-module callbacks, promise rejections) AND the native C++ exception
- * listener (New Architecture render crashes — see
- * {@link installNativeExceptionCapture}). Both feed the same de-duplicated
- * `[FATAL]` entry, so a crash reported through both seams shows up once.
- *
- * - Chains the previous handler (LogBox/redbox still fire; nothing swallowed).
- * - Idempotent, and a silent no-op off React Native (neither global present) —
- *   which also keeps it inert on the desktop dashboard / web mirrors.
- * - Recording respects an explicit `uninstallConsoleCapture()` (user OFF), but
- *   the hooks themselves stay chained — they can't be safely removed.
- */
-export function installFatalErrorCapture() {
-  if (fatalInstalled) return;
-  // Latch only once a seam is actually attached. Setting the flag up front
-  // means an install that runs before `InitializeCore` has published
-  // `ErrorUtils` would latch anyway and never retry — silently losing promise
-  // rejections and native-callback errors, which travel ONLY that seam.
-  const nativeInstalled = installNativeExceptionCapture();
-  const errorUtils = globalThis.ErrorUtils;
-  if (typeof errorUtils?.setGlobalHandler !== "function") {
-    fatalInstalled = nativeInstalled;
-    return;
-  }
-  fatalInstalled = true;
-  const previous = typeof errorUtils.getGlobalHandler === "function" ? errorUtils.getGlobalHandler() : undefined;
-  errorUtils.setGlobalHandler((error, isFatal) => {
-    try {
-      if (!captureDisabledByUser) recordFatalError(error, isFatal);
-    } catch {
-      // Capture must never interfere with error reporting.
-    }
-    if (typeof previous === "function") previous(error, isFatal);
-  });
-}
-
-/**
- * Patch the global console methods. Idempotent — safe to call more than once.
- * Each patched method still forwards to the original so normal logging keeps
- * working (Metro terminal, Chrome, native logcat/Xcode).
- *
- * Also installs the fatal-error hook (see `installFatalErrorCapture`) so every
- * install path captures crashes, not just `console.*` calls.
- */
-export function installConsoleCapture() {
-  if (getAccountAccess().status === "locked") return;
-  captureDisabledByUser = false;
-  installFatalErrorCapture();
-  if (installed) return;
-  installed = true;
-  for (const method of METHODS) {
-    const original = console[method];
-    if (typeof original !== "function") continue;
-    originals[method] = original;
-    // Named so origin parsing can identify (and skip) this frame by function
-    // name — in a Metro bundle every frame shares one bundle URL, so filename
-    // filtering can't distinguish our wrapper from the real caller.
-    console[method] = function buoyConsoleProxy(...args) {
-      record(method, args);
-      original.apply(console, args);
-    };
-  }
-}
-
-/** Restore the original console methods. Also mutes fatal-error recording
- * (the hook itself stays chained — see `installFatalErrorCapture`). */
-export function uninstallConsoleCapture() {
-  captureDisabledByUser = true;
-  if (!installed) return;
-  installed = false;
-  for (const method of METHODS) {
-    const original = originals[method];
-    if (original) console[method] = original;
-    delete originals[method];
-  }
-}
-
-/** Subscribe to changes. Returns an unsubscribe function. */
-export function subscribe(listener) {
-  return store.subscribe(listener);
-}
-
-/** Current snapshot (stable reference between mutations for useSyncExternalStore). */
-export function getEntries() {
-  return store.getSnapshot();
-}
-
-/** Clear all captured entries. Fires onClear listeners (e.g. to forward the
- * clear to a remote device when running in mirror mode). */
-export function clearEntries() {
-  void clearSavedBuffer();
-  store.clear();
-}
-
-// ─── Remote-mirror mode (desktop dashboard) ──────────────────────────────────
-// The desktop imports this same store but, instead of patching its own console,
-// drives it from device snapshots via replaceEntries(). Capture is never
-// installed there, so local and remote modes never mix.
-
-/** Replace the whole entry list from a remote snapshot. */
-export function replaceEntries(next) {
-  store.set(next);
-}
-
-/** Register a listener fired when clearEntries() is called. Returns an
- * unsubscribe function. Used by the dashboard to forward clears to the device. */
-export function onClear(listener) {
-  return store.onClear(listener);
-}
-
-// ─── Preserve log (persist across reload) ────────────────────────────────────
-// Default OFF: the buffer is in-memory only, so a reload starts fresh. When ON,
-// the buffer is saved to storage (debounced) and restored on the next launch.
-
-const PRESERVE_KEY = "@react_buoy_console_preserve";
-const BUFFER_KEY = "@react_buoy_console_buffer";
-const SAVE_DEBOUNCE_MS = 600;
-let preserveLog = false;
-let persistenceReady = false;
-let persistenceGeneration = 0;
-let bufferWrites = Promise.resolve();
-const preserveListeners = new Set();
-let saveTimer = null;
-function emitPreserve() {
-  for (const listener of preserveListeners) listener();
-}
-function scheduleSave() {
-  if (!preserveLog || !hasAccountAccess()) return;
-  if (saveTimer) clearTimeout(saveTimer);
-  saveTimer = setTimeout(saveBuffer, SAVE_DEBOUNCE_MS);
-}
-async function saveBuffer() {
-  saveTimer = null;
-  if (!preserveLog || !hasAccountAccess()) return;
-  try {
-    const serializable = store.getSnapshot().map(entry => ({
-      ...entry,
-      args: sanitizeArgs(entry.args)
-    }));
-    const generation = persistenceGeneration;
-    bufferWrites = bufferWrites.then(async () => {
-      if (generation !== persistenceGeneration || !preserveLog || !hasAccountAccess()) return;
-      await persistentStorage.setItem(BUFFER_KEY, JSON.stringify(serializable));
-    }).catch(() => {});
-    await bufferWrites;
-  } catch {
-    // Storage unavailable — preserve is best-effort.
-  }
-}
-async function clearSavedBuffer() {
-  persistenceGeneration++;
-  persistenceReady = false;
-  try {
-    bufferWrites = bufferWrites.then(() => persistentStorage.removeItem(BUFFER_KEY)).catch(() => {});
-    await bufferWrites;
-  } catch {
-    // ignore
-  }
-}
-
-/**
- * Load the persisted preserve-log flag and, if enabled, restore the saved
- * buffer. If disabled, drop any saved buffer so the session starts fresh.
- * Idempotent — safe to call from ConsoleRoot on every mount.
- */
-export async function initConsolePersistence() {
-  if (persistenceReady || !hasAccountAccess()) return;
-  persistenceReady = true;
-  const generation = persistenceGeneration;
-  try {
-    preserveLog = (await persistentStorage.getItem(PRESERVE_KEY)) === "true";
-  } catch {
-    preserveLog = false;
-  }
-  if (generation !== persistenceGeneration || !hasAccountAccess()) {
-    persistenceReady = false;
-    return;
-  }
-  emitPreserve();
-  if (!preserveLog) {
-    await clearSavedBuffer();
-    return;
-  }
-  try {
-    const raw = await persistentStorage.getItem(BUFFER_KEY);
-    if (generation !== persistenceGeneration || !hasAccountAccess()) {
-      persistenceReady = false;
-      return;
-    }
-    if (raw) {
-      const saved = JSON.parse(raw);
-      if (Array.isArray(saved) && saved.length) {
-        // Prepend restored entries before anything captured this session.
-        store.update(current => [...saved, ...current]);
-        store.bumpIdAbove(Math.max(...saved.map(e => e.id)));
-      }
-    }
-  } catch {
-    // Corrupt/absent buffer — ignore.
-  }
-}
-
-/** Whether logs persist across reload. */
-export function getPreserveLog() {
-  return preserveLog;
-}
-
-/** Toggle preserve-log. Persists the flag; saves or drops the buffer. */
-export function setPreserveLog(next) {
-  if (preserveLog === next) return;
-  preserveLog = next;
-  emitPreserve();
-  persistentStorage.setItem(PRESERVE_KEY, String(next)).catch(() => {});
-  if (next) saveBuffer();else clearSavedBuffer();
-}
-
-/** Subscribe to preserve-log changes. Returns an unsubscribe function. */
-export function subscribePreserveLog(listener) {
-  preserveListeners.add(listener);
-  return () => {
-    preserveListeners.delete(listener);
-  };
-}
-//# sourceMappingURL=consoleLogStore.js.map
+This error is located at:
+${C(e.componentStack)}`:"";const a=`${t} ${n}${o}`;b({id:s.allocId(),method:"error",level:"error",args:[t,n,...o?[o.trim()]:[]],message:a,timestamp:Date.now(),stack:q(e),fatal:true},r)}function Z(){const e=globalThis.RN$registerExceptionListener;if(typeof e!=="function")return false;e(t=>{try{if(!d)Q(t)}catch{}});return true}export function installFatalErrorCapture(){if(E)return;const e=Z();const t=globalThis.ErrorUtils;if(typeof t?.setGlobalHandler!=="function"){E=e;return}E=true;const n=typeof t.getGlobalHandler==="function"?t.getGlobalHandler():void 0;t.setGlobalHandler((r,o)=>{try{if(!d)X(r,o)}catch{}if(typeof n==="function")n(r,o)})}export function installConsoleCapture(){if(F().status==="locked")return;d=false;installFatalErrorCapture();if(m)return;m=true;for(const e of A){const t=console[e];if(typeof t!=="function")continue;h[e]=t;console[e]=function n(...r){W(e,r);t.apply(console,r)}}}export function uninstallConsoleCapture(){d=true;if(!m)return;m=false;for(const e of A){const t=h[e];if(t)console[e]=t;delete h[e]}}export function subscribe(e){return s.subscribe(e)}export function getEntries(){return s.getSnapshot()}export function clearEntries(){void w();s.clear()}export function replaceEntries(e){s.set(e)}export function onClear(e){return s.onClear(e)}const D="@react_buoy_console_preserve";const $="@react_buoy_console_buffer";const ee=600;let i=false;let p=false;let l=0;let f=Promise.resolve();const v=new Set;let g=null;function _(){for(const e of v)e()}function x(){if(!i||!c())return;if(g)clearTimeout(g);g=setTimeout(O,ee)}async function O(){g=null;if(!i||!c())return;try{const e=s.getSnapshot().map(n=>({...n,args:M(n.args)}));const t=l;f=f.then(async()=>{if(t!==l||!i||!c())return;await u.setItem($,JSON.stringify(e))}).catch(()=>{});await f}catch{}}async function w(){l++;p=false;try{f=f.then(()=>u.removeItem($)).catch(()=>{});await f}catch{}}export async function initConsolePersistence(){if(p||!c())return;p=true;const e=l;try{i=await u.getItem(D)==="true"}catch{i=false}if(e!==l||!c()){p=false;return}_();if(!i){await w();return}try{const t=await u.getItem($);if(e!==l||!c()){p=false;return}if(t){const n=JSON.parse(t);if(Array.isArray(n)&&n.length){s.update(r=>[...n,...r]);s.bumpIdAbove(Math.max(...n.map(r=>r.id)))}}}catch{}}export function getPreserveLog(){return i}export function setPreserveLog(e){if(i===e)return;i=e;_();u.setItem(D,String(e)).catch(()=>{});if(e)O();else w()}export function subscribePreserveLog(e){v.add(e);return()=>{v.delete(e)}}

package/lib/module/store/sanitize.js

@@ -1,77 +1 @@
-"use strict";
-
-/**
- * sanitizeArgs — deep-convert captured console arguments into JSON-safe values.
- *
- * Captured `args` can hold Errors, functions, bigints, symbols, and circular
- * references. Both the external-sync snapshot (device → desktop) and the
- * preserve-log persistence need plain JSON, so this produces a structural copy
- * (objects/arrays preserved so they stay expandable) with cycles broken.
- *
- * Strings are capped: a single `console.log` of a multi-MB payload (API dump,
- * base64, …) used to ride every snapshot uncapped and drop the whole console
- * panel at the 2MB emit budget.
- */
-
-const MAX_DEPTH = 6;
-const MAX_ARRAY = 100;
-const MAX_KEYS = 100;
-
-/** Max chars of one string on the wire / in the persisted buffer. */
-export const SNAPSHOT_STRING_LIMIT = 2 * 1024;
-export function capString(value, limit = SNAPSHOT_STRING_LIMIT) {
-  if (value.length <= limit) return value;
-  return `${value.slice(0, limit)}… [${value.length - limit} more]`;
-}
-function sanitizeValue(value, depth, seen) {
-  if (value === null) return null;
-  // Checked inline rather than through a `const t = typeof value` alias: the
-  // alias does not narrow `value`, so the string branch could not be handed to
-  // a `(s: string)` function without a cast — which is how this file stopped
-  // compiling.
-  if (typeof value === "string") return capString(value);
-  if (typeof value === "boolean") return value;
-  if (typeof value === "number") return Number.isFinite(value) ? value : String(value);
-  if (typeof value === "undefined") return "undefined";
-  if (typeof value === "bigint") return `${String(value)}n`;
-  if (typeof value === "function") {
-    return `ƒ ${value.name || "(anonymous)"}`;
-  }
-  if (typeof value === "symbol") return value.toString();
-  if (value instanceof Error) {
-    return {
-      name: value.name,
-      message: capString(value.message),
-      stack: value.stack ? capString(value.stack, 4 * 1024) : value.stack
-    };
-  }
-  if (depth >= MAX_DEPTH) return Array.isArray(value) ? "[Array]" : "{…}";
-  const obj = value;
-  if (seen.has(obj)) return "[Circular]";
-  seen.add(obj);
-  try {
-    if (Array.isArray(value)) {
-      const out = value.slice(0, MAX_ARRAY).map(v => sanitizeValue(v, depth + 1, seen));
-      if (value.length > MAX_ARRAY) out.push(`… ${value.length - MAX_ARRAY} more`);
-      return out;
-    }
-    const out = {};
-    for (const key of Object.keys(obj).slice(0, MAX_KEYS)) {
-      try {
-        out[key] = sanitizeValue(obj[key], depth + 1, seen);
-      } catch {
-        out[key] = "[Unserializable]";
-      }
-    }
-    return out;
-  } finally {
-    seen.delete(obj);
-  }
-}
-
-/** Deep-sanitize an array of console arguments into JSON-safe values. */
-export function sanitizeArgs(args) {
-  const seen = new WeakSet();
-  return args.map(arg => sanitizeValue(arg, 0, seen));
-}
-//# sourceMappingURL=sanitize.js.map
+"use strict";const y=6;const f=100;const g=100;export const SNAPSHOT_STRING_LIMIT=2*1024;export function capString(r,t=SNAPSHOT_STRING_LIMIT){if(r.length<=t)return r;return`${r.slice(0,t)}\u2026 [${r.length-t} more]`}function e(r,t,n){if(r===null)return null;if(typeof r==="string")return capString(r);if(typeof r==="boolean")return r;if(typeof r==="number")return Number.isFinite(r)?r:String(r);if(typeof r==="undefined")return"undefined";if(typeof r==="bigint")return`${String(r)}n`;if(typeof r==="function"){return`\u0192 ${r.name||"(anonymous)"}`}if(typeof r==="symbol")return r.toString();if(r instanceof Error){return{name:r.name,message:capString(r.message),stack:r.stack?capString(r.stack,4*1024):r.stack}}if(t>=y)return Array.isArray(r)?"[Array]":"{\u2026}";const o=r;if(n.has(o))return"[Circular]";n.add(o);try{if(Array.isArray(r)){const i=r.slice(0,f).map(c=>e(c,t+1,n));if(r.length>f)i.push(`\u2026 ${r.length-f} more`);return i}const s={};for(const i of Object.keys(o).slice(0,g)){try{s[i]=e(o[i],t+1,n)}catch{s[i]="[Unserializable]"}}return s}finally{n.delete(o)}}export function sanitizeArgs(r){const t=new WeakSet;return r.map(n=>e(n,0,t))}