@dimina-kit/devtools 0.4.0-dev.20260828161241 → 0.4.0-dev.20260907055341

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/workspace-compile-modes.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Wires a `CompileModeStore` into `WorkspaceService` for whichever project is
+ * currently open. Extracted out of workspace-service.ts to keep that file
+ * under the repo's file-length ratchet — this is the sole owner of the
+ * store's lifecycle (open/replace/dispose); `WorkspaceService` only forwards
+ * to it.
+ */
+import { type CompileModeCommand } from '../../../shared/compile-mode-state.js';
+import type { CompileConfig } from '../../../shared/types.js';
+import type { ProjectsProvider } from '../projects/types.js';
+import { type CompileModeChange, type CompileModeSnapshot, type CompileModeStore } from './compile-mode-store.js';
+export interface CompileModeManager {
+    /**
+     * Creates and returns a store for `projectPath` as a standalone handle —
+     * it does NOT touch the current store or subscribe to `onChange`. The
+     * caller owns the handle until it either passes it to `adopt` or disposes
+     * it itself (e.g. because the open it belongs to was superseded).
+     */
+    open(projectPath: string): Promise<CompileModeStore>;
+    /**
+     * Makes `store` the current one: disposes whatever was current (and its
+     * subscription) first, then wires `store` up. The current store must only
+     * ever change here, alongside the session it belongs to — never as a side
+     * effect of merely opening one.
+     */
+    adopt(store: CompileModeStore): void;
+    /** Disposes the current store, if any. Safe to call when none is open. */
+    disposeCurrent(): void;
+    /**
+     * `projectPath` omitted returns the currently open project's snapshot
+     * (for callers, like the popover, that don't track a project path of
+     * their own); given, it must match the open store's project or this
+     * throws — a caller that DOES know the path never silently reads another
+     * project's modes.
+     */
+    getCompileModeState(projectPath?: string): CompileModeSnapshot;
+    applyCompileModeCommand(command: CompileModeCommand): Promise<CompileModeChange>;
+    getCompileConfig(projectPath: string): Promise<CompileConfig>;
+    /** Untouched by the store redesign — a direct provider passthrough. */
+    saveCompileConfig(projectPath: string, config: CompileConfig): Promise<void>;
+}
+export declare function createCompileModeManager(provider: ProjectsProvider, onChange: (change: CompileModeChange) => void): CompileModeManager;
+/**
+ * Opens a store handle for `projectPath` right after a compile succeeds,
+ * WITHOUT making it current — the caller decides whether to `adopt` it once
+ * it has confirmed (under the op lock) that its open is still the latest
+ * one; a superseded open disposes the handle itself instead. On failure,
+ * closes `session` (best-effort) and returns the error message. A session
+ * that compiled but whose store failed to open must not be left running, so
+ * this centralizes that cleanup for callers.
+ */
+export declare function openCompileModeStoreAfterCompile(manager: CompileModeManager, projectPath: string, session: {
+    close(): Promise<void>;
+}): Promise<{
+    store: CompileModeStore;
+} | {
+    error: string;
+}>;
+//# sourceMappingURL=workspace-compile-modes.d.ts.map

package/dist/main/services/workspace/workspace-compile-modes.js

