@dimina-kit/devtools 0.4.0 → 0.5.0-dev.20260908120530

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

@@ -1,27 +1,34 @@
 import type { BrowserWindow } from 'electron';
+import { type RuntimeContext, type RuntimeEvents } from '@dimina-kit/electron-runtime/main/runtime-context';
 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 { InternalDevtoolsWindow } from '../windows/internal-devtools-window/index.js';
+import { type CdpSessionBroker } from './cdp-session/index.js';
 import type { AppDataTap } from './simulator-appdata/index.js';
 import type { StorageApi } from './simulator-storage/index.js';
 import type { SyncStorageChange } from '../../shared/ipc-channels.js';
 import { DisposableRegistry, type ConnectionRegistry } from '@dimina-kit/electron-deck/main';
 import type { SenderPolicy } from '../utils/ipc-registry.js';
+import type { AppServices } from './app-services.js';
 import { type RendererNotifier } from './notifications/renderer-notifier.js';
+import { type CompileLogBuffer } from './workspace/compile-log-buffer.js';
+import { type SessionStatusStore } from './workspace/session-status-store.js';
 import { type ViewManager } from './views/view-manager.js';
 import { type WindowService } from './window-service.js';
 import { type WorkspaceService } from './workspace/workspace-service.js';
 import { type SimulatorApiRegistry } from './simulator/custom-apis.js';
+import { type SimulatorUiExtensionRegistry } from './simulator/ui-extensions.js';
 import { sanitizeTemplates } from './projects/templates.js';
-import type { ProjectsProvider, ProjectTemplate } from './projects/types.js';
-import type { CustomCreateProjectDialogResult } from '../../shared/types.js';
+import type { Project, ProjectsProvider, ProjectTemplate } from './projects/types.js';
+import type { CustomCreateProjectDialogResult, CustomEditProjectDialogResult } from '../../shared/types.js';
 /**
  * Shared mutable state for the workbench application.
  * Passed to each IPC module so they can read/write shared state without closures.
  */
