@dimina-kit/devtools 0.4.0-dev.20260616102751 → 0.4.0-dev.20260624040247

package/dist/main/ipc/bridge-router.js

@@ -11,6 +11,46 @@ import { ServiceHostPool } from '../services/service-host-pool/pool.js';
 import { registerMiniappSessionConfigurator, SHARED_MINIAPP_PARTITION, } from '../services/views/miniapp-partition.js';
 import { createConsoleForwarder } from '../services/console-forward/index.js';
 import { STORAGE_API_NAMES } from '../services/simulator-storage/index.js';
+// The compiled `logic.js` ships a RELATIVE `//# sourceMappingURL=logic.js.map`.
+// `injectLogicBundle` loads it via `executeJavaScript`, which gives the injected
+// script no base URL of its own — so DevTools resolves that relative map against
+// the service-host DOCUMENT and 404s, leaving console frames / Sources links
+// pointing at the compiled bundle instead of the developer's source. This rewrite
+// turns the directive absolute.
+//
+// Inlined (not imported from `service-host/sourcemap-rewrite.cjs`) ON PURPOSE:
+// the shipped main entry is the FLAT esbuild bundle (`dist/main/index.bundle.js`,
+// see electron-builder.yml `extraMetadata.main`). A runtime `createRequire(...)`
+// of the relative `.cjs` resolved against `import.meta.url`, which is the bundle
+// at `dist/main/` (one level shallower than the tsc tree `dist/main/ipc/`), so
+// the path 404'd and the PACKAGED app crashed on load. Bundling the logic inline
+// is bundler-proof. KEEP IN SYNC with `service-host/sourcemap-rewrite.cjs` (the
+// copied-not-bundled service-host preload still requires that one).
+function rewriteSourceMappingUrl(source, scriptUrl) {
+    if (typeof source !== 'string' || !source)
+        return source;
+    const re = /(^|\n)[ \t]*\/\/[#@][ \t]*sourceMappingURL=([^\n]*)/g;
+    let lastIndex = -1;
+    let lastValue = '';
+    let m;
+    while ((m = re.exec(source)) !== null) {
+        lastIndex = m.index + m[1].length;
+        lastValue = (m[2] || '').trim();
+    }
+    if (lastIndex < 0 || !lastValue)
+        return source;
+    // Already absolute (scheme://, protocol-relative //host, or data:)? Leave it.
+    if (/^(?:[a-z][a-z0-9+.-]*:)?\/\//i.test(lastValue) || /^data:/i.test(lastValue))
+        return source;
+    let absolute;
+    try {
+        absolute = new URL(lastValue, scriptUrl).toString();
+    }
+    catch {
+        return source;
+    }
+    return `${source.slice(0, lastIndex)}\n//# sourceMappingURL=${absolute}`;
+}
 const STACK_ID = 'stack_0';
 /** Hard ceiling on the pre-warm pool, mirroring ServiceHostPool/doc §3.3. */
 const PREWARM_MAX_POOL_SIZE = 4;
@@ -413,7 +453,10 @@ async function handleSpawn(state, ctx, event, opts) {
     const appSessionId = bridgeId;
     const simulatorWc = resolveSimulatorWebContents(ctx, opts.simulatorWcId, event.sender);
     const pagePath = normalizePagePath(opts.pagePath || 'pages/index/index');
-    const pkgRoot = path.resolve(opts.pkgRoot || process.cwd());
+    const workspaceProjectPath = typeof ctx.workspace.getProjectPath === 'function'
+        ? ctx.workspace.getProjectPath()
+        : '';
+    const pkgRoot = path.resolve(opts.pkgRoot || workspaceProjectPath || process.cwd());
     const root = opts.root || 'main';
     // Resource base resolution. Preferred: the simulator-supplied dev-server
     // origin, which statically serves the compiled `<appId>/<root>/…` tree (same
@@ -465,6 +508,7 @@ async function handleSpawn(state, ctx, event, opts) {
             appId,
             pagePath,
             pkgRoot,
+            root,
             resourceBaseUrl,
             hostEnvSnapshot: hostEnv,
         });
@@ -568,6 +612,7 @@ async function handleSpawn(state, ctx, event, opts) {
             appId,
             pagePath,
             pkgRoot,
+            root,
             resourceBaseUrl,
             hostEnvSnapshot: hostEnv,
         }));
