@forgeax/interface 0.4.1

package/dist/package/node/lib/global-shortcuts.js

@@ -0,0 +1,551 @@
+/**
+ * Global keyboard shortcuts · Blender-inspired, IME-safe.
+ *
+ *   Ctrl+Shift+F  toggle fullscreen (hide TopBar / Sidebar / ChatPanel / StatusBar)
+ *   Ctrl+,        open / close Settings
+ *   Ctrl+Shift+B  toggle Sidebar
+ *   Ctrl+Shift+C  toggle ChatPanel
+ *   Ctrl+Shift+D  toggle Dashboard overlay
+ *   Ctrl+Shift+0  open Settings → Plugins
+ *   Ctrl+/        focus chat composer
+ *   Ctrl+Shift+H  open Settings → Changelog (was Ctrl+H before 2026-08-04 —
+ *                 UE-parity editor hide claimed Ctrl+H for "show all hidden")
+ *   Esc           stop viewport Play; otherwise close current overlay
+ *                 (Settings → Dashboard → Fullscreen)
+ *
+ * IME 安全:
+ *   - 总是用 Ctrl+Shift 复合,避开浏览器原生 (Ctrl+1/2/3 切 tab · Ctrl+J 下载 · Ctrl+B 收藏栏 · Ctrl+W/T 关/开 tab)
+ *   - keydown 时检查 `event.isComposing` / `event.keyCode === 229` (中文输入法组词中)
+ *   - target 是 input/textarea/contenteditable 时跳过非 Esc / Ctrl+/ (允许"focus composer"在输入框里也能撤焦再聚)
+ *   - macOS:Cmd 与 Ctrl 同义 (event.metaKey || event.ctrlKey)
+ *
+ * 注册:在 App 顶层调用 `useGlobalShortcuts()` 一次。
+ */
+import { useEffect } from 'react';
+import { installKeydownObservation } from '@forgeax/app-shell/react';
+import { t } from '../i18n/index.js';
+import { useShellStore } from '../store.js';
+import { toggleCommandPalette } from './command-palette-store.js';
+// Helper: is the event happening inside a text-editing surface?
+// Guards against non-Element targets (e.g. window / document from synthetic
+// dispatch) where .tagName / .closest aren't defined.
+// Exported for unit tests (T4-9 typing-target-guard coverage).
+export function isTypingTarget(e) {
+    const t = e.target;
+    if (typeof document !== 'undefined' && document.querySelector('.im-editor[data-listening="1"]'))
+        return true;
+    if (!t || !(t instanceof Element))
+        return false;
+    const tag = t.tagName;
+    if (tag === 'INPUT' || tag === 'TEXTAREA' || tag === 'SELECT')
+        return true;
+    if (t.isContentEditable)
+        return true;
+    // RichInput composer / Input Map panel
+    if (t.closest('.im-editor, .kc-composer-rich, [data-kc-composer], [contenteditable="true"]'))
+        return true;
+    return false;
+}
+/** Preview canvases own their edit-domain keyboard input locally. */
+export function isKeyboardOwnedSurface(e) {
+    const t = e.target;
+    return t instanceof Element && t.closest('[data-fx-keyboard-surface]') !== null;
+}
+export function shouldSkipGlobalShortcut(e, shortcut) {
+    return shortcut.group === 'edit' && isKeyboardOwnedSurface(e);
+}
+// IME-composing check — Chinese input methods send a stream of keydowns
+// while composing; key === "Process" or keyCode === 229 signals "the user
+// is in IME, don't intercept anything."
+// Exported for unit tests (T4-9 IME-guard coverage).
+export function isComposing(e) {
+    if (e.isComposing)
+        return true;
+    if (e.keyCode === 229)
+        return true;
+    if (e.key === 'Process')
+        return true;
+    return false;
+}
+/** IME / synthetic events may omit `key`; never call `.toLowerCase()` blindly. */
+function safeKeyLower(e) {
+    return typeof e.key === 'string' ? e.key.toLowerCase() : '';
+}
+// Ctrl-or-Cmd helper.
+function mod(e) {
+    return e.ctrlKey || e.metaKey;
+}
+// Is the scene editor the surface the user is currently looking at?
+//
+// The remaining legacy `edit` group (Ctrl+D / viewport W-E-R-F …) is injected
+// globally at boot and still dispatches against module-level editor selection /
+// viewport state. This coarse surface gate lets those keys escape whenever the editor is
+// not the foreground surface. Two facts, both interface-local (no editor
+// import, no focus/DOM resolver — that larger redesign is ADR-0029 scope; this
+// is its Phase 0 short-term mitigation):
+//   1. an overlay (Dashboard / Settings) is covering the shell, or
+//   2. the editor Page anchor is not currently visible.
+// Read live at event time (cached snapshot — cheap) so switching tab / opening
+// an overlay takes effect immediately.
+export function isEditorSurfaceActive() {
+    if (useShellStore.getState().activeOverlay)
+        return false;
+    const anchor = typeof document === 'undefined'
+        ? null
+        : document.querySelector('[data-surface-anchor="edit"]');
+    return Boolean(anchor && anchor.getClientRects().length > 0);
+}
+let routerDeps = null;
+const transientKeydownHandlers = new Set();
+export function registerGlobalKeydownHandler(handler) {
+    transientKeydownHandlers.add(handler);
+    return () => transientKeydownHandlers.delete(handler);
+}
+export function dispatchGlobalKeydownHandlers(event) {
+    for (const handler of [...transientKeydownHandlers]) {
+        if (handler(event))
+            return true;
+    }
+    return false;
+}
+/** Inject the editor-side callbacks the router needs. Called once at host boot
+ *  (forgeax-editor standalone/main.tsx) BEFORE the App mounts (useGlobalShortcuts
+ *  reads this at effect time, which is after mount, so registration first is safe). */
+export function registerKeyboardRouterDeps(deps) {
+    routerDeps = deps;
+}
+/** Read the currently injected router deps. Returns null until the host has
+ *  called registerKeyboardRouterDeps() at boot. Command-bus wrappers
+ *  (editor-commands extension) resolve deps lazily via this getter so they
+ *  stay editor-agnostic and boot-order-safe. */
+export function getKeyboardRouterDeps() {
+    return routerDeps;
+}
+// Build the edit-domain shortcut list from injected deps. Pure dispatcher: every
+// branch routes through a dep callback (which the editor maps onto gateway ops),
+// so this file stays editor-agnostic. Three-layer guards (IME / typing-target /
+// play-mode) are enforced by the host's onKey wrapper (isComposing / isTypingTarget)
+// plus the per-op play-mode checks below.
+function editShortcuts(deps) {
+    const routeCtrlD = () => {
+        const domain = deps.getLastSelectionDomain() ?? 'entity';
+        if (domain === 'asset') {
+            for (const a of deps.getAssetSelection())
+                deps.duplicateAsset(a.guid, a.packPath);
+            return true;
+        }
+        const ids = deps.getEntitySelection();
+        if (ids.length > 0) {
+            deps.duplicateEntities(ids);
+            return true;
+        }
+        return false;
+    };
+    // UE-parity editor hide (docs 2026-08-04-editor-hide-ue-parity-plan M2):
+    // H hides the selection, Ctrl+H shows every hidden entity, Shift+H hides
+    // the unselected (isolate). Entity-domain only; under Play the game keeps
+    // its keys (same guard as entity Delete).
+    const routeH = () => {
+        if (deps.isPlayMode())
+            return false;
+        const ids = deps.getEntitySelection();
+        if (ids.length === 0)
+            return false;
+        deps.hideEntities(ids);
+        return true;
+    };
+    const routeShiftH = () => {
+        if (deps.isPlayMode())
+            return false;
+        if (deps.getEntitySelection().length === 0)
+            return false;
+        deps.hideUnselected();
+        return true;
+    };
+    const routeCtrlH = () => {
+        if (deps.isPlayMode())
+            return false;
+        deps.showAllHidden();
+        return true;
+    };
+    // Viewport Game View toggle. Plain G is editor-only while not playing so a
+    // running game retains its gameplay binding; Shift+G remains the explicit
+    // Play shortcut and is also available in Edit Viewport.
+    const routeShiftG = () => {
+        deps.dispatch({ kind: 'setDisplay', display: deps.getDisplay() === 'game' ? 'scene' : 'game' }, 'human');
+        return true;
+    };
+    const routeEditorOwnedPlayKey = (e) => {
+        if (!e)
+            return true;
+        deps.handleViewportKeyDown(e);
+        return true;
+    };
+    const routeViewportInput = (e) => {
+        if (!e)
+            return false;
+        if (deps.getInputTarget() === 'game')
+            return false;
+        deps.handleViewportKeyDown(e);
+        return true;
+    };
+    return [
+        {
+            combo: 'Ctrl+D',
+            group: 'edit',
+            label: t('shortcuts.duplicateSelection'),
+            match: (e) => mod(e) && !e.shiftKey && !e.altKey
+                && (e.code === 'KeyD' || safeKeyLower(e) === 'd'),
+            run: routeCtrlD,
+        },
+        {
+            combo: 'H',
+            group: 'edit',
+            label: t('shortcuts.hideSelected'),
+            match: (e) => !mod(e) && !e.shiftKey && !e.altKey && e.code === 'KeyH',
+            run: routeH,
+        },
+        {
+            combo: 'Shift+H',
+            group: 'edit',
+            label: t('shortcuts.hideUnselected'),
+            match: (e) => !mod(e) && e.shiftKey && !e.altKey && e.code === 'KeyH',
+            run: routeShiftH,
+        },
+        {
+            combo: 'Ctrl+H',
+            group: 'edit',
+            label: t('shortcuts.showAllHidden'),
+            match: (e) => mod(e) && !e.shiftKey && !e.altKey && e.code === 'KeyH',
+            run: routeCtrlH,
+        },
+        {
+            combo: 'Shift+G',
+            group: 'edit',
+            label: t('shortcuts.toggleViewportGameView'),
+            match: (e) => !mod(e) && e.shiftKey && !e.altKey
+                && (e.key === 'g' || e.key === 'G'),
+            run: routeShiftG,
+        },
+        {
+            combo: 'G',
+            group: 'edit',
+            label: t('shortcuts.toggleViewportGameView'),
+            match: (e) => !mod(e) && !e.shiftKey && !e.altKey
+                && !deps.isPlayMode() && deps.getInputTarget() !== 'game'
+                && (e.key === 'g' || e.key === 'G'),
+            run: routeShiftG,
+        },
+        {
+            combo: 'Ctrl+Z',
+            group: 'edit',
+            label: t('shortcuts.undo'),
+            allowInInput: true,
+            match: (e) => mod(e) && !e.altKey && !e.shiftKey && (e.code === 'KeyZ' || safeKeyLower(e) === 'z'),
+            run: () => { deps.undo(); return true; },
+        },
+        {
+            combo: 'Ctrl+Shift+Z',
+            group: 'edit',
+            label: t('shortcuts.redo'),
+            allowInInput: true,
+            match: (e) => mod(e) && !e.altKey && e.shiftKey && (e.code === 'KeyZ' || safeKeyLower(e) === 'z'),
+            run: () => { deps.redo(); return true; },
+        },
+        {
+            combo: 'Ctrl+Y',
+            group: 'edit',
+            label: t('shortcuts.redo'),
+            allowInInput: true,
+            match: (e) => mod(e) && !e.altKey && !e.shiftKey && (e.code === 'KeyY' || safeKeyLower(e) === 'y'),
+            run: () => { deps.redo(); return true; },
+        },
+        {
+            combo: 'Ctrl+S',
+            group: 'edit',
+            label: t('shortcuts.save'),
+            // Must fire while typing in Input Map / MI fields (⌘/Ctrl+S is a document
+            // command, not a text-editing key). Without this, focus inside `.im-editor`
+            // makes isTypingTarget true and silently drops save.
+            allowInInput: true,
+            match: (e) => mod(e) && !e.altKey && !e.shiftKey && (e.code === 'KeyS' || safeKeyLower(e) === 's'),
+            run: () => { deps.save(); return true; },
+        },
+        {
+            combo: 'Viewport camera and fly input',
+            group: 'edit',
+            label: t('shortcuts.viewportNavigation'),
+            match: (e) => {
+                if (deps.getInputTarget() === 'game')
+                    return false;
+                const key = safeKeyLower(e);
+                if (!key)
+                    return false;
+                // UE-style view presets (Alt+G/H/J/K) route to the viewport handler,
+                // which owns the camera. All other Alt combos stay excluded here.
+                if (e.altKey) {
+                    return !mod(e) && !e.shiftKey && ['g', 'h', 'j', 'k'].includes(key);
+                }
+                const plainCameraKey = !mod(e)
+                    && (['w', 'e', 'r', 'f', 'a', 's', 'd', 'q', 'v', 'z', 'c', 'escape', 'shift'].includes(key)
+                        || /^[1-9]$/.test(key));
+                const bookmarkKey = mod(e) && !e.shiftKey && /^[1-9]$/.test(key);
+                return plainCameraKey || bookmarkKey;
+            },
+            run: routeViewportInput,
+        },
+        {
+            combo: 'Play editor input shield',
+            group: 'edit',
+            label: t('shortcuts.shieldGameInput'),
+            match: () => deps.isPlayMode() && deps.getInputTarget() !== 'game',
+            run: routeEditorOwnedPlayKey,
+        },
+    ];
+}
+// Build the shortcut registry. Each match() / run() is plain JS so we can
+// drive them from a Settings table later (or a Command Palette).
+export function buildShortcuts() {
+    const store = useShellStore.getState;
+    const shortcuts = [
+        // ── Layout (collapse / fullscreen) ──
+        {
+            combo: 'Ctrl+Shift+F',
+            group: 'layout',
+            label: t('shortcuts.gameFullscreen'),
+            match: (e) => mod(e) && e.shiftKey && e.code === 'KeyF',
+            run: () => { store().toggleFullscreen(); return true; },
+        },
+        {
+            combo: 'Ctrl+Shift+Enter',
+            group: 'layout',
+            label: t('shortcuts.browserFullscreen'),
+            match: (e) => mod(e) && e.shiftKey && (e.code === 'Enter' || e.key === 'Enter'),
+            run: () => {
+                // Browser-native fullscreen toggle. Independent of store.fullscreen
+                // — user can have either, both, or neither. Esc exits the native FS
+                // automatically; fullscreenchange listener below keeps state in sync
+                // if needed (we don't currently mirror native FS into the store,
+                // because the two modes are intentionally orthogonal).
+                try {
+                    if (!document.fullscreenElement) {
+                        void document.documentElement.requestFullscreen?.().catch(() => { });
+                    }
+                    else {
+                        void document.exitFullscreen?.().catch(() => { });
+                    }
+                }
+                catch { /* old browsers without FS API */ }
+                return true;
+            },
+        },
+        {
+            combo: 'Ctrl+Shift+B',
+            group: 'layout',
+            label: t('shortcuts.toggleSidebar'),
+            match: (e) => mod(e) && e.shiftKey && e.code === 'KeyB',
+            run: () => { store().toggleSidebar(); return true; },
+        },
+        {
+            combo: 'Ctrl+Shift+C',
+            group: 'layout',
+            label: t('shortcuts.toggleChatPanel'),
+            match: (e) => mod(e) && e.shiftKey && e.code === 'KeyC',
+            run: () => { store().toggleChatpanel(); return true; },
+        },
+        {
+            // 3-state chat toggle: closed → open at default (ChatDock); open but dragged
+            // into the centre grid → move it home; open at default → close. ChatDock owns
+            // the actual work (it holds chat's dockview api + panelLocations) — we just
+            // fire the intent so a single handler converges every route. preventDefault
+            // always so F1 never opens the browser help page.
+            combo: 'F1',
+            group: 'layout',
+            label: t('shortcuts.revealChat'),
+            match: (e) => !mod(e) && !e.shiftKey && !e.altKey && (e.key === 'F1' || e.code === 'F1'),
+            run: () => { window.dispatchEvent(new CustomEvent('forgeax:chat-toggle')); return true; },
+        },
+        // ── Overlay (Dashboard / Settings) ──
+        {
+            combo: 'Ctrl+Shift+D',
+            group: 'overlay',
+            label: t('shortcuts.toggleDashboard'),
+            match: (e) => mod(e) && e.shiftKey && e.code === 'KeyD',
+            run: () => { const s = store(); s.activeOverlay === 'dashboard' ? s.closeOverlay() : s.openOverlay('dashboard'); return true; },
+        },
+        {
+            combo: 'Ctrl+,',
+            group: 'overlay',
+            label: t('shortcuts.toggleSettings'),
+            match: (e) => mod(e) && !e.shiftKey && (e.key === ',' || e.code === 'Comma'),
+            run: () => { const s = store(); s.activeOverlay === 'settings' ? s.closeOverlay() : s.openOverlay('settings'); return true; },
+        },
+        {
+            combo: 'Ctrl+Shift+H',
+            group: 'overlay',
+            label: t('shortcuts.openChangelog'),
+            match: (e) => mod(e) && e.shiftKey && e.code === 'KeyH',
+            run: () => { store().openOverlay('settings', 'changelog'); return true; },
+        },
+        {
+            combo: 'Esc',
+            group: 'overlay',
+            label: t('shortcuts.closeOverlay'),
+            allowInInput: true,
+            match: (e) => e.key === 'Escape' && !mod(e) && !e.shiftKey && !e.altKey,
+            run: () => {
+                // Escape is a Play-only viewport shortcut: stop the transient play
+                // session and return to edit mode. The listener stays in the single
+                // global router; outside Play this branch is inactive.
+                if (routerDeps?.isPlayMode()) {
+                    routerDeps.dispatch({ kind: 'stop' }, 'human');
+                    return true;
+                }
+                const s = store();
+                // Browser fullscreen exits automatically on Esc — but be defensive
+                // in case some browser swallows the event before reaching the native
+                // handler; explicit exit is a no-op when no element is fullscreen.
+                if (document.fullscreenElement) {
+                    void document.exitFullscreen?.().catch(() => { });
+                    return true;
+                }
+                if (s.fullscreen) {
+                    s.setFullscreen(false);
+                    return true;
+                }
+                if (s.activeOverlay) {
+                    s.closeOverlay();
+                    return true;
+                }
+                return false;
+            },
+        },
+        {
+            combo: 'Ctrl+Shift+0',
+            group: 'overlay',
+            label: t('shortcuts.openExtensions'),
+            match: (e) => mod(e) && e.shiftKey && (e.code === 'Digit0' || e.key === '0' || e.key === ')'),
+            run: () => { store().openOverlay('settings', 'plugins'); return true; },
+        },
+        // ── Focus ──
+        {
+            combo: 'Ctrl+/',
+            group: 'focus',
+            label: t('shortcuts.focusComposer'),
+            allowInInput: true,
+            match: (e) => mod(e) && !e.shiftKey && (e.key === '/' || e.code === 'Slash'),
+            run: () => {
+                // Auto-uncollapse first if hidden.
+                const s = store();
+                if (s.chatpanelCollapsed)
+                    s.toggleChatpanel();
+                // Focus the composer's editable element. Selector covers RichInput
+                // (preferred new path) and the legacy textarea fallback.
+                const el = document.querySelector('.kc-composer-rich [contenteditable="true"]') ||
+                    document.querySelector('.kc-composer textarea') ||
+                    document.querySelector('[data-kc-composer]');
+                if (el) {
+                    el.focus();
+                    // Move caret to end if it's a contenteditable
+                    if (el.isContentEditable) {
+                        const sel = window.getSelection();
+                        const range = document.createRange();
+                        range.selectNodeContents(el);
+                        range.collapse(false);
+                        sel?.removeAllRanges();
+                        sel?.addRange(range);
+                    }
+                }
+                return true;
+            },
+        },
+    ];
+    // Inject the host editor's remaining edit-domain shortcuts when deps were
+    // registered at boot. Focus-owned F2/Delete/Mod+A live in host.keybindings.
+    if (routerDeps)
+        shortcuts.push(...editShortcuts(routerDeps));
+    shortcuts.push({
+        combo: 'Ctrl+K',
+        group: 'general',
+        label: t('shortcuts.toggleCommandPalette'),
+        match: (e) => mod(e) && !e.altKey && !e.shiftKey && (e.code === 'KeyK' || safeKeyLower(e) === 'k'),
+        run: () => { toggleCommandPalette(); return true; },
+    });
+    return shortcuts;
+}
+/**
+ * Mount once at App root. Returns nothing — purely an effect.
+ *
+ * `passive: false` so we can preventDefault — required for Ctrl+, (Chrome
+ * historically had no native binding but treat it as user gesture) and
+ * Ctrl+Shift+1/2/3 (which Chrome maps to tab switching only WITHOUT Shift,
+ * so we're safe, but we preventDefault anyway).
+ */
+export function useGlobalShortcuts(keybindings) {
+    useEffect(() => {
+        const shortcuts = buildShortcuts();
+        const onKey = (e) => {
+            // 0. IME composing — bail. Never intercept Chinese pinyin chord.
+            if (isComposing(e))
+                return;
+            // 1. Short-lived interaction owners (drag cancel, etc.) get priority
+            // inside the same global listener and can consume the event before
+            // discoverable editor commands see it.
+            if (dispatchGlobalKeydownHandlers(e)) {
+                e.preventDefault();
+                e.stopPropagation();
+                return;
+            }
+            // 2. The contextual resolver gets first refusal inside the ONE capture
+            // listener. A handled or disabled-but-claimed binding must not fall into
+            // legacy application shortcuts; passthrough/unclaimed continues below.
+            const contextual = keybindings?.handle(e);
+            if (contextual?.status === 'handled' || contextual?.status === 'claimed-disabled')
+                return;
+            // 3. Find first matching legacy shortcut.
+            for (const s of shortcuts) {
+                // A focused preview owns camera/fly keys locally. Keep non-edit global
+                // shortcuts available, but never route preview input to the main editor.
+                if (shouldSkipGlobalShortcut(e, s))
+                    continue;
+                // 3a. Typing target → skip before match() (match may call safeKeyLower).
+                if (isTypingTarget(e) && !s.allowInInput)
+                    continue;
+                // 3b. Surface gate — edit-group keys only act while the scene editor is
+                // the foreground surface; otherwise let them escape (fall through to the
+                // focused component / browser default). See isEditorSurfaceActive.
+                if (s.group === 'edit' && !isEditorSurfaceActive())
+                    continue;
+                if (!s.match(e))
+                    continue;
+                const shouldPreventDefault = s.run(e) !== false;
+                if (shouldPreventDefault) {
+                    e.preventDefault();
+                    e.stopPropagation();
+                }
+                return;
+            }
+        };
+        const disposeKeydownObservation = installKeydownObservation({
+            target: window,
+            capture: true, // capture-phase: beat ChatPanel handlers
+            onKeyDown: onKey,
+        });
+        return disposeKeydownObservation;
+    }, [keybindings]);
+}
+// macOS pretty-printing for shortcut combos shown in Settings.
+// Returns the canonical UI string. When platform is omitted, auto-detects macOS.
+export function prettyCombo(combo, platform) {
+    const isMac = platform === 'mac'
+        || (platform === undefined
+            && typeof navigator !== 'undefined'
+            && /mac/i.test(navigator.platform));
+    if (!isMac)
+        return combo;
+    return combo
+        .replace(/Ctrl/g, '⌘')
+        .replace(/Shift/g, '⇧')
+        .replace(/Alt/g, '⌥')
+        .replace(/\+/g, '');
+}

