@dimina-kit/devtools 0.4.0-dev.20260702182435 → 0.4.0-dev.20260703101348

package/dist/main/ipc/project-fs.js

@@ -468,6 +468,40 @@ function writeFileSync(root, p, content) {
         nodeFs.closeSync(fd);
     }
 }
+/**
+ * Reads one directory's entries. Returns `null` (caller skips the directory)
+ * for `EACCES`/`ENOENT`/`ENOTDIR` — a directory can disappear or become
+ * unreadable between being queued and being walked. Any other error is
+ * rethrown.
+ */
+async function readDirEntriesSafe(dir) {
+    try {
+        return await fs.readdir(dir, { withFileTypes: true });
+    }
+    catch (err) {
+        const code = err.code;
+        if (code === 'EACCES' || code === 'ENOENT' || code === 'ENOTDIR')
+            return null;
+        throw err;
+    }
+}
+/**
+ * Classifies one readdir entry: a non-`SKIP_DIRS` directory is queued for
+ * walking; a plain file is recorded as a `safeRoot`-relative POSIX path.
+ * Skipped directories and non-file/non-directory entries (symlinks, sockets,
+ * etc.) are a no-op.
+ */
+function collectListEntry(entry, dir, safeRoot, out, queue) {
+    const full = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+        if (!SKIP_DIRS.has(entry.name))
+            queue.push(full);
+        return;
+    }
+    if (entry.isFile()) {
+        out.push(path.relative(safeRoot, full).split(path.sep).join('/'));
+    }
+}
 async function listFiles(root, rootArg) {
     const safeRoot = await resolveWithinProjectRoot(rootArg, root);
     const out = [];
@@ -476,29 +510,13 @@ async function listFiles(root, rootArg) {
         if (out.length >= LIST_FILE_LIMIT)
             break;
         const dir = queue.shift();
-        let entries;
-        try {
-            entries = await fs.readdir(dir, { withFileTypes: true });
-        }
-        catch (err) {
-            const code = err.code;
-            if (code === 'EACCES' || code === 'ENOENT' || code === 'ENOTDIR')
-                continue;
-            throw err;
-        }
-        for (const e of entries) {
+        const entries = await readDirEntriesSafe(dir);
+        if (entries === null)
+            continue;
+        for (const entry of entries) {
             if (out.length >= LIST_FILE_LIMIT)
                 break;
-            const full = path.join(dir, e.name);
-            if (e.isDirectory()) {
-                if (SKIP_DIRS.has(e.name))
-                    continue;
-                queue.push(full);
-                continue;
-            }
-            if (!e.isFile())
-                continue;
-            out.push(path.relative(safeRoot, full).split(path.sep).join('/'));
+            collectListEntry(entry, dir, safeRoot, out, queue);
         }
     }
     return out;

package/dist/main/services/automation/handlers/app.js

@@ -76,122 +76,141 @@ appHandlers['App.getPageStack'] = async (ctx) => {
     }
     return { pageStack };
 };
-appHandlers['App.callWxMethod'] = async (ctx, params) => {
-    const method = params.method;
-    const args = params.args || [];
-    // NATIVE-HOST: the authoritative `wx.*` runs in the hidden service-host
-    // window (the simulator / render-guest context has no `wx`). Run EVERY method
-    // there — nav so the page stack goes through the real runtime path, and
-    // non-nav (setNavigationBarTitle / getSystemInfoSync / tabBar APIs / …) so
-    // they don't fall through to the default-arch eval-in-simulator path below,
-    // which throws "wx is not defined" under native-host.
-    if (ctx.bridge?.isNativeHost()) {
-        const serviceWc = ctx.bridge.getServiceWc();
-        if (!serviceWc)
-            throw new Error('Service host not connected');
-        if (NAV_METHODS.has(method) || method === 'navigateBack') {
-            const arg = method === 'navigateBack'
-                ? (args[0] ?? { delta: 1 })
-                : (args[0] ?? {});
-            // Capture the active page BEFORE navigating so we can wait for it to
-            // actually change, instead of blindly sleeping a fixed duration.
-            const since = ctx.bridge.getActiveBridgeId();
-            await serviceWc.executeJavaScript(`wx.${method}(${JSON.stringify(arg)})`);
-            // Wait for the bridge's `activePage` signal (the new page mounted), with a
-            // timeout floor = the old blind-wait duration. Resolves as soon as the new
-            // page is active — far faster than the fixed sleep for the common case —
-            // and still bounded for edges (e.g. switchTab back to an already-mounted
-            // tab keeps the same bridgeId, so it falls through to the floor, same as
-            // the old behaviour). See wait-active-page.ts.
-            const timeoutMs = method === 'navigateBack' ? 1500 : 2000;
-            await waitForActivePage(ctx.bridge, {
-                since,
-                timeoutMs,
-                onTimeout: () => console.warn(`[automation] ${method}: activePage signal not seen within ${timeoutMs}ms — proceeding on timeout floor`),
-            });
-            return { result: undefined };
+/** Nav (incl. navigateBack) on the native-host service-host `wx`, waiting for the page to actually change. */
+async function runNativeHostNav(bridge, serviceWc, method, args) {
+    const arg = method === 'navigateBack'
+        ? (args[0] ?? { delta: 1 })
+        : (args[0] ?? {});
+    // Capture the active page BEFORE navigating so we can wait for it to
+    // actually change, instead of blindly sleeping a fixed duration.
+    const since = bridge.getActiveBridgeId();
+    await serviceWc.executeJavaScript(`wx.${method}(${JSON.stringify(arg)})`);
+    // Wait for the bridge's `activePage` signal (the new page mounted), with a
+    // timeout floor = the old blind-wait duration. Resolves as soon as the new
+    // page is active — far faster than the fixed sleep for the common case —
+    // and still bounded for edges (e.g. switchTab back to an already-mounted
+    // tab keeps the same bridgeId, so it falls through to the floor, same as
+    // the old behaviour). See wait-active-page.ts.
+    const timeoutMs = method === 'navigateBack' ? 1500 : 2000;
+    await waitForActivePage(bridge, {
+        since,
+        timeoutMs,
+        onTimeout: () => console.warn(`[automation] ${method}: activePage signal not seen within ${timeoutMs}ms — proceeding on timeout floor`),
+    });
+    return { result: undefined };
+}
+/**
+ * Non-nav `wx.*` on the native-host service-host, returning its (sync) value.
+ * Async methods that report via a success callback return undefined here,
+ * same as the default-arch generic path (`runSimulatorGeneric`).
+ */
+async function runNativeHostGeneric(serviceWc, method, args) {
+    const argsStr = args.map((a) => JSON.stringify(a)).join(', ');
+    const result = await serviceWc.executeJavaScript(`
+    new Promise((resolve, reject) => {
+      try {
+        if (typeof wx === 'undefined' || typeof wx[${JSON.stringify(method)}] !== 'function') {
+          reject(new Error('wx.' + ${JSON.stringify(method)} + ' is not a function in service host'))
+          return
         }
-        // Non-nav: invoke on the service-host wx and return its (sync) value. Async
-        // methods that report via a success callback return undefined here, same as
-        // the default-arch generic path below.
-        const argsStr = args.map((a) => JSON.stringify(a)).join(', ');
-        const result = await serviceWc.executeJavaScript(`
-      new Promise((resolve, reject) => {
+        resolve(wx.${method}(${argsStr}))
+      } catch (e) { reject(e && e.message ? e.message : String(e)) }
+    })
+  `);
+    return { result };
+}
+/**
+ * NATIVE-HOST: the authoritative `wx.*` runs in the hidden service-host
+ * window (the simulator / render-guest context has no `wx`). Run EVERY method
+ * there — nav so the page stack goes through the real runtime path, and
+ * non-nav (setNavigationBarTitle / getSystemInfoSync / tabBar APIs / …) so
+ * they don't fall through to the default-arch eval-in-simulator path, which
+ * throws "wx is not defined" under native-host.
+ */
+async function runNativeHostWxMethod(bridge, method, args) {
+    const serviceWc = bridge.getServiceWc();
+    if (!serviceWc)
+        throw new Error('Service host not connected');
+    if (NAV_METHODS.has(method) || method === 'navigateBack') {
+        return runNativeHostNav(bridge, serviceWc, method, args);
+    }
+    return runNativeHostGeneric(serviceWc, method, args);
+}
+/**
+ * Try clicking a matching DOM element for a nav target. We can't use
+ * `inIframe` here — tabBar mini-apps keep prior tabs' iframes around
+ * (display:none) and `iframes[length-1]` ends up being the hidden,
+ * freshly-cached tab rather than the visible one. Pick the visible iframe
+ * explicitly.
+ */
+async function clickNavTarget(ctx, cleanUrl) {
+    return evalInSim(ctx, `(() => {
+    const iframes = Array.from(document.querySelectorAll('iframe'))
+    const visible = iframes.filter((f) => {
+      const cs = window.getComputedStyle(f)
+      if (cs.display === 'none' || cs.visibility === 'hidden') return false
+      const rect = f.getBoundingClientRect()
+      return rect.width > 0 && rect.height > 0
+    })
+    const target = visible[visible.length - 1] || iframes[iframes.length - 1]
+    if (!target || !target.contentDocument) return false
+    const path = ${JSON.stringify(cleanUrl)}
+    const el = Array.from(target.contentDocument.querySelectorAll('[data-path]'))
+      .find((e) => e.getAttribute('data-path') === path)
+    if (el) { el.click(); return true }
+    return false
+  })()`).catch(() => false);
+}
+/**
+ * Fallback cascade for navigation methods when no matching DOM element was
+ * found to click:
+ *   1. iframe wx[method] — page-iframe surface (older arch, where jdimina
+ *      installed `window.wx` on each page frame).
+ *   2. top-window wx[method] — set up by simulator/main.tsx, binds
+ *      MiniApp.switchTab / navigateTo / etc. Required for switchTab since
+ *      page-iframe wx (jdimina) doesn't expose it.
+ */
+async function invokeNavViaWx(ctx, method, cleanUrl) {
+    const apiName = JSON.stringify(method);
+    const urlJson = JSON.stringify(cleanUrl);
+    await evalInSim(ctx, `(() => {
+      const iframes = Array.from(document.querySelectorAll('iframe'))
+      for (const f of iframes) {
         try {
-          if (typeof wx === 'undefined' || typeof wx[${JSON.stringify(method)}] !== 'function') {
-            reject(new Error('wx.' + ${JSON.stringify(method)} + ' is not a function in service host'))
+          if (f.contentWindow && f.contentWindow.wx && typeof f.contentWindow.wx[${apiName}] === 'function') {
+            f.contentWindow.wx[${apiName}]({ url: ${urlJson} })
             return
           }
-          resolve(wx.${method}(${argsStr}))
-        } catch (e) { reject(e && e.message ? e.message : String(e)) }
-      })
-    `);
-        return { result };
-    }
-    // For navigation methods, handle specially via DOM click / wx.* on the iframe
-    if (['navigateTo', 'redirectTo', 'reLaunch', 'switchTab'].includes(method)) {
-        const opts = args[0];
-        const url = opts?.url;
-        if (url) {
-            const cleanUrl = url.startsWith('/') ? url : `/${url}`;
-            // Try clicking a matching DOM element first. We can't use `inIframe`
-            // here — tabBar mini-apps keep prior tabs' iframes around (display:none)
-            // and `iframes[length-1]` ends up being the hidden, freshly-cached tab
-            // rather than the visible one. Pick the visible iframe explicitly.
-            const clicked = await evalInSim(ctx, `(() => {
-        const iframes = Array.from(document.querySelectorAll('iframe'))
-        const visible = iframes.filter((f) => {
-          const cs = window.getComputedStyle(f)
-          if (cs.display === 'none' || cs.visibility === 'hidden') return false
-          const rect = f.getBoundingClientRect()
-          return rect.width > 0 && rect.height > 0
-        })
-        const target = visible[visible.length - 1] || iframes[iframes.length - 1]
-        if (!target || !target.contentDocument) return false
-        const path = ${JSON.stringify(cleanUrl)}
-        const el = Array.from(target.contentDocument.querySelectorAll('[data-path]'))
-          .find((e) => e.getAttribute('data-path') === path)
-        if (el) { el.click(); return true }
-        return false
-      })()`).catch(() => false);
-            if (!clicked) {
-                // Fallback cascade for navigation methods:
-                //   1. iframe wx[method] — page-iframe surface (older arch, where
-                //      jdimina installed `window.wx` on each page frame).
-                //   2. top-window wx[method] — set up by simulator/main.tsx, binds
-                //      MiniApp.switchTab / navigateTo / etc. Required for switchTab
-                //      since page-iframe wx (jdimina) doesn't expose it.
-                const apiName = JSON.stringify(method);
-                const urlJson = JSON.stringify(cleanUrl);
-                await evalInSim(ctx, `(() => {
-            const iframes = Array.from(document.querySelectorAll('iframe'))
-            for (const f of iframes) {
-              try {
-                if (f.contentWindow && f.contentWindow.wx && typeof f.contentWindow.wx[${apiName}] === 'function') {
-                  f.contentWindow.wx[${apiName}]({ url: ${urlJson} })
-                  return
-                }
-              } catch (_) {}
-            }
-            if (typeof wx !== 'undefined' && wx && typeof wx[${apiName}] === 'function') {
-              wx[${apiName}]({ url: ${urlJson} })
-            }
-          })()`);
-            }
-            // Wait for navigation
-            await new Promise((r) => setTimeout(r, 2000));
-        }
-        return { result: undefined };
-    }
-    // For navigateBack
-    if (method === 'navigateBack') {
-        await evalInSim(ctx, 'history.back()');
-        await new Promise((r) => setTimeout(r, 1500));
+        } catch (_) {}
+      }
+      if (typeof wx !== 'undefined' && wx && typeof wx[${apiName}] === 'function') {
+        wx[${apiName}]({ url: ${urlJson} })
+      }
+    })()`);
+}
+/** Default-arch nav: handled via DOM click / wx.* on the iframe. */
+async function runSimulatorNav(ctx, method, args) {
+    const opts = args[0];
+    const url = opts?.url;
+    if (!url)
         return { result: undefined };
+    const cleanUrl = url.startsWith('/') ? url : `/${url}`;
+    const clicked = await clickNavTarget(ctx, cleanUrl);
+    if (!clicked) {
+        await invokeNavViaWx(ctx, method, cleanUrl);
     }
-    // General wx method call
+    // Wait for navigation
+    await new Promise((r) => setTimeout(r, 2000));
+    return { result: undefined };
+}
+async function runSimulatorNavigateBack(ctx) {
+    await evalInSim(ctx, 'history.back()');
+    await new Promise((r) => setTimeout(r, 1500));
+    return { result: undefined };
+}
+/** General wx method call — async wx methods with success/fail callbacks. */
+async function runSimulatorGeneric(ctx, method, args) {
     const argsStr = args.map((a) => JSON.stringify(a)).join(', ');
-    // Async wx methods with success/fail callbacks
     const result = await evalInSim(ctx, `
     new Promise((resolve, reject) => {
       try {
@@ -203,6 +222,21 @@ appHandlers['App.callWxMethod'] = async (ctx, params) => {
     })
   `);
     return { result };
+}
+appHandlers['App.callWxMethod'] = async (ctx, params) => {
+    const method = params.method;
+    const args = params.args || [];
+    const bridge = ctx.bridge;
+    if (bridge?.isNativeHost()) {
+        return runNativeHostWxMethod(bridge, method, args);
+    }
+    if (NAV_METHODS.has(method)) {
+        return runSimulatorNav(ctx, method, args);
+    }
+    if (method === 'navigateBack') {
+        return runSimulatorNavigateBack(ctx);
+    }
+    return runSimulatorGeneric(ctx, method, args);
 };
 appHandlers['App.callFunction'] = async (ctx, params) => {
     const fnDecl = params.functionDeclaration;

package/dist/main/services/console-forward/index.d.ts

@@ -1,5 +1,6 @@
 import { type Disposable } from '@dimina-kit/electron-deck/main';
 import type { BridgeRouterHandle } from '../../ipc/bridge-router.js';
+import type { DiagnosticsBus } from '../diagnostics/index.js';
 /**
  * One console entry posted by a guest preload. Shape mirrors
  * render-host/preload.cjs + service-host/preload.cjs `emitConsoleLog`:
@@ -31,6 +32,16 @@ export interface ConsoleForwarder extends Disposable {
      * render→service forward is internal and not exposed as a sink.
      */
     subscribe(sink: ConsoleSink): Disposable;
+    /**
+     * Flush any diagnostic queued for `appSessionId` (plus the global,
+     * session-less queue) into that session's now-ready service-host wc.
+     * Idempotent: entries are removed from their bucket as they flush, so a
+     * repeat call for the same session injects nothing further. Call once the
+     * session's service-host webContents has actually navigated/loaded (e.g.
+     * from `bootServiceHost`, after `did-finish-load`) — calling it earlier just
+     * finds nothing resolvable and leaves the queue intact for a later call.
+     */
+    notifyServiceHostReady(appSessionId: string): void;
 }
-export declare function createConsoleForwarder(bridge: Pick<BridgeRouterHandle, 'getServiceWc' | 'getServiceWcForBridge'>): ConsoleForwarder;
+export declare function createConsoleForwarder(bridge: Pick<BridgeRouterHandle, 'getServiceWc' | 'getServiceWcForBridge'>, diagnostics?: DiagnosticsBus): ConsoleForwarder;
 //# sourceMappingURL=index.d.ts.map

package/dist/main/services/console-forward/index.js

@@ -25,9 +25,81 @@ function buildForwardScript(level, args) {
     // `consoleAPICalled` whose top frame URL === RENDER_FORWARD_SOURCE_URL.
     return `(()=>{try{const a=JSON.parse(${JSON.stringify(argsJson)});console[${JSON.stringify(method)}]('[视图]',...a)}catch(_){}})()\n//# sourceURL=${RENDER_FORWARD_SOURCE_URL}`;
 }
-export function createConsoleForwarder(bridge) {
+/** `Diagnostic.severity` → the literal `console.<method>` call to emit (dot form, not computed — kept greppable/CDP-attributable like a hand-written call site). */
+const DIAGNOSTIC_CONSOLE_CALL = {
+    error: 'console.error',
+    warn: 'console.warn',
+    info: 'console.info',
+};
+/**
+ * Build the `executeJavaScript` source that injects one diagnostic into the
+ * service host's console, prefixed `[dimina-kit]`. Args ride as a JSON string
+ * (same anti-injection shape as `buildForwardScript`) and the sourceURL is the
+ * SAME sentinel the render mirror uses, so this line is exempt from
+ * service-console's loop-safety skip too.
+ */
+function buildDiagnosticScript(severity, message) {
+    const call = DIAGNOSTIC_CONSOLE_CALL[severity];
+    const argsJson = JSON.stringify([`[dimina-kit] ${message}`]);
+    return `(()=>{try{const a=JSON.parse(${JSON.stringify(argsJson)});${call}(...a)}catch(_){}})()\n//# sourceURL=${RENDER_FORWARD_SOURCE_URL}`;
+}
+export function createConsoleForwarder(bridge, diagnostics) {
     const sinks = new Set();
     const registry = new DisposableRegistry();
+    // Diagnostics queued because no live service-host wc could be resolved yet,
+    // bucketed by the owning appSessionId; diagnostics with no appSessionId land
+    // in `pendingGlobal` instead. `notifyServiceHostReady` drains both into the
+    // session that just became ready.
+    const pendingBySession = new Map();
+    const pendingGlobal = [];
+    // Sessions whose service host has finished loading service.html (the caller
+    // signals this via `notifyServiceHostReady`). A resolvable wc alone is NOT
+    // readiness: the window exists (and is bound) before its spawn navigation
+    // lands, and anything injected into that pre-load document is wiped by the
+    // navigation — the diagnostic would silently vanish from the Console panel.
+    const readySessions = new Set();
+    function injectDiagnostic(wc, d) {
+        wc.executeJavaScript(buildDiagnosticScript(d.severity, d.message), true).catch(() => { });
+    }
+    /**
+     * Inject a diagnostic into its owning session's service-host console, or
+     * queue it until that host is READY (not merely constructed — see
+     * `readySessions`). Ownership is strict: a session-owned diagnostic NEVER
+     * falls back to the currently-active host — while `handleSpawn` is still
+     * running, the new session's host doesn't exist yet and the "active" host
+     * is the OUTGOING session's window, so a fallback would land the message in
+     * a console about to be destroyed instead of the session it explains. Only
+     * session-less diagnostics may use the active host. Never throws — a
+     * missing/destroyed/not-yet-ready host is a normal state, not an error.
+     */
+    function handleDiagnostic(d) {
+        if (d.appSessionId) {
+            const wc = readySessions.has(d.appSessionId) && bridge.getServiceWcForBridge
+                ? bridge.getServiceWcForBridge(d.appSessionId)
+                : null;
+            if (wc && !wc.isDestroyed()) {
+                injectDiagnostic(wc, d);
+                return;
+            }
+            const bucket = pendingBySession.get(d.appSessionId);
+            if (bucket)
+                bucket.push(d);
+            else
+                pendingBySession.set(d.appSessionId, [d]);
+            return;
+        }
+        const wc = bridge.getServiceWc();
+        if (wc && !wc.isDestroyed()) {
+            injectDiagnostic(wc, d);
+            return;
+        }
+        pendingGlobal.push(d);
+    }
+    if (diagnostics) {
+        // replay:true so diagnostics reported before this forwarder existed (early
+        // boot, buffered on the bus) are queued/injected here too.
+        registry.add(diagnostics.subscribe(handleDiagnostic, { replay: true }));
+    }
     /**
      * Render→service forward. Resolves the service host for the entry's owning
      * page (multi-app safe), falling back to the active app's service host when
@@ -79,8 +151,34 @@ export function createConsoleForwarder(bridge) {
             sinks.add(sink);
             return registry.add(toDisposable(() => { sinks.delete(sink); }));
         },
+        notifyServiceHostReady(appSessionId) {
+            // Readiness is sticky per session: from here on, session-owned
+            // diagnostics inject directly instead of queueing.
+            readySessions.add(appSessionId);
+            // Re-resolve fresh rather than trusting whatever `handleDiagnostic` saw at
+            // report time — the caller invokes this exactly when it knows the wc just
+            // became live, so that resolution wins even if an earlier snapshot was
+            // destroyed/missing.
+            const wc = bridge.getServiceWcForBridge ? bridge.getServiceWcForBridge(appSessionId) : null;
+            if (!wc)
+                return;
+            const sessionEntries = pendingBySession.get(appSessionId);
+            if (sessionEntries) {
+                for (const d of sessionEntries)
+                    injectDiagnostic(wc, d);
+                pendingBySession.delete(appSessionId);
+            }
+            if (pendingGlobal.length) {
+                for (const d of pendingGlobal)
+                    injectDiagnostic(wc, d);
+                pendingGlobal.length = 0;
+            }
+        },
         dispose() {
             sinks.clear();
+            pendingBySession.clear();
+            pendingGlobal.length = 0;
+            readySessions.clear();
             return registry.disposeAll();
         },
     };

package/dist/main/services/diagnostics/index.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Diagnostics bus: the single authoritative channel for developer-facing
+ * diagnostics synthesized by main (e.g. "page not found", "logic bundle
+ * unreachable") that do not originate from a real `console.*` call the
+ * embedded service-host DevTools' CDP capture could observe on its own.
+ *
+ * Main-synthesized diagnostics used to reach only `ctx.guestConsole.emit`,
+ * which fans out to automation subscribers but — for `source:'service'`
+ * entries — is never injected into the service host's own console (see
+ * `console-forward`'s render-only forward invariant), so they never appeared
+ * in the Console panel. This bus is the fix: `report()` is the one place a
+ * diagnostic is born, and `console-forward` subscribes to inject each one
+ * into the owning session's service-host console (queuing until that
+ * session's window is ready — see `notifyServiceHostReady`).
+ */
+export type DiagnosticSeverity = 'error' | 'warn' | 'info';
+export interface Diagnostic {
+    severity: DiagnosticSeverity;
+    code: string;
+    message: string;
+    appSessionId?: string;
+    ts: number;
+}
+export interface DiagnosticsBus {
+    /** Record one diagnostic: buffers it, mirrors it to the main-process console, and synchronously notifies every live subscriber. No-op after `dispose()`. */
+    report(d: {
+        severity: DiagnosticSeverity;
+        code: string;
+        message: string;
+        appSessionId?: string;
+    }): void;
+    /**
+     * Register a sink. With `replay` (default true) the sink is first called,
+     * in order, for every buffered diagnostic still held, then for every
+     * diagnostic reported from now on; `replay: false` skips the backlog and
+     * only delivers diagnostics reported after this call.
+     */
+    subscribe(sink: (d: Diagnostic) => void, opts?: {
+        replay?: boolean;
+    }): {
+        dispose(): void;
+    };
+    /** Clears subscribers and the buffer. `report()` becomes a no-op afterward (including the console mirror — dispose means fully off, not "log-only"). */
+    dispose(): void;
+}
+export declare function createDiagnosticsBus(opts?: {
+    bufferCap?: number;
+}): DiagnosticsBus;
+//# sourceMappingURL=index.d.ts.map

package/dist/main/services/diagnostics/index.js

@@ -0,0 +1,61 @@
+const DEFAULT_BUFFER_CAP = 200;
+const CONSOLE_METHOD = {
+    error: 'error',
+    warn: 'warn',
+    info: 'info',
+};
+export function createDiagnosticsBus(opts) {
+    const bufferCap = opts?.bufferCap && opts.bufferCap > 0 ? opts.bufferCap : DEFAULT_BUFFER_CAP;
+    const buffer = [];
+    const sinks = new Set();
+    let disposed = false;
+    return {
+        report(d) {
+            if (disposed)
+                return;
+            const entry = { ...d, ts: Date.now() };
+            buffer.push(entry);
+            // Ring buffer: drop the oldest once over cap. Bounded at `bufferCap` so a
+            // burst of synthesized diagnostics can never grow this without limit.
+            if (buffer.length > bufferCap)
+                buffer.shift();
+            // The one guaranteed-visible sink: unlike Console-panel injection (which
+            // needs a live, ready service-host wc), the main-process terminal is
+            // always there.
+            console[CONSOLE_METHOD[entry.severity]](`[dimina-kit:${entry.code}] ${entry.message}`);
+            for (const sink of sinks) {
+                try {
+                    sink(entry);
+                }
+                catch { /* a sink must never break the others */ }
+            }
+        },
+        subscribe(sink, subOpts) {
+            const replay = subOpts?.replay ?? true;
+            if (replay) {
+                for (const entry of buffer) {
+                    try {
+                        sink(entry);
+                    }
+                    catch { /* isolate a replay throw same as a live one */ }
+                }
+            }
+            sinks.add(sink);
+            let released = false;
+            return {
+                dispose() {
+                    if (released)
+                        return;
+                    released = true;
+                    sinks.delete(sink);
+                },
+            };
+        },
+        dispose() {
+            disposed = true;
+            sinks.clear();
+            buffer.length = 0;
+        },
+    };
+}
+//# sourceMappingURL=index.js.map