@@ -690,7 +735,10 @@ async function injectLogicBundle(ap) {
         const res = await fetch(logicUrl);
         if (!res.ok)
             throw new Error(`logic.js fetch ${res.status} at ${logicUrl}`);
-        const logicContent = await res.text();
+        // Rewrite the relative `sourceMappingURL` to an absolute dev-server URL
+        // BEFORE injecting — `executeJavaScript` gives the script no base URL, so a
+        // relative map would 404 and break sourcemapped console frames / Sources.
+        const logicContent = rewriteSourceMappingUrl(await res.text(), logicUrl);
         await ap.serviceWc.executeJavaScript(`${logicContent}\n//# sourceURL=${logicUrl}`, true);
     }
     catch (error) {
@@ -1056,13 +1104,13 @@ function makeLoadResource(ap, page, target) {
             // dimina's service runtime reads hostEnv as `{ systemInfo, menuRect }`
             // (core/host-env.js init → getSystemInfo/getMenuRect; invokeAPI resolves
             // getSystemInfoSync/getWindowInfo/getDeviceInfo from hostEnv.systemInfo).
-            // We previously sent the FLAT HostEnvSnapshot, so `systemInfo` was null →
-            // `wx.getSystemInfoSync()` returned null and pages reading
-            // `.screenWidth` threw. Nest it under `systemInfo`. (render does NOT read
-            // hostEnv, so this is service-only; the devtools sync-api-patch reads the
-            // separate __diminaSpawnContext.hostEnvSnapshot and is unaffected.)
-            // menuRect stays null as before — getMenuButtonBoundingClientRect is
-            // served by the sync-api-patch / DeviceShell capsule, not this path.
+            // The snapshot must be nested under `systemInfo`: a FLAT HostEnvSnapshot
+            // leaves `systemInfo` null → `wx.getSystemInfoSync()` returns null and
+            // pages reading `.screenWidth` throw. (render does NOT read hostEnv, so
+            // this is service-only; the devtools sync-api-patch reads the separate
+            // __diminaSpawnContext.hostEnvSnapshot and is unaffected.)
+            // menuRect stays null — getMenuButtonBoundingClientRect is served by the
+            // sync-api-patch / DeviceShell capsule, not this path.
             hostEnv: { systemInfo: ap.hostEnv, menuRect: null },
         },
     };

package/dist/main/ipc/projects.js

@@ -49,7 +49,7 @@ export function registerProjectsIpc(ctx) {
         const [dirPath] = validate(ProjectsChannel.Remove, ProjectsRemoveSchema, args);
         return ctx.workspace.removeProject(dirPath);
     })
