@dimina-kit/devtools 0.4.0-dev.20260701083540 → 0.4.0-dev.20260701155140

package/dist/main/app/app.js

@@ -1,4 +1,5 @@
 import { setupCdpPort, registerDifileScheme, suppressInsecureCspWarnings } from './bootstrap.js';
+import { installMaxListenersWarningDiagnostic } from './max-listeners-diagnostic.js';
 import { registerProjectFsIpc } from '../ipc/project-fs.js';
 import { app, BrowserWindow, nativeImage, session } from 'electron';
 import fs from 'fs';
@@ -317,6 +318,11 @@ export function runDevtoolsBootstrap(config = {}) {
     setupCdpPort();
     // Dev-only: silence Electron Insecure-CSP warning; no-op when packaged.
     suppressInsecureCspWarnings();
+    // Dev-only: decode any MaxListenersExceededWarning to the concrete wc that
+    // tripped it (id/type/url), so a stray listener accrual is pinned rather than
+    // guessed. Registered once, pre-ready; harmless if it never fires.
+    if (!app.isPackaged)
+        installMaxListenersWarningDiagnostic();
     // Privileged scheme registration must run before app.whenReady (else throws).
     registerDifileScheme();
     // The embedded workbench editor (the sole devtools editor) needs
@@ -497,6 +503,11 @@ export async function createDevtoolsRuntime(config = {}) {
     if (storage.storageApi) {
         context.storageApi = storage.storageApi;
         context.registry.add(() => { context.storageApi = undefined; });
+        // SYNC wx storage writes bypass main (they hit the service-host localStorage
+        // directly); the service-host posts `storageChanged` and bridge-router routes
+        // it here so the Storage panel stays live without a manual reload.
+        context.onServiceStorageChanged = storage.onSyncStorageChange;
+        context.registry.add(() => { context.onServiceStorageChanged = undefined; });
     }
     // Native-host WXML + AppData panels: main sources the data (WXML pulled
     // from the active render guest; AppData tapped from the service→render

package/dist/main/app/max-listeners-diagnostic.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Runtime diagnostic for `MaxListenersExceededWarning`.
+ *
+ * Node prints `MaxListenersExceededWarning: N <event> listeners added to
+ * [emitter]` when an EventEmitter crosses its (default 10) ceiling, but the
+ * message alone does not identify WHICH Electron WebContents tripped it. This
+ * hook decodes the warning's `emitter` (present on the warning object in current
+ * Node) into the wc's id / type / url so a stray listener accrual can be pinned
+ * to a concrete surface (DevTools host, service host, main window, …) instead of
+ * guessed at. Dev-only; a no-op counterpart is returned when disabled.
+ */
+export interface MaxListenersWarningReport {
+    event: string | undefined;
+    count: number | undefined;
+    wcId: number | undefined;
+    wcType: string | undefined;
+    url: string | undefined;
+    destroyed: boolean | undefined;
+    stack: string | undefined;
+}
+/**
+ * Decode a warning into a flat report, or `null` if it is not a
+ * `MaxListenersExceededWarning`. Pure — no logging, no process state.
+ */
+export declare function describeMaxListenersWarning(warning: Error): MaxListenersWarningReport | null;
+/**
+ * Register a `process.on('warning')` listener that logs a decoded report for any
+ * `MaxListenersExceededWarning`. Returns a disposer that removes the listener.
+ * Other warning kinds pass through untouched.
+ */
+export declare function installMaxListenersWarningDiagnostic(log?: (report: MaxListenersWarningReport) => void): () => void;
+//# sourceMappingURL=max-listeners-diagnostic.d.ts.map

package/dist/main/app/max-listeners-diagnostic.js

@@ -0,0 +1,59 @@
+/**
+ * Runtime diagnostic for `MaxListenersExceededWarning`.
+ *
+ * Node prints `MaxListenersExceededWarning: N <event> listeners added to
+ * [emitter]` when an EventEmitter crosses its (default 10) ceiling, but the
+ * message alone does not identify WHICH Electron WebContents tripped it. This
+ * hook decodes the warning's `emitter` (present on the warning object in current
+ * Node) into the wc's id / type / url so a stray listener accrual can be pinned
+ * to a concrete surface (DevTools host, service host, main window, …) instead of
+ * guessed at. Dev-only; a no-op counterpart is returned when disabled.
+ */
+// Run a probe thunk, swallowing anything it throws. The method call lives INSIDE
+// the thunk (not eagerly bound at the call site) so a malformed emitter whose
+// `getType`/`getURL`/`isDestroyed` is a non-function value throws here and is
+// caught, rather than blowing up while evaluating the argument.
+function callSafe(fn) {
+    try {
+        return fn();
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Decode a warning into a flat report, or `null` if it is not a
+ * `MaxListenersExceededWarning`. Pure — no logging, no process state.
+ */
+export function describeMaxListenersWarning(warning) {
+    if (warning.name !== 'MaxListenersExceededWarning')
+        return null;
+    const w = warning;
+    const emitter = (w.emitter ?? undefined);
+    return {
+        event: w.type,
+        count: w.count,
+        wcId: typeof emitter?.id === 'number' ? emitter.id : undefined,
+        wcType: callSafe(() => emitter?.getType?.()),
+        url: callSafe(() => emitter?.getURL?.()),
+        destroyed: callSafe(() => emitter?.isDestroyed?.()),
+        stack: warning.stack,
+    };
+}
+/**
+ * Register a `process.on('warning')` listener that logs a decoded report for any
+ * `MaxListenersExceededWarning`. Returns a disposer that removes the listener.
+ * Other warning kinds pass through untouched.
+ */
+export function installMaxListenersWarningDiagnostic(log = (r) => console.warn('[max-listeners]', r)) {
+    const onWarning = (warning) => {
+        const report = describeMaxListenersWarning(warning);
+        if (report)
+            log(report);
+    };
+    process.on('warning', onWarning);
+    return () => {
+        process.removeListener('warning', onWarning);
+    };
+}
+//# sourceMappingURL=max-listeners-diagnostic.js.map