package/dist/package/node/lib/logSink.js

@@ -0,0 +1,128 @@
+/**
+ * logSink — best-effort persistence of the in-memory observe/debug streams
+ * (Console / Network / Info) to disk via `POST /api/logs`.
+ *
+ * Why: those three streams live only in the browser store (cap 500, in-memory),
+ * so a refresh / crash / closed tab loses them — useless for after-the-fact
+ * debugging. This sink mirrors every entry to `.forgeax/logs/<stream>.jsonl`
+ * on the server (size-rotated there).
+ *
+ * Contract: `recordLog(stream, entry)` is fire-and-forget and NEVER throws into
+ * its caller (the store mutators) — logging must not break the UI. Entries are
+ * batched and flushed on a short debounce, when a queue gets large, or when the
+ * tab is hidden / unloaded (sendBeacon) so the last buffer survives a close.
+ */
+// Per-page-load correlation id, stamped onto every POST so the three client
+// streams (console/network/info) of ONE browser session can be joined on disk
+// (and matched against a session's window in the server log). Minted once.
+const SESSION_ID = (() => {
+    try {
+        const c = globalThis.crypto;
+        if (c?.randomUUID)
+            return c.randomUUID();
+    }
+    catch { /* no crypto */ }
+    return `sid-${Date.now().toString(36)}-${Math.floor(Math.random() * 1e9).toString(36)}`;
+})();
+const QUEUES = { console: [], network: [], info: [] };
+const FLUSH_MS = 2000;
+const MAX_QUEUE = 100; // flush immediately past this to bound memory + payload size
+let timer = null;
+// Disk-write dedup: a per-frame error flood (e.g. a RAF-loop console.error at
+// 60Hz) would otherwise write 60 identical lines/sec. Collapse consecutive
+// identical entries within a window onto a single queued record + `repeat` count.
+// (The in-memory store's collapseEntries only folds the UI view, not disk.)
+const DEDUP_WINDOW_MS = 1000;
+const lastSig = {
+    console: null, network: null, info: null,
+};
+function sigOf(entry) {
+    if (!entry || typeof entry !== 'object')
+        return String(entry);
+    const { ts: _ts, id: _id, repeat: _r, ...rest } = entry;
+    void _ts;
+    void _id;
+    void _r;
+    try {
+        return JSON.stringify(rest);
+    }
+    catch {
+        return '';
+    }
+}
+function schedule() {
+    if (timer)
+        return;
+    timer = setTimeout(() => { timer = null; void flushAll(); }, FLUSH_MS);
+}
+async function flushStream(stream) {
+    const entries = QUEUES[stream];
+    if (entries.length === 0)
+        return;
+    // Detach the current batch up front so concurrent recordLog calls queue into
+    // a fresh array (and we don't double-send on failure).
+    QUEUES[stream] = [];
+    lastSig[stream] = null; // post-flush dups start a fresh record (don't bump a sent one)
+    try {
+        await fetch('/api/logs', {
+            method: 'POST',
+            headers: { 'content-type': 'application/json' },
+            body: JSON.stringify({ stream, entries, sessionId: SESSION_ID }),
+            keepalive: true,
+        });
+    }
+    catch {
+        // Drop on failure rather than retry — an unreachable server shouldn't grow
+        // an unbounded in-memory backlog. The store still has the live entries.
+    }
+}
+async function flushAll() {
+    await Promise.all(Object.keys(QUEUES).map(flushStream));
+}
+export function recordLog(stream, entry) {
+    try {
+        const now = Date.now();
+        const sig = sigOf(entry);
+        const last = lastSig[stream];
+        if (last && last.sig === sig && now - last.ts < DEDUP_WINDOW_MS) {
+            // Identical flood within the window → bump `repeat` on the queued record
+            // instead of pushing a duplicate line.
+            last.entry.repeat = (typeof last.entry.repeat === 'number' ? last.entry.repeat : 1) + 1;
+            last.ts = now;
+            return;
+        }
+        const rec = (entry && typeof entry === 'object')
+            ? entry
+            : { value: entry };
+        const q = QUEUES[stream];
+        q.push(rec);
+        lastSig[stream] = { sig, ts: now, entry: rec };
+        if (q.length >= MAX_QUEUE)
+            void flushStream(stream);
+        else
+            schedule();
+    }
+    catch { /* never throw into the UI */ }
+}
+// Flush via sendBeacon on tab hide / unload — fetch() may be cancelled mid-flight
+// when the document is tearing down, but a beacon is guaranteed-delivered.
+if (typeof window !== 'undefined') {
+    const beaconFlush = () => {
+        for (const stream of Object.keys(QUEUES)) {
+            const entries = QUEUES[stream];
+            if (entries.length === 0)
+                continue;
+            QUEUES[stream] = [];
+            try {
+                const blob = new Blob([JSON.stringify({ stream, entries, sessionId: SESSION_ID })], { type: 'application/json' });
+                navigator.sendBeacon('/api/logs', blob);
+            }
+            catch { /* ignore */ }
+        }
+    };
+    window.addEventListener('visibilitychange', () => {
+        if (document.visibilityState === 'hidden')
+            beaconFlush();
+    });
+    window.addEventListener('pagehide', beaconFlush);
+}