-        // ── Phase 3: template catalog + create flow ──
+        // ── template catalog + create flow ──
         .handle(ProjectsChannel.ListTemplates, () => {
         // Sanitize at the IPC boundary: `generate` is a function and the
         // structured-clone algorithm Electron uses for invoke would otherwise

package/dist/main/ipc/simulator.js

@@ -7,7 +7,7 @@ export function registerSimulatorIpc(ctx) {
     return new IpcRegistry(ctx.senderPolicy)
         .handle(SimulatorChannel.AttachNative, (_, ...args) => {
         const [simulatorUrl, simWidth] = validate(SimulatorChannel.AttachNative, SimulatorAttachNativeSchema, args);
-        ctx.views.attachNativeSimulator(simulatorUrl, simWidth);
+        return ctx.views.attachNativeSimulator(simulatorUrl, simWidth);
     })
         .handle(SimulatorChannel.Detach, () => {
         ctx.views.detachSimulator();

package/dist/main/runtime/devtools-backend.d.ts

@@ -11,7 +11,7 @@ import type { WorkbenchAppConfig } from '../../shared/types.js';
  * v2 scope: the backend owns window creation (the framework skips its own when a
  * backend is present), so `assemble` ignores the framework `runtime` and builds
  * the real devtools main window itself. Trust/frame unification and surfacing
- * the runtime facade are deferred (see framework-extraction-v2.md §7).
+ * the runtime facade are deferred.
  *
  * NOT migrating onto deck's high-level host API (Window facade / runtime.view /
  * DeckSession / grants) is a DELIBERATE, reviewed decision — not a backlog item.

package/dist/main/runtime/devtools-backend.js

@@ -11,7 +11,7 @@ import { registerAppLifecycle } from '../app/lifecycle.js';
  * v2 scope: the backend owns window creation (the framework skips its own when a
  * backend is present), so `assemble` ignores the framework `runtime` and builds
  * the real devtools main window itself. Trust/frame unification and surfacing
- * the runtime facade are deferred (see framework-extraction-v2.md §7).
+ * the runtime facade are deferred.
  *
  * NOT migrating onto deck's high-level host API (Window facade / runtime.view /
  * DeckSession / grants) is a DELIBERATE, reviewed decision — not a backlog item.

package/dist/main/runtime/miniapp-runtime.d.ts

@@ -6,7 +6,7 @@
  * would drag every nested internal service type (ViewManager,
  * BridgeRouterHandle, SimulatorApiRegistry, Electron WebContents…) onto the
  * public semver face, so any internal refactor of those services becomes an
- * unreviewed breaking change for downstream hosts (qdmp). Instead this module
+ * unreviewed breaking change for downstream hosts. Instead this module
  * names ONLY the audited downstream consumption surface, with structural DTOs
  * and zero Electron types — non-Electron consumers can compile against it.
  *
@@ -83,9 +83,9 @@ declare global {
     }
 }
 /**
- * Host-facing control surface for the toolbar WebContentsView — the exact
- * post-R2 message-channel surface (`send`/`onMessage`), with no `webContents`
- * escape hatch (that would put Electron types on the contract).
+ * Host-facing control surface for the toolbar WebContentsView — a
+ * message-channel surface (`send`/`onMessage`), with no `webContents` escape
+ * hatch (that would put Electron types on the contract).
  */
 export interface MiniappHostToolbar {
     /**
@@ -171,7 +171,7 @@ export interface MiniappWorkspace {
     } | null;
 }
 /**
- * The stable miniapp-kernel surface a downstream host (qdmp) consumes.
+ * The stable miniapp-kernel surface a downstream host consumes.
  * Compiler-enforced and versionable: widening it back toward internal
  * plumbing is a deliberate semver decision, not an accident of projection.
  */

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

@@ -1,4 +1,5 @@
 import { DisposableRegistry, toDisposable } from '@dimina-kit/electron-deck/main';
+import { RENDER_FORWARD_SOURCE_URL } from '../service-console/console-api.js';
 /** Console levels we re-emit into the service host. Anything else maps to 'log'. */
 const FORWARDABLE_LEVELS = new Set(['log', 'warn', 'error', 'info', 'debug']);
 /**
@@ -16,7 +17,13 @@ function buildForwardScript(level, args) {
     const argsJson = JSON.stringify(args ?? []);
     // `console[method]` (not `console.log`) preserves the original level so the
     // DevTools severity filter still works on the forwarded line.
-    return `(()=>{try{const a=JSON.parse(${JSON.stringify(argsJson)});console[${JSON.stringify(method)}]('[视图]',...a)}catch(_){}})()`;
+    //
+    // The trailing `//# sourceURL` stamps this injected line with a sentinel URL.
+    // The service-console CDP capture (services/service-console) attached to THIS
+    // service host would otherwise re-capture this `console[...]` call as a fresh
+    // service entry and re-broadcast it to automation (duplicate). It skips any
+    // `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) {
     const sinks = new Set();

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

@@ -36,7 +36,7 @@
  * no longer active is dropped (its in-flight command id is settled with an error
  * so the front-end never leaks a pending request, and stale nodes never bleed into
  * the new tree); and switching away and BACK to a previously-wired guest RESUMES
- * its forwarding (a snapshot would strand it — that was bug B2).
+ * its forwarding (a snapshot would strand it).
  *
  * ── Degradation ──────────────────────────────────────────────────────────────
  * Hook unavailable / `DevToolsAPI` missing / no active guest → routing is simply
@@ -46,7 +46,7 @@
  *
  * This is a production feature (no env gate, default on for the native simulator).
  * It deliberately re-implements the small pure helpers it needs (routing table,
- * hook + dispatch scripts) rather than importing the throwaway spike file.
+ * hook + dispatch scripts) as self-contained code.
  */
 import { webContents as electronWebContents } from 'electron';
 /**
@@ -173,7 +173,11 @@ function buildDocumentUpdatedScript() {
 }
 const DRAIN_INTERVAL_MS = 150;
 /** Bounded retry for the front-end hook install (front-end boots asynchronously). */
-const INSTALL_POLL_TRIES = 80;
+// Per-load install poll window. Must outlast the gap between a devtools
+// front-end `dom-ready` and `InspectorFrontendHost` becoming available on a
+// cold/slow open (pool cold-start). 200×50ms = 10s — generous, and each future
+// front-end load re-arms a fresh window anyway (see the `dom-ready` listener).
+const INSTALL_POLL_TRIES = 200;
 const INSTALL_POLL_INTERVAL_MS = 50;
 /**
  * Install Elements forwarding on a DevTools front-end host wc. Returns a disposer
@@ -194,8 +198,8 @@ export function installElementsForward(deps) {
     // bridge per check — NOT a generation snapshot. An event/response is honoured
     // only while its originating guest is still the active one, so switching away
     // and BACK to a previously-wired guest RESUMES its forwarding (a snapshot would
-    // strand it forever — that was bug B2). It also means destroying some OTHER
-    // (non-active) guest never stales the active guest's in-flight commands.
+    // strand it forever). It also means destroying some OTHER (non-active) guest
+    // never stales the active guest's in-flight commands.
     const isActiveWcId = (id) => {
         const a = activeRenderWc();
         return a != null && a.id === id;
@@ -391,7 +395,7 @@ export function installElementsForward(deps) {
             }
             // A destroyed guest is no longer the active one, so its in-flight commands
             // fail `isActiveWcId` and settle as errors on their own — no global bump
-            // (which would wrongly stale OTHER, still-active guests' commands: bug MINOR-3).
+            // (which would wrongly stale OTHER, still-active guests' commands).
             // If we own this wc's session there is nothing left to detach; drop it.
             selfAttached.delete(wc.id);
         };
@@ -504,6 +508,17 @@ export function installElementsForward(deps) {
     const onReady = () => {
         if (disposed)
             return;
+        // Re-arm safe: a devtools front-end (re)load re-runs this, so clear any
+        // in-flight timers from a prior attempt before starting fresh ones — without
+        // this a reload would stack intervals (leak) and double-drain.
+        if (installTimer) {
+            clearInterval(installTimer);
+            installTimer = null;
+        }
+        if (drainTimer) {
+            clearInterval(drainTimer);
+            drainTimer = null;
+        }
         let tries = 0;
         installTimer = setInterval(() => {
             tries++;
@@ -550,12 +565,17 @@ export function installElementsForward(deps) {
                 .catch(() => { });
         }, DRAIN_INTERVAL_MS);
     };
-    if (devtoolsWc.isLoading()) {
-        devtoolsWc.once('dom-ready', onReady);
-    }
-    else {
-        onReady();
-    }
+    // Re-install on EVERY devtools front-end load, not once. The hook lives in the
+    // front-end's `globalThis` (`__diminaElementsHookInstalled`), so any front-end
+    // (re)load wipes it — most importantly a service-host pool SWAP, which re-opens
+    // DevTools (`pointNativeDevtoolsAtServiceWc`) and re-bootstraps the front-end.
+    // A single-shot `once('dom-ready')` left the hook uninstalled after such a
+    // reload, so Elements silently fell back to the native service-host DOM. A
+    // PERSISTENT listener re-runs the (idempotent — the sentinel returns 'already')
+    // install on each load; the immediate call covers an already-loaded wc and the
+    // first `openDevTools` whose `dom-ready` may have fired before this ran.
+    devtoolsWc.on('dom-ready', onReady);
+    onReady();
     let devtoolsClosedSub;
     try {
         // Devtools front-end wc is never pool-reset → use `'closed'` (fires only on
@@ -577,6 +597,10 @@ export function installElementsForward(deps) {
             devtoolsClosedSub?.dispose();
         }
         catch { /* already gone */ }
+        try {
+            devtoolsWc.removeListener('dom-ready', onReady);
+        }
+        catch { /* already gone */ }
         stop();
     };
 }

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

