@dimina-kit/devtools 0.4.0-dev.20260703051110 → 0.4.0-dev.20260706064107

package/dist/main/services/compile-standby.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Wires devkit's warm-standby compile worker into the devtools runtime.
+ *
+ * While no project is open, devkit keeps one project-agnostic compile worker
+ * forked + prewarmed; every openProject adopts it so the first compile skips
+ * fork + compiler import (~1.6s). This module owns exactly the glue devtools
+ * needs on top: turn the accelerator on at boot, mirror its lifecycle events
+ * onto the diagnostics bus (a user-machine bug report then carries the whole
+ * standby story), and shut it down with the context.
+ *
+ * Failure-transparent by design: if devkit is missing or predates the standby
+ * API, the accelerator silently stays off — compilation itself is untouched
+ * (the adapter falls back to devkit's normal cold-fork path, or the host runs
+ * its own adapter entirely).
+ */
+import type { DiagnosticsBus } from './diagnostics/index.js';
+export interface CompileStandbyDeps {
+    /** Test hook: replaces the dynamic import('@dimina-kit/devkit'). */
+    loadDevkit?: () => Promise<unknown>;
+}
+export declare function setupCompileWorkerStandby(ctx: {
+    diagnostics?: DiagnosticsBus;
+}, deps?: CompileStandbyDeps): {
+    dispose: () => Promise<void>;
+};
+//# sourceMappingURL=compile-standby.d.ts.map

package/dist/main/services/compile-standby.js

@@ -0,0 +1,57 @@
+const EVENT_SEVERITY = {
+    'spawned': 'info',
+    'prewarmed': 'info',
+    'adopted': 'info',
+    'died': 'warn',
+    'health-check-failed': 'warn',
+    'degraded': 'error',
+};
+export function setupCompileWorkerStandby(ctx, deps = {}) {
+    const loadDevkit = deps.loadDevkit ?? (() => import('@dimina-kit/devkit'));
+    let manager = null;
+    let disposed = false;
+    const forward = (ev) => {
+        try {
+            const detail = [
+                `compile standby ${ev.type}`,
+                typeof ev.pid === 'number' ? `pid=${ev.pid}` : null,
+                ev.reason ? `— ${ev.reason}` : null,
+            ].filter(Boolean).join(' ');
+            ctx.diagnostics?.report({
+                severity: EVENT_SEVERITY[ev.type] ?? 'info',
+                code: 'compile-standby',
+                message: detail,
+            });
+        }
+        catch {
+            // telemetry must never break the standby
+        }
+    };
+    void (async () => {
+        let enable;
+        try {
+            const devkit = await loadDevkit();
+            enable = devkit.enableCompileWorkerStandby;
+        }
+        catch {
+            // devkit unavailable — the accelerator quietly stays off.
+            return;
+        }
+        if (typeof enable !== 'function')
+            return;
+        manager = enable({ onEvent: forward });
+        // A teardown that raced the async load wins: the manager is disposed the
+        // moment it exists, so a quitting app can never leak a fresh spare.
+        if (disposed)
+            void manager.dispose();
+    })();
+    return {
+        dispose: async () => {
+            if (disposed)
+                return;
+            disposed = true;
+            await manager?.dispose();
+        },
+    };
+}
+//# sourceMappingURL=compile-standby.js.map

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

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