@@ -0,0 +1,93 @@
+/**
+ * Wires a `CompileModeStore` into `WorkspaceService` for whichever project is
+ * currently open. Extracted out of workspace-service.ts to keep that file
+ * under the repo's file-length ratchet — this is the sole owner of the
+ * store's lifecycle (open/replace/dispose); `WorkspaceService` only forwards
+ * to it.
+ */
+import { selectedMode } from '../../../shared/compile-mode-state.js';
+import { compileConfigFromMode } from '../../../shared/compile-modes.js';
+import * as repo from '../projects/project-repository.js';
+import { createCompileModeAdapter } from './compile-mode-adapter.js';
+import { openCompileModeStore, } from './compile-mode-store.js';
+export function createCompileModeManager(provider, onChange) {
+    const adapter = createCompileModeAdapter(provider);
+    let store = null;
+    let unsubscribe = null;
+    function disposeCurrent() {
+        unsubscribe?.();
+        unsubscribe = null;
+        store?.dispose();
+        store = null;
+    }
+    async function open(projectPath) {
+        return openCompileModeStore({
+            projectPath,
+            load: () => adapter.getCompileModes(projectPath),
+            persist: (stored) => adapter.saveCompileModes(projectPath, stored),
+        });
+    }
+    function adopt(handle) {
+        disposeCurrent();
+        store = handle;
+        unsubscribe = handle.onChange(onChange);
+    }
+    function getCompileModeState(projectPath) {
+        if (!store || (projectPath !== undefined && projectPath !== store.projectPath)) {
+            throw new Error(`no compile-mode store open for ${projectPath ?? ''}`);
+        }
+        return store.get();
+    }
+    function applyCompileModeCommand(command) {
+        if (!store)
+            return Promise.reject(new Error('no compile-mode store open'));
+        return store.apply(command);
+    }
+    // Mirrors project-repository.ts's own getCompileConfig: 普通编译 (and any
+    // selected mode that left its start page blank) resolves to an empty
+    // startPage, filled in here with the project's real entry page rather than
+    // a mini-program-only literal.
+    async function getCompileConfig(projectPath) {
+        if (store && store.projectPath === projectPath) {
+            const config = compileConfigFromMode(selectedMode(store.get().state));
+            if (config.startPage)
+                return config;
+            return { ...config, startPage: repo.getProjectPages(projectPath).entryPagePath };
+        }
+        return adapter.getCompileConfig(projectPath);
+    }
+    return {
+        open,
+        adopt,
+        disposeCurrent,
+        getCompileModeState,
+        applyCompileModeCommand,
+        getCompileConfig,
+        saveCompileConfig: adapter.saveCompileConfig,
+    };
+}
+/**
+ * Opens a store handle for `projectPath` right after a compile succeeds,
+ * WITHOUT making it current — the caller decides whether to `adopt` it once
+ * it has confirmed (under the op lock) that its open is still the latest
+ * one; a superseded open disposes the handle itself instead. On failure,
+ * closes `session` (best-effort) and returns the error message. A session
+ * that compiled but whose store failed to open must not be left running, so
+ * this centralizes that cleanup for callers.
+ */
+export async function openCompileModeStoreAfterCompile(manager, projectPath, session) {
+    try {
+        const store = await manager.open(projectPath);
+        return { store };
+    }
+    catch (err) {
+        try {
+            await session.close();
+        }
+        catch (closeErr) {
+            console.warn('[workspace] closing session after compile-mode store open failure (non-fatal):', closeErr);
+        }
+        return { error: err instanceof Error ? err.message : String(err) };
+    }
+}
+//# sourceMappingURL=workspace-compile-modes.js.map

package/dist/main/services/workspace/workspace-referer.d.ts

@@ -0,0 +1,17 @@
+import type { ProjectSession } from '../../../shared/types.js';
+/**
+ * The forced `servicewechat.com` Referer is stored per project partition, so
+ * every workspace call must name the project it is acting for. Both helpers
+ * therefore take the session and project path explicitly: a workspace that
+ * reached for its own mutable `currentSession` after resetting it would clear
+ * nothing, and one that passed no project at all would be asking to wipe a
+ * partition that belongs to whichever project happens to be open elsewhere.
+ */
+/** Forces this project's Referer. No-op for a session without a usable appId. */
+export declare function applyRefererForSession(session: ProjectSession, projectPath: string): void;
+/**
+ * Clears only this project's own entry. Call BEFORE the caller resets its
+ * session/path state, otherwise there is no partition left to name.
+ */
+export declare function clearRefererForSession(session: ProjectSession | null, projectPath: string): void;
+//# sourceMappingURL=workspace-referer.d.ts.map

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