@@ -26,7 +26,19 @@ export declare function computeNativeSimulatorViewParams(rect: {
     bounds: Bounds;
     zoomFactor: number;
 };
+/** Renderer-side width of the settings PANEL (the opaque right strip). The
+ * settings WebContentsView itself spans the full content area (see
+ * `computeSettingsBounds`) as a transparent backdrop; the panel is positioned
+ * inside it at this width by `settings.tsx`. */
 export declare const SETTINGS_W = 320;
+/**
+ * The settings overlay is a FULL-content-area transparent backdrop (header
+ * excluded), identical to the popover region — NOT a right-edge strip. The
+ * renderer paints a transparent backdrop over the whole area and an opaque
+ * `SETTINGS_W`-wide panel on the right; a click on the transparent backdrop
+ * closes the overlay (clicks outside the panel must reach the backdrop, which is
+ * only possible when the view spans the whole area rather than just the strip).
+ */
 export declare function computeSettingsBounds(contentWidth: number, contentHeight: number, headerHeight: number): Bounds;
 export declare function computePopoverBounds(contentWidth: number, contentHeight: number, headerHeight: number): Bounds;
 //# sourceMappingURL=index.d.ts.map

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

@@ -23,12 +23,24 @@ export function computeNativeSimulatorViewParams(rect, zoomPercent) {
         zoomFactor,
     };
 }