@@ -253,6 +253,16 @@ export function createNetworkForwarder(bridge) {
     // degrade, dropped if we go ready (so a request shows in exactly one sink).
     let probeConsoleBuffer = [];
     let readyTimeoutTimer = null;
+    // Wall-clock deadline for the CURRENT probe, set once when 'probing' begins.
+    // scheduleReadyRetry() re-checks this on every retry so the retry chain is
+    // itself authoritative on giving up — it does not depend on winning a race
+    // against readyTimeoutTimer firing first (two timers due at the same virtual
+    // instant have no guaranteed firing order under fake timers, which let a
+    // never-ready host's retry chain outlive the nominal timeout in CI: an
+    // "Aborting after running 10000 timers" abort in `network-forward`'s
+    // ready-timeout test). readyTimeoutTimer stays as a backstop for hosts that
+    // never retry at all (e.g. the queue drains before the deadline).
+    let probeDeadline = null;
     // ── Batched native dispatch into the DevTools front-end ───────────────────
     // Queued raw CDP messages (already namespaced + JSON-stringified) awaiting a
     // microtask flush — coalescing many events into one executeJavaScript avoids
@@ -269,6 +279,7 @@ export function createNetworkForwarder(bridge) {
         if (sink === 'probing')
             return;
         sink = 'probing';
+        probeDeadline = Date.now() + DEVTOOLS_READY_TIMEOUT_MS;
         if (readyTimeoutTimer)
             clearTimeout(readyTimeoutTimer);
         readyTimeoutTimer = setTimeout(() => {
@@ -281,6 +292,7 @@ export function createNetworkForwarder(bridge) {
     /** Native path confirmed live: console buffer is moot, drop it. */
     function markReady() {
         sink = 'ready';
+        probeDeadline = null;
         if (readyTimeoutTimer) {
             clearTimeout(readyTimeoutTimer);
             readyTimeoutTimer = null;
@@ -299,6 +311,7 @@ export function createNetworkForwarder(bridge) {
      */
     function degradeToConsole() {
         sink = 'degraded';
+        probeDeadline = null;
         dispatchQueue = [];
         if (readyTimeoutTimer) {
             clearTimeout(readyTimeoutTimer);
@@ -444,10 +457,21 @@ export function createNetworkForwarder(bridge) {
     function scheduleReadyRetry() {
         if (readyRetryTimer || sink === 'ready' || sink === 'degraded')
             return;
+        // Self-terminate on the same deadline readyTimeoutTimer enforces, instead of
+        // trusting that timer to win a same-instant race against this one (see the
+        // comment on `probeDeadline`'s declaration).
+        if (probeDeadline !== null && Date.now() >= probeDeadline) {
+            degradeToConsole();
+            return;
+        }
         readyRetryTimer = setTimeout(() => {
             readyRetryTimer = null;
             if (sink === 'degraded')
                 return;
+            if (probeDeadline !== null && Date.now() >= probeDeadline) {
+                degradeToConsole();
+                return;
+            }
             if (dispatchQueue.length > 0)
                 scheduleFlush();
         }, READY_RETRY_MS);
@@ -504,6 +528,7 @@ export function createNetworkForwarder(bridge) {
         // A new simulator attach restarts the native sink: 'idle' until the next
         // event re-probes the (possibly already-set) host.
         sink = 'idle';
+        probeDeadline = null;
         if (readyRetryTimer) {
             clearTimeout(readyRetryTimer);
             readyRetryTimer = null;
@@ -692,6 +717,7 @@ export function createNetworkForwarder(bridge) {
             clearTimeout(readyRetryTimer);
             readyRetryTimer = null;
         }
+        probeDeadline = null;
         // Records buffered while probing the OLD host are stale — drop, don't flush
         // (their native copies were already queued; on a host swap we restart clean).
         probeConsoleBuffer = [];
@@ -732,6 +758,12 @@ export function createNetworkForwarder(bridge) {
                 catch { /* gone */ }
             });
         }
+        // A host swap while still 'probing' the OLD host must not inherit its
+        // window: beginProbing()'s `sink === 'probing'` guard would otherwise skip
+        // (re-)arming readyTimeoutTimer/probeDeadline for the NEW host, leaving it
+        // probing forever with no timeout. Force through 'idle' so beginProbing()
+        // always arms a fresh window for whichever host is now current.
+        sink = 'idle';
         beginProbing();
         if (dispatchQueue.length > 0)
             scheduleFlush();

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

@@ -11,6 +11,43 @@ export interface ProjectStatusPayload {
     message: string;
     /** True when the status update is emitted by the file-watcher rebuild loop. */
     hotReload?: boolean;
+    /** Freshly-read page list, carried on a hot-reload status so the launch dropdown stays current. Absent when the read failed or wasn't attempted. */
+    pages?: string[];
+    /** Present (`'dead'`) once the project's file watcher has stopped — saves no longer trigger an automatic rebuild. */
+    watcher?: 'dead';
+}
+/**
+ * Payload for the `session:runtimeStatus` push — the post-compile SESSION
+ * lifecycle main tracks per `appSessionId` in bridge-router (`AppSession`
+ * itself is main-private; this is the public projection). A successful
+ * compile only means the resource tree exists; it says nothing about whether
+ * the simulator actually booted — this closes that gap.
+ */
+export interface SessionRuntimeStatusPayload {
+    appId: string;
+    phase: 'launching' | 'running' | 'launch-failed' | 'crashed';
+    /**
+     * Machine-readable cause, present on `'launch-failed'` and `'crashed'`:
+     * `'timeout'` — the launch watchdog (`LAUNCH_TIMEOUT_MS`) expired before the
+     * root page reported `domReady`; `'logic-bundle-unreachable'` — the
+     * compiled `logic.js` could not be fetched/executed;
+     * `'service-host-navigation-failed'` — the service-host window failed to
+     * navigate to its spawn URL; `'service-host-crashed'` — the service host's
+     * renderer process was gone. Plain `string` (not a literal union) so an
+     * unrecognized future code degrades gracefully instead of a type error.
+     */
+    code?: string;
+    /** Human-readable detail, mirroring the short form of the matching `ctx.diagnostics` report. */
+    reason?: string;
+    /**
+     * Present on `'launching'` when `handleSpawn`'s page-mount gate
+     * (`resolveRootPagePath`) substituted the resolved page for the request —
+     * i.e. `SpawnResult.pageFallbackApplied` was true for this spawn.
+     */
+    pageFallback?: {
+        requested: string;
+        resolved: string;
+    };
 }
 /**
  * Payload for the `project:compileLog` push — one filtered dmcc log line.
@@ -51,6 +88,8 @@ export interface WorkbenchSettingsInitPayload {
 export interface RendererNotifier {
     /** Broadcast project compile status transitions to the main renderer. */
     projectStatus(payload: ProjectStatusPayload): void;
+    /** Broadcast a session's post-compile runtime lifecycle to the main renderer. */
+    sessionRuntimeStatus(payload: SessionRuntimeStatusPayload): void;
     /** Push one per-line dmcc compile-log entry to the main renderer. */
     compileLog(payload: CompileLogPayload): void;
     /** Ask the main renderer to navigate back to its landing screen. */

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

@@ -1,4 +1,4 @@
-import { ProjectChannel, WindowChannel, SettingsChannel, PopoverChannel, WorkbenchSettingsChannel, EditorChannel, ViewChannel, } from '../../../shared/ipc-channels.js';
+import { ProjectChannel, SessionChannel, WindowChannel, SettingsChannel, PopoverChannel, WorkbenchSettingsChannel, EditorChannel, ViewChannel, } from '../../../shared/ipc-channels.js';
 /** Safely resolve a WebContents, skipping destroyed / missing targets. */
 function liveWebContents(wc) {
     if (!wc)
@@ -24,6 +24,9 @@ export function createRendererNotifier(ctx) {
         projectStatus(payload) {
             sendToMain(ProjectChannel.Status, payload);
         },
+        sessionRuntimeStatus(payload) {
+            sendToMain(SessionChannel.RuntimeStatus, payload);
+        },
         compileLog(payload) {
             sendToMain(ProjectChannel.CompileLog, payload);
         },

package/dist/main/services/projects/project-repository.js

@@ -103,7 +103,8 @@ export function getProjectPages(dirPath) {
             entryPagePath: appJson.entryPagePath || appJson.pages?.[0] || '',
         };
     }
-    catch {
+    catch (err) {
+        log.warn(`Failed to read project pages from ${appJsonPath}`, err);
         return { pages: [], entryPagePath: '' };
     }
 }

package/dist/main/services/views/simulator-session-policy.js

@@ -19,6 +19,12 @@ import { session } from 'electron';
 import { toDisposable } from '@dimina-kit/electron-deck/main';
 import { getSimulatorServicewechatReferer } from '../simulator/referer.js';
 import { registerMiniappSessionConfigurator, SHARED_MINIAPP_PARTITION, } from './miniapp-partition.js';
+/** The response headers this policy owns outright (compared lowercase). */
+const CORS_OVERRIDE_HEADERS = new Set([
+    'access-control-allow-origin',
+    'access-control-allow-headers',
+    'access-control-allow-methods',
+]);
 /** Apply the simulator runtime's referer + CORS webRequest policy to one
  * session. Each session installs its own listeners (a webRequest listener is
  * per-session), so this runs once per partition. */
@@ -35,6 +41,17 @@ function applySimulatorWebRequestPolicy(simulatorSession) {
         // CORS for the native render/service hosts to fetch compiled app resources
         // cross-origin. (The COOP/COEP cross-origin-isolation headers were only for
         // the removed default-path SharedArrayBuffer sync Worker — dropped.)
+        //
+        // This policy is the single authority for these three headers: any value
+        // the server itself sent must be REPLACED, not shadowed. responseHeaders
+        // keys keep the server's original casing, so assigning the lowercase key
+        // beside an existing `Access-Control-Allow-Origin` puts BOTH on the wire —
+        // Chromium then rejects the response for carrying multiple ACAO values
+        // (`*, *`), breaking every fetch against a CORS-compliant backend.
+        for (const key of Object.keys(headers)) {
+            if (CORS_OVERRIDE_HEADERS.has(key.toLowerCase()))
+                delete headers[key];
+        }
         headers['access-control-allow-origin'] = ['*'];
         headers['access-control-allow-headers'] = ['*'];
         headers['access-control-allow-methods'] = ['*'];

package/dist/main/services/workbench-context.d.ts

@@ -2,6 +2,7 @@ import type { BrowserWindow } from 'electron';
 import type { CompilationAdapter, CustomFileTypes, WorkbenchConfig } from '../../shared/types.js';
 import type { BridgeRouterHandle } from '../ipc/bridge-router.js';
 import type { ConsoleForwarder } from './console-forward/index.js';
+import type { DiagnosticsBus } from './diagnostics/index.js';
 import type { NetworkForwarder } from './network-forward/index.js';
 import type { AppDataTap } from './simulator-appdata/index.js';
 import type { StorageApi } from './simulator-storage/index.js';
@@ -167,6 +168,15 @@ export interface WorkbenchContext {
      * installed.
      */
     consoleForwarder?: ConsoleForwarder;
+    /**
+     * Authoritative diagnostics bus for main-synthesized developer diagnostics
+     * (page-not-found, logic-bundle-unreachable, service-host-navigation-failed,
+     * …), set by `installBridgeRouter`. `consoleForwarder` subscribes to it so
+     * every diagnostic also surfaces in the owning session's embedded DevTools
+     * Console panel, not just the main-process log. Undefined until the bridge
+     * router is installed.
+     */
+    diagnostics?: DiagnosticsBus;
     /**
      * Native-host network forwarder, set in app bootstrap. Attaches the CDP
      * debugger to the simulator WCV (where `wx.request`/`downloadFile`/`uploadFile`

package/dist/main/services/workspace/workspace-service.js

@@ -38,8 +38,8 @@ export function createWorkspaceService(ctx) {
     // wins request tokens, so a close mid-open can't disposeAll() the views the open
     // is building or desync currentSession vs the bridge appSessions. See op-lock.ts.
     const opLock = createOpLock();
-    function sendStatus(status, message, hotReload) {
-        ctx.notify.projectStatus(hotReload ? { status, message, hotReload: true } : { status, message });
+    function sendStatus(status, message, hotReload, pages, watcherDead) {
+        ctx.notify.projectStatus({ status, message, ...(hotReload ? { hotReload: true } : {}), ...(pages ? { pages } : {}), ...(watcherDead ? { watcher: 'dead' } : {}) });
     }
     function bestEffort(label, fn) {
         try {
@@ -127,8 +127,17 @@ export function createWorkspaceService(ctx) {
                 sourcemap: true,
                 fileTypes: ctx.fileTypes,
                 watch: compile.watch,
-                onRebuild: () => sendStatus('ready', '编译完成，已重启', true),
+                onRebuild: () => {
+                    // getProjectPages never throws — failure yields the empty-pages
+                    // shape. Empty means "read failed or degenerate project" (a valid
+                    // app.json names ≥1 page) and is withheld so the renderer keeps its
+                    // previous dropdown instead of blanking; the push is never blocked.
+                    const { pages } = repo.getProjectPages(projectPath);
+                    sendStatus('ready', '编译完成，已重启', true, pages.length ? pages : undefined);
+                },
                 onBuildError: (err) => sendStatus('error', String(err)),
+                // Watcher died mid-session (EMFILE, permission loss, …): non-fatal, so 'ready' stays but `watcher: 'dead'` flags that saves no longer auto-rebuild.
+                onWatcherError: () => sendStatus('ready', '文件监听已停止，保存不再触发自动编译', false, undefined, true),
                 onLog: (entry) => {
                     if (sessionGeneration !== logGeneration)
                         return;

package/dist/main/windows/service-host-window/create.d.ts

@@ -28,6 +28,13 @@ export interface ServiceHostWindowOptions {
      * which page logic referencing `qd.*` throws `ReferenceError: qd is not defined`.
      */
     apiNamespaces?: string[];
+    /**
+     * Observes a spawn-navigation `loadURL` rejection (NOT encoded into the
+     * spawn URL). Without it the fresh-window path swallows the failure entirely
+     * — `did-finish-load` never fires, the session hangs, and the only signal is
+     * the launch watchdog's late timeout instead of the real cause.
+     */
+    onLoadFailed?: (err: unknown) => void;
 }
 /**
  * Construct an (un-navigated) service-host BrowserWindow. Split out from
@@ -52,8 +59,15 @@ export declare function buildServiceHostSpawnUrl(opts: ServiceHostWindowOptions)
  * preload re-evaluates on this navigation, rebuilding `__diminaSpawnContext`.
  * Returns the load promise (resolves on did-finish-load). Attaches the dev-only
  * detached-DevTools hook, matching the original behavior.
+ *
+ * A `loadURL` rejection is swallowed — the pooled-window recycle path expects
+ * a failed navigation not to reject the caller — but `opts.onLoadFailed`, when
+ * given, still observes the original rejection reason (routed by the caller
+ * into the diagnostics bus) before this resolves.
  */
-export declare function navigateServiceHost(win: BrowserWindow, url: string): Promise<void>;
+export declare function navigateServiceHost(win: BrowserWindow, url: string, opts?: {
+    onLoadFailed?: (err: unknown) => void;
+}): Promise<void>;
 /**
  * The spec a `ServiceHostPool` uses to pre-warm service-host windows. Keeps the
  * pooled window byte-equivalent to `constructServiceHostWindow`'s output, and

package/dist/main/windows/service-host-window/create.js

@@ -72,9 +72,17 @@ export function buildServiceHostSpawnUrl(opts) {
  * preload re-evaluates on this navigation, rebuilding `__diminaSpawnContext`.
  * Returns the load promise (resolves on did-finish-load). Attaches the dev-only
  * detached-DevTools hook, matching the original behavior.
+ *
+ * A `loadURL` rejection is swallowed — the pooled-window recycle path expects
+ * a failed navigation not to reject the caller — but `opts.onLoadFailed`, when
+ * given, still observes the original rejection reason (routed by the caller
+ * into the diagnostics bus) before this resolves.
  */
-export function navigateServiceHost(win, url) {
-    const loaded = Promise.resolve(win.loadURL(url)).then(() => undefined, () => undefined);
+export function navigateServiceHost(win, url, opts) {
+    const loaded = Promise.resolve(win.loadURL(url)).then(() => undefined, (err) => {
+        opts?.onLoadFailed?.(err);
+        return undefined;
+    });
     if (!app.isPackaged && process.env.NODE_ENV !== 'test') {
         // Recycled pooled windows get navigated repeatedly. A `once` hook that never
         // fires (the spawn was disposed before its service.html settled) stays on the
@@ -141,7 +149,7 @@ export function createServiceHostWindow(opts) {
     // so its logic-layer localStorage/cookies are shared with the project's render
     // side only, never with other projects.
     const win = constructServiceHostWindow({ appId: opts.appId, partition: miniappPartition(opts.appId, opts.projectPath) });
-    void navigateServiceHost(win, buildServiceHostSpawnUrl(opts));
+    void navigateServiceHost(win, buildServiceHostSpawnUrl(opts), { onLoadFailed: opts.onLoadFailed });
     return win;
 }
 //# sourceMappingURL=create.js.map