@dimina-kit/devtools 0.4.0-dev.20260801163345 → 0.4.0-dev.20260824071518

package/dist/main/ipc/index.d.ts

@@ -1,6 +1,7 @@
 export { registerAppIpc } from './app.js';
 export { registerSimulatorIpc } from './simulator.js';
 export { registerPopoverIpc, popoverModule } from './popover.js';
+export { registerTooltipIpc, tooltipModule } from './tooltip.js';
 export { registerProjectsIpc, projectsModule } from './projects.js';
 export { registerSessionIpc, sessionModule } from './session.js';
 export { registerSettingsIpc, settingsModule } from './settings.js';

package/dist/main/ipc/index.js

@@ -1,6 +1,7 @@
 export { registerAppIpc } from './app.js';
 export { registerSimulatorIpc } from './simulator.js';
 export { registerPopoverIpc, popoverModule } from './popover.js';
+export { registerTooltipIpc, tooltipModule } from './tooltip.js';
 export { registerProjectsIpc, projectsModule } from './projects.js';
 export { registerSessionIpc, sessionModule } from './session.js';
 export { registerSettingsIpc, settingsModule } from './settings.js';

package/dist/main/ipc/session.js

@@ -22,6 +22,17 @@ export function registerSessionIpc(ctx) {
     })
         .handle(ProjectChannel.Close, () => {
         return ctx.workspace.closeProject();
+    })
+        .handle(ProjectChannel.Rebuild, async () => {
+        const session = ctx.workspace.getSession();
+        if (!session)
+            throw new Error('project:rebuild — no active project session');
+        // A host CompilationAdapter predating session.rebuild must not break:
+        // degrade discernibly so the renderer falls back to reattach-only.
+        if (typeof session.rebuild !== 'function')
+            return { supported: false };
+        await session.rebuild();
+        return { supported: true };
     })
         .handle(ProjectChannel.CaptureThumbnail, (_, ...args) => {
         const [projectPath] = validate(ProjectChannel.CaptureThumbnail, ProjectCaptureThumbnailSchema, args);

package/dist/main/ipc/tooltip.d.ts

@@ -0,0 +1,13 @@
+import type { WorkbenchModule } from '../services/module.js';
+import type { ViewManager } from '../services/views/view-manager.js';
+import type { Disposable } from '@dimina-kit/electron-deck/main';
+import { type SenderPolicy } from '../utils/ipc-registry.js';
+/** Module-local narrow deps — deliberately NOT `Pick<WorkbenchContext, ...>`
+ * (the gate in eslint.config.* is shrink-only; see its message). */
+export interface TooltipIpcDeps {
+    views: Pick<ViewManager, 'prepareTooltip' | 'showTooltip' | 'hideTooltip' | 'markOverlayReady' | 'applyTooltipMeasurement'>;
+    senderPolicy?: SenderPolicy;
+}
+export declare function registerTooltipIpc(ctx: TooltipIpcDeps): Disposable;
+export declare const tooltipModule: WorkbenchModule;
+//# sourceMappingURL=tooltip.d.ts.map

package/dist/main/ipc/tooltip.js

@@ -0,0 +1,28 @@
+import { OverlayChannel, TooltipChannel } from '../../shared/ipc-channels.js';
+import { TooltipMeasuredSchema, TooltipShowSchema } from '../../shared/ipc-schemas.js';
+import { validate } from '../utils/ipc-schema.js';
+import { IpcRegistry } from '../utils/ipc-registry.js';
+export function registerTooltipIpc(ctx) {
+    return new IpcRegistry(ctx.senderPolicy)
+        .on(TooltipChannel.Prepare, () => {
+        ctx.views.prepareTooltip();
+    })
+        .on(TooltipChannel.Show, (_event, ...args) => {
+        const [data] = validate(TooltipChannel.Show, TooltipShowSchema, args);
+        ctx.views.showTooltip(data);
+    })
+        .on(TooltipChannel.Hide, () => {
+        ctx.views.hideTooltip();
+    })
+        .on(OverlayChannel.Ready, (event) => {
+        ctx.views.markOverlayReady(event.sender.id);
+    })
+        .on(TooltipChannel.Measured, (event, ...args) => {
+        const [measurement] = validate(TooltipChannel.Measured, TooltipMeasuredSchema, args);
+        ctx.views.applyTooltipMeasurement(event.sender.id, measurement);
+    });
+}
+export const tooltipModule = {
+    setup: (ctx) => registerTooltipIpc(ctx),
+};
+//# sourceMappingURL=tooltip.js.map

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

@@ -41,4 +41,15 @@ export declare const SETTINGS_W = 320;
  */
 export declare function computeSettingsBounds(contentWidth: number, contentHeight: number, headerHeight: number): Bounds;
 export declare function computePopoverBounds(contentWidth: number, contentHeight: number, headerHeight: number): Bounds;
+export declare function computeTooltipMaxWidth(contentWidth: number): number;
+/**
+ * Position the tooltip overlay relative to its trigger's own bounding rect
+ * (both in main-window content coordinates). Prefers directly below the
+ * anchor, flips above when there isn't room; always clamped horizontally
+ * inside the content area.
+ */
+export declare function computeTooltipBounds(anchor: Bounds, contentWidth: number, contentHeight: number, measured: {
+    width: number;
+    height: number;
+}): Bounds;
 //# sourceMappingURL=index.d.ts.map

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

@@ -52,4 +52,27 @@ export function computePopoverBounds(contentWidth, contentHeight, headerHeight)
         height: contentHeight - headerHeight,
     };
 }