+/** Renderer-side width of the settings PANEL (the opaque right strip). The
+ * settings WebContentsView itself spans the full content area (see
+ * `computeSettingsBounds`) as a transparent backdrop; the panel is positioned
+ * inside it at this width by `settings.tsx`. */
 export const SETTINGS_W = 320;
+/**
+ * The settings overlay is a FULL-content-area transparent backdrop (header
+ * excluded), identical to the popover region — NOT a right-edge strip. The
+ * renderer paints a transparent backdrop over the whole area and an opaque
+ * `SETTINGS_W`-wide panel on the right; a click on the transparent backdrop
+ * closes the overlay (clicks outside the panel must reach the backdrop, which is
+ * only possible when the view spans the whole area rather than just the strip).
+ */
 export function computeSettingsBounds(contentWidth, contentHeight, headerHeight) {
     return {
-        x: Math.max(0, contentWidth - SETTINGS_W),
+        x: 0,
         y: headerHeight,
-        width: Math.min(SETTINGS_W, Math.max(1, contentWidth)),
+        width: Math.max(1, contentWidth),
         height: Math.max(1, contentHeight - headerHeight),
     };
 }

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

@@ -14,8 +14,8 @@
  * `direct-request.ts`/`simulator-api-network.ts`, which call `fetch()` /
  * `XMLHttpRequest`). Those requests therefore go through the simulator WCV's
  * network stack — a DIFFERENT webContents than the one the DevTools front-end
