@dimina-kit/devtools 0.4.0-dev.20260711141929 → 0.4.0-dev.20260716163758

package/dist/main/services/simulator-appdata/index.js

@@ -1,5 +1,5 @@
 import { SimulatorAppDataChannel } from '../../../shared/ipc-channels.js';
-import { AppDataAccumulator, decodeWorkerMessage, decodedToInput, } from '../../../shared/appdata-accumulator.js';
+import { AppDataAccumulator, decodeWorkerMessage, decodedToInput, } from '@dimina-kit/inspect';
 import { DisposableRegistry } from '@dimina-kit/electron-deck/main';
 import { IpcRegistry } from '../../utils/ipc-registry.js';
 const EMPTY_SNAPSHOT = { bridges: [], entries: {} };

package/dist/main/services/views/native-simulator-view.d.ts

@@ -15,6 +15,12 @@ import type { ViewManagerContext } from './view-manager.js';
 export interface NativeSimulatorView {
     attachNativeSimulator(simulatorUrl: string, simWidth: number): Promise<void>;
     softReloadNativeSimulator(simulatorUrl: string): boolean;
+    /**
+     * Hot-swap stylesheets in every live render-host guest WITHOUT respawning the
+     * shell (page stack / form state / focus survive). Returns false when no live
+     * guest exists, so the caller falls back to a full reload.
+     */
+    refreshSimulatorStyles(): boolean;
     detachSimulator(): void;
     getSimulatorWebContentsId(): number | null;
     getSimulatorWebContents(): WebContents | null;

package/dist/main/services/views/native-simulator-view.js

@@ -6,6 +6,7 @@ import { SimulatorCustomApiBridgeChannel } from '../../../shared/ipc-channels.js
 import * as layout from '../layout/index.js';
 import { handleCustomApiBridgeRequest, } from '../simulator/custom-apis.js';
 import { configureMiniappSession, miniappPartition } from './miniapp-partition.js';
+import { refreshGuestStylesheets } from './refresh-styles.js';
 import { parseRoute } from '../../../shared/simulator-route.js';
 import { SIMULATOR_EVENTS } from '../../../shared/bridge-channels.js';
 import { VIEW_ID } from '../../../shared/view-ids.js';
@@ -377,6 +378,20 @@ export function createNativeSimulatorView(ctx, reconciler, deps) {
         nativeSimulatorView.webContents.send(SIMULATOR_EVENTS.RELAUNCH, payload);
         return true;
     }
+    /**
+     * Style-only hot swap: cache-bust every render-host stylesheet in place so a
+     * recompiled `.css` re-applies against the already-mounted page WITHOUT
+     * respawning the DeviceShell — page stack / form state / scroll / focus all
+     * survive (unlike `softReloadNativeSimulator`, which reboots the app session).
+     * Returns false when the shell isn't ready or no guest is live, so the caller
+     * falls back to a full reload rather than silently swallowing the rebuild.
+     */
+    function refreshSimulatorStyles() {
+        const view = nativeSimulatorView;
+        if (!view || view.webContents.isDestroyed() || !nativeSimulatorShellReady)
+            return false;
+        return refreshGuestStylesheets(view);
+    }
     function detachSimulator() {
         settleNativeSimulatorReady?.();
         settleNativeSimulatorReady = null;
@@ -414,6 +429,7 @@ export function createNativeSimulatorView(ctx, reconciler, deps) {
     return {
         attachNativeSimulator,
         softReloadNativeSimulator,
+        refreshSimulatorStyles,
         detachSimulator,
         getSimulatorWebContentsId: () => simulatorWebContentsId,
         getSimulatorWebContents: () => {

package/dist/main/services/views/refresh-styles.d.ts

@@ -0,0 +1,10 @@
+import { type WebContentsView } from 'electron';
+/**
+ * Hot-swap the stylesheets of every live render-host guest of `view` in place
+ * (no shell respawn — page stack / form state / scroll / focus survive). Guests
+ * are found via `hostWebContents === view.webContents` — the same nesting
+ * pattern the zoom propagation uses. Returns false when no live guest is found,
+ * so the caller can fall back to a full reload rather than dropping the edit.
+ */
+export declare function refreshGuestStylesheets(view: WebContentsView): boolean;
+//# sourceMappingURL=refresh-styles.d.ts.map

package/dist/main/services/views/refresh-styles.js

@@ -0,0 +1,57 @@
+import { webContents } from 'electron';
+/**
+ * Injected into each live render-host guest to hot-swap its stylesheets in
+ * place: for every `<link rel=stylesheet>`, insert a cache-busted clone
+ * (`?__hmr=<ts>`) so the browser re-fetches the recompiled `.css` and re-applies
+ * it against the already-mounted DOM, then drop the stale sheet once the fresh
+ * one loads (no unstyled flash). Recurses into same-origin iframes because a
+ * render-host page nests its content in an iframe. Self-contained (runs in the
+ * guest realm via `executeJavaScript`), defensive (never throws). Mirrors
+ * `@dimina-kit/devkit`'s `refreshStylesheets` (the SSE web-preview equivalent).
+ */
+const REFRESH_STYLES_JS = `(function refresh(doc){
+  try {
+    var links = doc.querySelectorAll('link[rel="stylesheet"]');
+    for (var i = 0; i < links.length; i++) {
+      var link = links[i];
+      try {
+        var u = new URL(link.href, doc.baseURI || undefined);
+        u.searchParams.set('__hmr', String(Date.now()));
+        var next = link.cloneNode();
+        next.href = u.href;
+        next.addEventListener('load', (function(stale){ return function(){ stale.remove(); }; })(link));
+        link.parentNode.insertBefore(next, link.nextSibling);
+      } catch (e) {}
+    }
+    var frames = doc.querySelectorAll('iframe');
+    for (var j = 0; j < frames.length; j++) {
+      try { if (frames[j].contentDocument) refresh(frames[j].contentDocument); } catch (e) {}
+    }
+  } catch (e) {}
+})(document);`;
+/**
+ * Hot-swap the stylesheets of every live render-host guest of `view` in place
+ * (no shell respawn — page stack / form state / scroll / focus survive). Guests
+ * are found via `hostWebContents === view.webContents` — the same nesting
+ * pattern the zoom propagation uses. Returns false when no live guest is found,
+ * so the caller can fall back to a full reload rather than dropping the edit.
+ */
+export function refreshGuestStylesheets(view) {
+    const simWc = view.webContents;
+    let refreshed = 0;
+    try {
+        for (const wc of webContents.getAllWebContents()) {
+            if (wc.isDestroyed())
+                continue;
+            if (wc.hostWebContents !== simWc)
+                continue;
+            wc.executeJavaScript(REFRESH_STYLES_JS).catch(() => { });
+            refreshed++;
+        }
+    }
+    catch {
+        return false;
+    }
+    return refreshed > 0;
+}
+//# sourceMappingURL=refresh-styles.js.map

package/dist/main/services/views/view-manager.d.ts

@@ -104,6 +104,13 @@ export interface ViewManager {
      * back to the hard attachNativeSimulator rebuild.
      */
     softReloadNativeSimulator(simulatorUrl: string): boolean;
+    /**
+     * Style-only fast path after a watcher rebuild: hot-swap the render-host
+     * stylesheets in place (no shell respawn), preserving the page stack / form
+     * state / focus. Returns false when no live+ready guest exists so the caller
+     * falls back to the full soft reload.
+     */
+    refreshSimulatorStyles(): boolean;
     /**
      * Destroy and null out the simulator view (e.g. on simulator detach).
      * Also destroys the cached settings view and hides the popover —
@@ -195,11 +202,29 @@ export interface ViewManager {
     /**
      * Store the workbench COI base URL without loading it. The heavy
      * WebContentsView load is deferred to the first visible
-     * `setWorkbenchBounds`, keeping it off the app boot critical path.
+     * `setWorkbenchBounds` — and further deferred while `holdWorkbenchAttach`
+     * is in force — keeping it off the app boot critical path.
      */
     setWorkbenchSource(url: string): void;
     /** Destroy the workbench editor view (teardown). No-op if never attached. */
     detachWorkbench(): void;
+    /**
+     * Close the workbench attach gate: while held (and the view does not exist
+     * yet), the lazy attach is deferred so the editor's heavy load stays out of
+     * a project open's boot-critical window (teardown + first compile). Returns
+     * an idempotent release fn bound to this hold; a newer hold supersedes it
+     * (its release becomes a no-op), explicit user intent (openFileInWorkbench)
+     * opens the gate, and a 3s cap self-releases with a warn so the editor is
+     * never deferred unboundedly. The gate never hides or destroys a live view.
+     */
+    holdWorkbenchAttach(): () => void;
+    /**
+     * Void the current workbench attach hold WITHOUT the release replay. For
+     * teardown paths that preempt an in-flight open (closeProject, disposeAll):
+     * the superseded open's late release or its cap firing must not rebuild the
+     * editor view after the project is gone. No-op when nothing is held.
+     */
+    cancelWorkbenchAttachHold(): void;
     /**
      * Reveal a project file in the embedded workbench at a 1-based line/column
      * (the open-in-editor target coordinate convention). Drives the workbench's

package/dist/main/services/views/view-manager.js

@@ -58,6 +58,10 @@ export function createViewManager(ctx) {
         safeArea.dispose();
     }
     function disposeAll() {
+        // App-level teardown invalidates any in-flight open's attach hold first,
+        // so the held-detach preserve path below can't keep a desired around for
+        // a release/cap replay to rebuild.
+        workbench.cancelWorkbenchAttachHold();
         disposeProjectViews();
         // Host-scoped teardown: the toolbar view, its port channel, and the
         // ref-counted session-runtime preload registration.
@@ -66,6 +70,7 @@ export function createViewManager(ctx) {
     return {
         attachNativeSimulator: nativeSimulator.attachNativeSimulator,
         softReloadNativeSimulator: nativeSimulator.softReloadNativeSimulator,
+        refreshSimulatorStyles: nativeSimulator.refreshSimulatorStyles,
         detachSimulator: nativeSimulator.detachSimulator,
         reapplySafeArea: (device) => safeArea.reapplyAll(device),
         showSettings: overlayPanels.showSettings,
@@ -89,6 +94,8 @@ export function createViewManager(ctx) {
         setWorkbenchSource: workbench.setWorkbenchSource,
         detachWorkbench: workbench.detachWorkbench,
         openFileInWorkbench: workbench.openFileInWorkbench,
+        holdWorkbenchAttach: workbench.holdWorkbenchAttach,
+        cancelWorkbenchAttachHold: workbench.cancelWorkbenchAttachHold,
         setHostToolbarHeight: hostToolbar.setHostToolbarHeight,
         hostToolbar: hostToolbar.control,
     };

package/dist/main/services/views/workbench-view.d.ts

@@ -10,6 +10,8 @@ export interface WorkbenchView {
     setWorkbenchSource(url: string): void;
     detachWorkbench(): void;
     openFileInWorkbench(relPath: string, line: number, column: number): boolean;
+    holdWorkbenchAttach(): () => void;
+    cancelWorkbenchAttachHold(): void;
 }
 export declare function createWorkbenchView(ctx: ViewManagerContext, reconciler: PlacementReconciler): WorkbenchView;
 //# sourceMappingURL=workbench-view.d.ts.map

package/dist/main/services/views/workbench-view.js

@@ -2,6 +2,12 @@ import { nativeTheme, WebContentsView } from 'electron';
 import { handleWindowOpenExternal } from '../../windows/navigation-hardening.js';
 import { VIEW_ID } from '../../../shared/view-ids.js';
 import { destroyChildView } from './destroy-child-view.js';
+/**
+ * Upper bound on how long a hold may defer the workbench attach. A hung or
+ * very slow first compile (or a lost release on some open path) degrades to a
+ * bounded editor delay plus a warn — never a permanently blank editor slot.
+ */
+const ATTACH_HOLD_CAP_MS = 3000;
 export function createWorkbenchView(ctx, reconciler) {
     let workbenchView = null;
     // Whether the devtools-theme → workbench-theme `nativeTheme` listener is live.
@@ -11,8 +17,20 @@ export function createWorkbenchView(ctx, reconciler) {
     // heavy WebContentsView load is deferred until the 'editor' slot first becomes
     // visible (first non-zero `setWorkbenchBounds`) so it never sits on the app
     // boot critical path (which would delay preload/window-ready and trip the e2e
-    // health check into a relaunch).
+    // health check into a relaunch), and further deferred while an attach hold
+    // (below) is in force.
     let workbenchUrl = null;
+    // Attach gate: while held (and the view does not exist yet), the lazy attach
+    // is deferred so the workbench's heavy load never competes with a project
+    // open's boot-critical window (old-session teardown + first compile) for
+    // CPU. Generation-tagged: a newer hold supersedes an older one (latest-wins,
+    // mirroring the open op-lock), so a superseded open's late release cannot
+    // open a newer open's gate. The gate only postpones creation — it never
+    // hides or destroys an existing view, and detachWorkbench leaves it intact
+    // (an in-flight open holds across the old view's teardown).
+    let attachHeld = false;
+    let attachHoldGeneration = 0;
+    let attachHoldTimer = null;
     /** Current devtools color scheme, mirrored into the workbench's theme. */
     function workbenchThemeScheme() {
         return nativeTheme.shouldUseDarkColors ? 'dark' : 'light';
@@ -70,6 +88,53 @@ export function createWorkbenchView(ctx, reconciler) {
     function setWorkbenchSource(url) {
         workbenchUrl = url;
     }
+    // Release the gate for `generation` (stale generations no-op) and replay the
+    // reconcile so a pending visible desired attaches through the normal lazy
+    // path. `viaCap` marks the self-release at the hold cap — loud, so a slow
+    // compile and a lost release stay distinguishable from a normal settle.
+    function releaseAttachHold(generation, viaCap) {
+        if (!attachHeld || generation !== attachHoldGeneration)
+            return;
+        attachHeld = false;
+        if (attachHoldTimer) {
+            clearTimeout(attachHoldTimer);
+            attachHoldTimer = null;
+        }
+        if (viaCap) {
+            console.warn(`[workbench] attach gate: hold not released within ${ATTACH_HOLD_CAP_MS}ms (compile still running or a release was lost) — attaching now`);
+        }
+        reconciler.reconcileNow();
+    }
+    /**
+     * Close the attach gate until the returned release fn runs, a newer hold
+     * supersedes it, explicit user intent (openFileInWorkbench) opens it, or the
+     * cap timer fires. The release fn is idempotent and generation-bound.
+     */
+    function holdWorkbenchAttach() {
+        const generation = ++attachHoldGeneration;
+        attachHeld = true;
+        if (attachHoldTimer)
+            clearTimeout(attachHoldTimer);
+        attachHoldTimer = setTimeout(() => releaseAttachHold(generation, true), ATTACH_HOLD_CAP_MS);
+        return () => releaseAttachHold(generation, false);
+    }
+    /**
+     * Void the current hold WITHOUT the release replay: the gate belongs to an
+     * open request, and a teardown that preempts it (closeProject / app-level
+     * disposeAll) invalidates that request — its late release or cap firing must
+     * not rebuild the view after the project is gone. Bumping the generation
+     * turns every pending release fn into a no-op; no-op when nothing is held.
+     */
+    function cancelWorkbenchAttachHold() {
+        if (!attachHeld && !attachHoldTimer)
+            return;
+        attachHeld = false;
+        attachHoldGeneration++;
+        if (attachHoldTimer) {
+            clearTimeout(attachHoldTimer);
+            attachHoldTimer = null;
+        }
+    }
     function detachWorkbench() {
         if (workbenchThemeSyncBound) {
             nativeTheme.removeListener('updated', pushWorkbenchTheme);
@@ -77,7 +142,17 @@ export function createWorkbenchView(ctx, reconciler) {
         }
         destroyChildView(ctx.windows.mainWindow, workbenchView);
         workbenchView = null;
-        reconciler.deleteBaseDesired(VIEW_ID.workbench);
+        if (attachHeld) {
+            // A held detach is a project-switch teardown: the renderer published the
+            // incoming project's placement before the open started, so that desired
+            // is the ONLY thing the release replay can rebuild the view from — keep
+            // it (gateHidden hides it while held) and just forget the destroyed
+            // instance so the rebuilt view is treated as a fresh attach.
+            reconciler.forgetActual(VIEW_ID.workbench);
+        }
+        else {
+            reconciler.deleteBaseDesired(VIEW_ID.workbench);
+        }
         reconciler.reconcileNow();
     }
     // Build the `file:///workspace/<rel>` URI string with each path SEGMENT
@@ -123,6 +198,11 @@ export function createWorkbenchView(ctx, reconciler) {
     // the document is actually shown; false when there is no workbench view or
     // every attempt failed.
     function openFileInWorkbench(relPath, line, column) {
+        // Explicit user intent (a source-link click) beats the boot-priority
+        // scheduling: open the gate first so the release's reconcile replay can
+        // lazy-create the view synchronously before the liveness check below.
+        if (attachHeld)
+            releaseAttachHold(attachHoldGeneration, false);
         if (!workbenchView || workbenchView.webContents.isDestroyed())
             return false;
         // The workbench mirrors the active project under file:///workspace/<rel>; the
@@ -148,12 +228,12 @@ export function createWorkbenchView(ctx, reconciler) {
         return true;
     }
     // workbench is gated until it has a source or a live view (it lazy-creates
-    // from the URL in the attach op).
+    // from the URL in the attach op), and while an attach hold is in force.
     reconciler.registerView(VIEW_ID.workbench, {
         getView: () => workbenchView,
-        gateHidden: () => !workbenchView && !workbenchUrl,
+        gateHidden: () => !workbenchView && (!workbenchUrl || attachHeld),
         beforeAttach: () => {
-            if (!workbenchView && workbenchUrl) {
+            if (!workbenchView && workbenchUrl && !attachHeld) {
                 // Lazy-load the workbench; attachWorkbench adds it to the contentView.
                 void attachWorkbench(workbenchUrl);
                 return true;
@@ -161,10 +241,10 @@ export function createWorkbenchView(ctx, reconciler) {
             return false;
         },
         ensureLazy: (desired) => {
-            if (desired?.placement.visible && !workbenchView && workbenchUrl)
+            if (desired?.placement.visible && !workbenchView && workbenchUrl && !attachHeld)
                 void attachWorkbench(workbenchUrl);
         },
     });
-    return { attachWorkbench, setWorkbenchSource, detachWorkbench, openFileInWorkbench };
+    return { attachWorkbench, setWorkbenchSource, detachWorkbench, openFileInWorkbench, holdWorkbenchAttach, cancelWorkbenchAttachHold };
 }
 //# sourceMappingURL=workbench-view.js.map

package/dist/main/services/workspace/open-project-guards.d.ts

@@ -0,0 +1,16 @@
+import type { ProjectSession } from '../../../shared/types.js';
+import type { ProjectsProvider } from '../projects/types.js';
+/**
+ * Run the provider's project-dir validation, folding a throwing/rejecting
+ * validator into the same dirError failure path as a returned error string —
+ * a broken validator is a failed validation, not a crashed open.
+ */
+export declare function validateProjectDirSafe(provider: ProjectsProvider, projectPath: string): Promise<string | null>;
+/**
+ * Adapter-return boundary: a session without a string appId can't be driven by
+ * the renderer, so it must never become active. Close the live resources the
+ * adapter already spun up (best-effort) and return the error message; null when
+ * valid.
+ */
+export declare function rejectInvalidAppId(session: ProjectSession): Promise<string | null>;
+//# sourceMappingURL=open-project-guards.d.ts.map

package/dist/main/services/workspace/open-project-guards.js

@@ -0,0 +1,42 @@
+import { z } from 'zod';
+/**
+ * Run the provider's project-dir validation, folding a throwing/rejecting
+ * validator into the same dirError failure path as a returned error string —
+ * a broken validator is a failed validation, not a crashed open.
+ */
+export async function validateProjectDirSafe(provider, projectPath) {
+    try {
+        return provider.validateProjectDir
+            ? await provider.validateProjectDir(projectPath)
+            : null;
+    }
+    catch (err) {
+        return err instanceof Error ? err.message : String(err);
+    }
+}
+/**
+ * Runtime guard for the adapter-return boundary: `session.appInfo` must carry a
+ * NON-EMPTY string `appId` (the renderer scopes IPC by it; the bridge's
+ * handleSpawn also rejects empty appIds, so accepting `''` would desync layers).
+ * Loose: extra fields pass through — only the contract-critical `appId` is enforced.
+ */
+const SessionAppInfoSchema = z.looseObject({ appId: z.string().min(1) });
+/**
+ * Adapter-return boundary: a session without a string appId can't be driven by
+ * the renderer, so it must never become active. Close the live resources the
+ * adapter already spun up (best-effort) and return the error message; null when
+ * valid.
+ */
+export async function rejectInvalidAppId(session) {
+    if (SessionAppInfoSchema.safeParse(session.appInfo).success)
+        return null;
+    try {
+        await session.close();
+    }
+    catch (closeErr) {
+        console.warn('[workspace] closing appId-less adapter session failed (non-fatal):', closeErr);
+    }
+    return 'adapter returned session.appInfo without a string appId — '
+        + 'the CompilationAdapter must supply appInfo.appId';
+}
+//# sourceMappingURL=open-project-guards.js.map

package/dist/main/services/workspace/rebuild-status.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Decide and emit the post-rebuild status for one watcher rebuild. Style-only
+ * rebuild fast path: hot-swap the render-host stylesheets in place instead of
+ * respawning the DeviceShell — page stack / form state / scroll / focus survive
+ * (no jitter, no focus steal); `hotReload: false` keeps the renderer from bumping
+ * its reload token (the respawn signal). Falls through to the full reload when
+ * the swap can't run (no live render guest yet) so an edit is never dropped.
+ * `getProjectPages` never throws; empty pages are withheld so the renderer keeps
+ * its previous launch dropdown.
+ */
+export declare function reportRebuildStatus(info: {
+    styleOnly?: boolean;
+} | undefined, deps: {
+    projectPath: string;
+    repo: {
+        getProjectPages: (p: string) => {
+            pages: string[];
+        };
+    };
+    autoReload: boolean;
+    refreshSimulatorStyles: () => boolean;
+    sendStatus: (status: string, message: string, hotReload?: boolean, pages?: string[]) => void;
+}): void;
+//# sourceMappingURL=rebuild-status.d.ts.map

package/dist/main/services/workspace/rebuild-status.js

@@ -0,0 +1,20 @@
+/**
+ * Decide and emit the post-rebuild status for one watcher rebuild. Style-only
+ * rebuild fast path: hot-swap the render-host stylesheets in place instead of
+ * respawning the DeviceShell — page stack / form state / scroll / focus survive
+ * (no jitter, no focus steal); `hotReload: false` keeps the renderer from bumping
+ * its reload token (the respawn signal). Falls through to the full reload when
+ * the swap can't run (no live render guest yet) so an edit is never dropped.
+ * `getProjectPages` never throws; empty pages are withheld so the renderer keeps
+ * its previous launch dropdown.
+ */
+export function reportRebuildStatus(info, deps) {
+    const { pages } = deps.repo.getProjectPages(deps.projectPath);
+    const pageList = pages.length ? pages : undefined;
+    if (info?.styleOnly && deps.autoReload && deps.refreshSimulatorStyles()) {
+        deps.sendStatus('ready', '样式已热更新', false, pageList);
+        return;
+    }
+    deps.sendStatus('ready', deps.autoReload ? '编译完成，已重启' : '编译完成', deps.autoReload, pageList);
+}
+//# sourceMappingURL=rebuild-status.js.map

package/dist/main/services/workspace/workspace-lifecycle-race.testutil.d.ts

@@ -4,6 +4,8 @@ export declare function stubProjectsProvider(): import('../projects/types.js').P
 export declare function makeViewsSpy(): {
     views: {
         disposeAll: import("vitest").Mock<() => void>;
+        holdWorkbenchAttach: import("vitest").Mock<() => (() => void)>;
+        cancelWorkbenchAttachHold: import("vitest").Mock<() => void>;
         disposeProjectViews: import("vitest").Mock<() => void>;
         detachWorkbench: import("vitest").Mock<() => void>;
         detachSimulator: import("vitest").Mock<() => void>;

package/dist/main/services/workspace/workspace-lifecycle-race.testutil.js

@@ -15,6 +15,8 @@ export function makeViewsSpy() {
     const events = [];
     const views = {
         disposeAll: vi.fn(() => { events.push('views.disposeAll'); }),
+        holdWorkbenchAttach: vi.fn(() => vi.fn()),
+        cancelWorkbenchAttachHold: vi.fn(() => { }),
         // Project-scoped teardown: closeProject must call THIS, never disposeAll
         // (which would also kill the host toolbar — see view-manager-dispose-scopes.test.ts).
         disposeProjectViews: vi.fn(() => { events.push('views.disposeProjectViews'); }),
@@ -42,6 +44,8 @@ export function makeClosingHarness(closeBehavior) {
     };
     const views = {
         disposeAll: vi.fn(),
+        holdWorkbenchAttach: vi.fn(() => vi.fn()),
+        cancelWorkbenchAttachHold: vi.fn(() => { }),
         disposeProjectViews: vi.fn(),
         detachWorkbench: vi.fn(),
         detachSimulator: vi.fn(),

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

@@ -1,16 +1,10 @@
-import { z } from 'zod';
+import { rejectInvalidAppId, validateProjectDirSafe } from './open-project-guards.js';
 import * as repo from '../projects/project-repository.js';
+import { reportRebuildStatus } from './rebuild-status.js';
 import { DEFAULT_COMPILE_CONFIG } from '../projects/types.js';
 import { clearSimulatorServicewechatReferer, setSimulatorServicewechatReferer, } from '../simulator/referer.js';
 import { loadWorkbenchSettings } from '../settings/index.js';
 import { createOpLock } from './op-lock.js';
-/**
- * Runtime guard for the adapter-return boundary: `session.appInfo` must carry a
- * NON-EMPTY string `appId` (the renderer scopes IPC by it; the bridge's
- * handleSpawn also rejects empty appIds, so accepting `''` would desync layers).
- * Loose: extra fields pass through — only the contract-critical `appId` is enforced.
- */
-const SessionAppInfoSchema = z.looseObject({ appId: z.string().min(1) });
 /** Build a workspace service bound to the given workbench context. */
 export function createWorkspaceService(ctx) {
     let currentSession = null;
@@ -126,15 +120,10 @@ export function createWorkspaceService(ctx) {
                 projectPath,
                 sourcemap: true,
                 fileTypes: ctx.fileTypes,
-                // Two independent gates: autoBuild = recompile on save; autoReload = refresh the simulator afterwards (off ⇒ page/form state survives; hotReload below stays false so the native simulator, which has no SSE reload, isn't refreshed).
+                // Two independent gates: autoBuild = recompile on save; autoReload = reflect the rebuild in the simulator afterwards (off ⇒ page/form state survives). A style-only rebuild takes the in-place stylesheet hot-swap path (see reportRebuildStatus); any other change does a full reload.
                 watch: compile.autoBuild,
                 autoReload: preview.autoReload,
-                onRebuild: () => {
-                    // getProjectPages never throws; empty pages (read failed / degenerate
-                    // project) are withheld so the renderer keeps its previous dropdown.
-                    const { pages } = repo.getProjectPages(projectPath);
-                    sendStatus('ready', preview.autoReload ? '编译完成，已重启' : '编译完成', preview.autoReload, pages.length ? pages : undefined);
-                },
+                onRebuild: info => reportRebuildStatus(info, { projectPath, repo, autoReload: preview.autoReload, refreshSimulatorStyles: ctx.views.refreshSimulatorStyles, sendStatus }),
                 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),
@@ -151,24 +140,6 @@ export function createWorkspaceService(ctx) {
             return { error: String(err) };
         }
     }
-    /**
-     * Adapter-return boundary: a session without a string appId can't be driven by
-     * the renderer, so it must never become active. Close the live resources the
-     * adapter already spun up (best-effort) and return the error message; null when
-     * valid.
-     */
-    async function rejectInvalidAppId(session) {
-        if (SessionAppInfoSchema.safeParse(session.appInfo).success)
-            return null;
-        try {
-            await session.close();
-        }
-        catch (closeErr) {
-            console.warn('[workspace] closing appId-less adapter session failed (non-fatal):', closeErr);
-        }
-        return 'adapter returned session.appInfo without a string appId — '
-            + 'the CompilationAdapter must supply appInfo.appId';
-    }
     function applyRefererFromSession(session) {
         const appInfo = session.appInfo;
         if (appInfo && typeof appInfo.appId === 'string' && appInfo.appId.length > 0) {
@@ -215,7 +186,14 @@ export function createWorkspaceService(ctx) {
             // in-flight one; ownerSeq only grows, so a late-resolving earlier request
             // can't clobber a later one that already took over).
             opLock.takeOwnership(mySeq);
+            // Defer the workbench editor's heavy attach while this open's
+            // boot-critical window (old-session teardown + first compile) runs.
+            // The release is idempotent and bound to this hold, so every exit path
+            // below releases unconditionally; the gate's own cap timer backstops
+            // any future path that forgets to.
+            const releaseWorkbenchHold = ctx.views.holdWorkbenchAttach();
             if (await runOpenTeardown(mySeq)) {
+                releaseWorkbenchHold();
                 return { success: false, error: 'superseded by a newer project open/close' };
             }
             // Reject obviously broken projects up front so we never spin up a
@@ -225,10 +203,9 @@ export function createWorkspaceService(ctx) {
             // `fetch(…).then(r=>r.text()).then(JSON.parse)` pipeline dies on the
             // dev server's HTML SPA fallback with
             // `SyntaxError: Unexpected token '<', "<!doctype "…`.
-            const dirError = provider.validateProjectDir
-                ? await provider.validateProjectDir(projectPath)
-                : null;
+            const dirError = await validateProjectDirSafe(provider, projectPath);
             if (dirError) {
+                releaseWorkbenchHold();
                 sendStatus('error', dirError);
                 return { success: false, error: dirError };
             }
@@ -237,6 +214,9 @@ export function createWorkspaceService(ctx) {
             // generation — runCompile's onLog closure checks it per line.
             const sessionGeneration = ++logGeneration;
             const compiled = await runCompile(projectPath, sessionGeneration);
+            // The compile settling — success OR failure — ends the boot-critical
+            // window (a failed compile is when the user needs the editor most).
+            releaseWorkbenchHold();
             if ('error' in compiled) {
                 sendStatus('error', compiled.error);
                 return { success: false, error: compiled.error };
@@ -286,6 +266,11 @@ export function createWorkspaceService(ctx) {
                 // we meant to close.
                 if (!opLock.isOwner(mySeq))
                     return;
+                // Void any in-flight open's workbench attach hold BEFORE the teardown
+                // awaits below: the superseded open's compile can settle mid-close, and
+                // its release (or the gate's cap) must not rebuild the editor view for
+                // a project that is being closed.
+                ctx.views.cancelWorkbenchAttachHold();
                 // Mark the close in progress BEFORE disposeSession nulls currentSession,
                 // so bridge getters refuse to resolve the dying session during the
                 // session.close() await (cleared in the finally once views are gone).

package/dist/native-host/common/common.js

@@ -12,7 +12,7 @@ function r(e, t) {
 	if (e === t) return !0;
 	if (typeof e != "object" || typeof t != "object" || e == null || t == null) return !1;
 	let n = Object.keys(e), i = Object.keys(t);
-	return n.length === i.length ? n.every((n) => r(e[n], t[n])) : !1;
+	return n.length === i.length && n.every((n) => r(e[n], t[n]));
 }
 function i(e, t) {
 	return Object.prototype.hasOwnProperty.call(e, t);