+const TOOLTIP_GAP = 6;
+const TOOLTIP_EDGE_MARGIN = 4;
+export function computeTooltipMaxWidth(contentWidth) {
+    return Math.max(1, contentWidth - TOOLTIP_EDGE_MARGIN * 2);
+}
+/**
+ * Position the tooltip overlay relative to its trigger's own bounding rect
+ * (both in main-window content coordinates). Prefers directly below the
+ * anchor, flips above when there isn't room; always clamped horizontally
+ * inside the content area.
+ */
+export function computeTooltipBounds(anchor, contentWidth, contentHeight, measured) {
+    const availableWidth = computeTooltipMaxWidth(contentWidth);
+    const width = Math.min(availableWidth, Math.max(1, Math.ceil(measured.width)));
+    const height = Math.max(1, Math.ceil(measured.height));
+    const below = anchor.y + anchor.height + TOOLTIP_GAP;
+    const fitsBelow = below + height <= contentHeight;
+    const y = fitsBelow ? below : Math.max(0, anchor.y - TOOLTIP_GAP - height);
+    const centeredX = anchor.x + anchor.width / 2 - width / 2;
+    const maxX = Math.max(TOOLTIP_EDGE_MARGIN, contentWidth - width - TOOLTIP_EDGE_MARGIN);
+    const x = Math.min(maxX, Math.max(TOOLTIP_EDGE_MARGIN, centeredX));
+    return { x, y, width, height };
+}
 //# sourceMappingURL=index.js.map

package/dist/main/services/network-forward/frontend-dispatch.js