- * inspects — so they were invisible in the Network panel after the native-host
- * refactor. THAT is the regression this service closes.
+ * inspects — so they are otherwise invisible in the Network panel. This service
+ * surfaces them.
  *
  * ── How it surfaces them (primary sink: native Network tab) ─────────────────
  * We attach the CDP `webContents.debugger` to the simulator WCV, `Network.enable`,
@@ -32,9 +32,8 @@
  * into a namespaced virtual id (`dimina:sim:<epoch>:<rawId>`) before dispatch,
  * keeping a raw→virtual map so redirects / extra-info / completion events on the
  * same request stay correlated. We inject on the MAIN session (no `sessionId`),
- * i.e. the events appear as activity on the currently-inspected target. This is
- * the one-shot approach the Codex review settled on; child-target routing
- * (`Target.attachedToTarget` + hooking outbound CDP) is explicitly deferred.
+ * i.e. the events appear as activity on the currently-inspected target. Child-
+ * target routing (`Target.attachedToTarget` + hooking outbound CDP) is deferred.
  *
  * ── Fallback sink (console line) ────────────────────────────────────────────
  * If the DevTools host wc is unavailable, or `window.DevToolsAPI.dispatchMessage`
@@ -127,7 +126,7 @@ export interface NetworkForwarder extends Disposable {
  * Anything carrying a requestId must be namespaced consistently — even methods
  * we don't (yet) forward — so the raw→virtual map stays coherent if forwarding
  * is widened later. `requestServedFromCache` and `resourceChangedPriority` are
- * included for that reason (MINOR: rewrite-only today, not forwarded).
+ * included for that reason (rewrite-only today, not forwarded).
  */
 export declare const REWRITE_REQUEST_ID_METHODS: ReadonlySet<string>;
 /** The Network.* methods this one-shot pass forwards to the front-end. */

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

@@ -5,7 +5,7 @@ import { DisposableRegistry, toDisposable } from '@dimina-kit/electron-deck/main
  * Anything carrying a requestId must be namespaced consistently — even methods
  * we don't (yet) forward — so the raw→virtual map stays coherent if forwarding
  * is widened later. `requestServedFromCache` and `resourceChangedPriority` are
- * included for that reason (MINOR: rewrite-only today, not forwarded).
+ * included for that reason (rewrite-only today, not forwarded).
  */
 export const REWRITE_REQUEST_ID_METHODS = new Set([
     'Network.requestWillBeSent',
@@ -243,10 +243,9 @@ export function createNetworkForwarder(bridge) {
     let attachDisposables = null;
     // The DevTools front-end host wc (primary sink), set by the ViewManager.
     let devtoolsWc = null;
-    // Teardown for the wc 'destroyed' watcher on the current host (clears the host
-    // here, in this file — view-manager is owned by another change and untouched).
+    // Teardown for the wc 'destroyed' watcher on the current host (clears the host).
     let devtoolsHostDisposable = null;
-    // ── Native-sink state machine (MAJOR 1) ───────────────────────────────────
+    // ── Native-sink state machine ─────────────────────────────────────────────
     let sink = 'idle';
     // Buffered completed-request records while 'probing' — flushed to console if we
     // degrade, dropped if we go ready (so a request shows in exactly one sink).
@@ -321,7 +320,7 @@ export function createNetworkForwarder(bridge) {
     /** Trim the native queue to its cap, preferring to keep request-opening events.
      * Active requests' first events (requestWillBeSent / ...ExtraInfo) are retained
      * so later responseReceived/loadingFinished never become orphans in the panel;
-     * we drop the oldest NON-opening (low-value / completion) events first. (MAJOR 2) */
+     * we drop the oldest NON-opening (low-value / completion) events first. */
     function trimQueue() {
         if (dispatchQueue.length <= MAX_DISPATCH_QUEUE)
             return;
@@ -355,15 +354,15 @@ export function createNetworkForwarder(bridge) {
         }
         const wc = resolveDevtoolsWc();
         if (!wc) {
-            // Host went away mid-flight. Keep the queue bounded (MAJOR 2: cap applies on
+            // Host went away mid-flight. Keep the queue bounded (the cap applies on
             // EVERY path, not just no-host) and wait — setDevtoolsHost re-arms probing.
             trimQueue();
             return;
         }
         if (sink === 'idle')
             beginProbing();
-        // Pack greedily up to MAX_BATCH_CHARS so one executeJavaScript stays sized
-        // (MAJOR 5); oversized single messages go via the chunked transport.
+        // Pack greedily up to MAX_BATCH_CHARS so one executeJavaScript stays sized;
+        // oversized single messages go via the chunked transport.
         const batch = [];
         let batchChars = 0;
         let i = 0;
@@ -421,7 +420,7 @@ export function createNetworkForwarder(bridge) {
         }).catch(() => {
             // wc navigated / torn down mid-call, OR the script overflowed IPC. Re-queue
             // (bounded) and let the next flush re-resolve the host. Best-effort; the
-            // ready-timeout still governs giving up. (MAJOR 5: backoff via retry timer.)
+            // ready-timeout still governs giving up. Backoff is via the retry timer.
             if (sink === 'degraded')
                 return;
             dispatchQueue = batch.concat(dispatchQueue);
@@ -654,7 +653,7 @@ export function createNetworkForwarder(bridge) {
     }
     /**
      * Route a completed request to EXACTLY ONE sink, per the native-sink state
-     * machine (MAJOR 1 — no double-display):
+     * machine (no double-display):
      *  - 'ready'    : native path already rendered it → suppress console.
      *  - 'degraded' : native abandoned → console.
      *  - 'idle'     : no host configured → console (the native queue never flushes).

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

@@ -39,10 +39,9 @@ export interface WorkbenchSettingsInitPayload {
 }
 /**
  * Unified entry point for every main → renderer event sent by the devtools
- * main process. Every site that previously called
- * `someWebContents.send(channel, payload)` now goes through a typed method
- * here so that channel names, payload shapes and `isDestroyed()` guards live
- * in exactly one place.
+ * main process. Instead of calling `someWebContents.send(channel, payload)`
+ * directly, every site goes through a typed method here so that channel names,
+ * payload shapes and `isDestroyed()` guards live in exactly one place.
  *
  * Methods resolve their target `WebContents` lazily from references provided
  * at call time (or read from the owning context) and silently no-op when the

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

@@ -3,7 +3,7 @@
 // higher-level coordination (session + renderer notifications) lives in
 // ../workspace/workspace-service.ts.
 //
-// Phase 1 adds the extensibility surface: `types.ts` (ProjectsProvider,
+// The extensibility surface lives in `types.ts` (ProjectsProvider,
 // ProjectTemplate, CreateProjectInput) and `local-provider.ts` (the default
 // implementation injected when the host omits `projectsProvider`).
 export * from './project-repository.js';

package/dist/main/services/projects/types.d.ts

@@ -1,6 +1,6 @@
 /**
  * Public extensibility surface for the project list panel. Hosts that embed
- * dimina-devtools (e.g. qdmp) can inject implementations of these types via
+ * dimina-devtools (downstream hosts) can inject implementations of these types via
  * `WorkbenchAppConfig` to fully take over the project source-of-truth, the
  * template catalog, and the "新建项目" dialog.
  */

package/dist/main/services/projects/types.js

@@ -1,6 +1,6 @@
 /**
  * Public extensibility surface for the project list panel. Hosts that embed
- * dimina-devtools (e.g. qdmp) can inject implementations of these types via
+ * dimina-devtools (downstream hosts) can inject implementations of these types via
  * `WorkbenchAppConfig` to fully take over the project source-of-truth, the
  * template catalog, and the "新建项目" dialog.
  */

package/dist/main/services/service-console/console-api.d.ts

@@ -0,0 +1,77 @@
+/**
+ * Pure helpers for the native-host service-console forwarder.
+ *
+ * The service-host's console is captured via CDP `Runtime.consoleAPICalled`,
+ * which preserves native source attribution. A `console.*` monkeypatch in
+ * `service-host/preload.cjs` would add a stack frame, so Chrome DevTools (attached
+ * natively to the service host) would attribute EVERY service-layer log to the
+ * wrapper line instead of the developer's source.
+ *
+ * These functions turn the CDP event shape into the `GuestConsoleEntry` shape
+ * the existing console fan-out (automation `App.logAdded`) expects, WITHOUT any
+ * electron / IO dependency so they are unit-testable in isolation. The async
+ * deep-fetch (`Runtime.callFunctionOn`) for object args lives in `index.ts`.
+ */
+/**
+ * sourceURL stamped on the render→service `[视图]` re-injection script
+ * (`console-forward.buildForwardScript`). The CDP capture skips any
+ * `consoleAPICalled` whose top frame carries this URL so a forwarded render line
+ * is not re-captured and re-broadcast as a service entry (duplicate / loop).
+ */
+export declare const RENDER_FORWARD_SOURCE_URL = "dimina://render-console-forward";
+export type ConsoleLevel = 'log' | 'warn' | 'error' | 'info' | 'debug';
+/** Subset of a CDP `Runtime.RemoteObject` we read. */
+export interface RemoteObjectLike {
+    type?: string;
+    subtype?: string;
+    value?: unknown;
+    unserializableValue?: string;
+    description?: string;
+    objectId?: string;
+    preview?: {
+        properties?: Array<{
+            name: string;
+            value: string;
+            type: string;
+        }>;
+        subtype?: string;
+        overflow?: boolean;
+    };
+}
+/** Subset of a CDP `Runtime.consoleAPICalled` params we read. */
+export interface ConsoleApiParamsLike {
+    type?: string;
+    args?: RemoteObjectLike[];
+    stackTrace?: {
+        callFrames?: Array<{
+            url?: string;
+        }>;
+    };
+}
+/**
+ * CDP `consoleAPICalled.type` → our console level. CDP emits `'warning'` where
+ * we use `'warn'`; every other known level passes through; anything else (e.g.
+ * `'dir'`, `'table'`, `'trace'`, `undefined`) maps to `'log'`.
+ */
+export declare function mapConsoleApiType(type: string | undefined): ConsoleLevel;
+/**
+ * A single RemoteObject → a JSON-serializable value WITHOUT a CDP round-trip
+ * (shallow). Objects that need their full contents are flagged by
+ * {@link needsDeepFetch} and deep-serialized by the caller; this is the
+ * inline/best-effort fallback.
+ */
+export declare function remoteObjectToValue(ro: RemoteObjectLike): unknown;
+/**
+ * Whether this RemoteObject must be deep-fetched via `Runtime.callFunctionOn`
+ * (returnByValue) to be fully serialized — i.e. a real object/array referenced
+ * by `objectId` with no inline `value`. Functions, primitives, `null`, and
+ * already-inlined values do not.
+ */
+export declare function needsDeepFetch(ro: RemoteObjectLike): boolean;
+/**
+ * True when a `consoleAPICalled` event is the render→service `[视图]`
+ * re-injection (its top call frame URL === the sentinel) and must NOT be
+ * re-forwarded — the original render entry already reached every consumer.
+ */
+export declare function isRenderForwardEvent(params: ConsoleApiParamsLike, sentinelUrl: string): boolean;
+//# sourceMappingURL=console-api.d.ts.map