-export interface WorkbenchContext {
+export interface WorkbenchContext extends RuntimeContext {
     adapter: CompilationAdapter;
     /** Absolute path to the preload script loaded into the simulator webview */
     preloadPath: string;
@@ -45,6 +52,18 @@ export interface WorkbenchContext {
     windows: WindowService;
     /** Unified main → renderer event dispatcher */
     notify: RendererNotifier;
+    /**
+     * Authoritative, queryable compile status of the active session. Fed by the
+     * notifier tap (every `notify.projectStatus` is recorded here first), read
+     * by MCP `project_status` / awaited by `project_open` / `project_wait_ready`.
+     */
+    sessionStatus: SessionStatusStore;
+    /**
+     * Cursor-readable ring buffer over the compile log lines. Fed by the
+     * notifier tap (every `notify.compileLog` is appended here first), read
+     * incrementally by MCP `compile_logs`.
+     */
+    compileLogBuffer: CompileLogBuffer;
     /**
      * Open (or re-focus) the standalone workbench-settings window. First-class
      * member so contract holders (`MiniappRuntime` / `MenuContext`) can open
@@ -78,6 +97,17 @@ export interface WorkbenchContext {
         parentWindow: BrowserWindow;
         templates: ProjectTemplate[];
     }) => Promise<CustomCreateProjectDialogResult>;
+    /**
+     * Optional host hook for the "编辑项目" dialog. When present, the
+     * `projects:openEditDialog` IPC runs it and wraps whatever it resolves to
+     * as `{ result }`; when absent, the IPC returns `null` and the renderer
+     * shows the built-in dialog. `project` comes from `workspace.listProjects`,
+     * not the renderer's IPC args.
+     */
+    customEditProjectDialog?: (ctx: {
+        parentWindow: BrowserWindow;
+        project: Project;
+    }) => Promise<CustomEditProjectDialogResult>;
     /**
      * Host permission gate consulted by `workspace.openProject` BEFORE any side
      * effect. Throwing vetoes the open (see `WorkbenchAppConfig.onBeforeOpenProject`).
@@ -91,6 +121,14 @@ export interface WorkbenchContext {
      * lazily so it stays correct as windows/views come and go.
      */
     senderPolicy: SenderPolicy;
+    /**
+     * The subset of `senderPolicy` this context structurally OWNS — its own
+     * window's renderer, its settings window and the overlay views mounted
+     * inside it. Excludes the app-wide trusted-window map, which no single
+     * context can claim. `createWindowContextRouter` uses it to decide which
+     * window a message actually came from.
+     */
+    ownsSender: SenderPolicy;
     /**
      * Reference-counted map of `webContents.id` → live registration count for
      * host-owned BrowserWindows registered as trusted senders via
@@ -99,16 +137,31 @@ export interface WorkbenchContext {
      * single `closed` event, which zeroes the count outright) to un-trust it.
      * Consulted by `createWorkbenchSenderPolicy` in addition to the static
      * main-window / overlay checks.
+     *
+     * Supplied by {@link AppServices} when the caller has one: the host
+     * registers its window against the application, so the same map backs every
+     * context.
      */
     trustedWindowSenderIds: Map<number, number>;
     /**
-     * Per-context registry of host-registered simulator custom APIs. Populated
-     * via `instance.registerSimulatorApi`; read by the simulator IPC handlers.
-     * One registry per context — no process-global crosstalk.
+     * Registry of host-registered simulator custom APIs. Populated via
+     * `instance.registerSimulatorApi`; read by the simulator IPC handlers.
+     *
+     * Supplied by {@link AppServices} when the caller has one, and therefore
+     * registrations are shared across contexts. The invocation facade supplies
+     * THIS window's project path, independently of focus, without changing the
+     * app-owned handlers or their lifetime.
      */
     simulatorApis: SimulatorApiRegistry;
+    /**
+     * Per-context downstream simulator UI extensions. It owns renderer bundle
+     * installation and follows the active native simulator WebContentsView.
+     */
+    simulatorUiExtensions: SimulatorUiExtensionRegistry;
     /** Aggregates dispose handlers for every IPC handler, listener, watcher, and CDP session registered by the workbench. */
     registry: DisposableRegistry;
+    /** Runtime-domain events consumed by optional DevTools panels and renderer notifications. */
+    events: RuntimeEvents;
     /**
      * Per-webContents connection registry. Each trusted webContents (main window,
      * overlay views, native simulator/render guests) is one `Connection` that
@@ -119,6 +172,14 @@ export interface WorkbenchContext {
      * `own()`-ing their per-endpoint resources and observing `reset`/`closed`.
      */
     connections: ConnectionRegistry;
+    /**
+     * Single owner of every render-guest `wc.debugger` (CDP) session: safe-area,
+     * elements-forward, render-inspect and network-forward all `acquire()` a
+     * lease from this instead of each hand-rolling their own attach/reuse/detach
+     * bookkeeping (see cdp-session/index.ts's design doc for why that duplication
+     * was a real bug, not just repetition).
+     */
+    cdpSessionBroker: CdpSessionBroker;
     /**
      * Accessor over the bridge-router's private state, set by `installBridgeRouter`.
      * Lets other main services (simulator-storage, automation, appdata) resolve
@@ -188,6 +249,15 @@ export interface WorkbenchContext {
      * DevTools host exist. Undefined until bootstrap wires it.
      */
     networkForward?: NetworkForwarder;
+    /**
+     * Controller for the standalone internal (app-wide) DevTools debug window
+     * — the independent floating CDP panel that debugs the whole Electron app
+     * (as opposed to the right-panel CDP, which inspects only the user's
+     * mini-program). Assembled in app bootstrap via
+     * `createInternalDevtoolsWindow(mainWindow)`; undefined only in contexts
+     * that skip that wiring (e.g. narrow test doubles).
+     */
+    internalDevtoolsWindow?: InternalDevtoolsWindow;
 }
 /**
  * Inputs for `createWorkbenchContext`. The scalar config fields it shares with
@@ -197,13 +267,21 @@ export interface WorkbenchContext {
  * because their shapes intentionally differ from the config:
  *  - `preloadPath` / `rendererDir` are REQUIRED here (the caller resolves the
  *    defaults before constructing the context) but optional in the config;
- *  - `projectsProvider` / `projectTemplates` / `customCreateProjectDialog` use
- *    the main-process types, not the structural mirrors in `shared/types`.
+ *  - `projectsProvider` / `projectTemplates` / `customCreateProjectDialog` /
+ *    `customEditProjectDialog` use the main-process types, not the structural
+ *    mirrors in `shared/types`.
  */
 export interface CreateContextOptions extends Pick<WorkbenchConfig, 'adapter' | 'apiNamespaces' | 'appName' | 'fileTypes'> {
     mainWindow: BrowserWindow;
     preloadPath: string;
     rendererDir: string;
+    /**
+     * Services owned by the application rather than by this window. When
+     * present their instances are adopted instead of constructing per-context
+     * ones, so every window shares the host's single registration. Optional so
+     * focused unit tests can still build a stand-alone context.
+     */
+    appServices?: AppServices;
     brandingProvider?: WorkbenchContext['brandingProvider'];
     /** Host-supplied project list backend. Defaults to LocalProjectsProvider. */
     projectsProvider?: ProjectsProvider;
@@ -213,6 +291,8 @@ export interface CreateContextOptions extends Pick<WorkbenchConfig, 'adapter' |
     builtinTemplates?: 'all' | 'none' | readonly string[];
     /** Host-supplied "新建项目" dialog hook. */
     customCreateProjectDialog?: WorkbenchContext['customCreateProjectDialog'];
+    /** Host-supplied "编辑项目" dialog hook. */
+    customEditProjectDialog?: WorkbenchContext['customEditProjectDialog'];
     /** Host permission gate run before a project opens (throw to veto). */
     onBeforeOpenProject?: WorkbenchContext['onBeforeOpenProject'];
 }

package/dist/main/services/workbench-context.js

@@ -1,18 +1,26 @@
+import { createRuntimeEvents, } from '@dimina-kit/electron-runtime/main/runtime-context';
+import { createCdpSessionBroker } from './cdp-session/index.js';
 import { createConnectionRegistry, DisposableRegistry, } from '@dimina-kit/electron-deck/main';
-import { createWorkbenchSenderPolicy } from '../utils/sender-policy.js';
+import { createWorkbenchOwnedSenderCheck, createWorkbenchSenderPolicy, } from '../utils/sender-policy.js';
 import { defaultAdapter } from './default-adapter.js';
 import { createRendererNotifier, } from './notifications/renderer-notifier.js';
+import { createCompileLogBuffer, } from './workspace/compile-log-buffer.js';
+import { createSessionStatusStore, } from './workspace/session-status-store.js';
+import { tapNotifierIntoStores } from './workspace/status-tap.js';
 import { createViewManager } from './views/view-manager.js';
 import { createWindowService } from './window-service.js';
 import { openSettingsWindow } from '../windows/settings-window/index.js';
 import { createWorkspaceService, } from './workspace/workspace-service.js';
 import { createLocalProjectsProvider } from './projects/local-provider.js';
 import { createSimulatorApiRegistry, } from './simulator/custom-apis.js';
+import { createSimulatorUiExtensionRegistry, } from './simulator/ui-extensions.js';
 import { resolveTemplates, sanitizeTemplates } from './projects/templates.js';
 import { BUILTIN_TEMPLATES } from './projects/builtin-templates.js';
+import { runtimeAssetPaths } from '../utils/paths.js';
 export function createWorkbenchContext(opts) {
     const ctx = {
         adapter: opts.adapter ?? defaultAdapter,
+        assets: runtimeAssetPaths,
         preloadPath: opts.preloadPath,
         rendererDir: opts.rendererDir,
         apiNamespaces: opts.apiNamespaces ?? [],
@@ -21,25 +29,65 @@ export function createWorkbenchContext(opts) {
         brandingProvider: opts.brandingProvider,
     };
     ctx.registry = new DisposableRegistry();
+    ctx.events = createRuntimeEvents();
+    ctx.registry.add(ctx.events.on('session-status', (payload) => {
+        ctx.notify?.sessionRuntimeStatus(payload);
+    }));
+    ctx.registry.add(ctx.events.on('app-data-evict', ({ appId, bridgeId }) => {
+        ctx.appData?.evictBridge(appId, bridgeId);
+    }));
+    ctx.registry.add(ctx.events.on('app-data-message', ({ appId, message }) => {
+        ctx.appData?.onServiceToRender(appId, message);
+    }));
+    ctx.registry.add(ctx.events.on('storage-changed', ({ appId, change }) => {
+        ctx.onServiceStorageChanged?.(appId, change);
+    }));
+    ctx.registry.add(() => ctx.events.clear());
     // Empty connection registry as a first-class context field. Connections are
     // acquired by real wiring points (app bootstrap, view-manager endpoints),
     // NOT here — the constructor stays side-effect-free so focused unit tests can
     // build a context with a minimal mainWindow fake.
     ctx.connections = createConnectionRegistry();
-    ctx.trustedWindowSenderIds = new Map();
-    ctx.simulatorApis = createSimulatorApiRegistry();
+    ctx.cdpSessionBroker = createCdpSessionBroker({ connections: ctx.connections });
+    ctx.registry.add(() => ctx.cdpSessionBroker.dispose());
+    ctx.trustedWindowSenderIds =
+        opts.appServices?.trustedWindowSenderIds ?? new Map();
+    const simulatorApis = opts.appServices?.simulatorApis ?? createSimulatorApiRegistry();
+    ctx.simulatorApis = {
+        ...simulatorApis,
+        invoke: (name, params) => simulatorApis.invoke(name, params, {
+            projectPath: ctx.workspace.hasActiveSession() ? ctx.workspace.getProjectPath() : null,
+        }),
+    };
+    ctx.simulatorUiExtensions = createSimulatorUiExtensionRegistry();
+    ctx.registry.add(() => ctx.simulatorUiExtensions.clear());
     ctx.windows = createWindowService(opts.mainWindow);
     ctx.views = createViewManager(ctx);
-    ctx.notify = createRendererNotifier(ctx);
+    // Full view teardown belongs to the CONTEXT's life, not a project's:
+    // closeProject only disposes project-scoped views, so this registration is
+    // the one place that releases the HOST-scoped toolbar (its view and the
+    // ref-counted session-runtime preload) when the app/context winds down.
+    ctx.registry.add(() => ctx.views.disposeAll());
+    ctx.sessionStatus = createSessionStatusStore();
+    ctx.compileLogBuffer = createCompileLogBuffer();
+    // Tap the notify gate: the two compile-state pushes land in the
+    // main-process authorities above BEFORE the renderer broadcast, so MCP
+    // reads and the renderer view derive from the same single site.
+    ctx.notify = tapNotifierIntoStores(createRendererNotifier(ctx), ctx.sessionStatus, ctx.compileLogBuffer);
     // Lazy closure (not a bound snapshot): reads ctx.windows/notify/rendererDir
     // at call time through the live context, which structurally satisfies the
     // helper's narrow OpenSettingsWindowDeps.
     ctx.openSettings = () => openSettingsWindow(ctx);
-    ctx.projectsProvider = opts.projectsProvider ?? createLocalProjectsProvider();
-    ctx.projectTemplates = resolveTemplates(BUILTIN_TEMPLATES, opts.projectTemplates ?? [], opts.builtinTemplates ?? 'all');
+    ctx.projectsProvider =
+        opts.appServices?.projectsProvider ?? opts.projectsProvider ?? createLocalProjectsProvider();
+    ctx.projectTemplates =
+        opts.appServices?.projectTemplates ??
+            resolveTemplates(BUILTIN_TEMPLATES, opts.projectTemplates ?? [], opts.builtinTemplates ?? 'all');
     ctx.customCreateProjectDialog = opts.customCreateProjectDialog;
+    ctx.customEditProjectDialog = opts.customEditProjectDialog;
     ctx.onBeforeOpenProject = opts.onBeforeOpenProject;
     ctx.workspace = createWorkspaceService(ctx);
+    ctx.ownsSender = createWorkbenchOwnedSenderCheck(ctx);
     ctx.senderPolicy = createWorkbenchSenderPolicy(ctx);
     return ctx;
 }

package/dist/main/services/workspace/compile-log-buffer.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Ring buffer over the per-line dmcc compile log, readable by cursor.
+ *
+ * The renderer gets each line pushed (`notify.compileLog`); MCP clients pull
+ * incrementally instead: pass the previous read's `nextCursor` to receive
+ * only lines that arrived since. `seq` is monotonic for the buffer's whole
+ * lifetime — `clear()` (a fresh project open) drops the entries but never
+ * resets the counter, so a stale cursor from before the clear simply reads
+ * the new compile's lines instead of duplicating old ones.
+ */
+export interface CompileLogRecord {
+    /** Monotonic id (1-based); never reused, survives clear(). */
+    seq: number;
+    /** Main-process capture time of the line. */
+    at: number;
+    stream: 'stdout' | 'stderr';
+    text: string;
+}
+export interface CompileLogRead {
+    /** Oldest-first entries with seq > afterSeq (post stream-filter), capped at limit. */
+    entries: CompileLogRecord[];
+    /** Pass back as the next read's afterSeq; unchanged when nothing new matched. */
+    nextCursor: number;
+}
+export interface CompileLogBuffer {
+    append(entry: {
+        at: number;
+        stream: 'stdout' | 'stderr';
+        text: string;
+    }): void;
+    read(opts?: {
+        afterSeq?: number;
+        limit?: number;
+        stream?: 'stdout' | 'stderr';
+    }): CompileLogRead;
+    /** Drop all entries (fresh compile timeline); seq keeps growing. */
+    clear(): void;
+}
+export declare function createCompileLogBuffer(capacity?: number): CompileLogBuffer;
+//# sourceMappingURL=compile-log-buffer.d.ts.map

package/dist/main/services/workspace/compile-log-buffer.js

@@ -0,0 +1,41 @@
+/**
+ * Ring buffer over the per-line dmcc compile log, readable by cursor.
+ *
+ * The renderer gets each line pushed (`notify.compileLog`); MCP clients pull
+ * incrementally instead: pass the previous read's `nextCursor` to receive
+ * only lines that arrived since. `seq` is monotonic for the buffer's whole
+ * lifetime — `clear()` (a fresh project open) drops the entries but never
+ * resets the counter, so a stale cursor from before the clear simply reads
+ * the new compile's lines instead of duplicating old ones.
+ */
+const DEFAULT_CAPACITY = 1000;
+const DEFAULT_READ_LIMIT = 100;
+export function createCompileLogBuffer(capacity = DEFAULT_CAPACITY) {
+    const entries = [];
+    let seq = 0;
+    return {
+        append(entry) {
+            entries.push({ seq: ++seq, ...entry });
+            if (entries.length > capacity)
+                entries.splice(0, entries.length - capacity);
+        },
+        read({ afterSeq = 0, limit = DEFAULT_READ_LIMIT, stream } = {}) {
+            const matched = [];
+            for (const entry of entries) {
+                if (entry.seq <= afterSeq)
+                    continue;
+                if (stream && entry.stream !== stream)
+                    continue;
+                matched.push(entry);
+                if (matched.length >= limit)
+                    break;
+            }
+            const last = matched[matched.length - 1];
+            return { entries: matched, nextCursor: last ? last.seq : afterSeq };
+        },
+        clear() {
+            entries.length = 0;
+        },
+    };
+}
+//# sourceMappingURL=compile-log-buffer.js.map

package/dist/main/services/workspace/compile-mode-adapter.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Adapts the compile-mode half of `ProjectsProvider` — where every method is
+ * optional — onto the four methods `WorkspaceService` always exposes.
+ *
+ * A host may implement the mode list, only the older single-config pair, or
+ * neither. Each direction degrades on its own so a partial host still gets the
+ * behavior it can support instead of an exception.
+ */
+import type { CompileConfig, CompileModes } from '../../../shared/types.js';
+import type { ProjectsProvider } from '../projects/types.js';
+export interface CompileModeAdapter {
+    getCompileConfig(projectPath: string): Promise<CompileConfig>;
+    saveCompileConfig(projectPath: string, config: CompileConfig): Promise<void>;
+    getCompileModes(projectPath: string): Promise<CompileModes>;
+    saveCompileModes(projectPath: string, modes: CompileModes): Promise<void>;
+}
+export declare function createCompileModeAdapter(provider: ProjectsProvider): CompileModeAdapter;
+//# sourceMappingURL=compile-mode-adapter.d.ts.map

package/dist/main/services/workspace/compile-mode-adapter.js

@@ -0,0 +1,57 @@
+/**
+ * Adapts the compile-mode half of `ProjectsProvider` — where every method is
+ * optional — onto the four methods `WorkspaceService` always exposes.
+ *
+ * A host may implement the mode list, only the older single-config pair, or
+ * neither. Each direction degrades on its own so a partial host still gets the
+ * behavior it can support instead of an exception.
+ */
+import { compileConfigToModes, emptyCompileModes, resolveCompileConfig, } from '../../../shared/compile-modes.js';
+import { DEFAULT_COMPILE_CONFIG } from '../projects/types.js';
+export function createCompileModeAdapter(provider) {
+    return {
+        // Prefer the host's own resolver: only it can substitute the project's
+        // entry page for 普通编译's empty start page. Deriving from the mode list
+        // is the fallback for hosts that implement modes but not this.
+        async getCompileConfig(projectPath) {
+            if (provider.getCompileConfig) {
+                return (await provider.getCompileConfig(projectPath));
+            }
+            if (provider.getCompileModes) {
+                return resolveCompileConfig(await provider.getCompileModes(projectPath));
+            }
+            return DEFAULT_COMPILE_CONFIG;
+        },
+        async saveCompileConfig(projectPath, config) {
+            if (provider.saveCompileConfig) {
+                await provider.saveCompileConfig(projectPath, config);
+            }
+            // No persistence when the host opts out; the renderer's edits then
+            // do not survive a reload, matching the documented contract.
+        },
+        // Mirror of saveCompileModes' degradation: a host still on the single
+        // config gets it projected into one selected mode, so its start page and
+        // params actually launch instead of being read as 普通编译 and dropped.
+        async getCompileModes(projectPath) {
+            if (provider.getCompileModes) {
+                return await provider.getCompileModes(projectPath);
+            }
+            if (provider.getCompileConfig) {
+                return compileConfigToModes((await provider.getCompileConfig(projectPath)));
+            }
+            return emptyCompileModes();
+        },
+        async saveCompileModes(projectPath, modes) {
+            if (provider.saveCompileModes) {
+                await provider.saveCompileModes(projectPath, modes);
+                return;
+            }
+            // Degrade for a host still on the single-config setter: the selection
+            // still takes effect, it just cannot store the named list.
+            if (provider.saveCompileConfig) {
+                await provider.saveCompileConfig(projectPath, resolveCompileConfig(modes));
+            }
+        },
+    };
+}
+//# sourceMappingURL=compile-mode-adapter.js.map

package/dist/main/services/workspace/compile-mode-store.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Single owner of one open project's compile modes: the only thing allowed
+ * to read/write the persisted file and to advance the in-memory snapshot.
+ * `apply()` calls are serialized through a queue so two commands issued
+ * back-to-back never interleave their persists, and persist-before-adopt
+ * means a write that fails on disk is never visible in `get()` or broadcast
+ * to `onChange` listeners — memory never runs ahead of what's on disk.
+ */
+import { type CompileModeChange, type CompileModeCommand, type CompileModeSnapshot, type MintId } from '../../../shared/compile-mode-state.js';
+import type { CompileModes } from '../../../shared/types.js';
+export type { CompileModeChange, CompileModeSnapshot };
+export interface CompileModeStore {
+    readonly projectPath: string;
+    get(): CompileModeSnapshot;
+    apply(command: CompileModeCommand): Promise<CompileModeChange>;
+    onChange(listener: (change: CompileModeChange) => void): () => void;
+    dispose(): void;
+}
+export declare function openCompileModeStore(input: {
+    projectPath: string;
+    load(): Promise<unknown>;
+    persist(stored: CompileModes): Promise<void>;
+    mintId?: MintId;
+}): Promise<CompileModeStore>;
+//# sourceMappingURL=compile-mode-store.d.ts.map

package/dist/main/services/workspace/compile-mode-store.js

@@ -0,0 +1,71 @@
+/**
+ * Single owner of one open project's compile modes: the only thing allowed
+ * to read/write the persisted file and to advance the in-memory snapshot.
+ * `apply()` calls are serialized through a queue so two commands issued
+ * back-to-back never interleave their persists, and persist-before-adopt
+ * means a write that fails on disk is never visible in `get()` or broadcast
+ * to `onChange` listeners — memory never runs ahead of what's on disk.
+ */
+import { applyCompileModeCommand, stateFromStored, storedFromState, } from '../../../shared/compile-mode-state.js';
+let nextIdCounter = 0;
+function defaultMintId() {
+    nextIdCounter += 1;
+    return `compile-mode-${nextIdCounter}`;
+}
+export async function openCompileModeStore(input) {
+    const mintId = input.mintId ?? defaultMintId;
+    const raw = await input.load();
+    let revision = 0;
+    let state = stateFromStored(raw, mintId);
+    let disposed = false;
+    const listeners = new Set();
+    // Serializes apply() calls: each call chains onto this promise so the next
+    // command's persist only starts after the previous one has fully settled.
+    let queue = Promise.resolve();
+    function get() {
+        return { revision, state };
+    }
+    // Not `async` on purpose: an async function wrapping a returned promise
+    // adds an extra microtask hop before a caller's `.then` fires, which is
+    // enough to let the queue's OWN downstream continuation (chaining the next
+    // apply()) run ahead of a caller that is racing to inspect order — this
+    // function must return `run` itself so a caller's `.then` is attached
+    // directly to it, same as the queue's internal continuation.
+    function apply(command) {
+        if (disposed) {
+            return Promise.reject(new Error('compile-mode store disposed'));
+        }
+        const run = queue.then(() => runApply(command));
+        // Keep the queue alive even if this command rejects, so a later apply()
+        // still runs instead of being stuck behind a broken link forever.
+        queue = run.then(() => undefined, () => undefined);
+        return run;
+    }
+    async function runApply(command) {
+        if (disposed) {
+            throw new Error('compile-mode store disposed');
+        }
+        const result = applyCompileModeCommand(state, command, mintId);
+        if (result.state === state) {
+            // No-op: nothing to persist or broadcast.
+            return { revision, state, relaunch: false };
+        }
+        await input.persist(storedFromState(result.state));
+        state = result.state;
+        revision += 1;
+        const change = { revision, state, relaunch: result.relaunch };
+        for (const listener of listeners)
+            listener(change);
+        return change;
+    }
+    function onChange(listener) {
+        listeners.add(listener);
+        return () => listeners.delete(listener);
+    }
+    function dispose() {
+        disposed = true;
+        listeners.clear();
+    }
+    return { projectPath: input.projectPath, get, apply, onChange, dispose };
+}
+//# sourceMappingURL=compile-mode-store.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,37 @@
+/**
+ * Decide and emit the post-rebuild status for one completed rebuild.
+ *
+ * Explicit rebuild (`info.explicit` — the 重新编译 button, via
+ * `session.rebuild()`): the renderer's own relaunch drives a hard re-attach
+ * once the rebuild IPC resolves, and that re-attach is the run's ONLY
+ * reflection. Emitting `hotReload: true` here as well would race a soft
+ * reload against it — the two arrive through different channels with no
+ * ordering guarantee, so the soft reload can land AFTER the hard re-attach
+ * and drag the simulator back to the drifted page. The style fast path is a
+ * soft-update path too and is skipped for the same reason.
+ *
+ * Watcher rebuild (explicit absent/false) — style-only 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;
+    explicit?: 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