@@ -113,7 +113,8 @@ export function createFrontendReplyChannel(hostWc, isDisposed) {
 export function drainOutboundBatch(batch, handle) {
     if (!Array.isArray(batch))
         return;
-    for (const raw of batch) {
+    const entries = batch;
+    for (const raw of entries) {
         if (!raw || typeof raw !== 'object')
             continue;
         const cmd = raw;

package/dist/main/services/notifications/renderer-notifier.d.ts

@@ -123,6 +123,8 @@ export interface RendererNotifier {
     popoverInit(popoverView: WebContentsView, payload: unknown): void;
     /** Initialise the currently shown settings overlay (no-op if hidden). */
     settingsInit(payload: SettingsInitPayload): void;
+    /** Push the label text (+ anchor) into the tooltip overlay's own renderer. */
+    tooltipInit(tooltipView: WebContentsView, payload: unknown): void;
     /** Initialise the standalone workbench-settings window. */
     workbenchSettingsInit(window: BrowserWindow, payload: WorkbenchSettingsInitPayload): void;
 }

package/dist/main/services/notifications/renderer-notifier.js

@@ -1,4 +1,4 @@
-import { ProjectChannel, SessionChannel, WindowChannel, SettingsChannel, PopoverChannel, WorkbenchSettingsChannel, EditorChannel, ViewChannel, } from '../../../shared/ipc-channels.js';
+import { ProjectChannel, SessionChannel, WindowChannel, SettingsChannel, PopoverChannel, TooltipChannel, WorkbenchSettingsChannel, EditorChannel, ViewChannel, } from '../../../shared/ipc-channels.js';
 /** Safely resolve a WebContents, skipping destroyed / missing targets. */
 function liveWebContents(wc) {
     if (!wc)
@@ -54,6 +54,12 @@ export function createRendererNotifier(ctx) {
                 return;
             wc.send(PopoverChannel.Init, payload);
         },
+        tooltipInit(tooltipView, payload) {
+            const wc = liveWebContents(tooltipView.webContents);
+            if (!wc)
+                return;
+            wc.send(TooltipChannel.Init, payload);
+        },
         settingsInit(payload) {
             const wc = liveWebContents(ctx.views.getSettingsWebContents());
             if (!wc)

package/dist/main/services/simulator-current-page/index.d.ts

@@ -6,9 +6,11 @@
  * page a nested render-host `<webview>`), not a renderer `<webview>` the main
  * window can observe — so in-app navigation (navigateTo / switchTab / back)
  * never reaches the renderer's `<webview>` did-navigate events. This service
- * taps the bridge's active-page signal and pushes the new route to the
- * main-window renderer (`SimulatorChannel.CurrentPage`), keeping the toolbar in
- * sync without polling.
+ * taps the bridge's active-page signal and pushes the route — page path plus
+ * its launch query, so the simulator's page-path bar shows params just like
+ * WeChat DevTools and a recompile can restore them — to the main-window
+ * renderer (`SimulatorChannel.CurrentPage`), keeping the toolbar in sync
+ * without polling.
  *
  * Inert on the default dimina-fe path (which derives the current page from the
  * simulator `<webview>`'s navigation events); app.ts gates the call on

package/dist/main/services/simulator-current-page/index.js

@@ -1,4 +1,5 @@
 import { SimulatorChannel } from '../../../shared/ipc-channels.js';
+import { encodePageSpec } from '../../../shared/simulator-route.js';
 import { DisposableRegistry } from '@dimina-kit/electron-deck/main';
 export function setupSimulatorCurrentPage(host, options) {
     const registry = new DisposableRegistry();
@@ -11,7 +12,13 @@ export function setupSimulatorCurrentPage(host, options) {
             return;
         if (host.isDestroyed())
             return;
-        host.send(SimulatorChannel.CurrentPage, ev.pagePath);
+        // Bridge queries are `Record<string, unknown>` (they may hold numbers from
+        // the URL); the route format wants strings. encodePageSpec re-encodes with
+        // `?k=v&…` so the renderer can decode it back into { pagePath, query }.
+        const query = {};
+        for (const [k, v] of Object.entries(ev.query ?? {}))
+            query[k] = String(v);
+        host.send(SimulatorChannel.CurrentPage, encodePageSpec({ pagePath: ev.pagePath, query }));
     });
     registry.add(off);
     return registry;

package/dist/main/services/views/clear-console-filter.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Clears the right-panel Console panel's text-filter box on a FRESH project
+ * open, together with the stale persisted keys behind it.
+ *
+ * ── Why this exists ──────────────────────────────────────────────────────
+ * The Console filter text is a DevTools-owned setting that DevTools itself
+ * persists: it lives on the `devtools://` origin's localStorage, backed by the
+ * default session's on-disk storage (verified on disk:
+ * `~/Library/Application Support/Dimina DevTools/Local Storage/leveldb` holds a
+ * `console.textFilter` entry). An earlier implementation of the internal-log
+ * hiding wrote `-/^\[service\]/`-style negative filters straight into the box
+ * (see console-filter.ts's header for that history); that value still sits in
+ * localStorage and is restored on every project reopen / app restart. We do NOT
+ * fight DevTools' persistence mechanism here — instead, on each fresh project
+ * open we remove the stale keys and reset the visible box, so a project starts
+ * with the developer's own filter surface genuinely empty.
+ *
+ * ── When it runs ─────────────────────────────────────────────────────────
+ * Only the PROJECT-OPEN path arms this (see native-simulator-devtools-host.ts:
+ * `attach()` sets the flag; the injection consumes it once). Service-host pool
+ * swaps (hot-reload respawn) rebuild the front-end host too, but deliberately do
+ * NOT clear — the developer may legitimately have typed a filter during the
+ * session and a respawn must not drop in-flight work.
+ *
+ * ── Discipline (mirrors console-filter.ts) ────────────────────────────────
+ * In-realm bootstrap probe before touching `Console.ConsoleView.instance()` (an
+ * early construction transitively creates IssuesManager and permanently kills
+ * the front-end's own bootstrap — see frontend-bootstrap-gate.ts); bounded
+ * retry; silent degradation on any failure. The main process additionally holds
+ * this whole injection behind `whenFrontendBootstrapped`.
+ */
+/**
+ * Build the `executeJavaScript` source that clears the Console filter box.
+ *
+ * Two levers, belt-and-suspenders:
+ *   1. remove the stale persisted keys (`console.textFilter` — the on-disk
+ *      leftover we actually observed, and its kebab-case sibling) so a Console
+ *      view constructed after this script reads an empty setting;
+ *   2. reset the already-constructed panel's visible box via
+ *      `filter.textFilterUI.setValue('')`, which persists the empty value back
+ *      through the panel's own setting path.
+ */
+export declare function buildClearConsoleFilterScript(): string;
+//# sourceMappingURL=clear-console-filter.d.ts.map

package/dist/main/services/views/clear-console-filter.js

@@ -0,0 +1,86 @@
+/**
+ * Clears the right-panel Console panel's text-filter box on a FRESH project
+ * open, together with the stale persisted keys behind it.
+ *
+ * ── Why this exists ──────────────────────────────────────────────────────
+ * The Console filter text is a DevTools-owned setting that DevTools itself
+ * persists: it lives on the `devtools://` origin's localStorage, backed by the
+ * default session's on-disk storage (verified on disk:
+ * `~/Library/Application Support/Dimina DevTools/Local Storage/leveldb` holds a
+ * `console.textFilter` entry). An earlier implementation of the internal-log
+ * hiding wrote `-/^\[service\]/`-style negative filters straight into the box
+ * (see console-filter.ts's header for that history); that value still sits in
+ * localStorage and is restored on every project reopen / app restart. We do NOT
+ * fight DevTools' persistence mechanism here — instead, on each fresh project
+ * open we remove the stale keys and reset the visible box, so a project starts
+ * with the developer's own filter surface genuinely empty.
+ *
+ * ── When it runs ─────────────────────────────────────────────────────────
+ * Only the PROJECT-OPEN path arms this (see native-simulator-devtools-host.ts:
+ * `attach()` sets the flag; the injection consumes it once). Service-host pool
+ * swaps (hot-reload respawn) rebuild the front-end host too, but deliberately do
+ * NOT clear — the developer may legitimately have typed a filter during the
+ * session and a respawn must not drop in-flight work.
+ *
+ * ── Discipline (mirrors console-filter.ts) ────────────────────────────────
+ * In-realm bootstrap probe before touching `Console.ConsoleView.instance()` (an
+ * early construction transitively creates IssuesManager and permanently kills
+ * the front-end's own bootstrap — see frontend-bootstrap-gate.ts); bounded
+ * retry; silent degradation on any failure. The main process additionally holds
+ * this whole injection behind `whenFrontendBootstrapped`.
+ */
+/**
+ * Build the `executeJavaScript` source that clears the Console filter box.
+ *
+ * Two levers, belt-and-suspenders:
+ *   1. remove the stale persisted keys (`console.textFilter` — the on-disk
+ *      leftover we actually observed, and its kebab-case sibling) so a Console
+ *      view constructed after this script reads an empty setting;
+ *   2. reset the already-constructed panel's visible box via
+ *      `filter.textFilterUI.setValue('')`, which persists the empty value back
+ *      through the panel's own setting path.
+ */
+export function buildClearConsoleFilterScript() {
+    return `(function(){
+    var attempts = 0;
+    var MAX = 100;
+    function bootstrapReady() {
+      try {
+        var eui = globalThis.EUI;
+        if (!eui || !eui.ShortcutRegistry || !eui.ShortcutRegistry.ShortcutRegistry) return false;
+        eui.ShortcutRegistry.ShortcutRegistry.instance();
+        return true;
+      } catch (_) { return false; }
+    }
+    function tryClear() {
+      attempts++;
+      var scheduleRetry = attempts < MAX;
+      if (!bootstrapReady()) {
+        if (scheduleRetry) { setTimeout(tryClear, 100); return; }
+        return;
+      }
+      try {
+        try { localStorage.removeItem('console.textFilter'); } catch(_) {}
+        try { localStorage.removeItem('console.text-filter'); } catch(_) {}
+        var ConsoleNS = globalThis.Console;
+        var view = ConsoleNS && ConsoleNS.ConsoleView ? ConsoleNS.ConsoleView.instance() : null;
+        var f = view ? view.filter : null;
+        var box = f && f.textFilterUI;
+        if (!box || typeof box.setValue !== 'function' || typeof box.value !== 'function') {
+          if (scheduleRetry) { setTimeout(tryClear, 100); return; }
+          return;
+        }
+        var current = box.value();
+        if (current) {
+          box.setValue('');
+          if (typeof f.updateCurrentFilter === 'function') f.updateCurrentFilter();
+          if (typeof f.onFilterChanged === 'function') f.onFilterChanged();
+        }
+      } catch(_) {
+        if (scheduleRetry) setTimeout(tryClear, 100);
+      }
+    }
+    tryClear();
+  })()`;
+}
+//# sourceMappingURL=clear-console-filter.js.map

package/dist/main/services/views/console-filter-test-fixtures.d.ts

@@ -0,0 +1,94 @@
+/**
+ * Fakes shaped like the Chrome DevTools front-end objects
+ * `buildInternalLogHideScript()`'s generated source talks to, shared by
+ * console-filter.test.ts (what the hook does) and
+ * console-filter-degradation.test.ts (what happens when the panel is not there
+ * or the front-end API has moved).
+ *
+ * These are STUBS OF A FOREIGN API, not a second implementation: every test
+ * runs the real generated script string through `new Function`, so the fakes
+ * only have to expose the handful of members the script reaches for. What they
+ * cannot prove is that the real front-end still has those members — that is
+ * e2e/console-filter-live.spec.ts's job.
+ */
+import { type Mock } from 'vitest';
+export interface FakeViewMessage {
+    consoleMessage: () => {
+        messageText: string;
+    };
+}
+export type ShouldBeVisible = (this: unknown, viewMessage: FakeViewMessage) => boolean;
+export interface FakeConsoleFilterClass {
+    original: Mock<ShouldBeVisible>;
+    prototype: {
+        shouldBeVisible?: ShouldBeVisible;
+    };
+    newInstance: () => {
+        shouldBeVisible: ShouldBeVisible;
+    };
+}
+export interface FakeConsoleView {
+    view: {
+        filter: {
+            currentFilter: object;
+            textFilterUI: {
+                value: () => string;
+                setValue: Mock<(next: string) => void>;
+            };
+        };
+        onFilterChanged: Mock<() => void>;
+    };
+    setValue: Mock<(next: string) => void>;
+    onFilterChanged: Mock<() => void>;
+    filterText: () => string;
+}
+/** A ConsoleViewMessage stub exposing the single field the hook inspects. */
+export declare function createViewMessage(messageText: string): FakeViewMessage;
+/**
+ * A ConsoleFilter "class": one shared prototype carrying `shouldBeVisible`,
+ * plus a factory for further instances off that same prototype — what
+ * `ConsoleFilter.clone()` produces. `original` is the pre-existing
+ * implementation the hook must delegate to.
+ */
+export declare function createConsoleFilterClass(verdict?: boolean | ShouldBeVisible): FakeConsoleFilterClass;
+/** A ConsoleFilter whose prototype chain carries no `shouldBeVisible` at all. */
+export declare function createConsoleFilterClassWithoutHook(): {
+    prototype: Record<string, unknown>;
+    newInstance: () => object;
+};
+/** The ConsoleView surface the script reaches through: filter + refresh entry point. */
+export declare function createConsoleView(currentFilter: object, initialFilterText?: string): FakeConsoleView;
+/** A front end whose bootstrap has finished: the probe returns instead of throwing. */
+export declare function createReadyEui(): {
+    ShortcutRegistry: {
+        ShortcutRegistry: {
+            instance: () => {};
+        };
+    };
+};
+export declare function createGlobalThis(view: unknown): {
+    EUI: {
+        ShortcutRegistry: {
+            ShortcutRegistry: {
+                instance: () => {};
+            };
+        };
+    };
+    Console: {
+        ConsoleView: {
+            instance: () => unknown;
+        };
+    };
+};
+export declare function run(script: string, fakeGlobalThis: object): void;
+/**
+ * Collect `console.warn` output as plain strings for the whole test file.
+ *
+ * Reading `warnSpy.mock.calls` instead would hand every assertion an untyped
+ * `any[]`; the degradation tests care about WHICH warning was emitted, so the
+ * text has to survive into the assertion with its type intact.
+ */
+export declare function recordWarnings(): {
+    messages: string[];
+};
+//# sourceMappingURL=console-filter-test-fixtures.d.ts.map

package/dist/main/services/views/console-filter-test-fixtures.js

@@ -0,0 +1,82 @@
+/**
+ * Fakes shaped like the Chrome DevTools front-end objects
+ * `buildInternalLogHideScript()`'s generated source talks to, shared by
+ * console-filter.test.ts (what the hook does) and
+ * console-filter-degradation.test.ts (what happens when the panel is not there
+ * or the front-end API has moved).
+ *
+ * These are STUBS OF A FOREIGN API, not a second implementation: every test
+ * runs the real generated script string through `new Function`, so the fakes
+ * only have to expose the handful of members the script reaches for. What they
+ * cannot prove is that the real front-end still has those members — that is
+ * e2e/console-filter-live.spec.ts's job.
+ */
+import { vi } from 'vitest';
+/** A ConsoleViewMessage stub exposing the single field the hook inspects. */
+export function createViewMessage(messageText) {
+    return { consoleMessage: () => ({ messageText }) };
+}
+/**
+ * A ConsoleFilter "class": one shared prototype carrying `shouldBeVisible`,
+ * plus a factory for further instances off that same prototype — what
+ * `ConsoleFilter.clone()` produces. `original` is the pre-existing
+ * implementation the hook must delegate to.
+ */
+export function createConsoleFilterClass(verdict = true) {
+    const impl = typeof verdict === 'function' ? verdict : () => verdict;
+    const original = vi.fn(impl);
+    const prototype = { shouldBeVisible: original };
+    return {
+        original,
+        prototype,
+        newInstance: () => Object.create(prototype),
+    };
+}
+/** A ConsoleFilter whose prototype chain carries no `shouldBeVisible` at all. */
+export function createConsoleFilterClassWithoutHook() {
+    const prototype = Object.create(null);
+    return { prototype, newInstance: () => Object.create(prototype) };
+}
+/** The ConsoleView surface the script reaches through: filter + refresh entry point. */
+export function createConsoleView(currentFilter, initialFilterText = '') {
+    let filterText = initialFilterText;
+    const setValue = vi.fn((next) => { filterText = next; });
+    const onFilterChanged = vi.fn();
+    return {
+        view: {
+            filter: {
+                currentFilter,
+                textFilterUI: { value: () => filterText, setValue },
+            },
+            onFilterChanged,
+        },
+        setValue,
+        onFilterChanged,
+        filterText: () => filterText,
+    };
+}
+/** A front end whose bootstrap has finished: the probe returns instead of throwing. */
+export function createReadyEui() {
+    return { ShortcutRegistry: { ShortcutRegistry: { instance: () => ({}) } } };
+}
+export function createGlobalThis(view) {
+    return { EUI: createReadyEui(), Console: { ConsoleView: { instance: () => view } } };
+}
+export function run(script, fakeGlobalThis) {
+    new Function('globalThis', script)(fakeGlobalThis);
+}
+/**
+ * Collect `console.warn` output as plain strings for the whole test file.
+ *
+ * Reading `warnSpy.mock.calls` instead would hand every assertion an untyped
+ * `any[]`; the degradation tests care about WHICH warning was emitted, so the
+ * text has to survive into the assertion with its type intact.
+ */
+export function recordWarnings() {
+    const record = { messages: [] };
+    vi.spyOn(console, 'warn').mockImplementation((...args) => {
+        record.messages.push(args.map((arg) => String(arg)).join(' '));
+    });
+    return record;
+}
+//# sourceMappingURL=console-filter-test-fixtures.js.map