@@ -0,0 +1,26 @@
+import { clearSimulatorServicewechatReferer, setSimulatorServicewechatReferer, } from '../simulator/referer.js';
+/**
+ * The forced `servicewechat.com` Referer is stored per project partition, so
+ * every workspace call must name the project it is acting for. Both helpers
+ * therefore take the session and project path explicitly: a workspace that
+ * reached for its own mutable `currentSession` after resetting it would clear
+ * nothing, and one that passed no project at all would be asking to wipe a
+ * partition that belongs to whichever project happens to be open elsewhere.
+ */
+/** Forces this project's Referer. No-op for a session without a usable appId. */
+export function applyRefererForSession(session, projectPath) {
+    const appInfo = session.appInfo;
+    if (!appInfo || typeof appInfo.appId !== 'string' || appInfo.appId.length === 0)
+        return;
+    setSimulatorServicewechatReferer(appInfo.appId, typeof appInfo.version === 'string' ? appInfo.version : undefined, projectPath);
+}
+/**
+ * Clears only this project's own entry. Call BEFORE the caller resets its
+ * session/path state, otherwise there is no partition left to name.
+ */
+export function clearRefererForSession(session, projectPath) {
+    if (!session)
+        return;
+    clearSimulatorServicewechatReferer(session.appInfo.appId, projectPath);
+}
+//# sourceMappingURL=workspace-referer.js.map

package/dist/main/services/workspace/workspace-service.d.ts

@@ -1,4 +1,6 @@
 import type { AppInfo, CompileConfig, ProjectSession } from '../../../shared/types.js';
+import type { CompileModeCommand } from '../../../shared/compile-mode-state.js';
+import type { CompileModeChange, CompileModeSnapshot } from './compile-mode-store.js';
 import type { WorkbenchContext } from '../workbench-context.js';
 import type { Project, ProjectPages, ProjectSettings } from '../projects/project-repository.js';
 import type { ProjectPatch } from '../projects/types.js';
@@ -57,6 +59,8 @@ export interface WorkspaceService {
     getProjectPages(projectPath: string): ProjectPages;
     getCompileConfig(projectPath: string): Promise<CompileConfig>;
     saveCompileConfig(projectPath: string, config: CompileConfig): Promise<void>;
+    getCompileModeState(projectPath?: string): CompileModeSnapshot;
+    applyCompileModeCommand(command: CompileModeCommand): Promise<CompileModeChange>;
     getProjectSettings(projectPath: string): ProjectSettings;
     updateProjectSettings(projectPath: string, patch: Partial<ProjectSettings>): void;
 }

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

@@ -1,10 +1,11 @@
+import { createCompileModeManager, openCompileModeStoreAfterCompile } from './workspace-compile-modes.js';
 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 { applyRefererForSession, clearRefererForSession } from './workspace-referer.js';
 import { loadWorkbenchSettings } from '../settings/index.js';
 import { createOpLock } from './op-lock.js';
+import { createThumbnailOps } from './workspace-thumbnails.js';
 /** Build a workspace service bound to the given workbench context. */
 export function createWorkspaceService(ctx) {
     let currentSession = null;
@@ -69,7 +70,7 @@ export function createWorkspaceService(ctx) {
         try {
             if (!opLock.isOwner(mySeq))
                 return true;
-            clearSimulatorServicewechatReferer();
+            clearRefererForSession(currentSession, currentProjectPath);
             // Switching projects tears down the embedded workbench editor (mirrors one
             // project's disk; saves would else hit the wrong project) AND the native
             // simulator (its 'destroyed' hook owns the bridge session). Back-to-list
@@ -81,6 +82,8 @@ export function createWorkspaceService(ctx) {
             // Invalidate the outgoing onLog generation before teardown so the dying
             // worker's buffered lines can't pollute the incoming compile timeline.
             logGeneration++;
+            // Dies with the outgoing session — no-op when none is open.
+            compileModes.disposeCurrent();
             await disposeSession();
             currentProjectPath = '';
             lastClosedProjectPath = '';
@@ -91,17 +94,22 @@ export function createWorkspaceService(ctx) {
         }
     }
     /**
-     * openProject critical section 2 — commit the new session under the lock, only
-     * if still the latest request. Returns false when superseded (caller discards
-     * the freshly-opened session instead of clobbering the newer one).
+     * openProject critical section 2 — commit the new session (and its
+     * compile-mode store handle) under the lock, only if still the latest
+     * request. Returns false when superseded (caller discards the
+     * freshly-opened session and store instead of clobbering the newer
+     * request's). `compileModes.adopt` must only run here, alongside
+     * `currentSession`/`currentProjectPath`, so the "current store" and
+     * "current session" always switch together.
      */
-    async function runOpenCommit(mySeq, session, projectPath) {
+    async function runOpenCommit(mySeq, session, projectPath, store) {
         const release = await opLock.acquire();
         try {
             if (!opLock.isOwner(mySeq))
                 return false;
             currentSession = session;
             currentProjectPath = projectPath;
+            compileModes.adopt(store);
             return true;
         }
         finally {
@@ -136,22 +144,26 @@ export function createWorkspaceService(ctx) {
             return { session };
         }
         catch (err) {
-            clearSimulatorServicewechatReferer();
+            // No appId resolved for this attempt; the outgoing project's own entry
+            // was already cleared by runOpenTeardown, so there is nothing to clear.
             return { error: String(err) };
         }
     }
-    function applyRefererFromSession(session) {
-        const appInfo = session.appInfo;
-        if (appInfo && typeof appInfo.appId === 'string' && appInfo.appId.length > 0) {
-            setSimulatorServicewechatReferer(appInfo.appId, typeof appInfo.version === 'string' ? appInfo.version : undefined);
-        }
-    }
     // Delegate to the host-injected (or default LocalProjectsProvider)
     // ProjectsProvider on the context. When the host omits an optional method,
     // we apply a safe documented default — never silently fall back to
     // `repo.*`, because a remote provider's project paths are not on the local
     // filesystem.
     const provider = ctx.projectsProvider;
+    // Owner of whichever project's compile modes are currently open; disposed/
+    // replaced alongside the session (teardown, openProject failures, close).
+    const compileModes = createCompileModeManager(provider, (change) => ctx.notify.compileModesChanged(change));
+    const thumbnails = createThumbnailOps({
+        ctx,
+        provider,
+        getSession: () => currentSession,
+        getProjectPath: () => currentProjectPath,
+    });
     return {
         listProjects: async () => provider.listProjects(),
         addProject: async (dirPath) => provider.addProject(dirPath),
@@ -236,15 +248,27 @@ export function createWorkspaceService(ctx) {
                 return { success: false, error: compiled.error };
             }
             const session = compiled.session;
+            // Opened right after compile as a standalone handle — not yet current;
+            // every failure branch below disposes THIS handle, never the current
+            // store, since this open may no longer own "current" by the time it
+            // gets here.
+            const opened = await openCompileModeStoreAfterCompile(compileModes, projectPath, session);
+            if ('error' in opened) {
+                sendStatus('error', opened.error);
+                return { success: false, error: opened.error };
+            }
+            const store = opened.store;
             const appIdError = await rejectInvalidAppId(session);
             if (appIdError) {
+                store.dispose();
                 sendStatus('error', appIdError);
                 return { success: false, error: appIdError };
             }
-            if (!(await runOpenCommit(mySeq, session, projectPath))) {
-                // Superseded during the compile above — discard the freshly-opened
-                // session (close its live compile/dev-server) rather than clobber the
-                // newer request.
+            if (!(await runOpenCommit(mySeq, session, projectPath, store))) {
+                // Superseded — discard the freshly-opened session and its own store
+                // handle rather than clobber the newer request's (already-adopted)
+                // current store.
+                store.dispose();
                 try {
                     await session.close();
                 }
@@ -258,7 +282,7 @@ export function createWorkspaceService(ctx) {
                     provider.updateLastOpened(projectPath);
             });
             bestEffort('sendStatus', () => sendStatus('ready', '编译完成'));
-            bestEffort('applyReferer', () => applyRefererFromSession(session));
+            bestEffort('applyReferer', () => applyRefererForSession(session, projectPath));
             return {
                 success: true,
                 port: session.port,
@@ -292,7 +316,8 @@ export function createWorkspaceService(ctx) {
                 // Invalidate the active session's onLog BEFORE teardown starts — lines
                 // flushed by the dying compile worker must not reach the panel.
                 logGeneration++;
-                clearSimulatorServicewechatReferer();
+                compileModes.disposeCurrent(); // dies with the session
+                clearRefererForSession(currentSession, currentProjectPath);
                 await disposeSession();
                 // Record the root being torn down BEFORE clearing it, so a teardown/
                 // debounced write already in flight can still be accepted against it.
@@ -314,73 +339,15 @@ export function createWorkspaceService(ctx) {
         getLastClosedProjectPath: () => lastClosedProjectPath,
         hasActiveSession: () => currentSession !== null,
         isClosing: () => closing,
-        async captureThumbnail(projectPath) {
-            if (!currentSession || projectPath !== currentProjectPath)
-                return null;
-            const simulatorWc = ctx.views.getSimulatorWebContents();
-            if (!simulatorWc)
-                return null;
-            if (ctx.views.getSimulatorProjectPath() !== projectPath)
-                return null;
-            const session = currentSession;
-            // Capture the active render-host guest (the mini-program content); the
-            // simulator WCV only holds the device-shell chrome. In native-host with no
-            // active guest (not mounted / mid page-switch / destroyed) return null
-            // rather than persist a device-shell frame as the page — that wrong-content
-            // frame is the bug this path exists to avoid. Non-native-host: the sim WCV.
-            const bridge = ctx.bridge;
-            const nativeHost = bridge?.isNativeHost() ?? false;
-            const renderGuest = nativeHost ? (bridge?.getActiveRenderWc() ?? null) : null;
-            if (nativeHost && !renderGuest)
-                return null;
-            const captureTarget = renderGuest ?? simulatorWc;
-            // A destroyed target means teardown is in flight (no valid frame) — return
-            // null rather than let capturePage() throw indistinguishably into the catch.
-            if (captureTarget.isDestroyed())
-                return null;
-            try {
-                const image = await captureTarget.capturePage();
-                if (currentSession !== session
-                    || currentProjectPath !== projectPath
-                    || ctx.views.getSimulatorWebContents() !== simulatorWc
-                    || ctx.views.getSimulatorProjectPath() !== projectPath
-                    // Captured target must still be the live one: a guest that navigated
-                    // mid-capture would otherwise persist a frame from the wrong page.
-                    || (nativeHost ? (bridge?.getActiveRenderWc() ?? null) : simulatorWc) !== captureTarget) {
-                    return null;
-                }
-                const dataUrl = `data:image/png;base64,${image.toPNG().toString('base64')}`;
-                if (provider.saveThumbnail) {
-                    await provider.saveThumbnail(projectPath, dataUrl);
-                }
-                // Always hand the renderer back the freshly-captured frame so the
-                // UI updates immediately even if the host's saveThumbnail is
-                // async or stores out-of-band.
-                return dataUrl;
-            }
-            catch {
-                return null;
-            }
-        },
-        async getThumbnail(projectPath) {
-            if (provider.getThumbnail) {
-                return (await provider.getThumbnail(projectPath)) ?? null;
-            }
-            return null;
-        },
+        captureThumbnail: thumbnails.captureThumbnail,
+        getThumbnail: thumbnails.getThumbnail,
         // `getProjectPages` reads the project's own `app.json` from disk and is
         // independent of the project registry — it stays on the repo helper.
         getProjectPages: (projectPath) => repo.getProjectPages(projectPath),
-        getCompileConfig: async (projectPath) => (provider.getCompileConfig
-            ? await provider.getCompileConfig(projectPath)
-            : DEFAULT_COMPILE_CONFIG),
-        saveCompileConfig: async (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.
-        },
+        getCompileConfig: (projectPath) => compileModes.getCompileConfig(projectPath),
+        saveCompileConfig: (projectPath, config) => compileModes.saveCompileConfig(projectPath, config),
+        getCompileModeState: (projectPath) => compileModes.getCompileModeState(projectPath),
+        applyCompileModeCommand: (command) => compileModes.applyCompileModeCommand(command),
         // Per-project settings (uploadWithSourceMap etc.) live in the project's
         // own `project.config.json`, not the registry — keep direct repo calls.
         getProjectSettings: (projectPath) => repo.getProjectSettings(projectPath),

package/dist/main/services/workspace/workspace-thumbnails.d.ts

@@ -0,0 +1,22 @@
+import type { ProjectSession } from '../../../shared/types.js';
+import type { BridgeRouterHandle } from '../../ipc/bridge-router.js';
+import type { ViewManager } from '../views/view-manager.js';
+import type { ProjectsProvider } from '../projects/types.js';
+import type { WorkspaceService } from './workspace-service.js';
+/**
+ * `captureThumbnail`/`getThumbnail` split out of WorkspaceService purely to keep
+ * workspace-service.ts under the repo's file-length gate — the semantics (session/
+ * project-path ownership, provider round-trip) still belong entirely to that service.
+ * Takes a narrow slice of WorkbenchContext (views + bridge) rather than the whole
+ * grab-bag type, so this split doesn't grow the WorkbenchContext-import ratchet.
+ */
+export declare function createThumbnailOps(input: {
+    ctx: {
+        views: Pick<ViewManager, 'getSimulatorWebContents' | 'getSimulatorProjectPath'>;
+        bridge?: BridgeRouterHandle;
+    };
+    provider: ProjectsProvider;
+    getSession(): ProjectSession | null;
+    getProjectPath(): string;
+}): Pick<WorkspaceService, 'captureThumbnail' | 'getThumbnail'>;
+//# sourceMappingURL=workspace-thumbnails.d.ts.map

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

@@ -0,0 +1,67 @@
+/**
+ * `captureThumbnail`/`getThumbnail` split out of WorkspaceService purely to keep
+ * workspace-service.ts under the repo's file-length gate — the semantics (session/
+ * project-path ownership, provider round-trip) still belong entirely to that service.
+ * Takes a narrow slice of WorkbenchContext (views + bridge) rather than the whole
+ * grab-bag type, so this split doesn't grow the WorkbenchContext-import ratchet.
+ */
+export function createThumbnailOps(input) {
+    const { ctx, provider, getSession, getProjectPath } = input;
+    return {
+        async captureThumbnail(projectPath) {
+            if (!getSession() || projectPath !== getProjectPath())
+                return null;
+            const simulatorWc = ctx.views.getSimulatorWebContents();
+            if (!simulatorWc)
+                return null;
+            if (ctx.views.getSimulatorProjectPath() !== projectPath)
+                return null;
+            const session = getSession();
+            // Capture the active render-host guest (the mini-program content); the
+            // simulator WCV only holds the device-shell chrome. In native-host with no
+            // active guest (not mounted / mid page-switch / destroyed) return null
+            // rather than persist a device-shell frame as the page — that wrong-content
+            // frame is the bug this path exists to avoid. Non-native-host: the sim WCV.
+            const bridge = ctx.bridge;
+            const nativeHost = bridge?.isNativeHost() ?? false;
+            const renderGuest = nativeHost ? (bridge?.getActiveRenderWc() ?? null) : null;
+            if (nativeHost && !renderGuest)
+                return null;
+            const captureTarget = renderGuest ?? simulatorWc;
+            // A destroyed target means teardown is in flight (no valid frame) — return
+            // null rather than let capturePage() throw indistinguishably into the catch.
+            if (captureTarget.isDestroyed())
+                return null;
+            try {
+                const image = await captureTarget.capturePage();
+                if (getSession() !== session
+                    || getProjectPath() !== projectPath
+                    || ctx.views.getSimulatorWebContents() !== simulatorWc
+                    || ctx.views.getSimulatorProjectPath() !== projectPath
+                    // Captured target must still be the live one: a guest that navigated
+                    // mid-capture would otherwise persist a frame from the wrong page.
+                    || (nativeHost ? (bridge?.getActiveRenderWc() ?? null) : simulatorWc) !== captureTarget) {
+                    return null;
+                }
+                const dataUrl = `data:image/png;base64,${image.toPNG().toString('base64')}`;
+                if (provider.saveThumbnail) {
+                    await provider.saveThumbnail(projectPath, dataUrl);
+                }
+                // Always hand the renderer back the freshly-captured frame so the
+                // UI updates immediately even if the host's saveThumbnail is
+                // async or stores out-of-band.
+                return dataUrl;
+            }
+            catch {
+                return null;
+            }
+        },
+        async getThumbnail(projectPath) {
+            if (provider.getThumbnail) {
+                return (await provider.getThumbnail(projectPath)) ?? null;
+            }
+            return null;
+        },
+    };
+}
+//# sourceMappingURL=workspace-thumbnails.js.map